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 #include "ac3.h"
  26 #include "parser.h"
  27
  28 AVCodecParser *av_first_parser = NULL;
  29
  30 void av_register_codec_parser(AVCodecParser *parser)
  31 {
  32     parser->next = av_first_parser;
  33     av_first_parser = parser;
  34 }
  35
  36 AVCodecParserContext *av_parser_init(int codec_id)
  37 {
  38     AVCodecParserContext *s;
  39     AVCodecParser *parser;
  40     int ret;
  41
  42     if(codec_id == CODEC_ID_NONE)
  43         return NULL;
  44
  45     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  46         if (parser->codec_ids[0] == codec_id ||
  47             parser->codec_ids[1] == codec_id ||
  48             parser->codec_ids[2] == codec_id ||
  49             parser->codec_ids[3] == codec_id ||
  50             parser->codec_ids[4] == codec_id)
  51             goto found;
  52     }
  53     return NULL;
  54  found:
  55     s = av_mallocz(sizeof(AVCodecParserContext));
  56     if (!s)
  57         return NULL;
  58     s->parser = parser;
  59     s->priv_data = av_mallocz(parser->priv_data_size);
  60     if (!s->priv_data) {
  61         av_free(s);
  62         return NULL;
  63     }
  64     if (parser->parser_init) {
  65         ret = parser->parser_init(s);
  66         if (ret != 0) {
  67             av_free(s->priv_data);
  68             av_free(s);
  69             return NULL;
  70         }
  71     }
  72     s->fetch_timestamp=1;
  73     return s;
  74 }
  75
  76 /**
  77  *
  78  * @param buf           input
  79  * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
  80  * @param pts           input presentation timestamp
  81  * @param dts           input decoding timestamp
  82  * @param poutbuf       will contain a pointer to the first byte of the output frame
  83  * @param poutbuf_size  will contain the length of the output frame
  84  * @return the number of bytes of the input bitstream used
  85  *
  86  * Example:
  87  * @code
  88  *   while(in_len){
  89  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
  90  *                                       in_data, in_len,
  91  *                                       pts, dts);
  92  *       in_data += len;
  93  *       in_len  -= len;
  94  *
  95  *       if(size)
  96  *          decode_frame(data, size);
  97  *   }
  98  * @endcode
  99  */
 100 int av_parser_parse(AVCodecParserContext *s,
 101                     AVCodecContext *avctx,
 102                     uint8_t **poutbuf, int *poutbuf_size,
 103                     const uint8_t *buf, int buf_size,
 104                     int64_t pts, int64_t dts)
 105 {
 106     int index, i, k;
 107     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 108
 109     if (buf_size == 0) {
 110         /* padding is always necessary even if EOF, so we add it here */
 111         memset(dummy_buf, 0, sizeof(dummy_buf));
 112         buf = dummy_buf;
 113     } else {
 114         /* add a new packet descriptor */
 115         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 116         s->cur_frame_start_index = k;
 117         s->cur_frame_offset[k] = s->cur_offset;
 118         s->cur_frame_pts[k] = pts;
 119         s->cur_frame_dts[k] = dts;
 120
 121         /* fill first PTS/DTS */
 122         if (s->fetch_timestamp){
 123             s->fetch_timestamp=0;
 124             s->last_pts = pts;
 125             s->last_dts = dts;
 126             s->cur_frame_pts[k] =
 127             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
 128         }
 129     }
 130
 131     /* WARNING: the returned index can be negative */
 132     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 133 //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);
 134     /* update the file pointer */
 135     if (*poutbuf_size) {
 136         /* fill the data for the current frame */
 137         s->frame_offset = s->last_frame_offset;
 138         s->pts = s->last_pts;
 139         s->dts = s->last_dts;
 140
 141         /* offset of the next frame */
 142         s->last_frame_offset = s->cur_offset + index;
 143         /* find the packet in which the new frame starts. It
 144            is tricky because of MPEG video start codes
 145            which can begin in one packet and finish in
 146            another packet. In the worst case, an MPEG
 147            video start code could be in 4 different
 148            packets. */
 149         k = s->cur_frame_start_index;
 150         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 151             if (s->last_frame_offset >= s->cur_frame_offset[k])
 152                 break;
 153             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 154         }
 155
 156         s->last_pts = s->cur_frame_pts[k];
 157         s->last_dts = s->cur_frame_dts[k];
 158
 159         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 160            so the next pts/dts is in the next chunk */
 161         if(index == buf_size){
 162             s->fetch_timestamp=1;
 163         }
 164     }
 165     if (index < 0)
 166         index = 0;
 167     s->cur_offset += index;
 168     return index;
 169 }
 170
 171 /**
 172  *
 173  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 174  * @deprecated use AVBitstreamFilter
 175  */
 176 int av_parser_change(AVCodecParserContext *s,
 177                      AVCodecContext *avctx,
 178                      uint8_t **poutbuf, int *poutbuf_size,
 179                      const uint8_t *buf, int buf_size, int keyframe){
 180
 181     if(s && s->parser->split){
 182         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
 183             int i= s->parser->split(avctx, buf, buf_size);
 184             buf += i;
 185             buf_size -= i;
 186         }
 187     }
 188
 189     /* cast to avoid warning about discarding qualifiers */
 190     *poutbuf= (uint8_t *) buf;
 191     *poutbuf_size= buf_size;
 192     if(avctx->extradata){
 193         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 194             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 195             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 196             int size= buf_size + avctx->extradata_size;
 197             *poutbuf_size= size;
 198             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 199
 200             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 201             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 202             return 1;
 203         }
 204     }
 205
 206     return 0;
 207 }
 208
 209 void av_parser_close(AVCodecParserContext *s)
 210 {
 211     if (s->parser->parser_close)
 212         s->parser->parser_close(s);
 213     av_free(s->priv_data);
 214     av_free(s);
 215 }
 216
 217 /*****************************************************/
 218
 219 /**
 220  * combines the (truncated) bitstream to a complete frame
 221  * @returns -1 if no complete frame could be created
 222  */
 223 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 224 {
 225 #if 0
 226     if(pc->overread){
 227         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 228         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 229     }
 230 #endif
 231
 232     /* copy overreaded bytes from last frame into buffer */
 233     for(; pc->overread>0; pc->overread--){
 234         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 235     }
 236
 237     /* flush remaining if EOF */
 238     if(!*buf_size && next == END_NOT_FOUND){
 239         next= 0;
 240     }
 241
 242     pc->last_index= pc->index;
 243
 244     /* copy into buffer end return */
 245     if(next == END_NOT_FOUND){
 246         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 247
 248         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 249         pc->index += *buf_size;
 250         return -1;
 251     }
 252
 253     *buf_size=
 254     pc->overread_index= pc->index + next;
 255
 256     /* append to buffer */
 257     if(pc->index){
 258         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 259
 260         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 261         pc->index = 0;
 262         *buf= pc->buffer;
 263     }
 264
 265     /* store overread bytes */
 266     for(;next < 0; next++){
 267         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 268         pc->overread++;
 269     }
 270
 271 #if 0
 272     if(pc->overread){
 273         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 274         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 275     }
 276 #endif
 277
 278     return 0;
 279 }
 280
 281 void ff_parse_close(AVCodecParserContext *s)
 282 {
 283     ParseContext *pc = s->priv_data;
 284
 285     av_free(pc->buffer);
 286 }
 287
 288 void ff_parse1_close(AVCodecParserContext *s)
 289 {
 290     ParseContext1 *pc1 = s->priv_data;
 291
 292     av_free(pc1->pc.buffer);
 293     av_free(pc1->enc);
 294 }
 295
 296 /*************************/
 297
 298 #ifdef CONFIG_MPEG4VIDEO_PARSER
 299 /* used by parser */
 300 /* XXX: make it use less memory */
 301 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 302                                   AVCodecContext *avctx,
 303                                   const uint8_t *buf, int buf_size)
 304 {
 305     ParseContext1 *pc = s1->priv_data;
 306     MpegEncContext *s = pc->enc;
 307     GetBitContext gb1, *gb = &gb1;
 308     int ret;
 309
 310     s->avctx = avctx;
 311     s->current_picture_ptr = &s->current_picture;
 312
 313     if (avctx->extradata_size && pc->first_picture){
 314         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 315         ret = ff_mpeg4_decode_picture_header(s, gb);
 316     }
 317
 318     init_get_bits(gb, buf, 8 * buf_size);
 319     ret = ff_mpeg4_decode_picture_header(s, gb);
 320     if (s->width) {
 321         avcodec_set_dimensions(avctx, s->width, s->height);
 322     }
 323     s1->pict_type= s->pict_type;
 324     pc->first_picture = 0;
 325     return ret;
 326 }
 327
 328 static int mpeg4video_parse_init(AVCodecParserContext *s)
 329 {
 330     ParseContext1 *pc = s->priv_data;
 331
 332     pc->enc = av_mallocz(sizeof(MpegEncContext));
 333     if (!pc->enc)
 334         return -1;
 335     pc->first_picture = 1;
 336     return 0;
 337 }
 338
 339 static int mpeg4video_parse(AVCodecParserContext *s,
 340                            AVCodecContext *avctx,
 341                            uint8_t **poutbuf, int *poutbuf_size,
 342                            const uint8_t *buf, int buf_size)
 343 {
 344     ParseContext *pc = s->priv_data;
 345     int next;
 346
 347     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 348         next= buf_size;
 349     }else{
 350         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 351
 352         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 353             *poutbuf = NULL;
 354             *poutbuf_size = 0;
 355             return buf_size;
 356         }
 357     }
 358     av_mpeg4_decode_header(s, avctx, buf, buf_size);
 359
 360     *poutbuf = (uint8_t *)buf;
 361     *poutbuf_size = buf_size;
 362     return next;
 363 }
 364 #endif
 365
 366 int ff_mpeg4video_split(AVCodecContext *avctx,
 367                            const uint8_t *buf, int buf_size)
 368 {
 369     int i;
 370     uint32_t state= -1;
 371
 372     for(i=0; i<buf_size; i++){
 373         state= (state<<8) | buf[i];
 374         if(state == 0x1B3 || state == 0x1B6)
 375             return i-3;
 376     }
 377     return 0;
 378 }
 379
 380 /*************************/
 381
 382 #ifdef CONFIG_MPEGAUDIO_PARSER
 383 typedef struct MpegAudioParseContext {
 384     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 385     uint8_t *inbuf_ptr;
 386     int frame_size;
 387     int free_format_frame_size;
 388     int free_format_next_header;
 389     uint32_t header;
 390     int header_count;
 391 } MpegAudioParseContext;
 392
 393 #define MPA_HEADER_SIZE 4
 394
 395 /* header + layer + bitrate + freq + lsf/mpeg25 */
 396 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 397 #define SAME_HEADER_MASK \
 398    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 399
 400 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 401 {
 402     MpegAudioParseContext *s = s1->priv_data;
 403     s->inbuf_ptr = s->inbuf;
 404     return 0;
 405 }
 406
 407 static int mpegaudio_parse(AVCodecParserContext *s1,
 408                            AVCodecContext *avctx,
 409                            uint8_t **poutbuf, int *poutbuf_size,
 410                            const uint8_t *buf, int buf_size)
 411 {
 412     MpegAudioParseContext *s = s1->priv_data;
 413     int len, ret, sr;
 414     uint32_t header;
 415     const uint8_t *buf_ptr;
 416
 417     *poutbuf = NULL;
 418     *poutbuf_size = 0;
 419     buf_ptr = buf;
 420     while (buf_size > 0) {
 421         len = s->inbuf_ptr - s->inbuf;
 422         if (s->frame_size == 0) {
 423             /* special case for next header for first frame in free
 424                format case (XXX: find a simpler method) */
 425             if (s->free_format_next_header != 0) {
 426                 s->inbuf[0] = s->free_format_next_header >> 24;
 427                 s->inbuf[1] = s->free_format_next_header >> 16;
 428                 s->inbuf[2] = s->free_format_next_header >> 8;
 429                 s->inbuf[3] = s->free_format_next_header;
 430                 s->inbuf_ptr = s->inbuf + 4;
 431                 s->free_format_next_header = 0;
 432                 goto got_header;
 433             }
 434             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 435                bytes to parse it */
 436             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
 437             if (len > 0) {
 438                 memcpy(s->inbuf_ptr, buf_ptr, len);
 439                 buf_ptr += len;
 440                 buf_size -= len;
 441                 s->inbuf_ptr += len;
 442             }
 443             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 444             got_header:
 445                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 446                     (s->inbuf[2] << 8) | s->inbuf[3];
 447
 448                 ret = mpa_decode_header(avctx, header, &sr);
 449                 if (ret < 0) {
 450                     s->header_count= -2;
 451                     /* no sync found : move by one byte (inefficient, but simple!) */
 452                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 453                     s->inbuf_ptr--;
 454                     dprintf("skip %x\n", header);
 455                     /* reset free format frame size to give a chance
 456                        to get a new bitrate */
 457                     s->free_format_frame_size = 0;
 458                 } else {
 459                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
 460                         s->header_count= -3;
 461                     s->header= header;
 462                     s->header_count++;
 463                     s->frame_size = ret;
 464
 465 #if 0
 466                     /* free format: prepare to compute frame size */
 467                     if (decode_header(s, header) == 1) {
 468                         s->frame_size = -1;
 469                     }
 470 #endif
 471                 }
 472                 if(s->header_count > 1)
 473                     avctx->sample_rate= sr;
 474             }
 475         } else
 476 #if 0
 477         if (s->frame_size == -1) {
 478             /* free format : find next sync to compute frame size */
 479             len = MPA_MAX_CODED_FRAME_SIZE - len;
 480             if (len > buf_size)
 481                 len = buf_size;
 482             if (len == 0) {
 483                 /* frame too long: resync */
 484                 s->frame_size = 0;
 485                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 486                 s->inbuf_ptr--;
 487             } else {
 488                 uint8_t *p, *pend;
 489                 uint32_t header1;
 490                 int padding;
 491
 492                 memcpy(s->inbuf_ptr, buf_ptr, len);
 493                 /* check for header */
 494                 p = s->inbuf_ptr - 3;
 495                 pend = s->inbuf_ptr + len - 4;
 496                 while (p <= pend) {
 497                     header = (p[0] << 24) | (p[1] << 16) |
 498                         (p[2] << 8) | p[3];
 499                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 500                         (s->inbuf[2] << 8) | s->inbuf[3];
 501                     /* check with high probability that we have a
 502                        valid header */
 503                     if ((header & SAME_HEADER_MASK) ==
 504                         (header1 & SAME_HEADER_MASK)) {
 505                         /* header found: update pointers */
 506                         len = (p + 4) - s->inbuf_ptr;
 507                         buf_ptr += len;
 508                         buf_size -= len;
 509                         s->inbuf_ptr = p;
 510                         /* compute frame size */
 511                         s->free_format_next_header = header;
 512                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 513                         padding = (header1 >> 9) & 1;
 514                         if (s->layer == 1)
 515                             s->free_format_frame_size -= padding * 4;
 516                         else
 517                             s->free_format_frame_size -= padding;
 518                         dprintf("free frame size=%d padding=%d\n",
 519                                 s->free_format_frame_size, padding);
 520                         decode_header(s, header1);
 521                         goto next_data;
 522                     }
 523                     p++;
 524                 }
 525                 /* not found: simply increase pointers */
 526                 buf_ptr += len;
 527                 s->inbuf_ptr += len;
 528                 buf_size -= len;
 529             }
 530         } else
 531 #endif
 532         if (len < s->frame_size) {
 533             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 534                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 535             len = FFMIN(s->frame_size - len, buf_size);
 536             memcpy(s->inbuf_ptr, buf_ptr, len);
 537             buf_ptr += len;
 538             s->inbuf_ptr += len;
 539             buf_size -= len;
 540         }
 541
 542         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
 543            && buf_size + buf_ptr - buf >= s->frame_size){
 544             if(s->header_count > 0){
 545                 *poutbuf = buf;
 546                 *poutbuf_size = s->frame_size;
 547             }
 548             buf_ptr = buf + s->frame_size;
 549             s->inbuf_ptr = s->inbuf;
 550             s->frame_size = 0;
 551             break;
 552         }
 553
 554         //    next_data:
 555         if (s->frame_size > 0 &&
 556             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 557             if(s->header_count > 0){
 558                 *poutbuf = s->inbuf;
 559                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
 560             }
 561             s->inbuf_ptr = s->inbuf;
 562             s->frame_size = 0;
 563             break;
 564         }
 565     }
 566     return buf_ptr - buf;
 567 }
 568 #endif /* CONFIG_MPEGAUDIO_PARSER */
 569
 570 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
 571 /* also used for ADTS AAC */
 572 typedef struct AC3ParseContext {
 573     uint8_t *inbuf_ptr;
 574     int frame_size;
 575     int header_size;
 576     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
 577                 int *bit_rate, int *samples);
 578     uint8_t inbuf[8192]; /* input buffer */
 579 } AC3ParseContext;
 580
 581 #define AC3_HEADER_SIZE 7
 582 #define AAC_HEADER_SIZE 7
 583
 584 #ifdef CONFIG_AC3_PARSER
 585
 586 static const uint8_t eac3_blocks[4] = {
 587     1, 2, 3, 6
 588 };
 589
 590 #endif /* CONFIG_AC3_PARSER */
 591
 592 #ifdef CONFIG_AAC_PARSER
 593 static const int aac_sample_rates[16] = {
 594     96000, 88200, 64000, 48000, 44100, 32000,
 595     24000, 22050, 16000, 12000, 11025, 8000, 7350
 596 };
 597
 598 static const int aac_channels[8] = {
 599     0, 1, 2, 3, 4, 5, 6, 8
 600 };
 601 #endif
 602
 603 #ifdef CONFIG_AC3_PARSER
 604 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 605                     int *bit_rate, int *samples)
 606 {
 607     unsigned int fscod, frmsizecod, acmod, bsid, lfeon, halfratecod;
 608     unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
 609     GetBitContext bits;
 610
 611     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
 612
 613     if(get_bits(&bits, 16) != 0x0b77)
 614         return 0;
 615
 616     bsid = show_bits_long(&bits, 29) & 0x1f;
 617     if(bsid <= 10) {             /* Normal AC-3 */
 618         skip_bits(&bits, 16);       /* crc */
 619         fscod = get_bits(&bits, 2);
 620         frmsizecod = get_bits(&bits, 6);
 621
 622         if(fscod == 3 && frmsizecod > 37)
 623             return 0;
 624
 625         skip_bits(&bits, 5);        /* bsid */
 626         skip_bits(&bits, 3);        /* bsmod */
 627         acmod = get_bits(&bits, 3);
 628         if(acmod & 1 && acmod != 1)
 629             skip_bits(&bits, 2);    /* cmixlev */
 630         if(acmod & 4)
 631             skip_bits(&bits, 2);    /* surmixlev */
 632         if(acmod & 2)
 633             skip_bits(&bits, 2);    /* dsurmod */
 634         lfeon = get_bits1(&bits);
 635
 636         halfratecod = FFMAX(bsid, 8) - 8;
 637         *sample_rate = ff_ac3_freqs[fscod] >> halfratecod;
 638         *bit_rate = (ff_ac3_bitratetab[frmsizecod] * 1000) >> halfratecod;
 639         *channels = ff_ac3_channels[acmod] + lfeon;
 640         *samples = 6 * 256;
 641
 642         return ff_ac3_frame_sizes[frmsizecod][fscod] * 2;
 643     } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
 644         strmtyp = get_bits(&bits, 2);
 645         substreamid = get_bits(&bits, 3);
 646
 647         if (strmtyp != 0 || substreamid != 0)
 648             return 0;   /* Currently don't support additional streams */
 649
 650         frmsiz = get_bits(&bits, 11) + 1;
 651         fscod = get_bits(&bits, 2);
 652         if (fscod == 3) {
 653             fscod2 = get_bits(&bits, 2);
 654             numblkscod = 3;
 655
 656             if(fscod2 == 3)
 657                 return 0;
 658
 659             *sample_rate = ff_ac3_freqs[fscod2] / 2;
 660         } else {
 661             numblkscod = get_bits(&bits, 2);
 662
 663             *sample_rate = ff_ac3_freqs[fscod];
 664         }
 665
 666         acmod = get_bits(&bits, 3);
 667         lfeon = get_bits1(&bits);
 668
 669         *samples = eac3_blocks[numblkscod] * 256;
 670         *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
 671         *channels = ff_ac3_channels[acmod] + lfeon;
 672
 673         return frmsiz * 2;
 674     }
 675
 676     /* Unsupported bitstream version */
 677     return 0;
 678 }
 679 #endif /* CONFIG_AC3_PARSER */
 680
 681 #ifdef CONFIG_AAC_PARSER
 682 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 683                     int *bit_rate, int *samples)
 684 {
 685     GetBitContext bits;
 686     int size, rdb, ch, sr;
 687
 688     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 689
 690     if(get_bits(&bits, 12) != 0xfff)
 691         return 0;
 692
 693     skip_bits1(&bits);          /* id */
 694     skip_bits(&bits, 2);        /* layer */
 695     skip_bits1(&bits);          /* protection_absent */
 696     skip_bits(&bits, 2);        /* profile_objecttype */
 697     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 698     if(!aac_sample_rates[sr])
 699         return 0;
 700     skip_bits1(&bits);          /* private_bit */
 701     ch = get_bits(&bits, 3);    /* channel_configuration */
 702     if(!aac_channels[ch])
 703         return 0;
 704     skip_bits1(&bits);          /* original/copy */
 705     skip_bits1(&bits);          /* home */
 706
 707     /* adts_variable_header */
 708     skip_bits1(&bits);          /* copyright_identification_bit */
 709     skip_bits1(&bits);          /* copyright_identification_start */
 710     size = get_bits(&bits, 13); /* aac_frame_length */
 711     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 712     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 713
 714     *channels = aac_channels[ch];
 715     *sample_rate = aac_sample_rates[sr];
 716     *samples = (rdb + 1) * 1024;
 717     *bit_rate = size * 8 * *sample_rate / *samples;
 718
 719     return size;
 720 }
 721 #endif /* CONFIG_AAC_PARSER */
 722
 723 #ifdef CONFIG_AC3_PARSER
 724 static int ac3_parse_init(AVCodecParserContext *s1)
 725 {
 726     AC3ParseContext *s = s1->priv_data;
 727     s->inbuf_ptr = s->inbuf;
 728     s->header_size = AC3_HEADER_SIZE;
 729     s->sync = ac3_sync;
 730     ac3_common_init();
 731     return 0;
 732 }
 733 #endif
 734
 735 #ifdef CONFIG_AAC_PARSER
 736 static int aac_parse_init(AVCodecParserContext *s1)
 737 {
 738     AC3ParseContext *s = s1->priv_data;
 739     s->inbuf_ptr = s->inbuf;
 740     s->header_size = AAC_HEADER_SIZE;
 741     s->sync = aac_sync;
 742     return 0;
 743 }
 744 #endif
 745
 746 /* also used for ADTS AAC */
 747 static int ac3_parse(AVCodecParserContext *s1,
 748                      AVCodecContext *avctx,
 749                      uint8_t **poutbuf, int *poutbuf_size,
 750                      const uint8_t *buf, int buf_size)
 751 {
 752     AC3ParseContext *s = s1->priv_data;
 753     const uint8_t *buf_ptr;
 754     int len, sample_rate, bit_rate, channels, samples;
 755
 756     *poutbuf = NULL;
 757     *poutbuf_size = 0;
 758
 759     buf_ptr = buf;
 760     while (buf_size > 0) {
 761         len = s->inbuf_ptr - s->inbuf;
 762         if (s->frame_size == 0) {
 763             /* no header seen : find one. We need at least s->header_size
 764                bytes to parse it */
 765             len = FFMIN(s->header_size - len, buf_size);
 766
 767             memcpy(s->inbuf_ptr, buf_ptr, len);
 768             buf_ptr += len;
 769             s->inbuf_ptr += len;
 770             buf_size -= len;
 771             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 772                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 773                               &samples);
 774                 if (len == 0) {
 775                     /* no sync found : move by one byte (inefficient, but simple!) */
 776                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 777                     s->inbuf_ptr--;
 778                 } else {
 779                     s->frame_size = len;
 780                     /* update codec info */
 781                     avctx->sample_rate = sample_rate;
 782                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 783                     if(avctx->codec_id == CODEC_ID_AC3){
 784                         if(avctx->channels!=1 && avctx->channels!=2){
 785                             avctx->channels = channels;
 786                         }
 787                     } else {
 788                         avctx->channels = channels;
 789                     }
 790                     avctx->bit_rate = bit_rate;
 791                     avctx->frame_size = samples;
 792                 }
 793             }
 794         } else {
 795             len = FFMIN(s->frame_size - len, buf_size);
 796
 797             memcpy(s->inbuf_ptr, buf_ptr, len);
 798             buf_ptr += len;
 799             s->inbuf_ptr += len;
 800             buf_size -= len;
 801
 802             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 803                 *poutbuf = s->inbuf;
 804                 *poutbuf_size = s->frame_size;
 805                 s->inbuf_ptr = s->inbuf;
 806                 s->frame_size = 0;
 807                 break;
 808             }
 809         }
 810     }
 811     return buf_ptr - buf;
 812 }
 813 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
 814
 815 #ifdef CONFIG_MPEG4VIDEO_PARSER
 816 AVCodecParser mpeg4video_parser = {
 817     { CODEC_ID_MPEG4 },
 818     sizeof(ParseContext1),
 819     mpeg4video_parse_init,
 820     mpeg4video_parse,
 821     ff_parse1_close,
 822     ff_mpeg4video_split,
 823 };
 824 #endif
 825 #ifdef CONFIG_MPEGAUDIO_PARSER
 826 AVCodecParser mpegaudio_parser = {
 827     { CODEC_ID_MP2, CODEC_ID_MP3 },
 828     sizeof(MpegAudioParseContext),
 829     mpegaudio_parse_init,
 830     mpegaudio_parse,
 831     NULL,
 832 };
 833 #endif
 834 #ifdef CONFIG_AC3_PARSER
 835 AVCodecParser ac3_parser = {
 836     { CODEC_ID_AC3 },
 837     sizeof(AC3ParseContext),
 838     ac3_parse_init,
 839     ac3_parse,
 840     NULL,
 841 };
 842 #endif
 843 #ifdef CONFIG_AAC_PARSER
 844 AVCodecParser aac_parser = {
 845     { CODEC_ID_AAC },
 846     sizeof(AC3ParseContext),
 847     aac_parse_init,
 848     ac3_parse,
 849     NULL,
 850 };
 851 #endif