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 /* also used for ADTS AAC */
 731 typedef struct AC3ParseContext {
 732     uint8_t inbuf[4096]; /* input buffer */
 733     uint8_t *inbuf_ptr;
 734     int frame_size;
 735     int header_size;
 736     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
 737                 int *bit_rate, int *samples);
 738 } AC3ParseContext;
 739
 740 #define AC3_HEADER_SIZE 7
 741 #define AAC_HEADER_SIZE 7
 742
 743 static const int ac3_sample_rates[4] = {
 744     48000, 44100, 32000, 0
 745 };
 746
 747 static const int ac3_frame_sizes[64][3] = {
 748     { 64,   69,   96   },
 749     { 64,   70,   96   },
 750     { 80,   87,   120  },
 751     { 80,   88,   120  },
 752     { 96,   104,  144  },
 753     { 96,   105,  144  },
 754     { 112,  121,  168  },
 755     { 112,  122,  168  },
 756     { 128,  139,  192  },
 757     { 128,  140,  192  },
 758     { 160,  174,  240  },
 759     { 160,  175,  240  },
 760     { 192,  208,  288  },
 761     { 192,  209,  288  },
 762     { 224,  243,  336  },
 763     { 224,  244,  336  },
 764     { 256,  278,  384  },
 765     { 256,  279,  384  },
 766     { 320,  348,  480  },
 767     { 320,  349,  480  },
 768     { 384,  417,  576  },
 769     { 384,  418,  576  },
 770     { 448,  487,  672  },
 771     { 448,  488,  672  },
 772     { 512,  557,  768  },
 773     { 512,  558,  768  },
 774     { 640,  696,  960  },
 775     { 640,  697,  960  },
 776     { 768,  835,  1152 },
 777     { 768,  836,  1152 },
 778     { 896,  975,  1344 },
 779     { 896,  976,  1344 },
 780     { 1024, 1114, 1536 },
 781     { 1024, 1115, 1536 },
 782     { 1152, 1253, 1728 },
 783     { 1152, 1254, 1728 },
 784     { 1280, 1393, 1920 },
 785     { 1280, 1394, 1920 },
 786 };
 787
 788 static const int ac3_bitrates[64] = {
 789     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
 790     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
 791     384, 448, 448, 512, 512, 576, 576, 640, 640,
 792 };
 793
 794 static const int ac3_channels[8] = {
 795     2, 1, 2, 3, 3, 4, 4, 5
 796 };
 797
 798 static int aac_sample_rates[16] = {
 799     96000, 88200, 64000, 48000, 44100, 32000,
 800     24000, 22050, 16000, 12000, 11025, 8000, 7350
 801 };
 802
 803 static int aac_channels[8] = {
 804     0, 1, 2, 3, 4, 5, 6, 8
 805 };
 806
 807 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 808                     int *bit_rate, int *samples)
 809 {
 810     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
 811     GetBitContext bits;
 812
 813     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
 814
 815     if(get_bits(&bits, 16) != 0x0b77)
 816         return 0;
 817
 818     skip_bits(&bits, 16);       /* crc */
 819     fscod = get_bits(&bits, 2);
 820     frmsizecod = get_bits(&bits, 6);
 821
 822     if(!ac3_sample_rates[fscod])
 823         return 0;
 824
 825     bsid = get_bits(&bits, 5);
 826     if(bsid > 8)
 827         return 0;
 828     skip_bits(&bits, 3);        /* bsmod */
 829     acmod = get_bits(&bits, 3);
 830     if(acmod & 1 && acmod != 1)
 831         skip_bits(&bits, 2);    /* cmixlev */
 832     if(acmod & 4)
 833         skip_bits(&bits, 2);    /* surmixlev */
 834     if(acmod & 2)
 835         skip_bits(&bits, 2);    /* dsurmod */
 836     lfeon = get_bits1(&bits);
 837
 838     *sample_rate = ac3_sample_rates[fscod];
 839     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
 840     *channels = ac3_channels[acmod] + lfeon;
 841     *samples = 6 * 256;
 842
 843     return ac3_frame_sizes[frmsizecod][fscod] * 2;
 844 }
 845
 846 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 847                     int *bit_rate, int *samples)
 848 {
 849     GetBitContext bits;
 850     int size, rdb, ch, sr;
 851
 852     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 853
 854     if(get_bits(&bits, 12) != 0xfff)
 855         return 0;
 856
 857     skip_bits1(&bits);          /* id */
 858     skip_bits(&bits, 2);        /* layer */
 859     skip_bits1(&bits);          /* protection_absent */
 860     skip_bits(&bits, 2);        /* profile_objecttype */
 861     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 862     if(!aac_sample_rates[sr])
 863         return 0;
 864     skip_bits1(&bits);          /* private_bit */
 865     ch = get_bits(&bits, 3);    /* channel_configuration */
 866     if(!aac_channels[ch])
 867         return 0;
 868     skip_bits1(&bits);          /* original/copy */
 869     skip_bits1(&bits);          /* home */
 870
 871     /* adts_variable_header */
 872     skip_bits1(&bits);          /* copyright_identification_bit */
 873     skip_bits1(&bits);          /* copyright_identification_start */
 874     size = get_bits(&bits, 13); /* aac_frame_length */
 875     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 876     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 877
 878     *channels = aac_channels[ch];
 879     *sample_rate = aac_sample_rates[sr];
 880     *samples = (rdb + 1) * 1024;
 881     *bit_rate = size * 8 * *sample_rate / *samples;
 882
 883     return size;
 884 }
 885
 886 static int ac3_parse_init(AVCodecParserContext *s1)
 887 {
 888     AC3ParseContext *s = s1->priv_data;
 889     s->inbuf_ptr = s->inbuf;
 890     s->header_size = AC3_HEADER_SIZE;
 891     s->sync = ac3_sync;
 892     return 0;
 893 }
 894
 895 static int aac_parse_init(AVCodecParserContext *s1)
 896 {
 897     AC3ParseContext *s = s1->priv_data;
 898     s->inbuf_ptr = s->inbuf;
 899     s->header_size = AAC_HEADER_SIZE;
 900     s->sync = aac_sync;
 901     return 0;
 902 }
 903
 904 /* also used for ADTS AAC */
 905 static int ac3_parse(AVCodecParserContext *s1,
 906                      AVCodecContext *avctx,
 907                      uint8_t **poutbuf, int *poutbuf_size,
 908                      const uint8_t *buf, int buf_size)
 909 {
 910     AC3ParseContext *s = s1->priv_data;
 911     const uint8_t *buf_ptr;
 912     int len, sample_rate, bit_rate, channels, samples;
 913
 914     *poutbuf = NULL;
 915     *poutbuf_size = 0;
 916
 917     buf_ptr = buf;
 918     while (buf_size > 0) {
 919         len = s->inbuf_ptr - s->inbuf;
 920         if (s->frame_size == 0) {
 921             /* no header seen : find one. We need at least s->header_size
 922                bytes to parse it */
 923             len = FFMIN(s->header_size - len, buf_size);
 924
 925             memcpy(s->inbuf_ptr, buf_ptr, len);
 926             buf_ptr += len;
 927             s->inbuf_ptr += len;
 928             buf_size -= len;
 929             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 930                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 931                               &samples);
 932                 if (len == 0) {
 933                     /* no sync found : move by one byte (inefficient, but simple!) */
 934                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 935                     s->inbuf_ptr--;
 936                 } else {
 937                     s->frame_size = len;
 938                     /* update codec info */
 939                     avctx->sample_rate = sample_rate;
 940                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 941                     if(avctx->codec_id == CODEC_ID_AC3){
 942                         if(avctx->channels!=1 && avctx->channels!=2){
 943                             avctx->channels = channels;
 944                         }
 945                     } else {
 946                         avctx->channels = channels;
 947                     }
 948                     avctx->bit_rate = bit_rate;
 949                     avctx->frame_size = samples;
 950                 }
 951             }
 952         } else {
 953             len = FFMIN(s->frame_size - len, buf_size);
 954
 955             memcpy(s->inbuf_ptr, buf_ptr, len);
 956             buf_ptr += len;
 957             s->inbuf_ptr += len;
 958             buf_size -= len;
 959
 960             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 961                 *poutbuf = s->inbuf;
 962                 *poutbuf_size = s->frame_size;
 963                 s->inbuf_ptr = s->inbuf;
 964                 s->frame_size = 0;
 965                 break;
 966             }
 967         }
 968     }
 969     return buf_ptr - buf;
 970 }
 971
 972 AVCodecParser mpegvideo_parser = {
 973     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
 974     sizeof(ParseContext1),
 975     NULL,
 976     mpegvideo_parse,
 977     parse1_close,
 978     mpegvideo_split,
 979 };
 980
 981 AVCodecParser mpeg4video_parser = {
 982     { CODEC_ID_MPEG4 },
 983     sizeof(ParseContext1),
 984     mpeg4video_parse_init,
 985     mpeg4video_parse,
 986     parse1_close,
 987     mpeg4video_split,
 988 };
 989
 990 AVCodecParser mpegaudio_parser = {
 991     { CODEC_ID_MP2, CODEC_ID_MP3 },
 992     sizeof(MpegAudioParseContext),
 993     mpegaudio_parse_init,
 994     mpegaudio_parse,
 995     NULL,
 996 };
 997
 998 AVCodecParser ac3_parser = {
 999     { CODEC_ID_AC3 },
1000     sizeof(AC3ParseContext),
1001     ac3_parse_init,
1002     ac3_parse,
1003     NULL,
1004 };
1005
1006 AVCodecParser aac_parser = {
1007     { CODEC_ID_AAC },
1008     sizeof(AC3ParseContext),
1009     aac_parse_init,
1010     ac3_parse,
1011     NULL,
1012 };