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