git.sesse.net Git - ffmpeg/blob - libavcodec/parser.c

   1 /*
   2  * Audio and Video frame extraction
   3  * Copyright (c) 2003 Fabrice Bellard.
   4  * Copyright (c) 2003 Michael Niedermayer.
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22 #include "avcodec.h"
  23 #include "mpegvideo.h"
  24 #include "mpegaudio.h"
  25
  26 AVCodecParser *av_first_parser = NULL;
  27
  28 void av_register_codec_parser(AVCodecParser *parser)
  29 {
  30     parser->next = av_first_parser;
  31     av_first_parser = parser;
  32 }
  33
  34 AVCodecParserContext *av_parser_init(int codec_id)
  35 {
  36     AVCodecParserContext *s;
  37     AVCodecParser *parser;
  38     int ret;
  39
  40     if(codec_id == CODEC_ID_NONE)
  41         return NULL;
  42
  43     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  44         if (parser->codec_ids[0] == codec_id ||
  45             parser->codec_ids[1] == codec_id ||
  46             parser->codec_ids[2] == codec_id ||
  47             parser->codec_ids[3] == codec_id ||
  48             parser->codec_ids[4] == codec_id)
  49             goto found;
  50     }
  51     return NULL;
  52  found:
  53     s = av_mallocz(sizeof(AVCodecParserContext));
  54     if (!s)
  55         return NULL;
  56     s->parser = parser;
  57     s->priv_data = av_mallocz(parser->priv_data_size);
  58     if (!s->priv_data) {
  59         av_free(s);
  60         return NULL;
  61     }
  62     if (parser->parser_init) {
  63         ret = parser->parser_init(s);
  64         if (ret != 0) {
  65             av_free(s->priv_data);
  66             av_free(s);
  67             return NULL;
  68         }
  69     }
  70     s->fetch_timestamp=1;
  71     return s;
  72 }
  73
  74 /**
  75  *
  76  * @param buf           input
  77  * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
  78  * @param pts           input presentation timestamp
  79  * @param dts           input decoding timestamp
  80  * @param poutbuf       will contain a pointer to the first byte of the output frame
  81  * @param poutbuf_size  will contain the length of the output frame
  82  * @return the number of bytes of the input bitstream used
  83  *
  84  * Example:
  85  * @code
  86  *   while(in_len){
  87  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
  88  *                                       in_data, in_len,
  89  *                                       pts, dts);
  90  *       in_data += len;
  91  *       in_len  -= len;
  92  *
  93  *       decode_frame(data, size);
  94  *   }
  95  * @endcode
  96  */
  97 int av_parser_parse(AVCodecParserContext *s,
  98                     AVCodecContext *avctx,
  99                     uint8_t **poutbuf, int *poutbuf_size,
 100                     const uint8_t *buf, int buf_size,
 101                     int64_t pts, int64_t dts)
 102 {
 103     int index, i, k;
 104     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 105
 106     if (buf_size == 0) {
 107         /* padding is always necessary even if EOF, so we add it here */
 108         memset(dummy_buf, 0, sizeof(dummy_buf));
 109         buf = dummy_buf;
 110     } else {
 111         /* add a new packet descriptor */
 112         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 113         s->cur_frame_start_index = k;
 114         s->cur_frame_offset[k] = s->cur_offset;
 115         s->cur_frame_pts[k] = pts;
 116         s->cur_frame_dts[k] = dts;
 117
 118         /* fill first PTS/DTS */
 119         if (s->fetch_timestamp){
 120             s->fetch_timestamp=0;
 121             s->last_pts = pts;
 122             s->last_dts = dts;
 123             s->cur_frame_pts[k] =
 124             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
 125         }
 126     }
 127
 128     /* WARNING: the returned index can be negative */
 129     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 130 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
 131     /* update the file pointer */
 132     if (*poutbuf_size) {
 133         /* fill the data for the current frame */
 134         s->frame_offset = s->last_frame_offset;
 135         s->pts = s->last_pts;
 136         s->dts = s->last_dts;
 137
 138         /* offset of the next frame */
 139         s->last_frame_offset = s->cur_offset + index;
 140         /* find the packet in which the new frame starts. It
 141            is tricky because of MPEG video start codes
 142            which can begin in one packet and finish in
 143            another packet. In the worst case, an MPEG
 144            video start code could be in 4 different
 145            packets. */
 146         k = s->cur_frame_start_index;
 147         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 148             if (s->last_frame_offset >= s->cur_frame_offset[k])
 149                 break;
 150             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 151         }
 152
 153         s->last_pts = s->cur_frame_pts[k];
 154         s->last_dts = s->cur_frame_dts[k];
 155
 156         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 157            so the next pts/dts is in the next chunk */
 158         if(index == buf_size){
 159             s->fetch_timestamp=1;
 160         }
 161     }
 162     if (index < 0)
 163         index = 0;
 164     s->cur_offset += index;
 165     return index;
 166 }
 167
 168 /**
 169  *
 170  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 171  * @deprecated use AVBitstreamFilter
 172  */
 173 int av_parser_change(AVCodecParserContext *s,
 174                      AVCodecContext *avctx,
 175                      uint8_t **poutbuf, int *poutbuf_size,
 176                      const uint8_t *buf, int buf_size, int keyframe){
 177
 178     if(s && s->parser->split){
 179         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
 180             int i= s->parser->split(avctx, buf, buf_size);
 181             buf += i;
 182             buf_size -= i;
 183         }
 184     }
 185
 186     /* cast to avoid warning about discarding qualifiers */
 187     *poutbuf= (uint8_t *) buf;
 188     *poutbuf_size= buf_size;
 189     if(avctx->extradata){
 190         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 191             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 192             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 193             int size= buf_size + avctx->extradata_size;
 194             *poutbuf_size= size;
 195             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 196
 197             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 198             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 199             return 1;
 200         }
 201     }
 202
 203     return 0;
 204 }
 205
 206 void av_parser_close(AVCodecParserContext *s)
 207 {
 208     if (s->parser->parser_close)
 209         s->parser->parser_close(s);
 210     av_free(s->priv_data);
 211     av_free(s);
 212 }
 213
 214 /*****************************************************/
 215
 216 //#define END_NOT_FOUND (-100)
 217
 218 #define PICTURE_START_CODE      0x00000100
 219 #define SEQ_START_CODE          0x000001b3
 220 #define EXT_START_CODE          0x000001b5
 221 #define SLICE_MIN_START_CODE    0x00000101
 222 #define SLICE_MAX_START_CODE    0x000001af
 223
 224 typedef struct ParseContext1{
 225     ParseContext pc;
 226 /* XXX/FIXME PC1 vs. PC */
 227     /* MPEG2 specific */
 228     int frame_rate;
 229     int progressive_sequence;
 230     int width, height;
 231
 232     /* XXX: suppress that, needed by MPEG4 */
 233     MpegEncContext *enc;
 234     int first_picture;
 235 } ParseContext1;
 236
 237 /**
 238  * combines the (truncated) bitstream to a complete frame
 239  * @returns -1 if no complete frame could be created
 240  */
 241 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 242 {
 243 #if 0
 244     if(pc->overread){
 245         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 246         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 247     }
 248 #endif
 249
 250     /* copy overreaded bytes from last frame into buffer */
 251     for(; pc->overread>0; pc->overread--){
 252         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 253     }
 254
 255     /* flush remaining if EOF */
 256     if(!*buf_size && next == END_NOT_FOUND){
 257         next= 0;
 258     }
 259
 260     pc->last_index= pc->index;
 261
 262     /* copy into buffer end return */
 263     if(next == END_NOT_FOUND){
 264         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 265
 266         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 267         pc->index += *buf_size;
 268         return -1;
 269     }
 270
 271     *buf_size=
 272     pc->overread_index= pc->index + next;
 273
 274     /* append to buffer */
 275     if(pc->index){
 276         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 277
 278         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 279         pc->index = 0;
 280         *buf= pc->buffer;
 281     }
 282
 283     /* store overread bytes */
 284     for(;next < 0; next++){
 285         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 286         pc->overread++;
 287     }
 288
 289 #if 0
 290     if(pc->overread){
 291         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 292         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 293     }
 294 #endif
 295
 296     return 0;
 297 }
 298
 299 /* XXX: merge with libavcodec ? */
 300 #define MPEG1_FRAME_RATE_BASE 1001
 301
 302 static const int frame_rate_tab[16] = {
 303         0,
 304     24000,
 305     24024,
 306     25025,
 307     30000,
 308     30030,
 309     50050,
 310     60000,
 311     60060,
 312   // Xing's 15fps: (9)
 313     15015,
 314   // libmpeg3's "Unofficial economy rates": (10-13)
 315      5005,
 316     10010,
 317     12012,
 318     15015,
 319   // random, just to avoid segfault !never encode these
 320     25025,
 321     25025,
 322 };
 323
 324 #ifdef CONFIG_MPEGVIDEO_PARSER
 325 //FIXME move into mpeg12.c
 326 static void mpegvideo_extract_headers(AVCodecParserContext *s,
 327                                       AVCodecContext *avctx,
 328                                       const uint8_t *buf, int buf_size)
 329 {
 330     ParseContext1 *pc = s->priv_data;
 331     const uint8_t *buf_end;
 332     uint32_t start_code;
 333     int frame_rate_index, ext_type, bytes_left;
 334     int frame_rate_ext_n, frame_rate_ext_d;
 335     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
 336     int horiz_size_ext, vert_size_ext, bit_rate_ext;
 337 //FIXME replace the crap with get_bits()
 338     s->repeat_pict = 0;
 339     buf_end = buf + buf_size;
 340     while (buf < buf_end) {
 341         start_code= -1;
 342         buf= ff_find_start_code(buf, buf_end, &start_code);
 343         bytes_left = buf_end - buf;
 344         switch(start_code) {
 345         case PICTURE_START_CODE:
 346             if (bytes_left >= 2) {
 347                 s->pict_type = (buf[1] >> 3) & 7;
 348             }
 349             break;
 350         case SEQ_START_CODE:
 351             if (bytes_left >= 7) {
 352                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
 353                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
 354                 avcodec_set_dimensions(avctx, pc->width, pc->height);
 355                 frame_rate_index = buf[3] & 0xf;
 356                 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
 357                 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
 358                 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
 359                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
 360                 avctx->sub_id = 1;
 361             }
 362             break;
 363         case EXT_START_CODE:
 364             if (bytes_left >= 1) {
 365                 ext_type = (buf[0] >> 4);
 366                 switch(ext_type) {
 367                 case 0x1: /* sequence extension */
 368                     if (bytes_left >= 6) {
 369                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
 370                         vert_size_ext = (buf[2] >> 5) & 3;
 371                         bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
 372                         frame_rate_ext_n = (buf[5] >> 5) & 3;
 373                         frame_rate_ext_d = (buf[5] & 0x1f);
 374                         pc->progressive_sequence = buf[1] & (1 << 3);
 375                         avctx->has_b_frames= !(buf[5] >> 7);
 376
 377                         pc->width  |=(horiz_size_ext << 12);
 378                         pc->height |=( vert_size_ext << 12);
 379                         avctx->bit_rate += (bit_rate_ext << 18) * 400;
 380                         avcodec_set_dimensions(avctx, pc->width, pc->height);
 381                         avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
 382                         avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
 383                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
 384                         avctx->sub_id = 2; /* forces MPEG2 */
 385                     }
 386                     break;
 387                 case 0x8: /* picture coding extension */
 388                     if (bytes_left >= 5) {
 389                         picture_structure = buf[2]&3;
 390                         top_field_first = buf[3] & (1 << 7);
 391                         repeat_first_field = buf[3] & (1 << 1);
 392                         progressive_frame = buf[4] & (1 << 7);
 393
 394                         /* check if we must repeat the frame */
 395                         if (repeat_first_field) {
 396                             if (pc->progressive_sequence) {
 397                                 if (top_field_first)
 398                                     s->repeat_pict = 4;
 399                                 else
 400                                     s->repeat_pict = 2;
 401                             } else if (progressive_frame) {
 402                                 s->repeat_pict = 1;
 403                             }
 404                         }
 405
 406                         /* the packet only represents half a frame
 407                            XXX,FIXME maybe find a different solution */
 408                         if(picture_structure != 3)
 409                             s->repeat_pict = -1;
 410                     }
 411                     break;
 412                 }
 413             }
 414             break;
 415         case -1:
 416             goto the_end;
 417         default:
 418             /* we stop parsing when we encounter a slice. It ensures
 419                that this function takes a negligible amount of time */
 420             if (start_code >= SLICE_MIN_START_CODE &&
 421                 start_code <= SLICE_MAX_START_CODE)
 422                 goto the_end;
 423             break;
 424         }
 425     }
 426  the_end: ;
 427 }
 428
 429 static int mpegvideo_parse(AVCodecParserContext *s,
 430                            AVCodecContext *avctx,
 431                            uint8_t **poutbuf, int *poutbuf_size,
 432                            const uint8_t *buf, int buf_size)
 433 {
 434     ParseContext1 *pc1 = s->priv_data;
 435     ParseContext *pc= &pc1->pc;
 436     int next;
 437
 438     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 439         next= buf_size;
 440     }else{
 441         next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
 442
 443         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 444             *poutbuf = NULL;
 445             *poutbuf_size = 0;
 446             return buf_size;
 447         }
 448
 449     }
 450     /* we have a full frame : we just parse the first few MPEG headers
 451        to have the full timing information. The time take by this
 452        function should be negligible for uncorrupted streams */
 453     mpegvideo_extract_headers(s, avctx, buf, buf_size);
 454 #if 0
 455     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
 456            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
 457 #endif
 458
 459     *poutbuf = (uint8_t *)buf;
 460     *poutbuf_size = buf_size;
 461     return next;
 462 }
 463
 464 static int mpegvideo_split(AVCodecContext *avctx,
 465                            const uint8_t *buf, int buf_size)
 466 {
 467     int i;
 468     uint32_t state= -1;
 469
 470     for(i=0; i<buf_size; i++){
 471         state= (state<<8) | buf[i];
 472         if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
 473             return i-3;
 474     }
 475     return 0;
 476 }
 477 #endif /* CONFIG_MPEGVIDEO_PARSER */
 478
 479 void ff_parse_close(AVCodecParserContext *s)
 480 {
 481     ParseContext *pc = s->priv_data;
 482
 483     av_free(pc->buffer);
 484 }
 485
 486 static void parse1_close(AVCodecParserContext *s)
 487 {
 488     ParseContext1 *pc1 = s->priv_data;
 489
 490     av_free(pc1->pc.buffer);
 491     av_free(pc1->enc);
 492 }
 493
 494 /*************************/
 495
 496 #ifdef CONFIG_MPEG4VIDEO_PARSER
 497 /* used by parser */
 498 /* XXX: make it use less memory */
 499 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 500                                   AVCodecContext *avctx,
 501                                   const uint8_t *buf, int buf_size)
 502 {
 503     ParseContext1 *pc = s1->priv_data;
 504     MpegEncContext *s = pc->enc;
 505     GetBitContext gb1, *gb = &gb1;
 506     int ret;
 507
 508     s->avctx = avctx;
 509     s->current_picture_ptr = &s->current_picture;
 510
 511     if (avctx->extradata_size && pc->first_picture){
 512         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 513         ret = ff_mpeg4_decode_picture_header(s, gb);
 514     }
 515
 516     init_get_bits(gb, buf, 8 * buf_size);
 517     ret = ff_mpeg4_decode_picture_header(s, gb);
 518     if (s->width) {
 519         avcodec_set_dimensions(avctx, s->width, s->height);
 520     }
 521     s1->pict_type= s->pict_type;
 522     pc->first_picture = 0;
 523     return ret;
 524 }
 525
 526 static int mpeg4video_parse_init(AVCodecParserContext *s)
 527 {
 528     ParseContext1 *pc = s->priv_data;
 529
 530     pc->enc = av_mallocz(sizeof(MpegEncContext));
 531     if (!pc->enc)
 532         return -1;
 533     pc->first_picture = 1;
 534     return 0;
 535 }
 536
 537 static int mpeg4video_parse(AVCodecParserContext *s,
 538                            AVCodecContext *avctx,
 539                            uint8_t **poutbuf, int *poutbuf_size,
 540                            const uint8_t *buf, int buf_size)
 541 {
 542     ParseContext *pc = s->priv_data;
 543     int next;
 544
 545     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 546         next= buf_size;
 547     }else{
 548         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 549
 550         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 551             *poutbuf = NULL;
 552             *poutbuf_size = 0;
 553             return buf_size;
 554         }
 555     }
 556     av_mpeg4_decode_header(s, avctx, buf, buf_size);
 557
 558     *poutbuf = (uint8_t *)buf;
 559     *poutbuf_size = buf_size;
 560     return next;
 561 }
 562 #endif
 563
 564 #ifdef CONFIG_CAVSVIDEO_PARSER
 565 static int cavsvideo_parse(AVCodecParserContext *s,
 566                            AVCodecContext *avctx,
 567                            uint8_t **poutbuf, int *poutbuf_size,
 568                            const uint8_t *buf, int buf_size)
 569 {
 570     ParseContext *pc = s->priv_data;
 571     int next;
 572
 573     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 574         next= buf_size;
 575     }else{
 576         next= ff_cavs_find_frame_end(pc, buf, buf_size);
 577
 578         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 579             *poutbuf = NULL;
 580             *poutbuf_size = 0;
 581             return buf_size;
 582         }
 583     }
 584     *poutbuf = (uint8_t *)buf;
 585     *poutbuf_size = buf_size;
 586     return next;
 587 }
 588 #endif /* CONFIG_CAVSVIDEO_PARSER */
 589
 590 static int mpeg4video_split(AVCodecContext *avctx,
 591                            const uint8_t *buf, int buf_size)
 592 {
 593     int i;
 594     uint32_t state= -1;
 595
 596     for(i=0; i<buf_size; i++){
 597         state= (state<<8) | buf[i];
 598         if(state == 0x1B3 || state == 0x1B6)
 599             return i-3;
 600     }
 601     return 0;
 602 }
 603
 604 /*************************/
 605
 606 #ifdef CONFIG_MPEGAUDIO_PARSER
 607 typedef struct MpegAudioParseContext {
 608     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 609     uint8_t *inbuf_ptr;
 610     int frame_size;
 611     int free_format_frame_size;
 612     int free_format_next_header;
 613     uint32_t header;
 614     int header_count;
 615 } MpegAudioParseContext;
 616
 617 #define MPA_HEADER_SIZE 4
 618
 619 /* header + layer + bitrate + freq + lsf/mpeg25 */
 620 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 621 #define SAME_HEADER_MASK \
 622    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 623
 624 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 625 {
 626     MpegAudioParseContext *s = s1->priv_data;
 627     s->inbuf_ptr = s->inbuf;
 628     return 0;
 629 }
 630
 631 static int mpegaudio_parse(AVCodecParserContext *s1,
 632                            AVCodecContext *avctx,
 633                            uint8_t **poutbuf, int *poutbuf_size,
 634                            const uint8_t *buf, int buf_size)
 635 {
 636     MpegAudioParseContext *s = s1->priv_data;
 637     int len, ret, sr;
 638     uint32_t header;
 639     const uint8_t *buf_ptr;
 640
 641     *poutbuf = NULL;
 642     *poutbuf_size = 0;
 643     buf_ptr = buf;
 644     while (buf_size > 0) {
 645         len = s->inbuf_ptr - s->inbuf;
 646         if (s->frame_size == 0) {
 647             /* special case for next header for first frame in free
 648                format case (XXX: find a simpler method) */
 649             if (s->free_format_next_header != 0) {
 650                 s->inbuf[0] = s->free_format_next_header >> 24;
 651                 s->inbuf[1] = s->free_format_next_header >> 16;
 652                 s->inbuf[2] = s->free_format_next_header >> 8;
 653                 s->inbuf[3] = s->free_format_next_header;
 654                 s->inbuf_ptr = s->inbuf + 4;
 655                 s->free_format_next_header = 0;
 656                 goto got_header;
 657             }
 658             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 659                bytes to parse it */
 660             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
 661             if (len > 0) {
 662                 memcpy(s->inbuf_ptr, buf_ptr, len);
 663                 buf_ptr += len;
 664                 buf_size -= len;
 665                 s->inbuf_ptr += len;
 666             }
 667             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 668             got_header:
 669                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 670                     (s->inbuf[2] << 8) | s->inbuf[3];
 671
 672                 ret = mpa_decode_header(avctx, header, &sr);
 673                 if (ret < 0) {
 674                     s->header_count= -2;
 675                     /* no sync found : move by one byte (inefficient, but simple!) */
 676                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 677                     s->inbuf_ptr--;
 678                     dprintf("skip %x\n", header);
 679                     /* reset free format frame size to give a chance
 680                        to get a new bitrate */
 681                     s->free_format_frame_size = 0;
 682                 } else {
 683                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
 684                         s->header_count= -3;
 685                     s->header= header;
 686                     s->header_count++;
 687                     s->frame_size = ret;
 688
 689 #if 0
 690                     /* free format: prepare to compute frame size */
 691                     if (decode_header(s, header) == 1) {
 692                         s->frame_size = -1;
 693                     }
 694 #endif
 695                 }
 696                 if(s->header_count > 1)
 697                     avctx->sample_rate= sr;
 698             }
 699         } else
 700 #if 0
 701         if (s->frame_size == -1) {
 702             /* free format : find next sync to compute frame size */
 703             len = MPA_MAX_CODED_FRAME_SIZE - len;
 704             if (len > buf_size)
 705                 len = buf_size;
 706             if (len == 0) {
 707                 /* frame too long: resync */
 708                 s->frame_size = 0;
 709                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 710                 s->inbuf_ptr--;
 711             } else {
 712                 uint8_t *p, *pend;
 713                 uint32_t header1;
 714                 int padding;
 715
 716                 memcpy(s->inbuf_ptr, buf_ptr, len);
 717                 /* check for header */
 718                 p = s->inbuf_ptr - 3;
 719                 pend = s->inbuf_ptr + len - 4;
 720                 while (p <= pend) {
 721                     header = (p[0] << 24) | (p[1] << 16) |
 722                         (p[2] << 8) | p[3];
 723                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 724                         (s->inbuf[2] << 8) | s->inbuf[3];
 725                     /* check with high probability that we have a
 726                        valid header */
 727                     if ((header & SAME_HEADER_MASK) ==
 728                         (header1 & SAME_HEADER_MASK)) {
 729                         /* header found: update pointers */
 730                         len = (p + 4) - s->inbuf_ptr;
 731                         buf_ptr += len;
 732                         buf_size -= len;
 733                         s->inbuf_ptr = p;
 734                         /* compute frame size */
 735                         s->free_format_next_header = header;
 736                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 737                         padding = (header1 >> 9) & 1;
 738                         if (s->layer == 1)
 739                             s->free_format_frame_size -= padding * 4;
 740                         else
 741                             s->free_format_frame_size -= padding;
 742                         dprintf("free frame size=%d padding=%d\n",
 743                                 s->free_format_frame_size, padding);
 744                         decode_header(s, header1);
 745                         goto next_data;
 746                     }
 747                     p++;
 748                 }
 749                 /* not found: simply increase pointers */
 750                 buf_ptr += len;
 751                 s->inbuf_ptr += len;
 752                 buf_size -= len;
 753             }
 754         } else
 755 #endif
 756         if (len < s->frame_size) {
 757             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 758                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 759             len = FFMIN(s->frame_size - len, buf_size);
 760             memcpy(s->inbuf_ptr, buf_ptr, len);
 761             buf_ptr += len;
 762             s->inbuf_ptr += len;
 763             buf_size -= len;
 764         }
 765
 766         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
 767            && buf_size + buf_ptr - buf >= s->frame_size){
 768             if(s->header_count > 0){
 769                 *poutbuf = buf;
 770                 *poutbuf_size = s->frame_size;
 771             }
 772             buf_ptr = buf + s->frame_size;
 773             s->inbuf_ptr = s->inbuf;
 774             s->frame_size = 0;
 775             break;
 776         }
 777
 778         //    next_data:
 779         if (s->frame_size > 0 &&
 780             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 781             if(s->header_count > 0){
 782                 *poutbuf = s->inbuf;
 783                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
 784             }
 785             s->inbuf_ptr = s->inbuf;
 786             s->frame_size = 0;
 787             break;
 788         }
 789     }
 790     return buf_ptr - buf;
 791 }
 792 #endif /* CONFIG_MPEGAUDIO_PARSER */
 793
 794 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
 795 /* also used for ADTS AAC */
 796 typedef struct AC3ParseContext {
 797     uint8_t *inbuf_ptr;
 798     int frame_size;
 799     int header_size;
 800     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
 801                 int *bit_rate, int *samples);
 802     uint8_t inbuf[8192]; /* input buffer */
 803 } AC3ParseContext;
 804
 805 #define AC3_HEADER_SIZE 7
 806 #define AAC_HEADER_SIZE 7
 807
 808 #ifdef CONFIG_AC3_PARSER
 809 static const int ac3_sample_rates[4] = {
 810     48000, 44100, 32000, 0
 811 };
 812
 813 static const int ac3_frame_sizes[64][3] = {
 814     { 64,   69,   96   },
 815     { 64,   70,   96   },
 816     { 80,   87,   120  },
 817     { 80,   88,   120  },
 818     { 96,   104,  144  },
 819     { 96,   105,  144  },
 820     { 112,  121,  168  },
 821     { 112,  122,  168  },
 822     { 128,  139,  192  },
 823     { 128,  140,  192  },
 824     { 160,  174,  240  },
 825     { 160,  175,  240  },
 826     { 192,  208,  288  },
 827     { 192,  209,  288  },
 828     { 224,  243,  336  },
 829     { 224,  244,  336  },
 830     { 256,  278,  384  },
 831     { 256,  279,  384  },
 832     { 320,  348,  480  },
 833     { 320,  349,  480  },
 834     { 384,  417,  576  },
 835     { 384,  418,  576  },
 836     { 448,  487,  672  },
 837     { 448,  488,  672  },
 838     { 512,  557,  768  },
 839     { 512,  558,  768  },
 840     { 640,  696,  960  },
 841     { 640,  697,  960  },
 842     { 768,  835,  1152 },
 843     { 768,  836,  1152 },
 844     { 896,  975,  1344 },
 845     { 896,  976,  1344 },
 846     { 1024, 1114, 1536 },
 847     { 1024, 1115, 1536 },
 848     { 1152, 1253, 1728 },
 849     { 1152, 1254, 1728 },
 850     { 1280, 1393, 1920 },
 851     { 1280, 1394, 1920 },
 852 };
 853
 854 static const int ac3_bitrates[64] = {
 855     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
 856     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
 857     384, 448, 448, 512, 512, 576, 576, 640, 640,
 858 };
 859
 860 static const int ac3_channels[8] = {
 861     2, 1, 2, 3, 3, 4, 4, 5
 862 };
 863 #endif /* CONFIG_AC3_PARSER */
 864
 865 #ifdef CONFIG_AAC_PARSER
 866 static const int aac_sample_rates[16] = {
 867     96000, 88200, 64000, 48000, 44100, 32000,
 868     24000, 22050, 16000, 12000, 11025, 8000, 7350
 869 };
 870
 871 static const int aac_channels[8] = {
 872     0, 1, 2, 3, 4, 5, 6, 8
 873 };
 874 #endif
 875
 876 #ifdef CONFIG_AC3_PARSER
 877 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 878                     int *bit_rate, int *samples)
 879 {
 880     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
 881     GetBitContext bits;
 882
 883     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
 884
 885     if(get_bits(&bits, 16) != 0x0b77)
 886         return 0;
 887
 888     skip_bits(&bits, 16);       /* crc */
 889     fscod = get_bits(&bits, 2);
 890     frmsizecod = get_bits(&bits, 6);
 891
 892     if(!ac3_sample_rates[fscod])
 893         return 0;
 894
 895     bsid = get_bits(&bits, 5);
 896     if(bsid > 8)
 897         return 0;
 898     skip_bits(&bits, 3);        /* bsmod */
 899     acmod = get_bits(&bits, 3);
 900     if(acmod & 1 && acmod != 1)
 901         skip_bits(&bits, 2);    /* cmixlev */
 902     if(acmod & 4)
 903         skip_bits(&bits, 2);    /* surmixlev */
 904     if(acmod & 2)
 905         skip_bits(&bits, 2);    /* dsurmod */
 906     lfeon = get_bits1(&bits);
 907
 908     *sample_rate = ac3_sample_rates[fscod];
 909     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
 910     *channels = ac3_channels[acmod] + lfeon;
 911     *samples = 6 * 256;
 912
 913     return ac3_frame_sizes[frmsizecod][fscod] * 2;
 914 }
 915 #endif /* CONFIG_AC3_PARSER */
 916
 917 #ifdef CONFIG_AAC_PARSER
 918 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 919                     int *bit_rate, int *samples)
 920 {
 921     GetBitContext bits;
 922     int size, rdb, ch, sr;
 923
 924     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 925
 926     if(get_bits(&bits, 12) != 0xfff)
 927         return 0;
 928
 929     skip_bits1(&bits);          /* id */
 930     skip_bits(&bits, 2);        /* layer */
 931     skip_bits1(&bits);          /* protection_absent */
 932     skip_bits(&bits, 2);        /* profile_objecttype */
 933     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 934     if(!aac_sample_rates[sr])
 935         return 0;
 936     skip_bits1(&bits);          /* private_bit */
 937     ch = get_bits(&bits, 3);    /* channel_configuration */
 938     if(!aac_channels[ch])
 939         return 0;
 940     skip_bits1(&bits);          /* original/copy */
 941     skip_bits1(&bits);          /* home */
 942
 943     /* adts_variable_header */
 944     skip_bits1(&bits);          /* copyright_identification_bit */
 945     skip_bits1(&bits);          /* copyright_identification_start */
 946     size = get_bits(&bits, 13); /* aac_frame_length */
 947     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 948     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 949
 950     *channels = aac_channels[ch];
 951     *sample_rate = aac_sample_rates[sr];
 952     *samples = (rdb + 1) * 1024;
 953     *bit_rate = size * 8 * *sample_rate / *samples;
 954
 955     return size;
 956 }
 957 #endif /* CONFIG_AAC_PARSER */
 958
 959 #ifdef CONFIG_AC3_PARSER
 960 static int ac3_parse_init(AVCodecParserContext *s1)
 961 {
 962     AC3ParseContext *s = s1->priv_data;
 963     s->inbuf_ptr = s->inbuf;
 964     s->header_size = AC3_HEADER_SIZE;
 965     s->sync = ac3_sync;
 966     return 0;
 967 }
 968 #endif
 969
 970 #ifdef CONFIG_AAC_PARSER
 971 static int aac_parse_init(AVCodecParserContext *s1)
 972 {
 973     AC3ParseContext *s = s1->priv_data;
 974     s->inbuf_ptr = s->inbuf;
 975     s->header_size = AAC_HEADER_SIZE;
 976     s->sync = aac_sync;
 977     return 0;
 978 }
 979 #endif
 980
 981 /* also used for ADTS AAC */
 982 static int ac3_parse(AVCodecParserContext *s1,
 983                      AVCodecContext *avctx,
 984                      uint8_t **poutbuf, int *poutbuf_size,
 985                      const uint8_t *buf, int buf_size)
 986 {
 987     AC3ParseContext *s = s1->priv_data;
 988     const uint8_t *buf_ptr;
 989     int len, sample_rate, bit_rate, channels, samples;
 990
 991     *poutbuf = NULL;
 992     *poutbuf_size = 0;
 993
 994     buf_ptr = buf;
 995     while (buf_size > 0) {
 996         len = s->inbuf_ptr - s->inbuf;
 997         if (s->frame_size == 0) {
 998             /* no header seen : find one. We need at least s->header_size
 999                bytes to parse it */
1000             len = FFMIN(s->header_size - len, buf_size);
1001
1002             memcpy(s->inbuf_ptr, buf_ptr, len);
1003             buf_ptr += len;
1004             s->inbuf_ptr += len;
1005             buf_size -= len;
1006             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
1007                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
1008                               &samples);
1009                 if (len == 0) {
1010                     /* no sync found : move by one byte (inefficient, but simple!) */
1011                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
1012                     s->inbuf_ptr--;
1013                 } else {
1014                     s->frame_size = len;
1015                     /* update codec info */
1016                     avctx->sample_rate = sample_rate;
1017                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
1018                     if(avctx->codec_id == CODEC_ID_AC3){
1019                         if(avctx->channels!=1 && avctx->channels!=2){
1020                             avctx->channels = channels;
1021                         }
1022                     } else {
1023                         avctx->channels = channels;
1024                     }
1025                     avctx->bit_rate = bit_rate;
1026                     avctx->frame_size = samples;
1027                 }
1028             }
1029         } else {
1030             len = FFMIN(s->frame_size - len, buf_size);
1031
1032             memcpy(s->inbuf_ptr, buf_ptr, len);
1033             buf_ptr += len;
1034             s->inbuf_ptr += len;
1035             buf_size -= len;
1036
1037             if(s->inbuf_ptr - s->inbuf == s->frame_size){
1038                 *poutbuf = s->inbuf;
1039                 *poutbuf_size = s->frame_size;
1040                 s->inbuf_ptr = s->inbuf;
1041                 s->frame_size = 0;
1042                 break;
1043             }
1044         }
1045     }
1046     return buf_ptr - buf;
1047 }
1048 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
1049
1050 #ifdef CONFIG_MPEGVIDEO_PARSER
1051 AVCodecParser mpegvideo_parser = {
1052     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
1053     sizeof(ParseContext1),
1054     NULL,
1055     mpegvideo_parse,
1056     parse1_close,
1057     mpegvideo_split,
1058 };
1059 #endif
1060 #ifdef CONFIG_MPEG4VIDEO_PARSER
1061 AVCodecParser mpeg4video_parser = {
1062     { CODEC_ID_MPEG4 },
1063     sizeof(ParseContext1),
1064     mpeg4video_parse_init,
1065     mpeg4video_parse,
1066     parse1_close,
1067     mpeg4video_split,
1068 };
1069 #endif
1070 #ifdef CONFIG_CAVSVIDEO_PARSER
1071 AVCodecParser cavsvideo_parser = {
1072     { CODEC_ID_CAVS },
1073     sizeof(ParseContext1),
1074     NULL,
1075     cavsvideo_parse,
1076     parse1_close,
1077     mpeg4video_split,
1078 };
1079 #endif
1080 #ifdef CONFIG_MPEGAUDIO_PARSER
1081 AVCodecParser mpegaudio_parser = {
1082     { CODEC_ID_MP2, CODEC_ID_MP3 },
1083     sizeof(MpegAudioParseContext),
1084     mpegaudio_parse_init,
1085     mpegaudio_parse,
1086     NULL,
1087 };
1088 #endif
1089 #ifdef CONFIG_AC3_PARSER
1090 AVCodecParser ac3_parser = {
1091     { CODEC_ID_AC3 },
1092     sizeof(AC3ParseContext),
1093     ac3_parse_init,
1094     ac3_parse,
1095     NULL,
1096 };
1097 #endif
1098 #ifdef CONFIG_AAC_PARSER
1099 AVCodecParser aac_parser = {
1100     { CODEC_ID_AAC },
1101     sizeof(AC3ParseContext),
1102     aac_parse_init,
1103     ac3_parse,
1104     NULL,
1105 };
1106 #endif