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 #ifdef CONFIG_MPEG4VIDEO_PARSER
 302 /* used by parser */
 303 /* XXX: make it use less memory */
 304 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 305                                   AVCodecContext *avctx,
 306                                   const uint8_t *buf, int buf_size)
 307 {
 308     ParseContext1 *pc = s1->priv_data;
 309     MpegEncContext *s = pc->enc;
 310     GetBitContext gb1, *gb = &gb1;
 311     int ret;
 312
 313     s->avctx = avctx;
 314     s->current_picture_ptr = &s->current_picture;
 315
 316     if (avctx->extradata_size && pc->first_picture){
 317         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 318         ret = ff_mpeg4_decode_picture_header(s, gb);
 319     }
 320
 321     init_get_bits(gb, buf, 8 * buf_size);
 322     ret = ff_mpeg4_decode_picture_header(s, gb);
 323     if (s->width) {
 324         avcodec_set_dimensions(avctx, s->width, s->height);
 325     }
 326     s1->pict_type= s->pict_type;
 327     pc->first_picture = 0;
 328     return ret;
 329 }
 330
 331 static int mpeg4video_parse_init(AVCodecParserContext *s)
 332 {
 333     ParseContext1 *pc = s->priv_data;
 334
 335     pc->enc = av_mallocz(sizeof(MpegEncContext));
 336     if (!pc->enc)
 337         return -1;
 338     pc->first_picture = 1;
 339     return 0;
 340 }
 341
 342 static int mpeg4video_parse(AVCodecParserContext *s,
 343                            AVCodecContext *avctx,
 344                            uint8_t **poutbuf, int *poutbuf_size,
 345                            const uint8_t *buf, int buf_size)
 346 {
 347     ParseContext *pc = s->priv_data;
 348     int next;
 349
 350     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 351         next= buf_size;
 352     }else{
 353         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 354
 355         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 356             *poutbuf = NULL;
 357             *poutbuf_size = 0;
 358             return buf_size;
 359         }
 360     }
 361     av_mpeg4_decode_header(s, avctx, buf, buf_size);
 362
 363     *poutbuf = (uint8_t *)buf;
 364     *poutbuf_size = buf_size;
 365     return next;
 366 }
 367 #endif
 368
 369 int ff_mpeg4video_split(AVCodecContext *avctx,
 370                            const uint8_t *buf, int buf_size)
 371 {
 372     int i;
 373     uint32_t state= -1;
 374
 375     for(i=0; i<buf_size; i++){
 376         state= (state<<8) | buf[i];
 377         if(state == 0x1B3 || state == 0x1B6)
 378             return i-3;
 379     }
 380     return 0;
 381 }
 382
 383 /*************************/
 384
 385 #ifdef CONFIG_MPEGAUDIO_PARSER
 386 typedef struct MpegAudioParseContext {
 387     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 388     uint8_t *inbuf_ptr;
 389     int frame_size;
 390     int free_format_frame_size;
 391     int free_format_next_header;
 392     uint32_t header;
 393     int header_count;
 394 } MpegAudioParseContext;
 395
 396 #define MPA_HEADER_SIZE 4
 397
 398 /* header + layer + bitrate + freq + lsf/mpeg25 */
 399 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 400 #define SAME_HEADER_MASK \
 401    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 402
 403 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 404 {
 405     MpegAudioParseContext *s = s1->priv_data;
 406     s->inbuf_ptr = s->inbuf;
 407     return 0;
 408 }
 409
 410 static int mpegaudio_parse(AVCodecParserContext *s1,
 411                            AVCodecContext *avctx,
 412                            uint8_t **poutbuf, int *poutbuf_size,
 413                            const uint8_t *buf, int buf_size)
 414 {
 415     MpegAudioParseContext *s = s1->priv_data;
 416     int len, ret, sr;
 417     uint32_t header;
 418     const uint8_t *buf_ptr;
 419
 420     *poutbuf = NULL;
 421     *poutbuf_size = 0;
 422     buf_ptr = buf;
 423     while (buf_size > 0) {
 424         len = s->inbuf_ptr - s->inbuf;
 425         if (s->frame_size == 0) {
 426             /* special case for next header for first frame in free
 427                format case (XXX: find a simpler method) */
 428             if (s->free_format_next_header != 0) {
 429                 s->inbuf[0] = s->free_format_next_header >> 24;
 430                 s->inbuf[1] = s->free_format_next_header >> 16;
 431                 s->inbuf[2] = s->free_format_next_header >> 8;
 432                 s->inbuf[3] = s->free_format_next_header;
 433                 s->inbuf_ptr = s->inbuf + 4;
 434                 s->free_format_next_header = 0;
 435                 goto got_header;
 436             }
 437             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 438                bytes to parse it */
 439             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
 440             if (len > 0) {
 441                 memcpy(s->inbuf_ptr, buf_ptr, len);
 442                 buf_ptr += len;
 443                 buf_size -= len;
 444                 s->inbuf_ptr += len;
 445             }
 446             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 447             got_header:
 448                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 449                     (s->inbuf[2] << 8) | s->inbuf[3];
 450
 451                 ret = mpa_decode_header(avctx, header, &sr);
 452                 if (ret < 0) {
 453                     s->header_count= -2;
 454                     /* no sync found : move by one byte (inefficient, but simple!) */
 455                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 456                     s->inbuf_ptr--;
 457                     dprintf(avctx, "skip %x\n", header);
 458                     /* reset free format frame size to give a chance
 459                        to get a new bitrate */
 460                     s->free_format_frame_size = 0;
 461                 } else {
 462                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
 463                         s->header_count= -3;
 464                     s->header= header;
 465                     s->header_count++;
 466                     s->frame_size = ret;
 467
 468 #if 0
 469                     /* free format: prepare to compute frame size */
 470                     if (decode_header(s, header) == 1) {
 471                         s->frame_size = -1;
 472                     }
 473 #endif
 474                 }
 475                 if(s->header_count > 1)
 476                     avctx->sample_rate= sr;
 477             }
 478         } else
 479 #if 0
 480         if (s->frame_size == -1) {
 481             /* free format : find next sync to compute frame size */
 482             len = MPA_MAX_CODED_FRAME_SIZE - len;
 483             if (len > buf_size)
 484                 len = buf_size;
 485             if (len == 0) {
 486                 /* frame too long: resync */
 487                 s->frame_size = 0;
 488                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 489                 s->inbuf_ptr--;
 490             } else {
 491                 uint8_t *p, *pend;
 492                 uint32_t header1;
 493                 int padding;
 494
 495                 memcpy(s->inbuf_ptr, buf_ptr, len);
 496                 /* check for header */
 497                 p = s->inbuf_ptr - 3;
 498                 pend = s->inbuf_ptr + len - 4;
 499                 while (p <= pend) {
 500                     header = (p[0] << 24) | (p[1] << 16) |
 501                         (p[2] << 8) | p[3];
 502                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 503                         (s->inbuf[2] << 8) | s->inbuf[3];
 504                     /* check with high probability that we have a
 505                        valid header */
 506                     if ((header & SAME_HEADER_MASK) ==
 507                         (header1 & SAME_HEADER_MASK)) {
 508                         /* header found: update pointers */
 509                         len = (p + 4) - s->inbuf_ptr;
 510                         buf_ptr += len;
 511                         buf_size -= len;
 512                         s->inbuf_ptr = p;
 513                         /* compute frame size */
 514                         s->free_format_next_header = header;
 515                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 516                         padding = (header1 >> 9) & 1;
 517                         if (s->layer == 1)
 518                             s->free_format_frame_size -= padding * 4;
 519                         else
 520                             s->free_format_frame_size -= padding;
 521                         dprintf(avctx, "free frame size=%d padding=%d\n",
 522                                 s->free_format_frame_size, padding);
 523                         decode_header(s, header1);
 524                         goto next_data;
 525                     }
 526                     p++;
 527                 }
 528                 /* not found: simply increase pointers */
 529                 buf_ptr += len;
 530                 s->inbuf_ptr += len;
 531                 buf_size -= len;
 532             }
 533         } else
 534 #endif
 535         if (len < s->frame_size) {
 536             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 537                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 538             len = FFMIN(s->frame_size - len, buf_size);
 539             memcpy(s->inbuf_ptr, buf_ptr, len);
 540             buf_ptr += len;
 541             s->inbuf_ptr += len;
 542             buf_size -= len;
 543         }
 544
 545         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
 546            && buf_size + buf_ptr - buf >= s->frame_size){
 547             if(s->header_count > 0){
 548                 *poutbuf = buf;
 549                 *poutbuf_size = s->frame_size;
 550             }
 551             buf_ptr = buf + s->frame_size;
 552             s->inbuf_ptr = s->inbuf;
 553             s->frame_size = 0;
 554             break;
 555         }
 556
 557         //    next_data:
 558         if (s->frame_size > 0 &&
 559             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 560             if(s->header_count > 0){
 561                 *poutbuf = s->inbuf;
 562                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
 563             }
 564             s->inbuf_ptr = s->inbuf;
 565             s->frame_size = 0;
 566             break;
 567         }
 568     }
 569     return buf_ptr - buf;
 570 }
 571 #endif /* CONFIG_MPEGAUDIO_PARSER */
 572
 573 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
 574 /* also used for ADTS AAC */
 575 typedef struct AC3ParseContext {
 576     uint8_t *inbuf_ptr;
 577     int frame_size;
 578     int header_size;
 579     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
 580                 int *bit_rate, int *samples);
 581     uint8_t inbuf[8192]; /* input buffer */
 582 } AC3ParseContext;
 583
 584 #define AC3_HEADER_SIZE 7
 585 #define AAC_HEADER_SIZE 7
 586
 587 #ifdef CONFIG_AC3_PARSER
 588
 589 static const uint8_t eac3_blocks[4] = {
 590     1, 2, 3, 6
 591 };
 592
 593 #endif /* CONFIG_AC3_PARSER */
 594
 595 #ifdef CONFIG_AAC_PARSER
 596 static const int aac_sample_rates[16] = {
 597     96000, 88200, 64000, 48000, 44100, 32000,
 598     24000, 22050, 16000, 12000, 11025, 8000, 7350
 599 };
 600
 601 static const int aac_channels[8] = {
 602     0, 1, 2, 3, 4, 5, 6, 8
 603 };
 604 #endif
 605
 606 #ifdef CONFIG_AC3_PARSER
 607 int ff_ac3_parse_header(const uint8_t buf[7], AC3HeaderInfo *hdr)
 608 {
 609     GetBitContext gbc;
 610
 611     memset(hdr, 0, sizeof(*hdr));
 612
 613     init_get_bits(&gbc, buf, 54);
 614
 615     hdr->sync_word = get_bits(&gbc, 16);
 616     if(hdr->sync_word != 0x0B77)
 617         return -1;
 618
 619     /* read ahead to bsid to make sure this is AC-3, not E-AC-3 */
 620     hdr->bsid = show_bits_long(&gbc, 29) & 0x1F;
 621     if(hdr->bsid > 10)
 622         return -2;
 623
 624     hdr->crc1 = get_bits(&gbc, 16);
 625     hdr->fscod = get_bits(&gbc, 2);
 626     if(hdr->fscod == 3)
 627         return -3;
 628
 629     hdr->frmsizecod = get_bits(&gbc, 6);
 630     if(hdr->frmsizecod > 37)
 631         return -4;
 632
 633     skip_bits(&gbc, 5); // skip bsid, already got it
 634
 635     hdr->bsmod = get_bits(&gbc, 3);
 636     hdr->acmod = get_bits(&gbc, 3);
 637     if((hdr->acmod & 1) && hdr->acmod != 1) {
 638         hdr->cmixlev = get_bits(&gbc, 2);
 639     }
 640     if(hdr->acmod & 4) {
 641         hdr->surmixlev = get_bits(&gbc, 2);
 642     }
 643     if(hdr->acmod == 2) {
 644         hdr->dsurmod = get_bits(&gbc, 2);
 645     }
 646     hdr->lfeon = get_bits1(&gbc);
 647
 648     hdr->halfratecod = FFMAX(hdr->bsid, 8) - 8;
 649     hdr->sample_rate = ff_ac3_freqs[hdr->fscod] >> hdr->halfratecod;
 650     hdr->bit_rate = (ff_ac3_bitratetab[hdr->frmsizecod>>1] * 1000) >> hdr->halfratecod;
 651     hdr->channels = ff_ac3_channels[hdr->acmod] + hdr->lfeon;
 652     hdr->frame_size = ff_ac3_frame_sizes[hdr->frmsizecod][hdr->fscod] * 2;
 653
 654     return 0;
 655 }
 656
 657 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 658                     int *bit_rate, int *samples)
 659 {
 660     int err;
 661     unsigned int fscod, acmod, bsid, lfeon;
 662     unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
 663     GetBitContext bits;
 664     AC3HeaderInfo hdr;
 665
 666     err = ff_ac3_parse_header(buf, &hdr);
 667
 668     if(err < 0 && err != -2)
 669         return 0;
 670
 671     bsid = hdr.bsid;
 672     if(bsid <= 10) {             /* Normal AC-3 */
 673         *sample_rate = hdr.sample_rate;
 674         *bit_rate = hdr.bit_rate;
 675         *channels = hdr.channels;
 676         *samples = AC3_FRAME_SIZE;
 677         return hdr.frame_size;
 678     } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
 679         init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
 680         strmtyp = get_bits(&bits, 2);
 681         substreamid = get_bits(&bits, 3);
 682
 683         if (strmtyp != 0 || substreamid != 0)
 684             return 0;   /* Currently don't support additional streams */
 685
 686         frmsiz = get_bits(&bits, 11) + 1;
 687         fscod = get_bits(&bits, 2);
 688         if (fscod == 3) {
 689             fscod2 = get_bits(&bits, 2);
 690             numblkscod = 3;
 691
 692             if(fscod2 == 3)
 693                 return 0;
 694
 695             *sample_rate = ff_ac3_freqs[fscod2] / 2;
 696         } else {
 697             numblkscod = get_bits(&bits, 2);
 698
 699             *sample_rate = ff_ac3_freqs[fscod];
 700         }
 701
 702         acmod = get_bits(&bits, 3);
 703         lfeon = get_bits1(&bits);
 704
 705         *samples = eac3_blocks[numblkscod] * 256;
 706         *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
 707         *channels = ff_ac3_channels[acmod] + lfeon;
 708
 709         return frmsiz * 2;
 710     }
 711
 712     /* Unsupported bitstream version */
 713     return 0;
 714 }
 715 #endif /* CONFIG_AC3_PARSER */
 716
 717 #ifdef CONFIG_AAC_PARSER
 718 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 719                     int *bit_rate, int *samples)
 720 {
 721     GetBitContext bits;
 722     int size, rdb, ch, sr;
 723
 724     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 725
 726     if(get_bits(&bits, 12) != 0xfff)
 727         return 0;
 728
 729     skip_bits1(&bits);          /* id */
 730     skip_bits(&bits, 2);        /* layer */
 731     skip_bits1(&bits);          /* protection_absent */
 732     skip_bits(&bits, 2);        /* profile_objecttype */
 733     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 734     if(!aac_sample_rates[sr])
 735         return 0;
 736     skip_bits1(&bits);          /* private_bit */
 737     ch = get_bits(&bits, 3);    /* channel_configuration */
 738     if(!aac_channels[ch])
 739         return 0;
 740     skip_bits1(&bits);          /* original/copy */
 741     skip_bits1(&bits);          /* home */
 742
 743     /* adts_variable_header */
 744     skip_bits1(&bits);          /* copyright_identification_bit */
 745     skip_bits1(&bits);          /* copyright_identification_start */
 746     size = get_bits(&bits, 13); /* aac_frame_length */
 747     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 748     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 749
 750     *channels = aac_channels[ch];
 751     *sample_rate = aac_sample_rates[sr];
 752     *samples = (rdb + 1) * 1024;
 753     *bit_rate = size * 8 * *sample_rate / *samples;
 754
 755     return size;
 756 }
 757 #endif /* CONFIG_AAC_PARSER */
 758
 759 #ifdef CONFIG_AC3_PARSER
 760 static int ac3_parse_init(AVCodecParserContext *s1)
 761 {
 762     AC3ParseContext *s = s1->priv_data;
 763     s->inbuf_ptr = s->inbuf;
 764     s->header_size = AC3_HEADER_SIZE;
 765     s->sync = ac3_sync;
 766     return 0;
 767 }
 768 #endif
 769
 770 #ifdef CONFIG_AAC_PARSER
 771 static int aac_parse_init(AVCodecParserContext *s1)
 772 {
 773     AC3ParseContext *s = s1->priv_data;
 774     s->inbuf_ptr = s->inbuf;
 775     s->header_size = AAC_HEADER_SIZE;
 776     s->sync = aac_sync;
 777     return 0;
 778 }
 779 #endif
 780
 781 /* also used for ADTS AAC */
 782 static int ac3_parse(AVCodecParserContext *s1,
 783                      AVCodecContext *avctx,
 784                      uint8_t **poutbuf, int *poutbuf_size,
 785                      const uint8_t *buf, int buf_size)
 786 {
 787     AC3ParseContext *s = s1->priv_data;
 788     const uint8_t *buf_ptr;
 789     int len, sample_rate, bit_rate, channels, samples;
 790
 791     *poutbuf = NULL;
 792     *poutbuf_size = 0;
 793
 794     buf_ptr = buf;
 795     while (buf_size > 0) {
 796         len = s->inbuf_ptr - s->inbuf;
 797         if (s->frame_size == 0) {
 798             /* no header seen : find one. We need at least s->header_size
 799                bytes to parse it */
 800             len = FFMIN(s->header_size - len, buf_size);
 801
 802             memcpy(s->inbuf_ptr, buf_ptr, len);
 803             buf_ptr += len;
 804             s->inbuf_ptr += len;
 805             buf_size -= len;
 806             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 807                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 808                               &samples);
 809                 if (len == 0) {
 810                     /* no sync found : move by one byte (inefficient, but simple!) */
 811                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 812                     s->inbuf_ptr--;
 813                 } else {
 814                     s->frame_size = len;
 815                     /* update codec info */
 816                     avctx->sample_rate = sample_rate;
 817                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 818                     if(avctx->codec_id == CODEC_ID_AC3){
 819                         if(avctx->channels!=1 && avctx->channels!=2){
 820                             avctx->channels = channels;
 821                         }
 822                     } else {
 823                         avctx->channels = channels;
 824                     }
 825                     avctx->bit_rate = bit_rate;
 826                     avctx->frame_size = samples;
 827                 }
 828             }
 829         } else {
 830             len = FFMIN(s->frame_size - len, buf_size);
 831
 832             memcpy(s->inbuf_ptr, buf_ptr, len);
 833             buf_ptr += len;
 834             s->inbuf_ptr += len;
 835             buf_size -= len;
 836
 837             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 838                 *poutbuf = s->inbuf;
 839                 *poutbuf_size = s->frame_size;
 840                 s->inbuf_ptr = s->inbuf;
 841                 s->frame_size = 0;
 842                 break;
 843             }
 844         }
 845     }
 846     return buf_ptr - buf;
 847 }
 848 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
 849
 850 #ifdef CONFIG_MPEG4VIDEO_PARSER
 851 AVCodecParser mpeg4video_parser = {
 852     { CODEC_ID_MPEG4 },
 853     sizeof(ParseContext1),
 854     mpeg4video_parse_init,
 855     mpeg4video_parse,
 856     ff_parse1_close,
 857     ff_mpeg4video_split,
 858 };
 859 #endif
 860 #ifdef CONFIG_MPEGAUDIO_PARSER
 861 AVCodecParser mpegaudio_parser = {
 862     { CODEC_ID_MP2, CODEC_ID_MP3 },
 863     sizeof(MpegAudioParseContext),
 864     mpegaudio_parse_init,
 865     mpegaudio_parse,
 866     NULL,
 867 };
 868 #endif
 869 #ifdef CONFIG_AC3_PARSER
 870 AVCodecParser ac3_parser = {
 871     { CODEC_ID_AC3 },
 872     sizeof(AC3ParseContext),
 873     ac3_parse_init,
 874     ac3_parse,
 875     NULL,
 876 };
 877 #endif
 878 #ifdef CONFIG_AAC_PARSER
 879 AVCodecParser aac_parser = {
 880     { CODEC_ID_AAC },
 881     sizeof(AC3ParseContext),
 882     aac_parse_init,
 883     ac3_parse,
 884     NULL,
 885 };
 886 #endif