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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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     *poutbuf= buf;
 163     *poutbuf_size= buf_size;
 164     if(avctx->extradata){
 165         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 166             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 167             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 168             int size= buf_size + avctx->extradata_size;
 169             *poutbuf_size= size;
 170             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 171
 172             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 173             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 174             return 1;
 175         }
 176     }
 177
 178     return 0;
 179 }
 180
 181 void av_parser_close(AVCodecParserContext *s)
 182 {
 183     if (s->parser->parser_close)
 184         s->parser->parser_close(s);
 185     av_free(s->priv_data);
 186     av_free(s);
 187 }
 188
 189 /*****************************************************/
 190
 191 //#define END_NOT_FOUND (-100)
 192
 193 #define PICTURE_START_CODE      0x00000100
 194 #define SEQ_START_CODE          0x000001b3
 195 #define EXT_START_CODE          0x000001b5
 196 #define SLICE_MIN_START_CODE    0x00000101
 197 #define SLICE_MAX_START_CODE    0x000001af
 198
 199 typedef struct ParseContext1{
 200     ParseContext pc;
 201 /* XXX/FIXME PC1 vs. PC */
 202     /* MPEG2 specific */
 203     int frame_rate;
 204     int progressive_sequence;
 205     int width, height;
 206
 207     /* XXX: suppress that, needed by MPEG4 */
 208     MpegEncContext *enc;
 209     int first_picture;
 210 } ParseContext1;
 211
 212 /**
 213  * combines the (truncated) bitstream to a complete frame
 214  * @returns -1 if no complete frame could be created
 215  */
 216 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 217 {
 218 #if 0
 219     if(pc->overread){
 220         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 221         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 222     }
 223 #endif
 224
 225     /* copy overreaded bytes from last frame into buffer */
 226     for(; pc->overread>0; pc->overread--){
 227         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 228     }
 229
 230     /* flush remaining if EOF */
 231     if(!*buf_size && next == END_NOT_FOUND){
 232         next= 0;
 233     }
 234
 235     pc->last_index= pc->index;
 236
 237     /* copy into buffer end return */
 238     if(next == END_NOT_FOUND){
 239         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 240
 241         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 242         pc->index += *buf_size;
 243         return -1;
 244     }
 245
 246     *buf_size=
 247     pc->overread_index= pc->index + next;
 248
 249     /* append to buffer */
 250     if(pc->index){
 251         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 252
 253         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 254         pc->index = 0;
 255         *buf= pc->buffer;
 256     }
 257
 258     /* store overread bytes */
 259     for(;next < 0; next++){
 260         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 261         pc->overread++;
 262     }
 263
 264 #if 0
 265     if(pc->overread){
 266         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 267         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 268     }
 269 #endif
 270
 271     return 0;
 272 }
 273
 274 static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
 275 {
 276     const uint8_t *buf_ptr;
 277     unsigned int state=0xFFFFFFFF, v;
 278     int val;
 279
 280     buf_ptr = *pbuf_ptr;
 281     while (buf_ptr < buf_end) {
 282         v = *buf_ptr++;
 283         if (state == 0x000001) {
 284             state = ((state << 8) | v) & 0xffffff;
 285             val = state;
 286             goto found;
 287         }
 288         state = ((state << 8) | v) & 0xffffff;
 289     }
 290     val = -1;
 291  found:
 292     *pbuf_ptr = buf_ptr;
 293     return val;
 294 }
 295
 296 /* XXX: merge with libavcodec ? */
 297 #define MPEG1_FRAME_RATE_BASE 1001
 298
 299 static const int frame_rate_tab[16] = {
 300         0,
 301     24000,
 302     24024,
 303     25025,
 304     30000,
 305     30030,
 306     50050,
 307     60000,
 308     60060,
 309   // Xing's 15fps: (9)
 310     15015,
 311   // libmpeg3's "Unofficial economy rates": (10-13)
 312      5005,
 313     10010,
 314     12012,
 315     15015,
 316   // random, just to avoid segfault !never encode these
 317     25025,
 318     25025,
 319 };
 320
 321 //FIXME move into mpeg12.c
 322 static void mpegvideo_extract_headers(AVCodecParserContext *s,
 323                                       AVCodecContext *avctx,
 324                                       const uint8_t *buf, int buf_size)
 325 {
 326     ParseContext1 *pc = s->priv_data;
 327     const uint8_t *buf_end;
 328     int32_t start_code;
 329     int frame_rate_index, ext_type, bytes_left;
 330     int frame_rate_ext_n, frame_rate_ext_d;
 331     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
 332     int horiz_size_ext, vert_size_ext, bit_rate_ext;
 333 //FIXME replace the crap with get_bits()
 334     s->repeat_pict = 0;
 335     buf_end = buf + buf_size;
 336     while (buf < buf_end) {
 337         start_code = find_start_code(&buf, buf_end);
 338         bytes_left = buf_end - buf;
 339         switch(start_code) {
 340         case PICTURE_START_CODE:
 341             if (bytes_left >= 2) {
 342                 s->pict_type = (buf[1] >> 3) & 7;
 343             }
 344             break;
 345         case SEQ_START_CODE:
 346             if (bytes_left >= 7) {
 347                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
 348                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
 349                 avcodec_set_dimensions(avctx, pc->width, pc->height);
 350                 frame_rate_index = buf[3] & 0xf;
 351                 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
 352                 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
 353                 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
 354                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
 355                 avctx->sub_id = 1;
 356             }
 357             break;
 358         case EXT_START_CODE:
 359             if (bytes_left >= 1) {
 360                 ext_type = (buf[0] >> 4);
 361                 switch(ext_type) {
 362                 case 0x1: /* sequence extension */
 363                     if (bytes_left >= 6) {
 364                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
 365                         vert_size_ext = (buf[2] >> 5) & 3;
 366                         bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
 367                         frame_rate_ext_n = (buf[5] >> 5) & 3;
 368                         frame_rate_ext_d = (buf[5] & 0x1f);
 369                         pc->progressive_sequence = buf[1] & (1 << 3);
 370                         avctx->has_b_frames= !(buf[5] >> 7);
 371
 372                         pc->width  |=(horiz_size_ext << 12);
 373                         pc->height |=( vert_size_ext << 12);
 374                         avctx->bit_rate += (bit_rate_ext << 18) * 400;
 375                         avcodec_set_dimensions(avctx, pc->width, pc->height);
 376                         avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
 377                         avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
 378                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
 379                         avctx->sub_id = 2; /* forces MPEG2 */
 380                     }
 381                     break;
 382                 case 0x8: /* picture coding extension */
 383                     if (bytes_left >= 5) {
 384                         picture_structure = buf[2]&3;
 385                         top_field_first = buf[3] & (1 << 7);
 386                         repeat_first_field = buf[3] & (1 << 1);
 387                         progressive_frame = buf[4] & (1 << 7);
 388
 389                         /* check if we must repeat the frame */
 390                         if (repeat_first_field) {
 391                             if (pc->progressive_sequence) {
 392                                 if (top_field_first)
 393                                     s->repeat_pict = 4;
 394                                 else
 395                                     s->repeat_pict = 2;
 396                             } else if (progressive_frame) {
 397                                 s->repeat_pict = 1;
 398                             }
 399                         }
 400
 401                         /* the packet only represents half a frame
 402                            XXX,FIXME maybe find a different solution */
 403                         if(picture_structure != 3)
 404                             s->repeat_pict = -1;
 405                     }
 406                     break;
 407                 }
 408             }
 409             break;
 410         case -1:
 411             goto the_end;
 412         default:
 413             /* we stop parsing when we encounter a slice. It ensures
 414                that this function takes a negligible amount of time */
 415             if (start_code >= SLICE_MIN_START_CODE &&
 416                 start_code <= SLICE_MAX_START_CODE)
 417                 goto the_end;
 418             break;
 419         }
 420     }
 421  the_end: ;
 422 }
 423
 424 static int mpegvideo_parse(AVCodecParserContext *s,
 425                            AVCodecContext *avctx,
 426                            uint8_t **poutbuf, int *poutbuf_size,
 427                            const uint8_t *buf, int buf_size)
 428 {
 429     ParseContext1 *pc1 = s->priv_data;
 430     ParseContext *pc= &pc1->pc;
 431     int next;
 432
 433     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 434         next= buf_size;
 435     }else{
 436         next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
 437
 438         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 439             *poutbuf = NULL;
 440             *poutbuf_size = 0;
 441             return buf_size;
 442         }
 443
 444     }
 445     /* we have a full frame : we just parse the first few MPEG headers
 446        to have the full timing information. The time take by this
 447        function should be negligible for uncorrupted streams */
 448     mpegvideo_extract_headers(s, avctx, buf, buf_size);
 449 #if 0
 450     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
 451            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
 452 #endif
 453
 454     *poutbuf = (uint8_t *)buf;
 455     *poutbuf_size = buf_size;
 456     return next;
 457 }
 458
 459 static int mpegvideo_split(AVCodecContext *avctx,
 460                            const uint8_t *buf, int buf_size)
 461 {
 462     int i;
 463     uint32_t state= -1;
 464
 465     for(i=0; i<buf_size; i++){
 466         state= (state<<8) | buf[i];
 467         if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
 468             return i-3;
 469     }
 470     return 0;
 471 }
 472
 473 void ff_parse_close(AVCodecParserContext *s)
 474 {
 475     ParseContext *pc = s->priv_data;
 476
 477     av_free(pc->buffer);
 478 }
 479
 480 static void parse1_close(AVCodecParserContext *s)
 481 {
 482     ParseContext1 *pc1 = s->priv_data;
 483
 484     av_free(pc1->pc.buffer);
 485     av_free(pc1->enc);
 486 }
 487
 488 /*************************/
 489
 490 /* used by parser */
 491 /* XXX: make it use less memory */
 492 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 493                                   AVCodecContext *avctx,
 494                                   const uint8_t *buf, int buf_size)
 495 {
 496     ParseContext1 *pc = s1->priv_data;
 497     MpegEncContext *s = pc->enc;
 498     GetBitContext gb1, *gb = &gb1;
 499     int ret;
 500
 501     s->avctx = avctx;
 502     s->current_picture_ptr = &s->current_picture;
 503
 504     if (avctx->extradata_size && pc->first_picture){
 505         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 506         ret = ff_mpeg4_decode_picture_header(s, gb);
 507     }
 508
 509     init_get_bits(gb, buf, 8 * buf_size);
 510     ret = ff_mpeg4_decode_picture_header(s, gb);
 511     if (s->width) {
 512         avcodec_set_dimensions(avctx, s->width, s->height);
 513     }
 514     s1->pict_type= s->pict_type;
 515     pc->first_picture = 0;
 516     return ret;
 517 }
 518
 519 static int mpeg4video_parse_init(AVCodecParserContext *s)
 520 {
 521     ParseContext1 *pc = s->priv_data;
 522
 523     pc->enc = av_mallocz(sizeof(MpegEncContext));
 524     if (!pc->enc)
 525         return -1;
 526     pc->first_picture = 1;
 527     return 0;
 528 }
 529
 530 static int mpeg4video_parse(AVCodecParserContext *s,
 531                            AVCodecContext *avctx,
 532                            uint8_t **poutbuf, int *poutbuf_size,
 533                            const uint8_t *buf, int buf_size)
 534 {
 535     ParseContext *pc = s->priv_data;
 536     int next;
 537
 538     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 539         next= buf_size;
 540     }else{
 541         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 542
 543         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 544             *poutbuf = NULL;
 545             *poutbuf_size = 0;
 546             return buf_size;
 547         }
 548     }
 549     av_mpeg4_decode_header(s, avctx, buf, buf_size);
 550
 551     *poutbuf = (uint8_t *)buf;
 552     *poutbuf_size = buf_size;
 553     return next;
 554 }
 555
 556 static int mpeg4video_split(AVCodecContext *avctx,
 557                            const uint8_t *buf, int buf_size)
 558 {
 559     int i;
 560     uint32_t state= -1;
 561
 562     for(i=0; i<buf_size; i++){
 563         state= (state<<8) | buf[i];
 564         if(state == 0x1B3 || state == 0x1B6)
 565             return i-3;
 566     }
 567     return 0;
 568 }
 569
 570 /*************************/
 571
 572 typedef struct MpegAudioParseContext {
 573     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 574     uint8_t *inbuf_ptr;
 575     int frame_size;
 576     int free_format_frame_size;
 577     int free_format_next_header;
 578     uint32_t header;
 579     int header_count;
 580 } MpegAudioParseContext;
 581
 582 #define MPA_HEADER_SIZE 4
 583
 584 /* header + layer + bitrate + freq + lsf/mpeg25 */
 585 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 586 #define SAME_HEADER_MASK \
 587    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 588
 589 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 590 {
 591     MpegAudioParseContext *s = s1->priv_data;
 592     s->inbuf_ptr = s->inbuf;
 593     return 0;
 594 }
 595
 596 static int mpegaudio_parse(AVCodecParserContext *s1,
 597                            AVCodecContext *avctx,
 598                            uint8_t **poutbuf, int *poutbuf_size,
 599                            const uint8_t *buf, int buf_size)
 600 {
 601     MpegAudioParseContext *s = s1->priv_data;
 602     int len, ret, sr;
 603     uint32_t header;
 604     const uint8_t *buf_ptr;
 605
 606     *poutbuf = NULL;
 607     *poutbuf_size = 0;
 608     buf_ptr = buf;
 609     while (buf_size > 0) {
 610         len = s->inbuf_ptr - s->inbuf;
 611         if (s->frame_size == 0) {
 612             /* special case for next header for first frame in free
 613                format case (XXX: find a simpler method) */
 614             if (s->free_format_next_header != 0) {
 615                 s->inbuf[0] = s->free_format_next_header >> 24;
 616                 s->inbuf[1] = s->free_format_next_header >> 16;
 617                 s->inbuf[2] = s->free_format_next_header >> 8;
 618                 s->inbuf[3] = s->free_format_next_header;
 619                 s->inbuf_ptr = s->inbuf + 4;
 620                 s->free_format_next_header = 0;
 621                 goto got_header;
 622             }
 623             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 624                bytes to parse it */
 625             len = MPA_HEADER_SIZE - len;
 626             if (len > buf_size)
 627                 len = buf_size;
 628             if (len > 0) {
 629                 memcpy(s->inbuf_ptr, buf_ptr, len);
 630                 buf_ptr += len;
 631                 buf_size -= len;
 632                 s->inbuf_ptr += len;
 633             }
 634             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 635             got_header:
 636                 sr= avctx->sample_rate;
 637                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 638                     (s->inbuf[2] << 8) | s->inbuf[3];
 639
 640                 ret = mpa_decode_header(avctx, header);
 641                 if (ret < 0) {
 642                     s->header_count= -2;
 643                     /* no sync found : move by one byte (inefficient, but simple!) */
 644                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 645                     s->inbuf_ptr--;
 646                     dprintf("skip %x\n", header);
 647                     /* reset free format frame size to give a chance
 648                        to get a new bitrate */
 649                     s->free_format_frame_size = 0;
 650                 } else {
 651                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
 652                         s->header_count= -3;
 653                     s->header= header;
 654                     s->header_count++;
 655                     s->frame_size = ret;
 656
 657 #if 0
 658                     /* free format: prepare to compute frame size */
 659                     if (decode_header(s, header) == 1) {
 660                         s->frame_size = -1;
 661                     }
 662 #endif
 663                 }
 664                 if(s->header_count <= 0)
 665                     avctx->sample_rate= sr; //FIXME ugly
 666             }
 667         } else
 668 #if 0
 669         if (s->frame_size == -1) {
 670             /* free format : find next sync to compute frame size */
 671             len = MPA_MAX_CODED_FRAME_SIZE - len;
 672             if (len > buf_size)
 673                 len = buf_size;
 674             if (len == 0) {
 675                 /* frame too long: resync */
 676                 s->frame_size = 0;
 677                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 678                 s->inbuf_ptr--;
 679             } else {
 680                 uint8_t *p, *pend;
 681                 uint32_t header1;
 682                 int padding;
 683
 684                 memcpy(s->inbuf_ptr, buf_ptr, len);
 685                 /* check for header */
 686                 p = s->inbuf_ptr - 3;
 687                 pend = s->inbuf_ptr + len - 4;
 688                 while (p <= pend) {
 689                     header = (p[0] << 24) | (p[1] << 16) |
 690                         (p[2] << 8) | p[3];
 691                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 692                         (s->inbuf[2] << 8) | s->inbuf[3];
 693                     /* check with high probability that we have a
 694                        valid header */
 695                     if ((header & SAME_HEADER_MASK) ==
 696                         (header1 & SAME_HEADER_MASK)) {
 697                         /* header found: update pointers */
 698                         len = (p + 4) - s->inbuf_ptr;
 699                         buf_ptr += len;
 700                         buf_size -= len;
 701                         s->inbuf_ptr = p;
 702                         /* compute frame size */
 703                         s->free_format_next_header = header;
 704                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 705                         padding = (header1 >> 9) & 1;
 706                         if (s->layer == 1)
 707                             s->free_format_frame_size -= padding * 4;
 708                         else
 709                             s->free_format_frame_size -= padding;
 710                         dprintf("free frame size=%d padding=%d\n",
 711                                 s->free_format_frame_size, padding);
 712                         decode_header(s, header1);
 713                         goto next_data;
 714                     }
 715                     p++;
 716                 }
 717                 /* not found: simply increase pointers */
 718                 buf_ptr += len;
 719                 s->inbuf_ptr += len;
 720                 buf_size -= len;
 721             }
 722         } else
 723 #endif
 724         if (len < s->frame_size) {
 725             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 726                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 727             len = s->frame_size - len;
 728             if (len > buf_size)
 729                 len = buf_size;
 730             memcpy(s->inbuf_ptr, buf_ptr, len);
 731             buf_ptr += len;
 732             s->inbuf_ptr += len;
 733             buf_size -= len;
 734         }
 735         //    next_data:
 736         if (s->frame_size > 0 &&
 737             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 738             if(s->header_count > 0){
 739                 *poutbuf = s->inbuf;
 740                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
 741             }
 742             s->inbuf_ptr = s->inbuf;
 743             s->frame_size = 0;
 744             break;
 745         }
 746     }
 747     return buf_ptr - buf;
 748 }
 749
 750 #ifdef CONFIG_AC3
 751 extern int a52_syncinfo (const uint8_t * buf, int * flags,
 752                          int * sample_rate, int * bit_rate);
 753
 754 typedef struct AC3ParseContext {
 755     uint8_t inbuf[4096]; /* input buffer */
 756     uint8_t *inbuf_ptr;
 757     int frame_size;
 758     int flags;
 759 } AC3ParseContext;
 760
 761 #define AC3_HEADER_SIZE 7
 762 #define A52_LFE 16
 763
 764 static int ac3_parse_init(AVCodecParserContext *s1)
 765 {
 766     AC3ParseContext *s = s1->priv_data;
 767     s->inbuf_ptr = s->inbuf;
 768     return 0;
 769 }
 770
 771 static int ac3_parse(AVCodecParserContext *s1,
 772                      AVCodecContext *avctx,
 773                      uint8_t **poutbuf, int *poutbuf_size,
 774                      const uint8_t *buf, int buf_size)
 775 {
 776     AC3ParseContext *s = s1->priv_data;
 777     const uint8_t *buf_ptr;
 778     int len, sample_rate, bit_rate;
 779     static const int ac3_channels[8] = {
 780         2, 1, 2, 3, 3, 4, 4, 5
 781     };
 782
 783     *poutbuf = NULL;
 784     *poutbuf_size = 0;
 785
 786     buf_ptr = buf;
 787     while (buf_size > 0) {
 788         len = s->inbuf_ptr - s->inbuf;
 789         if (s->frame_size == 0) {
 790             /* no header seen : find one. We need at least 7 bytes to parse it */
 791             len = AC3_HEADER_SIZE - len;
 792             if (len > buf_size)
 793                 len = buf_size;
 794             memcpy(s->inbuf_ptr, buf_ptr, len);
 795             buf_ptr += len;
 796             s->inbuf_ptr += len;
 797             buf_size -= len;
 798             if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
 799                 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
 800                 if (len == 0) {
 801                     /* no sync found : move by one byte (inefficient, but simple!) */
 802                     memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
 803                     s->inbuf_ptr--;
 804                 } else {
 805                     s->frame_size = len;
 806                     /* update codec info */
 807                     avctx->sample_rate = sample_rate;
 808                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 809                     if(avctx->channels!=1 && avctx->channels!=2){
 810                         avctx->channels = ac3_channels[s->flags & 7];
 811                         if (s->flags & A52_LFE)
 812                             avctx->channels++;
 813                     }
 814                     avctx->bit_rate = bit_rate;
 815                     avctx->frame_size = 6 * 256;
 816                 }
 817             }
 818         } else if (len < s->frame_size) {
 819             len = s->frame_size - len;
 820             if (len > buf_size)
 821                 len = buf_size;
 822
 823             memcpy(s->inbuf_ptr, buf_ptr, len);
 824             buf_ptr += len;
 825             s->inbuf_ptr += len;
 826             buf_size -= len;
 827         } else {
 828             *poutbuf = s->inbuf;
 829             *poutbuf_size = s->frame_size;
 830             s->inbuf_ptr = s->inbuf;
 831             s->frame_size = 0;
 832             break;
 833         }
 834     }
 835     return buf_ptr - buf;
 836 }
 837 #endif
 838
 839 AVCodecParser mpegvideo_parser = {
 840     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
 841     sizeof(ParseContext1),
 842     NULL,
 843     mpegvideo_parse,
 844     parse1_close,
 845     mpegvideo_split,
 846 };
 847
 848 AVCodecParser mpeg4video_parser = {
 849     { CODEC_ID_MPEG4 },
 850     sizeof(ParseContext1),
 851     mpeg4video_parse_init,
 852     mpeg4video_parse,
 853     parse1_close,
 854     mpeg4video_split,
 855 };
 856
 857 AVCodecParser mpegaudio_parser = {
 858     { CODEC_ID_MP2, CODEC_ID_MP3 },
 859     sizeof(MpegAudioParseContext),
 860     mpegaudio_parse_init,
 861     mpegaudio_parse,
 862     NULL,
 863 };
 864
 865 #ifdef CONFIG_AC3
 866 AVCodecParser ac3_parser = {
 867     { CODEC_ID_AC3 },
 868     sizeof(AC3ParseContext),
 869     ac3_parse_init,
 870     ac3_parse,
 871     NULL,
 872 };
 873 #endif