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 int ac3_channels[8] = {
 636     2, 1, 2, 3, 3, 4, 4, 5
 637 };
 638 #endif /* CONFIG_AC3_PARSER */
 639
 640 #ifdef CONFIG_AAC_PARSER
 641 static const int aac_sample_rates[16] = {
 642     96000, 88200, 64000, 48000, 44100, 32000,
 643     24000, 22050, 16000, 12000, 11025, 8000, 7350
 644 };
 645
 646 static const int aac_channels[8] = {
 647     0, 1, 2, 3, 4, 5, 6, 8
 648 };
 649 #endif
 650
 651 #ifdef CONFIG_AC3_PARSER
 652 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 653                     int *bit_rate, int *samples)
 654 {
 655     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
 656     GetBitContext bits;
 657
 658     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
 659
 660     if(get_bits(&bits, 16) != 0x0b77)
 661         return 0;
 662
 663     skip_bits(&bits, 16);       /* crc */
 664     fscod = get_bits(&bits, 2);
 665     frmsizecod = get_bits(&bits, 6);
 666
 667     if(!ac3_sample_rates[fscod])
 668         return 0;
 669
 670     bsid = get_bits(&bits, 5);
 671     if(bsid > 8)
 672         return 0;
 673     skip_bits(&bits, 3);        /* bsmod */
 674     acmod = get_bits(&bits, 3);
 675     if(acmod & 1 && acmod != 1)
 676         skip_bits(&bits, 2);    /* cmixlev */
 677     if(acmod & 4)
 678         skip_bits(&bits, 2);    /* surmixlev */
 679     if(acmod & 2)
 680         skip_bits(&bits, 2);    /* dsurmod */
 681     lfeon = get_bits1(&bits);
 682
 683     *sample_rate = ac3_sample_rates[fscod];
 684     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
 685     *channels = ac3_channels[acmod] + lfeon;
 686     *samples = 6 * 256;
 687
 688     return ac3_frame_sizes[frmsizecod][fscod] * 2;
 689 }
 690 #endif /* CONFIG_AC3_PARSER */
 691
 692 #ifdef CONFIG_AAC_PARSER
 693 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 694                     int *bit_rate, int *samples)
 695 {
 696     GetBitContext bits;
 697     int size, rdb, ch, sr;
 698
 699     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 700
 701     if(get_bits(&bits, 12) != 0xfff)
 702         return 0;
 703
 704     skip_bits1(&bits);          /* id */
 705     skip_bits(&bits, 2);        /* layer */
 706     skip_bits1(&bits);          /* protection_absent */
 707     skip_bits(&bits, 2);        /* profile_objecttype */
 708     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 709     if(!aac_sample_rates[sr])
 710         return 0;
 711     skip_bits1(&bits);          /* private_bit */
 712     ch = get_bits(&bits, 3);    /* channel_configuration */
 713     if(!aac_channels[ch])
 714         return 0;
 715     skip_bits1(&bits);          /* original/copy */
 716     skip_bits1(&bits);          /* home */
 717
 718     /* adts_variable_header */
 719     skip_bits1(&bits);          /* copyright_identification_bit */
 720     skip_bits1(&bits);          /* copyright_identification_start */
 721     size = get_bits(&bits, 13); /* aac_frame_length */
 722     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 723     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 724
 725     *channels = aac_channels[ch];
 726     *sample_rate = aac_sample_rates[sr];
 727     *samples = (rdb + 1) * 1024;
 728     *bit_rate = size * 8 * *sample_rate / *samples;
 729
 730     return size;
 731 }
 732 #endif /* CONFIG_AAC_PARSER */
 733
 734 #ifdef CONFIG_AC3_PARSER
 735 static int ac3_parse_init(AVCodecParserContext *s1)
 736 {
 737     AC3ParseContext *s = s1->priv_data;
 738     s->inbuf_ptr = s->inbuf;
 739     s->header_size = AC3_HEADER_SIZE;
 740     s->sync = ac3_sync;
 741     return 0;
 742 }
 743 #endif
 744
 745 #ifdef CONFIG_AAC_PARSER
 746 static int aac_parse_init(AVCodecParserContext *s1)
 747 {
 748     AC3ParseContext *s = s1->priv_data;
 749     s->inbuf_ptr = s->inbuf;
 750     s->header_size = AAC_HEADER_SIZE;
 751     s->sync = aac_sync;
 752     return 0;
 753 }
 754 #endif
 755
 756 /* also used for ADTS AAC */
 757 static int ac3_parse(AVCodecParserContext *s1,
 758                      AVCodecContext *avctx,
 759                      uint8_t **poutbuf, int *poutbuf_size,
 760                      const uint8_t *buf, int buf_size)
 761 {
 762     AC3ParseContext *s = s1->priv_data;
 763     const uint8_t *buf_ptr;
 764     int len, sample_rate, bit_rate, channels, samples;
 765
 766     *poutbuf = NULL;
 767     *poutbuf_size = 0;
 768
 769     buf_ptr = buf;
 770     while (buf_size > 0) {
 771         len = s->inbuf_ptr - s->inbuf;
 772         if (s->frame_size == 0) {
 773             /* no header seen : find one. We need at least s->header_size
 774                bytes to parse it */
 775             len = FFMIN(s->header_size - len, buf_size);
 776
 777             memcpy(s->inbuf_ptr, buf_ptr, len);
 778             buf_ptr += len;
 779             s->inbuf_ptr += len;
 780             buf_size -= len;
 781             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 782                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 783                               &samples);
 784                 if (len == 0) {
 785                     /* no sync found : move by one byte (inefficient, but simple!) */
 786                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 787                     s->inbuf_ptr--;
 788                 } else {
 789                     s->frame_size = len;
 790                     /* update codec info */
 791                     avctx->sample_rate = sample_rate;
 792                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 793                     if(avctx->codec_id == CODEC_ID_AC3){
 794                         if(avctx->channels!=1 && avctx->channels!=2){
 795                             avctx->channels = channels;
 796                         }
 797                     } else {
 798                         avctx->channels = channels;
 799                     }
 800                     avctx->bit_rate = bit_rate;
 801                     avctx->frame_size = samples;
 802                 }
 803             }
 804         } else {
 805             len = FFMIN(s->frame_size - len, buf_size);
 806
 807             memcpy(s->inbuf_ptr, buf_ptr, len);
 808             buf_ptr += len;
 809             s->inbuf_ptr += len;
 810             buf_size -= len;
 811
 812             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 813                 *poutbuf = s->inbuf;
 814                 *poutbuf_size = s->frame_size;
 815                 s->inbuf_ptr = s->inbuf;
 816                 s->frame_size = 0;
 817                 break;
 818             }
 819         }
 820     }
 821     return buf_ptr - buf;
 822 }
 823 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
 824
 825 #ifdef CONFIG_MPEG4VIDEO_PARSER
 826 AVCodecParser mpeg4video_parser = {
 827     { CODEC_ID_MPEG4 },
 828     sizeof(ParseContext1),
 829     mpeg4video_parse_init,
 830     mpeg4video_parse,
 831     ff_parse1_close,
 832     ff_mpeg4video_split,
 833 };
 834 #endif
 835 #ifdef CONFIG_MPEGAUDIO_PARSER
 836 AVCodecParser mpegaudio_parser = {
 837     { CODEC_ID_MP2, CODEC_ID_MP3 },
 838     sizeof(MpegAudioParseContext),
 839     mpegaudio_parse_init,
 840     mpegaudio_parse,
 841     NULL,
 842 };
 843 #endif
 844 #ifdef CONFIG_AC3_PARSER
 845 AVCodecParser ac3_parser = {
 846     { CODEC_ID_AC3 },
 847     sizeof(AC3ParseContext),
 848     ac3_parse_init,
 849     ac3_parse,
 850     NULL,
 851 };
 852 #endif
 853 #ifdef CONFIG_AAC_PARSER
 854 AVCodecParser aac_parser = {
 855     { CODEC_ID_AAC },
 856     sizeof(AC3ParseContext),
 857     aac_parse_init,
 858     ac3_parse,
 859     NULL,
 860 };
 861 #endif