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