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