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