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