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