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