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 mpeg4video_split(AVCodecContext *avctx,
 537                            const uint8_t *buf, int buf_size)
 538 {
 539     int i;
 540     uint32_t state= -1;
 541
 542     for(i=0; i<buf_size; i++){
 543         state= (state<<8) | buf[i];
 544         if(state == 0x1B3 || state == 0x1B6)
 545             return i-3;
 546     }
 547     return 0;
 548 }
 549
 550 /*************************/
 551
 552 typedef struct MpegAudioParseContext {
 553     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 554     uint8_t *inbuf_ptr;
 555     int frame_size;
 556     int free_format_frame_size;
 557     int free_format_next_header;
 558     uint32_t header;
 559     int header_count;
 560 } MpegAudioParseContext;
 561
 562 #define MPA_HEADER_SIZE 4
 563
 564 /* header + layer + bitrate + freq + lsf/mpeg25 */
 565 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 566 #define SAME_HEADER_MASK \
 567    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 568
 569 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 570 {
 571     MpegAudioParseContext *s = s1->priv_data;
 572     s->inbuf_ptr = s->inbuf;
 573     return 0;
 574 }
 575
 576 static int mpegaudio_parse(AVCodecParserContext *s1,
 577                            AVCodecContext *avctx,
 578                            uint8_t **poutbuf, int *poutbuf_size,
 579                            const uint8_t *buf, int buf_size)
 580 {
 581     MpegAudioParseContext *s = s1->priv_data;
 582     int len, ret, sr;
 583     uint32_t header;
 584     const uint8_t *buf_ptr;
 585
 586     *poutbuf = NULL;
 587     *poutbuf_size = 0;
 588     buf_ptr = buf;
 589     while (buf_size > 0) {
 590         len = s->inbuf_ptr - s->inbuf;
 591         if (s->frame_size == 0) {
 592             /* special case for next header for first frame in free
 593                format case (XXX: find a simpler method) */
 594             if (s->free_format_next_header != 0) {
 595                 s->inbuf[0] = s->free_format_next_header >> 24;
 596                 s->inbuf[1] = s->free_format_next_header >> 16;
 597                 s->inbuf[2] = s->free_format_next_header >> 8;
 598                 s->inbuf[3] = s->free_format_next_header;
 599                 s->inbuf_ptr = s->inbuf + 4;
 600                 s->free_format_next_header = 0;
 601                 goto got_header;
 602             }
 603             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 604                bytes to parse it */
 605             len = MPA_HEADER_SIZE - len;
 606             if (len > buf_size)
 607                 len = buf_size;
 608             if (len > 0) {
 609                 memcpy(s->inbuf_ptr, buf_ptr, len);
 610                 buf_ptr += len;
 611                 buf_size -= len;
 612                 s->inbuf_ptr += len;
 613             }
 614             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 615             got_header:
 616                 sr= avctx->sample_rate;
 617                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 618                     (s->inbuf[2] << 8) | s->inbuf[3];
 619
 620                 ret = mpa_decode_header(avctx, header);
 621                 if (ret < 0) {
 622                     s->header_count= -2;
 623                     /* no sync found : move by one byte (inefficient, but simple!) */
 624                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 625                     s->inbuf_ptr--;
 626                     dprintf("skip %x\n", header);
 627                     /* reset free format frame size to give a chance
 628                        to get a new bitrate */
 629                     s->free_format_frame_size = 0;
 630                 } else {
 631                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
 632                         s->header_count= -3;
 633                     s->header= header;
 634                     s->header_count++;
 635                     s->frame_size = ret;
 636
 637 #if 0
 638                     /* free format: prepare to compute frame size */
 639                     if (decode_header(s, header) == 1) {
 640                         s->frame_size = -1;
 641                     }
 642 #endif
 643                 }
 644                 if(s->header_count <= 0)
 645                     avctx->sample_rate= sr; //FIXME ugly
 646             }
 647         } else
 648 #if 0
 649         if (s->frame_size == -1) {
 650             /* free format : find next sync to compute frame size */
 651             len = MPA_MAX_CODED_FRAME_SIZE - len;
 652             if (len > buf_size)
 653                 len = buf_size;
 654             if (len == 0) {
 655                 /* frame too long: resync */
 656                 s->frame_size = 0;
 657                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 658                 s->inbuf_ptr--;
 659             } else {
 660                 uint8_t *p, *pend;
 661                 uint32_t header1;
 662                 int padding;
 663
 664                 memcpy(s->inbuf_ptr, buf_ptr, len);
 665                 /* check for header */
 666                 p = s->inbuf_ptr - 3;
 667                 pend = s->inbuf_ptr + len - 4;
 668                 while (p <= pend) {
 669                     header = (p[0] << 24) | (p[1] << 16) |
 670                         (p[2] << 8) | p[3];
 671                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 672                         (s->inbuf[2] << 8) | s->inbuf[3];
 673                     /* check with high probability that we have a
 674                        valid header */
 675                     if ((header & SAME_HEADER_MASK) ==
 676                         (header1 & SAME_HEADER_MASK)) {
 677                         /* header found: update pointers */
 678                         len = (p + 4) - s->inbuf_ptr;
 679                         buf_ptr += len;
 680                         buf_size -= len;
 681                         s->inbuf_ptr = p;
 682                         /* compute frame size */
 683                         s->free_format_next_header = header;
 684                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 685                         padding = (header1 >> 9) & 1;
 686                         if (s->layer == 1)
 687                             s->free_format_frame_size -= padding * 4;
 688                         else
 689                             s->free_format_frame_size -= padding;
 690                         dprintf("free frame size=%d padding=%d\n",
 691                                 s->free_format_frame_size, padding);
 692                         decode_header(s, header1);
 693                         goto next_data;
 694                     }
 695                     p++;
 696                 }
 697                 /* not found: simply increase pointers */
 698                 buf_ptr += len;
 699                 s->inbuf_ptr += len;
 700                 buf_size -= len;
 701             }
 702         } else
 703 #endif
 704         if (len < s->frame_size) {
 705             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 706                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 707             len = s->frame_size - len;
 708             if (len > buf_size)
 709                 len = buf_size;
 710             memcpy(s->inbuf_ptr, buf_ptr, len);
 711             buf_ptr += len;
 712             s->inbuf_ptr += len;
 713             buf_size -= len;
 714         }
 715         //    next_data:
 716         if (s->frame_size > 0 &&
 717             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 718             if(s->header_count > 0){
 719                 *poutbuf = s->inbuf;
 720                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
 721             }
 722             s->inbuf_ptr = s->inbuf;
 723             s->frame_size = 0;
 724             break;
 725         }
 726     }
 727     return buf_ptr - buf;
 728 }
 729
 730 typedef struct AC3ParseContext {
 731     uint8_t inbuf[4096]; /* input buffer */
 732     uint8_t *inbuf_ptr;
 733     int frame_size;
 734 } AC3ParseContext;
 735
 736 #define AC3_HEADER_SIZE 7
 737
 738 static const int ac3_sample_rates[4] = {
 739     48000, 44100, 32000, 0
 740 };
 741
 742 static const int ac3_frame_sizes[64][3] = {
 743     { 64,   69,   96   },
 744     { 64,   70,   96   },
 745     { 80,   87,   120  },
 746     { 80,   88,   120  },
 747     { 96,   104,  144  },
 748     { 96,   105,  144  },
 749     { 112,  121,  168  },
 750     { 112,  122,  168  },
 751     { 128,  139,  192  },
 752     { 128,  140,  192  },
 753     { 160,  174,  240  },
 754     { 160,  175,  240  },
 755     { 192,  208,  288  },
 756     { 192,  209,  288  },
 757     { 224,  243,  336  },
 758     { 224,  244,  336  },
 759     { 256,  278,  384  },
 760     { 256,  279,  384  },
 761     { 320,  348,  480  },
 762     { 320,  349,  480  },
 763     { 384,  417,  576  },
 764     { 384,  418,  576  },
 765     { 448,  487,  672  },
 766     { 448,  488,  672  },
 767     { 512,  557,  768  },
 768     { 512,  558,  768  },
 769     { 640,  696,  960  },
 770     { 640,  697,  960  },
 771     { 768,  835,  1152 },
 772     { 768,  836,  1152 },
 773     { 896,  975,  1344 },
 774     { 896,  976,  1344 },
 775     { 1024, 1114, 1536 },
 776     { 1024, 1115, 1536 },
 777     { 1152, 1253, 1728 },
 778     { 1152, 1254, 1728 },
 779     { 1280, 1393, 1920 },
 780     { 1280, 1394, 1920 },
 781 };
 782
 783 static const int ac3_bitrates[64] = {
 784     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
 785     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
 786     384, 448, 448, 512, 512, 576, 576, 640, 640,
 787 };
 788
 789 static const int ac3_channels[8] = {
 790     2, 1, 2, 3, 3, 4, 4, 5
 791 };
 792
 793 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 794                     int *bit_rate)
 795 {
 796     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
 797     GetBitContext bits;
 798
 799     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
 800
 801     if(get_bits(&bits, 16) != 0x0b77)
 802         return 0;
 803
 804     get_bits(&bits, 16);    /* crc */
 805     fscod = get_bits(&bits, 2);
 806     frmsizecod = get_bits(&bits, 6);
 807
 808     if(!ac3_sample_rates[fscod])
 809         return 0;
 810
 811     bsid = get_bits(&bits, 5);
 812     if(bsid > 8)
 813         return 0;
 814     get_bits(&bits, 3);     /* bsmod */
 815     acmod = get_bits(&bits, 3);
 816     if(acmod & 1 && acmod != 1)
 817         get_bits(&bits, 2); /* cmixlev */
 818     if(acmod & 4)
 819         get_bits(&bits, 2); /* surmixlev */
 820     if(acmod & 2)
 821         get_bits(&bits, 2); /* dsurmod */
 822     lfeon = get_bits(&bits, 1);
 823
 824     *sample_rate = ac3_sample_rates[fscod];
 825     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
 826     *channels = ac3_channels[acmod] + lfeon;
 827
 828     return ac3_frame_sizes[frmsizecod][fscod] * 2;
 829 }
 830
 831 static int ac3_parse_init(AVCodecParserContext *s1)
 832 {
 833     AC3ParseContext *s = s1->priv_data;
 834     s->inbuf_ptr = s->inbuf;
 835     return 0;
 836 }
 837
 838 static int ac3_parse(AVCodecParserContext *s1,
 839                      AVCodecContext *avctx,
 840                      uint8_t **poutbuf, int *poutbuf_size,
 841                      const uint8_t *buf, int buf_size)
 842 {
 843     AC3ParseContext *s = s1->priv_data;
 844     const uint8_t *buf_ptr;
 845     int len, sample_rate, bit_rate, channels;
 846
 847     *poutbuf = NULL;
 848     *poutbuf_size = 0;
 849
 850     buf_ptr = buf;
 851     while (buf_size > 0) {
 852         len = s->inbuf_ptr - s->inbuf;
 853         if (s->frame_size == 0) {
 854             /* no header seen : find one. We need at least 7 bytes to parse it */
 855             len = FFMIN(AC3_HEADER_SIZE - len, buf_size);
 856
 857             memcpy(s->inbuf_ptr, buf_ptr, len);
 858             buf_ptr += len;
 859             s->inbuf_ptr += len;
 860             buf_size -= len;
 861             if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
 862                 len = ac3_sync(s->inbuf, &channels, &sample_rate, &bit_rate);
 863                 if (len == 0) {
 864                     /* no sync found : move by one byte (inefficient, but simple!) */
 865                     memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
 866                     s->inbuf_ptr--;
 867                 } else {
 868                     s->frame_size = len;
 869                     /* update codec info */
 870                     avctx->sample_rate = sample_rate;
 871                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 872                     if(avctx->channels!=1 && avctx->channels!=2){
 873                         avctx->channels = channels;
 874                     }
 875                     avctx->bit_rate = bit_rate;
 876                     avctx->frame_size = 6 * 256;
 877                 }
 878             }
 879         } else {
 880             len = FFMIN(s->frame_size - len, buf_size);
 881
 882             memcpy(s->inbuf_ptr, buf_ptr, len);
 883             buf_ptr += len;
 884             s->inbuf_ptr += len;
 885             buf_size -= len;
 886
 887             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 888                 *poutbuf = s->inbuf;
 889                 *poutbuf_size = s->frame_size;
 890                 s->inbuf_ptr = s->inbuf;
 891                 s->frame_size = 0;
 892                 break;
 893             }
 894         }
 895     }
 896     return buf_ptr - buf;
 897 }
 898
 899 AVCodecParser mpegvideo_parser = {
 900     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
 901     sizeof(ParseContext1),
 902     NULL,
 903     mpegvideo_parse,
 904     parse1_close,
 905     mpegvideo_split,
 906 };
 907
 908 AVCodecParser mpeg4video_parser = {
 909     { CODEC_ID_MPEG4 },
 910     sizeof(ParseContext1),
 911     mpeg4video_parse_init,
 912     mpeg4video_parse,
 913     parse1_close,
 914     mpeg4video_split,
 915 };
 916
 917 AVCodecParser mpegaudio_parser = {
 918     { CODEC_ID_MP2, CODEC_ID_MP3 },
 919     sizeof(MpegAudioParseContext),
 920     mpegaudio_parse_init,
 921     mpegaudio_parse,
 922     NULL,
 923 };
 924
 925 AVCodecParser ac3_parser = {
 926     { CODEC_ID_AC3 },
 927     sizeof(AC3ParseContext),
 928     ac3_parse_init,
 929     ac3_parse,
 930     NULL,
 931 };