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, halfratecod;
 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 <= 10) {             /* 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         halfratecod = FFMAX(bsid, 8) - 8;
 690         *sample_rate = ac3_sample_rates[fscod] >> halfratecod;
 691         *bit_rate = (ac3_bitrates[frmsizecod] * 1000) >> halfratecod;
 692         *channels = ac3_channels[acmod] + lfeon;
 693         *samples = 6 * 256;
 694
 695         return ac3_frame_sizes[frmsizecod][fscod] * 2;
 696     } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
 697         strmtyp = get_bits(&bits, 2);
 698         substreamid = get_bits(&bits, 3);
 699
 700         if (strmtyp != 0 || substreamid != 0)
 701             return 0;   /* Currently don't support additional streams */
 702
 703         frmsiz = get_bits(&bits, 11) + 1;
 704         fscod = get_bits(&bits, 2);
 705         if (fscod == 3) {
 706             fscod2 = get_bits(&bits, 2);
 707             numblkscod = 3;
 708
 709             if(fscod2 == 3)
 710                 return 0;
 711
 712             *sample_rate = ac3_sample_rates[fscod2] / 2;
 713         } else {
 714             numblkscod = get_bits(&bits, 2);
 715
 716             *sample_rate = ac3_sample_rates[fscod];
 717         }
 718
 719         acmod = get_bits(&bits, 3);
 720         lfeon = get_bits1(&bits);
 721
 722         *samples = eac3_blocks[numblkscod] * 256;
 723         *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
 724         *channels = ac3_channels[acmod] + lfeon;
 725
 726         return frmsiz * 2;
 727     }
 728
 729     /* Unsupported bitstream version */
 730     return 0;
 731 }
 732 #endif /* CONFIG_AC3_PARSER */
 733
 734 #ifdef CONFIG_AAC_PARSER
 735 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 736                     int *bit_rate, int *samples)
 737 {
 738     GetBitContext bits;
 739     int size, rdb, ch, sr;
 740
 741     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 742
 743     if(get_bits(&bits, 12) != 0xfff)
 744         return 0;
 745
 746     skip_bits1(&bits);          /* id */
 747     skip_bits(&bits, 2);        /* layer */
 748     skip_bits1(&bits);          /* protection_absent */
 749     skip_bits(&bits, 2);        /* profile_objecttype */
 750     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 751     if(!aac_sample_rates[sr])
 752         return 0;
 753     skip_bits1(&bits);          /* private_bit */
 754     ch = get_bits(&bits, 3);    /* channel_configuration */
 755     if(!aac_channels[ch])
 756         return 0;
 757     skip_bits1(&bits);          /* original/copy */
 758     skip_bits1(&bits);          /* home */
 759
 760     /* adts_variable_header */
 761     skip_bits1(&bits);          /* copyright_identification_bit */
 762     skip_bits1(&bits);          /* copyright_identification_start */
 763     size = get_bits(&bits, 13); /* aac_frame_length */
 764     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 765     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 766
 767     *channels = aac_channels[ch];
 768     *sample_rate = aac_sample_rates[sr];
 769     *samples = (rdb + 1) * 1024;
 770     *bit_rate = size * 8 * *sample_rate / *samples;
 771
 772     return size;
 773 }
 774 #endif /* CONFIG_AAC_PARSER */
 775
 776 #ifdef CONFIG_AC3_PARSER
 777 static int ac3_parse_init(AVCodecParserContext *s1)
 778 {
 779     AC3ParseContext *s = s1->priv_data;
 780     s->inbuf_ptr = s->inbuf;
 781     s->header_size = AC3_HEADER_SIZE;
 782     s->sync = ac3_sync;
 783     return 0;
 784 }
 785 #endif
 786
 787 #ifdef CONFIG_AAC_PARSER
 788 static int aac_parse_init(AVCodecParserContext *s1)
 789 {
 790     AC3ParseContext *s = s1->priv_data;
 791     s->inbuf_ptr = s->inbuf;
 792     s->header_size = AAC_HEADER_SIZE;
 793     s->sync = aac_sync;
 794     return 0;
 795 }
 796 #endif
 797
 798 /* also used for ADTS AAC */
 799 static int ac3_parse(AVCodecParserContext *s1,
 800                      AVCodecContext *avctx,
 801                      uint8_t **poutbuf, int *poutbuf_size,
 802                      const uint8_t *buf, int buf_size)
 803 {
 804     AC3ParseContext *s = s1->priv_data;
 805     const uint8_t *buf_ptr;
 806     int len, sample_rate, bit_rate, channels, samples;
 807
 808     *poutbuf = NULL;
 809     *poutbuf_size = 0;
 810
 811     buf_ptr = buf;
 812     while (buf_size > 0) {
 813         len = s->inbuf_ptr - s->inbuf;
 814         if (s->frame_size == 0) {
 815             /* no header seen : find one. We need at least s->header_size
 816                bytes to parse it */
 817             len = FFMIN(s->header_size - len, buf_size);
 818
 819             memcpy(s->inbuf_ptr, buf_ptr, len);
 820             buf_ptr += len;
 821             s->inbuf_ptr += len;
 822             buf_size -= len;
 823             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 824                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 825                               &samples);
 826                 if (len == 0) {
 827                     /* no sync found : move by one byte (inefficient, but simple!) */
 828                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 829                     s->inbuf_ptr--;
 830                 } else {
 831                     s->frame_size = len;
 832                     /* update codec info */
 833                     avctx->sample_rate = sample_rate;
 834                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 835                     if(avctx->codec_id == CODEC_ID_AC3){
 836                         if(avctx->channels!=1 && avctx->channels!=2){
 837                             avctx->channels = channels;
 838                         }
 839                     } else {
 840                         avctx->channels = channels;
 841                     }
 842                     avctx->bit_rate = bit_rate;
 843                     avctx->frame_size = samples;
 844                 }
 845             }
 846         } else {
 847             len = FFMIN(s->frame_size - len, buf_size);
 848
 849             memcpy(s->inbuf_ptr, buf_ptr, len);
 850             buf_ptr += len;
 851             s->inbuf_ptr += len;
 852             buf_size -= len;
 853
 854             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 855                 *poutbuf = s->inbuf;
 856                 *poutbuf_size = s->frame_size;
 857                 s->inbuf_ptr = s->inbuf;
 858                 s->frame_size = 0;
 859                 break;
 860             }
 861         }
 862     }
 863     return buf_ptr - buf;
 864 }
 865 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
 866
 867 #ifdef CONFIG_MPEG4VIDEO_PARSER
 868 AVCodecParser mpeg4video_parser = {
 869     { CODEC_ID_MPEG4 },
 870     sizeof(ParseContext1),
 871     mpeg4video_parse_init,
 872     mpeg4video_parse,
 873     ff_parse1_close,
 874     ff_mpeg4video_split,
 875 };
 876 #endif
 877 #ifdef CONFIG_MPEGAUDIO_PARSER
 878 AVCodecParser mpegaudio_parser = {
 879     { CODEC_ID_MP2, CODEC_ID_MP3 },
 880     sizeof(MpegAudioParseContext),
 881     mpegaudio_parse_init,
 882     mpegaudio_parse,
 883     NULL,
 884 };
 885 #endif
 886 #ifdef CONFIG_AC3_PARSER
 887 AVCodecParser ac3_parser = {
 888     { CODEC_ID_AC3 },
 889     sizeof(AC3ParseContext),
 890     ac3_parse_init,
 891     ac3_parse,
 892     NULL,
 893 };
 894 #endif
 895 #ifdef CONFIG_AAC_PARSER
 896 AVCodecParser aac_parser = {
 897     { CODEC_ID_AAC },
 898     sizeof(AC3ParseContext),
 899     aac_parse_init,
 900     ac3_parse,
 901     NULL,
 902 };
 903 #endif