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(avctx, "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(avctx, "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     int err;
 608     unsigned int fscod, acmod, bsid, lfeon;
 609     unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
 610     GetBitContext bits;
 611     AC3HeaderInfo hdr;
 612
 613     err = ff_ac3_parse_header(buf, &hdr);
 614
 615     if(err < 0 && err != -2)
 616         return 0;
 617
 618     bsid = hdr.bsid;
 619     if(bsid <= 10) {             /* Normal AC-3 */
 620         *sample_rate = hdr.sample_rate;
 621         *bit_rate = hdr.bit_rate;
 622         *channels = hdr.channels;
 623         *samples = AC3_FRAME_SIZE;
 624         return hdr.frame_size;
 625     } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
 626         init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
 627         strmtyp = get_bits(&bits, 2);
 628         substreamid = get_bits(&bits, 3);
 629
 630         if (strmtyp != 0 || substreamid != 0)
 631             return 0;   /* Currently don't support additional streams */
 632
 633         frmsiz = get_bits(&bits, 11) + 1;
 634         fscod = get_bits(&bits, 2);
 635         if (fscod == 3) {
 636             fscod2 = get_bits(&bits, 2);
 637             numblkscod = 3;
 638
 639             if(fscod2 == 3)
 640                 return 0;
 641
 642             *sample_rate = ff_ac3_freqs[fscod2] / 2;
 643         } else {
 644             numblkscod = get_bits(&bits, 2);
 645
 646             *sample_rate = ff_ac3_freqs[fscod];
 647         }
 648
 649         acmod = get_bits(&bits, 3);
 650         lfeon = get_bits1(&bits);
 651
 652         *samples = eac3_blocks[numblkscod] * 256;
 653         *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
 654         *channels = ff_ac3_channels[acmod] + lfeon;
 655
 656         return frmsiz * 2;
 657     }
 658
 659     /* Unsupported bitstream version */
 660     return 0;
 661 }
 662 #endif /* CONFIG_AC3_PARSER */
 663
 664 #ifdef CONFIG_AAC_PARSER
 665 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 666                     int *bit_rate, int *samples)
 667 {
 668     GetBitContext bits;
 669     int size, rdb, ch, sr;
 670
 671     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 672
 673     if(get_bits(&bits, 12) != 0xfff)
 674         return 0;
 675
 676     skip_bits1(&bits);          /* id */
 677     skip_bits(&bits, 2);        /* layer */
 678     skip_bits1(&bits);          /* protection_absent */
 679     skip_bits(&bits, 2);        /* profile_objecttype */
 680     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 681     if(!aac_sample_rates[sr])
 682         return 0;
 683     skip_bits1(&bits);          /* private_bit */
 684     ch = get_bits(&bits, 3);    /* channel_configuration */
 685     if(!aac_channels[ch])
 686         return 0;
 687     skip_bits1(&bits);          /* original/copy */
 688     skip_bits1(&bits);          /* home */
 689
 690     /* adts_variable_header */
 691     skip_bits1(&bits);          /* copyright_identification_bit */
 692     skip_bits1(&bits);          /* copyright_identification_start */
 693     size = get_bits(&bits, 13); /* aac_frame_length */
 694     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 695     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 696
 697     *channels = aac_channels[ch];
 698     *sample_rate = aac_sample_rates[sr];
 699     *samples = (rdb + 1) * 1024;
 700     *bit_rate = size * 8 * *sample_rate / *samples;
 701
 702     return size;
 703 }
 704 #endif /* CONFIG_AAC_PARSER */
 705
 706 #ifdef CONFIG_AC3_PARSER
 707 static int ac3_parse_init(AVCodecParserContext *s1)
 708 {
 709     AC3ParseContext *s = s1->priv_data;
 710     s->inbuf_ptr = s->inbuf;
 711     s->header_size = AC3_HEADER_SIZE;
 712     s->sync = ac3_sync;
 713     return 0;
 714 }
 715 #endif
 716
 717 #ifdef CONFIG_AAC_PARSER
 718 static int aac_parse_init(AVCodecParserContext *s1)
 719 {
 720     AC3ParseContext *s = s1->priv_data;
 721     s->inbuf_ptr = s->inbuf;
 722     s->header_size = AAC_HEADER_SIZE;
 723     s->sync = aac_sync;
 724     return 0;
 725 }
 726 #endif
 727
 728 /* also used for ADTS AAC */
 729 static int ac3_parse(AVCodecParserContext *s1,
 730                      AVCodecContext *avctx,
 731                      uint8_t **poutbuf, int *poutbuf_size,
 732                      const uint8_t *buf, int buf_size)
 733 {
 734     AC3ParseContext *s = s1->priv_data;
 735     const uint8_t *buf_ptr;
 736     int len, sample_rate, bit_rate, channels, samples;
 737
 738     *poutbuf = NULL;
 739     *poutbuf_size = 0;
 740
 741     buf_ptr = buf;
 742     while (buf_size > 0) {
 743         len = s->inbuf_ptr - s->inbuf;
 744         if (s->frame_size == 0) {
 745             /* no header seen : find one. We need at least s->header_size
 746                bytes to parse it */
 747             len = FFMIN(s->header_size - len, buf_size);
 748
 749             memcpy(s->inbuf_ptr, buf_ptr, len);
 750             buf_ptr += len;
 751             s->inbuf_ptr += len;
 752             buf_size -= len;
 753             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 754                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 755                               &samples);
 756                 if (len == 0) {
 757                     /* no sync found : move by one byte (inefficient, but simple!) */
 758                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 759                     s->inbuf_ptr--;
 760                 } else {
 761                     s->frame_size = len;
 762                     /* update codec info */
 763                     avctx->sample_rate = sample_rate;
 764                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 765                     if(avctx->codec_id == CODEC_ID_AC3){
 766                         if(avctx->channels!=1 && avctx->channels!=2){
 767                             avctx->channels = channels;
 768                         }
 769                     } else {
 770                         avctx->channels = channels;
 771                     }
 772                     avctx->bit_rate = bit_rate;
 773                     avctx->frame_size = samples;
 774                 }
 775             }
 776         } else {
 777             len = FFMIN(s->frame_size - len, buf_size);
 778
 779             memcpy(s->inbuf_ptr, buf_ptr, len);
 780             buf_ptr += len;
 781             s->inbuf_ptr += len;
 782             buf_size -= len;
 783
 784             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 785                 *poutbuf = s->inbuf;
 786                 *poutbuf_size = s->frame_size;
 787                 s->inbuf_ptr = s->inbuf;
 788                 s->frame_size = 0;
 789                 break;
 790             }
 791         }
 792     }
 793     return buf_ptr - buf;
 794 }
 795 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
 796
 797 #ifdef CONFIG_MPEG4VIDEO_PARSER
 798 AVCodecParser mpeg4video_parser = {
 799     { CODEC_ID_MPEG4 },
 800     sizeof(ParseContext1),
 801     mpeg4video_parse_init,
 802     mpeg4video_parse,
 803     ff_parse1_close,
 804     ff_mpeg4video_split,
 805 };
 806 #endif
 807 #ifdef CONFIG_MPEGAUDIO_PARSER
 808 AVCodecParser mpegaudio_parser = {
 809     { CODEC_ID_MP2, CODEC_ID_MP3 },
 810     sizeof(MpegAudioParseContext),
 811     mpegaudio_parse_init,
 812     mpegaudio_parse,
 813     NULL,
 814 };
 815 #endif
 816 #ifdef CONFIG_AC3_PARSER
 817 AVCodecParser ac3_parser = {
 818     { CODEC_ID_AC3 },
 819     sizeof(AC3ParseContext),
 820     ac3_parse_init,
 821     ac3_parse,
 822     NULL,
 823 };
 824 #endif
 825 #ifdef CONFIG_AAC_PARSER
 826 AVCodecParser aac_parser = {
 827     { CODEC_ID_AAC },
 828     sizeof(AC3ParseContext),
 829     aac_parse_init,
 830     ac3_parse,
 831     NULL,
 832 };
 833 #endif