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 file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22 #include "avcodec.h"
  23 #include "mpegvideo.h"
  24 #include "mpegaudio.h"
  25
  26 AVCodecParser *av_first_parser = NULL;
  27
  28 void av_register_codec_parser(AVCodecParser *parser)
  29 {
  30     parser->next = av_first_parser;
  31     av_first_parser = parser;
  32 }
  33
  34 AVCodecParserContext *av_parser_init(int codec_id)
  35 {
  36     AVCodecParserContext *s;
  37     AVCodecParser *parser;
  38     int ret;
  39
  40     if(codec_id == CODEC_ID_NONE)
  41         return NULL;
  42
  43     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  44         if (parser->codec_ids[0] == codec_id ||
  45             parser->codec_ids[1] == codec_id ||
  46             parser->codec_ids[2] == codec_id ||
  47             parser->codec_ids[3] == codec_id ||
  48             parser->codec_ids[4] == codec_id)
  49             goto found;
  50     }
  51     return NULL;
  52  found:
  53     s = av_mallocz(sizeof(AVCodecParserContext));
  54     if (!s)
  55         return NULL;
  56     s->parser = parser;
  57     s->priv_data = av_mallocz(parser->priv_data_size);
  58     if (!s->priv_data) {
  59         av_free(s);
  60         return NULL;
  61     }
  62     if (parser->parser_init) {
  63         ret = parser->parser_init(s);
  64         if (ret != 0) {
  65             av_free(s->priv_data);
  66             av_free(s);
  67             return NULL;
  68         }
  69     }
  70     s->fetch_timestamp=1;
  71     return s;
  72 }
  73
  74 /**
  75  *
  76  * @param buf           input
  77  * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
  78  * @param pts           input presentation timestamp
  79  * @param dts           input decoding timestamp
  80  * @param poutbuf       will contain a pointer to the first byte of the output frame
  81  * @param poutbuf_size  will contain the length of the output frame
  82  * @return the number of bytes of the input bitstream used
  83  *
  84  * Example:
  85  * @code
  86  *   while(in_len){
  87  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
  88  *                                       in_data, in_len,
  89  *                                       pts, dts);
  90  *       in_data += len;
  91  *       in_len  -= len;
  92  *
  93  *       decode_frame(data, size);
  94  *   }
  95  * @endcode
  96  */
  97 int av_parser_parse(AVCodecParserContext *s,
  98                     AVCodecContext *avctx,
  99                     uint8_t **poutbuf, int *poutbuf_size,
 100                     const uint8_t *buf, int buf_size,
 101                     int64_t pts, int64_t dts)
 102 {
 103     int index, i, k;
 104     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 105
 106     if (buf_size == 0) {
 107         /* padding is always necessary even if EOF, so we add it here */
 108         memset(dummy_buf, 0, sizeof(dummy_buf));
 109         buf = dummy_buf;
 110     } else {
 111         /* add a new packet descriptor */
 112         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 113         s->cur_frame_start_index = k;
 114         s->cur_frame_offset[k] = s->cur_offset;
 115         s->cur_frame_pts[k] = pts;
 116         s->cur_frame_dts[k] = dts;
 117
 118         /* fill first PTS/DTS */
 119         if (s->fetch_timestamp){
 120             s->fetch_timestamp=0;
 121             s->last_pts = pts;
 122             s->last_dts = dts;
 123             s->cur_frame_pts[k] =
 124             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
 125         }
 126     }
 127
 128     /* WARNING: the returned index can be negative */
 129     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 130 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
 131     /* update the file pointer */
 132     if (*poutbuf_size) {
 133         /* fill the data for the current frame */
 134         s->frame_offset = s->last_frame_offset;
 135         s->pts = s->last_pts;
 136         s->dts = s->last_dts;
 137
 138         /* offset of the next frame */
 139         s->last_frame_offset = s->cur_offset + index;
 140         /* find the packet in which the new frame starts. It
 141            is tricky because of MPEG video start codes
 142            which can begin in one packet and finish in
 143            another packet. In the worst case, an MPEG
 144            video start code could be in 4 different
 145            packets. */
 146         k = s->cur_frame_start_index;
 147         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 148             if (s->last_frame_offset >= s->cur_frame_offset[k])
 149                 break;
 150             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 151         }
 152
 153         s->last_pts = s->cur_frame_pts[k];
 154         s->last_dts = s->cur_frame_dts[k];
 155
 156         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 157            so the next pts/dts is in the next chunk */
 158         if(index == buf_size){
 159             s->fetch_timestamp=1;
 160         }
 161     }
 162     if (index < 0)
 163         index = 0;
 164     s->cur_offset += index;
 165     return index;
 166 }
 167
 168 /**
 169  *
 170  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 171  * @deprecated use AVBitstreamFilter
 172  */
 173 int av_parser_change(AVCodecParserContext *s,
 174                      AVCodecContext *avctx,
 175                      uint8_t **poutbuf, int *poutbuf_size,
 176                      const uint8_t *buf, int buf_size, int keyframe){
 177
 178     if(s && s->parser->split){
 179         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
 180             int i= s->parser->split(avctx, buf, buf_size);
 181             buf += i;
 182             buf_size -= i;
 183         }
 184     }
 185
 186     /* cast to avoid warning about discarding qualifiers */
 187     *poutbuf= (uint8_t *) buf;
 188     *poutbuf_size= buf_size;
 189     if(avctx->extradata){
 190         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 191             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 192             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 193             int size= buf_size + avctx->extradata_size;
 194             *poutbuf_size= size;
 195             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 196
 197             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 198             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 199             return 1;
 200         }
 201     }
 202
 203     return 0;
 204 }
 205
 206 void av_parser_close(AVCodecParserContext *s)
 207 {
 208     if (s->parser->parser_close)
 209         s->parser->parser_close(s);
 210     av_free(s->priv_data);
 211     av_free(s);
 212 }
 213
 214 /*****************************************************/
 215
 216 //#define END_NOT_FOUND (-100)
 217
 218 #define PICTURE_START_CODE      0x00000100
 219 #define SEQ_START_CODE          0x000001b3
 220 #define EXT_START_CODE          0x000001b5
 221 #define SLICE_MIN_START_CODE    0x00000101
 222 #define SLICE_MAX_START_CODE    0x000001af
 223
 224 typedef struct ParseContext1{
 225     ParseContext pc;
 226 /* XXX/FIXME PC1 vs. PC */
 227     /* MPEG2 specific */
 228     AVRational frame_rate;
 229     int progressive_sequence;
 230     int width, height;
 231
 232     /* XXX: suppress that, needed by MPEG4 */
 233     MpegEncContext *enc;
 234     int first_picture;
 235 } ParseContext1;
 236
 237 /**
 238  * combines the (truncated) bitstream to a complete frame
 239  * @returns -1 if no complete frame could be created
 240  */
 241 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 242 {
 243 #if 0
 244     if(pc->overread){
 245         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 246         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 247     }
 248 #endif
 249
 250     /* copy overreaded bytes from last frame into buffer */
 251     for(; pc->overread>0; pc->overread--){
 252         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 253     }
 254
 255     /* flush remaining if EOF */
 256     if(!*buf_size && next == END_NOT_FOUND){
 257         next= 0;
 258     }
 259
 260     pc->last_index= pc->index;
 261
 262     /* copy into buffer end return */
 263     if(next == END_NOT_FOUND){
 264         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 265
 266         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 267         pc->index += *buf_size;
 268         return -1;
 269     }
 270
 271     *buf_size=
 272     pc->overread_index= pc->index + next;
 273
 274     /* append to buffer */
 275     if(pc->index){
 276         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 277
 278         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 279         pc->index = 0;
 280         *buf= pc->buffer;
 281     }
 282
 283     /* store overread bytes */
 284     for(;next < 0; next++){
 285         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 286         pc->overread++;
 287     }
 288
 289 #if 0
 290     if(pc->overread){
 291         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 292         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 293     }
 294 #endif
 295
 296     return 0;
 297 }
 298
 299 #ifdef CONFIG_MPEGVIDEO_PARSER
 300
 301 extern const AVRational ff_frame_rate_tab[];
 302
 303 //FIXME move into mpeg12.c
 304 static void mpegvideo_extract_headers(AVCodecParserContext *s,
 305                                       AVCodecContext *avctx,
 306                                       const uint8_t *buf, int buf_size)
 307 {
 308     ParseContext1 *pc = s->priv_data;
 309     const uint8_t *buf_end;
 310     uint32_t start_code;
 311     int frame_rate_index, ext_type, bytes_left;
 312     int frame_rate_ext_n, frame_rate_ext_d;
 313     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
 314     int horiz_size_ext, vert_size_ext, bit_rate_ext;
 315 //FIXME replace the crap with get_bits()
 316     s->repeat_pict = 0;
 317     buf_end = buf + buf_size;
 318     while (buf < buf_end) {
 319         start_code= -1;
 320         buf= ff_find_start_code(buf, buf_end, &start_code);
 321         bytes_left = buf_end - buf;
 322         switch(start_code) {
 323         case PICTURE_START_CODE:
 324             if (bytes_left >= 2) {
 325                 s->pict_type = (buf[1] >> 3) & 7;
 326             }
 327             break;
 328         case SEQ_START_CODE:
 329             if (bytes_left >= 7) {
 330                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
 331                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
 332                 avcodec_set_dimensions(avctx, pc->width, pc->height);
 333                 frame_rate_index = buf[3] & 0xf;
 334                 pc->frame_rate.den = avctx->time_base.den = ff_frame_rate_tab[frame_rate_index].num;
 335                 pc->frame_rate.num = avctx->time_base.num = ff_frame_rate_tab[frame_rate_index].den;
 336                 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
 337                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
 338                 avctx->sub_id = 1;
 339             }
 340             break;
 341         case EXT_START_CODE:
 342             if (bytes_left >= 1) {
 343                 ext_type = (buf[0] >> 4);
 344                 switch(ext_type) {
 345                 case 0x1: /* sequence extension */
 346                     if (bytes_left >= 6) {
 347                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
 348                         vert_size_ext = (buf[2] >> 5) & 3;
 349                         bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
 350                         frame_rate_ext_n = (buf[5] >> 5) & 3;
 351                         frame_rate_ext_d = (buf[5] & 0x1f);
 352                         pc->progressive_sequence = buf[1] & (1 << 3);
 353                         avctx->has_b_frames= !(buf[5] >> 7);
 354
 355                         pc->width  |=(horiz_size_ext << 12);
 356                         pc->height |=( vert_size_ext << 12);
 357                         avctx->bit_rate += (bit_rate_ext << 18) * 400;
 358                         avcodec_set_dimensions(avctx, pc->width, pc->height);
 359                         avctx->time_base.den = pc->frame_rate.den * (frame_rate_ext_n + 1);
 360                         avctx->time_base.num = pc->frame_rate.num * (frame_rate_ext_d + 1);
 361                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
 362                         avctx->sub_id = 2; /* forces MPEG2 */
 363                     }
 364                     break;
 365                 case 0x8: /* picture coding extension */
 366                     if (bytes_left >= 5) {
 367                         picture_structure = buf[2]&3;
 368                         top_field_first = buf[3] & (1 << 7);
 369                         repeat_first_field = buf[3] & (1 << 1);
 370                         progressive_frame = buf[4] & (1 << 7);
 371
 372                         /* check if we must repeat the frame */
 373                         if (repeat_first_field) {
 374                             if (pc->progressive_sequence) {
 375                                 if (top_field_first)
 376                                     s->repeat_pict = 4;
 377                                 else
 378                                     s->repeat_pict = 2;
 379                             } else if (progressive_frame) {
 380                                 s->repeat_pict = 1;
 381                             }
 382                         }
 383
 384                         /* the packet only represents half a frame
 385                            XXX,FIXME maybe find a different solution */
 386                         if(picture_structure != 3)
 387                             s->repeat_pict = -1;
 388                     }
 389                     break;
 390                 }
 391             }
 392             break;
 393         case -1:
 394             goto the_end;
 395         default:
 396             /* we stop parsing when we encounter a slice. It ensures
 397                that this function takes a negligible amount of time */
 398             if (start_code >= SLICE_MIN_START_CODE &&
 399                 start_code <= SLICE_MAX_START_CODE)
 400                 goto the_end;
 401             break;
 402         }
 403     }
 404  the_end: ;
 405 }
 406
 407 static int mpegvideo_parse(AVCodecParserContext *s,
 408                            AVCodecContext *avctx,
 409                            uint8_t **poutbuf, int *poutbuf_size,
 410                            const uint8_t *buf, int buf_size)
 411 {
 412     ParseContext1 *pc1 = s->priv_data;
 413     ParseContext *pc= &pc1->pc;
 414     int next;
 415
 416     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 417         next= buf_size;
 418     }else{
 419         next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
 420
 421         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 422             *poutbuf = NULL;
 423             *poutbuf_size = 0;
 424             return buf_size;
 425         }
 426
 427     }
 428     /* we have a full frame : we just parse the first few MPEG headers
 429        to have the full timing information. The time take by this
 430        function should be negligible for uncorrupted streams */
 431     mpegvideo_extract_headers(s, avctx, buf, buf_size);
 432 #if 0
 433     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
 434            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
 435 #endif
 436
 437     *poutbuf = (uint8_t *)buf;
 438     *poutbuf_size = buf_size;
 439     return next;
 440 }
 441
 442 static int mpegvideo_split(AVCodecContext *avctx,
 443                            const uint8_t *buf, int buf_size)
 444 {
 445     int i;
 446     uint32_t state= -1;
 447
 448     for(i=0; i<buf_size; i++){
 449         state= (state<<8) | buf[i];
 450         if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
 451             return i-3;
 452     }
 453     return 0;
 454 }
 455 #endif /* CONFIG_MPEGVIDEO_PARSER */
 456
 457 void ff_parse_close(AVCodecParserContext *s)
 458 {
 459     ParseContext *pc = s->priv_data;
 460
 461     av_free(pc->buffer);
 462 }
 463
 464 static void parse1_close(AVCodecParserContext *s)
 465 {
 466     ParseContext1 *pc1 = s->priv_data;
 467
 468     av_free(pc1->pc.buffer);
 469     av_free(pc1->enc);
 470 }
 471
 472 /*************************/
 473
 474 #ifdef CONFIG_MPEG4VIDEO_PARSER
 475 /* used by parser */
 476 /* XXX: make it use less memory */
 477 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 478                                   AVCodecContext *avctx,
 479                                   const uint8_t *buf, int buf_size)
 480 {
 481     ParseContext1 *pc = s1->priv_data;
 482     MpegEncContext *s = pc->enc;
 483     GetBitContext gb1, *gb = &gb1;
 484     int ret;
 485
 486     s->avctx = avctx;
 487     s->current_picture_ptr = &s->current_picture;
 488
 489     if (avctx->extradata_size && pc->first_picture){
 490         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 491         ret = ff_mpeg4_decode_picture_header(s, gb);
 492     }
 493
 494     init_get_bits(gb, buf, 8 * buf_size);
 495     ret = ff_mpeg4_decode_picture_header(s, gb);
 496     if (s->width) {
 497         avcodec_set_dimensions(avctx, s->width, s->height);
 498     }
 499     s1->pict_type= s->pict_type;
 500     pc->first_picture = 0;
 501     return ret;
 502 }
 503
 504 static int mpeg4video_parse_init(AVCodecParserContext *s)
 505 {
 506     ParseContext1 *pc = s->priv_data;
 507
 508     pc->enc = av_mallocz(sizeof(MpegEncContext));
 509     if (!pc->enc)
 510         return -1;
 511     pc->first_picture = 1;
 512     return 0;
 513 }
 514
 515 static int mpeg4video_parse(AVCodecParserContext *s,
 516                            AVCodecContext *avctx,
 517                            uint8_t **poutbuf, int *poutbuf_size,
 518                            const uint8_t *buf, int buf_size)
 519 {
 520     ParseContext *pc = s->priv_data;
 521     int next;
 522
 523     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 524         next= buf_size;
 525     }else{
 526         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 527
 528         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 529             *poutbuf = NULL;
 530             *poutbuf_size = 0;
 531             return buf_size;
 532         }
 533     }
 534     av_mpeg4_decode_header(s, avctx, buf, buf_size);
 535
 536     *poutbuf = (uint8_t *)buf;
 537     *poutbuf_size = buf_size;
 538     return next;
 539 }
 540 #endif
 541
 542 #ifdef CONFIG_CAVSVIDEO_PARSER
 543 static int cavsvideo_parse(AVCodecParserContext *s,
 544                            AVCodecContext *avctx,
 545                            uint8_t **poutbuf, int *poutbuf_size,
 546                            const uint8_t *buf, int buf_size)
 547 {
 548     ParseContext *pc = s->priv_data;
 549     int next;
 550
 551     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 552         next= buf_size;
 553     }else{
 554         next= ff_cavs_find_frame_end(pc, buf, buf_size);
 555
 556         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 557             *poutbuf = NULL;
 558             *poutbuf_size = 0;
 559             return buf_size;
 560         }
 561     }
 562     *poutbuf = (uint8_t *)buf;
 563     *poutbuf_size = buf_size;
 564     return next;
 565 }
 566 #endif /* CONFIG_CAVSVIDEO_PARSER */
 567
 568 static int mpeg4video_split(AVCodecContext *avctx,
 569                            const uint8_t *buf, int buf_size)
 570 {
 571     int i;
 572     uint32_t state= -1;
 573
 574     for(i=0; i<buf_size; i++){
 575         state= (state<<8) | buf[i];
 576         if(state == 0x1B3 || state == 0x1B6)
 577             return i-3;
 578     }
 579     return 0;
 580 }
 581
 582 /*************************/
 583
 584 #ifdef CONFIG_MPEGAUDIO_PARSER
 585 typedef struct MpegAudioParseContext {
 586     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 587     uint8_t *inbuf_ptr;
 588     int frame_size;
 589     int free_format_frame_size;
 590     int free_format_next_header;
 591     uint32_t header;
 592     int header_count;
 593 } MpegAudioParseContext;
 594
 595 #define MPA_HEADER_SIZE 4
 596
 597 /* header + layer + bitrate + freq + lsf/mpeg25 */
 598 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 599 #define SAME_HEADER_MASK \
 600    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 601
 602 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 603 {
 604     MpegAudioParseContext *s = s1->priv_data;
 605     s->inbuf_ptr = s->inbuf;
 606     return 0;
 607 }
 608
 609 static int mpegaudio_parse(AVCodecParserContext *s1,
 610                            AVCodecContext *avctx,
 611                            uint8_t **poutbuf, int *poutbuf_size,
 612                            const uint8_t *buf, int buf_size)
 613 {
 614     MpegAudioParseContext *s = s1->priv_data;
 615     int len, ret, sr;
 616     uint32_t header;
 617     const uint8_t *buf_ptr;
 618
 619     *poutbuf = NULL;
 620     *poutbuf_size = 0;
 621     buf_ptr = buf;
 622     while (buf_size > 0) {
 623         len = s->inbuf_ptr - s->inbuf;
 624         if (s->frame_size == 0) {
 625             /* special case for next header for first frame in free
 626                format case (XXX: find a simpler method) */
 627             if (s->free_format_next_header != 0) {
 628                 s->inbuf[0] = s->free_format_next_header >> 24;
 629                 s->inbuf[1] = s->free_format_next_header >> 16;
 630                 s->inbuf[2] = s->free_format_next_header >> 8;
 631                 s->inbuf[3] = s->free_format_next_header;
 632                 s->inbuf_ptr = s->inbuf + 4;
 633                 s->free_format_next_header = 0;
 634                 goto got_header;
 635             }
 636             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 637                bytes to parse it */
 638             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
 639             if (len > 0) {
 640                 memcpy(s->inbuf_ptr, buf_ptr, len);
 641                 buf_ptr += len;
 642                 buf_size -= len;
 643                 s->inbuf_ptr += len;
 644             }
 645             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 646             got_header:
 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, &sr);
 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 > 1)
 675                     avctx->sample_rate= sr;
 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