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
  26 AVCodecParser *av_first_parser = NULL;
  27
  28 void av_register_codec_parser(AVCodecParser *parser)
  29 {
  30     parser->next = av_first_parser;
  31     av_first_parser = parser;
  32 }
  33
  34 AVCodecParserContext *av_parser_init(int codec_id)
  35 {
  36     AVCodecParserContext *s;
  37     AVCodecParser *parser;
  38     int ret;
  39
  40     if(codec_id == CODEC_ID_NONE)
  41         return NULL;
  42
  43     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  44         if (parser->codec_ids[0] == codec_id ||
  45             parser->codec_ids[1] == codec_id ||
  46             parser->codec_ids[2] == codec_id ||
  47             parser->codec_ids[3] == codec_id ||
  48             parser->codec_ids[4] == codec_id)
  49             goto found;
  50     }
  51     return NULL;
  52  found:
  53     s = av_mallocz(sizeof(AVCodecParserContext));
  54     if (!s)
  55         return NULL;
  56     s->parser = parser;
  57     s->priv_data = av_mallocz(parser->priv_data_size);
  58     if (!s->priv_data) {
  59         av_free(s);
  60         return NULL;
  61     }
  62     if (parser->parser_init) {
  63         ret = parser->parser_init(s);
  64         if (ret != 0) {
  65             av_free(s->priv_data);
  66             av_free(s);
  67             return NULL;
  68         }
  69     }
  70     s->fetch_timestamp=1;
  71     return s;
  72 }
  73
  74 /**
  75  *
  76  * @param buf           input
  77  * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
  78  * @param pts           input presentation timestamp
  79  * @param dts           input decoding timestamp
  80  * @param poutbuf       will contain a pointer to the first byte of the output frame
  81  * @param poutbuf_size  will contain the length of the output frame
  82  * @return the number of bytes of the input bitstream used
  83  *
  84  * Example:
  85  * @code
  86  *   while(in_len){
  87  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
  88  *                                       in_data, in_len,
  89  *                                       pts, dts);
  90  *       in_data += len;
  91  *       in_len  -= len;
  92  *
  93  *       decode_frame(data, size);
  94  *   }
  95  * @endcode
  96  */
  97 int av_parser_parse(AVCodecParserContext *s,
  98                     AVCodecContext *avctx,
  99                     uint8_t **poutbuf, int *poutbuf_size,
 100                     const uint8_t *buf, int buf_size,
 101                     int64_t pts, int64_t dts)
 102 {
 103     int index, i, k;
 104     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 105
 106     if (buf_size == 0) {
 107         /* padding is always necessary even if EOF, so we add it here */
 108         memset(dummy_buf, 0, sizeof(dummy_buf));
 109         buf = dummy_buf;
 110     } else {
 111         /* add a new packet descriptor */
 112         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 113         s->cur_frame_start_index = k;
 114         s->cur_frame_offset[k] = s->cur_offset;
 115         s->cur_frame_pts[k] = pts;
 116         s->cur_frame_dts[k] = dts;
 117
 118         /* fill first PTS/DTS */
 119         if (s->fetch_timestamp){
 120             s->fetch_timestamp=0;
 121             s->last_pts = pts;
 122             s->last_dts = dts;
 123             s->cur_frame_pts[k] =
 124             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
 125         }
 126     }
 127
 128     /* WARNING: the returned index can be negative */
 129     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 130 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%lld, %lld, out:%lld, %lld, in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
 131     /* update the file pointer */
 132     if (*poutbuf_size) {
 133         /* fill the data for the current frame */
 134         s->frame_offset = s->last_frame_offset;
 135         s->pts = s->last_pts;
 136         s->dts = s->last_dts;
 137
 138         /* offset of the next frame */
 139         s->last_frame_offset = s->cur_offset + index;
 140         /* find the packet in which the new frame starts. It
 141            is tricky because of MPEG video start codes
 142            which can begin in one packet and finish in
 143            another packet. In the worst case, an MPEG
 144            video start code could be in 4 different
 145            packets. */
 146         k = s->cur_frame_start_index;
 147         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 148             if (s->last_frame_offset >= s->cur_frame_offset[k])
 149                 break;
 150             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 151         }
 152
 153         s->last_pts = s->cur_frame_pts[k];
 154         s->last_dts = s->cur_frame_dts[k];
 155
 156         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 157            so the next pts/dts is in the next chunk */
 158         if(index == buf_size){
 159             s->fetch_timestamp=1;
 160         }
 161     }
 162     if (index < 0)
 163         index = 0;
 164     s->cur_offset += index;
 165     return index;
 166 }
 167
 168 /**
 169  *
 170  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 171  * @deprecated use AVBitstreamFilter
 172  */
 173 int av_parser_change(AVCodecParserContext *s,
 174                      AVCodecContext *avctx,
 175                      uint8_t **poutbuf, int *poutbuf_size,
 176                      const uint8_t *buf, int buf_size, int keyframe){
 177
 178     if(s && s->parser->split){
 179         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
 180             int i= s->parser->split(avctx, buf, buf_size);
 181             buf += i;
 182             buf_size -= i;
 183         }
 184     }
 185
 186     /* cast to avoid warning about discarding qualifiers */
 187     *poutbuf= (uint8_t *) buf;
 188     *poutbuf_size= buf_size;
 189     if(avctx->extradata){
 190         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 191             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 192             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 193             int size= buf_size + avctx->extradata_size;
 194             *poutbuf_size= size;
 195             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 196
 197             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 198             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 199             return 1;
 200         }
 201     }
 202
 203     return 0;
 204 }
 205
 206 void av_parser_close(AVCodecParserContext *s)
 207 {
 208     if (s->parser->parser_close)
 209         s->parser->parser_close(s);
 210     av_free(s->priv_data);
 211     av_free(s);
 212 }
 213
 214 /*****************************************************/
 215
 216 //#define END_NOT_FOUND (-100)
 217
 218 #define PICTURE_START_CODE      0x00000100
 219 #define SEQ_START_CODE          0x000001b3
 220 #define EXT_START_CODE          0x000001b5
 221 #define SLICE_MIN_START_CODE    0x00000101
 222 #define SLICE_MAX_START_CODE    0x000001af
 223
 224 typedef struct ParseContext1{
 225     ParseContext pc;
 226 /* XXX/FIXME PC1 vs. PC */
 227     /* MPEG2 specific */
 228     int frame_rate;
 229     int progressive_sequence;
 230     int width, height;
 231
 232     /* XXX: suppress that, needed by MPEG4 */
 233     MpegEncContext *enc;
 234     int first_picture;
 235 } ParseContext1;
 236
 237 /**
 238  * combines the (truncated) bitstream to a complete frame
 239  * @returns -1 if no complete frame could be created
 240  */
 241 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 242 {
 243 #if 0
 244     if(pc->overread){
 245         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 246         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 247     }
 248 #endif
 249
 250     /* copy overreaded bytes from last frame into buffer */
 251     for(; pc->overread>0; pc->overread--){
 252         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 253     }
 254
 255     /* flush remaining if EOF */
 256     if(!*buf_size && next == END_NOT_FOUND){
 257         next= 0;
 258     }
 259
 260     pc->last_index= pc->index;
 261
 262     /* copy into buffer end return */
 263     if(next == END_NOT_FOUND){
 264         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 265
 266         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 267         pc->index += *buf_size;
 268         return -1;
 269     }
 270
 271     *buf_size=
 272     pc->overread_index= pc->index + next;
 273
 274     /* append to buffer */
 275     if(pc->index){
 276         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 277
 278         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 279         pc->index = 0;
 280         *buf= pc->buffer;
 281     }
 282
 283     /* store overread bytes */
 284     for(;next < 0; next++){
 285         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 286         pc->overread++;
 287     }
 288
 289 #if 0
 290     if(pc->overread){
 291         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 292         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 293     }
 294 #endif
 295
 296     return 0;
 297 }
 298
 299 /* XXX: merge with libavcodec ? */
 300 #define MPEG1_FRAME_RATE_BASE 1001
 301
 302 static const int frame_rate_tab[16] = {
 303         0,
 304     24000,
 305     24024,
 306     25025,
 307     30000,
 308     30030,
 309     50050,
 310     60000,
 311     60060,
 312   // Xing's 15fps: (9)
 313     15015,
 314   // libmpeg3's "Unofficial economy rates": (10-13)
 315      5005,
 316     10010,
 317     12012,
 318     15015,
 319   // random, just to avoid segfault !never encode these
 320     25025,
 321     25025,
 322 };
 323
 324 #ifdef CONFIG_MPEGVIDEO_PARSER
 325 //FIXME move into mpeg12.c
 326 static void mpegvideo_extract_headers(AVCodecParserContext *s,
 327                                       AVCodecContext *avctx,
 328                                       const uint8_t *buf, int buf_size)
 329 {
 330     ParseContext1 *pc = s->priv_data;
 331     const uint8_t *buf_end;
 332     uint32_t start_code;
 333     int frame_rate_index, ext_type, bytes_left;
 334     int frame_rate_ext_n, frame_rate_ext_d;
 335     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
 336     int horiz_size_ext, vert_size_ext, bit_rate_ext;
 337 //FIXME replace the crap with get_bits()
 338     s->repeat_pict = 0;
 339     buf_end = buf + buf_size;
 340     while (buf < buf_end) {
 341         start_code= -1;
 342         buf= ff_find_start_code(buf, buf_end, &start_code);
 343         bytes_left = buf_end - buf;
 344         switch(start_code) {
 345         case PICTURE_START_CODE:
 346             if (bytes_left >= 2) {
 347                 s->pict_type = (buf[1] >> 3) & 7;
 348             }
 349             break;
 350         case SEQ_START_CODE:
 351             if (bytes_left >= 7) {
 352                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
 353                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
 354                 avcodec_set_dimensions(avctx, pc->width, pc->height);
 355                 frame_rate_index = buf[3] & 0xf;
 356                 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
 357                 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
 358                 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
 359                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
 360                 avctx->sub_id = 1;
 361             }
 362             break;
 363         case EXT_START_CODE:
 364             if (bytes_left >= 1) {
 365                 ext_type = (buf[0] >> 4);
 366                 switch(ext_type) {
 367                 case 0x1: /* sequence extension */
 368                     if (bytes_left >= 6) {
 369                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
 370                         vert_size_ext = (buf[2] >> 5) & 3;
 371                         bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
 372                         frame_rate_ext_n = (buf[5] >> 5) & 3;
 373                         frame_rate_ext_d = (buf[5] & 0x1f);
 374                         pc->progressive_sequence = buf[1] & (1 << 3);
 375                         avctx->has_b_frames= !(buf[5] >> 7);
 376
 377                         pc->width  |=(horiz_size_ext << 12);
 378                         pc->height |=( vert_size_ext << 12);
 379                         avctx->bit_rate += (bit_rate_ext << 18) * 400;
 380                         avcodec_set_dimensions(avctx, pc->width, pc->height);
 381                         avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
 382                         avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
 383                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
 384                         avctx->sub_id = 2; /* forces MPEG2 */
 385                     }
 386                     break;
 387                 case 0x8: /* picture coding extension */
 388                     if (bytes_left >= 5) {
 389                         picture_structure = buf[2]&3;
 390                         top_field_first = buf[3] & (1 << 7);
 391                         repeat_first_field = buf[3] & (1 << 1);
 392                         progressive_frame = buf[4] & (1 << 7);
 393
 394                         /* check if we must repeat the frame */
 395                         if (repeat_first_field) {
 396                             if (pc->progressive_sequence) {
 397                                 if (top_field_first)
 398                                     s->repeat_pict = 4;
 399                                 else
 400                                     s->repeat_pict = 2;
 401                             } else if (progressive_frame) {
 402                                 s->repeat_pict = 1;
 403                             }
 404                         }
 405
 406                         /* the packet only represents half a frame
 407                            XXX,FIXME maybe find a different solution */
 408                         if(picture_structure != 3)
 409                             s->repeat_pict = -1;
 410                     }
 411                     break;
 412                 }
 413             }
 414             break;
 415         case -1:
 416             goto the_end;
 417         default:
 418             /* we stop parsing when we encounter a slice. It ensures
 419                that this function takes a negligible amount of time */
 420             if (start_code >= SLICE_MIN_START_CODE &&
 421                 start_code <= SLICE_MAX_START_CODE)
 422                 goto the_end;
 423             break;
 424         }
 425     }
 426  the_end: ;
 427 }
 428
 429 static int mpegvideo_parse(AVCodecParserContext *s,
 430                            AVCodecContext *avctx,
 431                            uint8_t **poutbuf, int *poutbuf_size,
 432                            const uint8_t *buf, int buf_size)
 433 {
 434     ParseContext1 *pc1 = s->priv_data;
 435     ParseContext *pc= &pc1->pc;
 436     int next;
 437
 438     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 439         next= buf_size;
 440     }else{
 441         next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
 442
 443         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 444             *poutbuf = NULL;
 445             *poutbuf_size = 0;
 446             return buf_size;
 447         }
 448
 449     }
 450     /* we have a full frame : we just parse the first few MPEG headers
 451        to have the full timing information. The time take by this
 452        function should be negligible for uncorrupted streams */
 453     mpegvideo_extract_headers(s, avctx, buf, buf_size);
 454 #if 0
 455     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
 456            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
 457 #endif
 458
 459     *poutbuf = (uint8_t *)buf;
 460     *poutbuf_size = buf_size;
 461     return next;
 462 }
 463
 464 static int mpegvideo_split(AVCodecContext *avctx,
 465                            const uint8_t *buf, int buf_size)
 466 {
 467     int i;
 468     uint32_t state= -1;
 469
 470     for(i=0; i<buf_size; i++){
 471         state= (state<<8) | buf[i];
 472         if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
 473             return i-3;
 474     }
 475     return 0;
 476 }
 477 #endif /* CONFIG_MPEGVIDEO_PARSER */
 478
 479 void ff_parse_close(AVCodecParserContext *s)
 480 {
 481     ParseContext *pc = s->priv_data;
 482
 483     av_free(pc->buffer);
 484 }
 485
 486 static void parse1_close(AVCodecParserContext *s)
 487 {
 488     ParseContext1 *pc1 = s->priv_data;
 489
 490     av_free(pc1->pc.buffer);
 491     av_free(pc1->enc);
 492 }
 493
 494 /*************************/
 495
 496 #ifdef CONFIG_MPEG4VIDEO_PARSER
 497 /* used by parser */
 498 /* XXX: make it use less memory */
 499 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 500                                   AVCodecContext *avctx,
 501                                   const uint8_t *buf, int buf_size)
 502 {
 503     ParseContext1 *pc = s1->priv_data;
 504     MpegEncContext *s = pc->enc;
 505     GetBitContext gb1, *gb = &gb1;
 506     int ret;
 507
 508     s->avctx = avctx;
 509     s->current_picture_ptr = &s->current_picture;
 510
 511     if (avctx->extradata_size && pc->first_picture){
 512         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 513         ret = ff_mpeg4_decode_picture_header(s, gb);
 514     }
 515
 516     init_get_bits(gb, buf, 8 * buf_size);
 517     ret = ff_mpeg4_decode_picture_header(s, gb);
 518     if (s->width) {
 519         avcodec_set_dimensions(avctx, s->width, s->height);
 520     }
 521     s1->pict_type= s->pict_type;
 522     pc->first_picture = 0;
 523     return ret;
 524 }
 525
 526 static int mpeg4video_parse_init(AVCodecParserContext *s)
 527 {
 528     ParseContext1 *pc = s->priv_data;
 529
 530     pc->enc = av_mallocz(sizeof(MpegEncContext));
 531     if (!pc->enc)
 532         return -1;
 533     pc->first_picture = 1;
 534     return 0;
 535 }
 536
 537 static int mpeg4video_parse(AVCodecParserContext *s,
 538                            AVCodecContext *avctx,
 539                            uint8_t **poutbuf, int *poutbuf_size,
 540                            const uint8_t *buf, int buf_size)
 541 {
 542     ParseContext *pc = s->priv_data;
 543     int next;
 544
 545     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 546         next= buf_size;
 547     }else{
 548         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 549
 550         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 551             *poutbuf = NULL;
 552             *poutbuf_size = 0;
 553             return buf_size;
 554         }
 555     }
 556     av_mpeg4_decode_header(s, avctx, buf, buf_size);
 557
 558     *poutbuf = (uint8_t *)buf;
 559     *poutbuf_size = buf_size;
 560     return next;
 561 }
 562 #endif
 563
 564 #ifdef CONFIG_CAVSVIDEO_PARSER
 565 static int cavsvideo_parse(AVCodecParserContext *s,
 566                            AVCodecContext *avctx,
 567                            uint8_t **poutbuf, int *poutbuf_size,
 568                            const uint8_t *buf, int buf_size)
 569 {
 570     ParseContext *pc = s->priv_data;
 571     int next;
 572
 573     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 574         next= buf_size;
 575     }else{
 576         next= ff_cavs_find_frame_end(pc, buf, buf_size);
 577
 578         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 579             *poutbuf = NULL;
 580             *poutbuf_size = 0;
 581             return buf_size;
 582         }
 583     }
 584     *poutbuf = (uint8_t *)buf;
 585     *poutbuf_size = buf_size;
 586     return next;
 587 }
 588 #endif /* CONFIG_CAVSVIDEO_PARSER */
 589
 590 static int mpeg4video_split(AVCodecContext *avctx,
 591                            const uint8_t *buf, int buf_size)
 592 {
 593     int i;
 594     uint32_t state= -1;
 595
 596     for(i=0; i<buf_size; i++){
 597         state= (state<<8) | buf[i];
 598         if(state == 0x1B3 || state == 0x1B6)
 599             return i-3;
 600     }
 601     return 0;
 602 }
 603
 604 /*************************/
 605
 606 #ifdef CONFIG_MPEGAUDIO_PARSER
 607 typedef struct MpegAudioParseContext {
 608     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 609     uint8_t *inbuf_ptr;
 610     int frame_size;
 611     int free_format_frame_size;
 612     int free_format_next_header;
 613     uint32_t header;
 614     int header_count;
 615 } MpegAudioParseContext;
 616
 617 #define MPA_HEADER_SIZE 4
 618
 619 /* header + layer + bitrate + freq + lsf/mpeg25 */
 620 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 621 #define SAME_HEADER_MASK \
 622    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 623
 624 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 625 {
 626     MpegAudioParseContext *s = s1->priv_data;
 627     s->inbuf_ptr = s->inbuf;
 628     return 0;
 629 }
 630
 631 static int mpegaudio_parse(AVCodecParserContext *s1,
 632                            AVCodecContext *avctx,
 633                            uint8_t **poutbuf, int *poutbuf_size,
 634                            const uint8_t *buf, int buf_size)
 635 {
 636     MpegAudioParseContext *s = s1->priv_data;
 637     int len, ret, sr;
 638     uint32_t header;
 639     const uint8_t *buf_ptr;
 640
 641     *poutbuf = NULL;
 642     *poutbuf_size = 0;
 643     buf_ptr = buf;
 644     while (buf_size > 0) {
 645         len = s->inbuf_ptr - s->inbuf;
 646         if (s->frame_size == 0) {
 647             /* special case for next header for first frame in free
 648                format case (XXX: find a simpler method) */
 649             if (s->free_format_next_header != 0) {
 650                 s->inbuf[0] = s->free_format_next_header >> 24;
 651                 s->inbuf[1] = s->free_format_next_header >> 16;
 652                 s->inbuf[2] = s->free_format_next_header >> 8;
 653                 s->inbuf[3] = s->free_format_next_header;
 654                 s->inbuf_ptr = s->inbuf + 4;
 655                 s->free_format_next_header = 0;
 656                 goto got_header;
 657             }
 658             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 659                bytes to parse it */
 660             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
 661             if (len > 0) {
 662                 memcpy(s->inbuf_ptr, buf_ptr, len);
 663                 buf_ptr += len;
 664                 buf_size -= len;
 665                 s->inbuf_ptr += len;
 666             }
 667             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 668             got_header:
 669                 sr= avctx->sample_rate;
 670                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 671                     (s->inbuf[2] << 8) | s->inbuf[3];
 672
 673                 ret = mpa_decode_header(avctx, header);
 674                 if (ret < 0) {
 675                     s->header_count= -2;
 676                     /* no sync found : move by one byte (inefficient, but simple!) */
 677                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 678                     s->inbuf_ptr--;
 679                     dprintf("skip %x\n", header);
 680                     /* reset free format frame size to give a chance
 681                        to get a new bitrate */
 682                     s->free_format_frame_size = 0;
 683                 } else {
 684                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
 685                         s->header_count= -3;
 686                     s->header= header;
 687                     s->header_count++;
 688                     s->frame_size = ret;
 689
 690 #if 0
 691                     /* free format: prepare to compute frame size */
 692                     if (decode_header(s, header) == 1) {
 693                         s->frame_size = -1;
 694                     }
 695 #endif
 696                 }
 697                 if(s->header_count <= 0)
 698                     avctx->sample_rate= sr; //FIXME ugly
 699             }
 700         } else
 701 #if 0
 702         if (s->frame_size == -1) {
 703             /* free format : find next sync to compute frame size */
 704             len = MPA_MAX_CODED_FRAME_SIZE - len;
 705             if (len > buf_size)
 706                 len = buf_size;
 707             if (len == 0) {
 708                 /* frame too long: resync */
 709                 s->frame_size = 0;
 710                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 711                 s->inbuf_ptr--;
 712             } else {
 713                 uint8_t *p, *pend;
 714                 uint32_t header1;
 715                 int padding;
 716
 717                 memcpy(s->inbuf_ptr, buf_ptr, len);
 718                 /* check for header */
 719                 p = s->inbuf_ptr - 3;
 720                 pend = s->inbuf_ptr + len - 4;
 721                 while (p <= pend) {
 722                     header = (p[0] << 24) | (p[1] << 16) |
 723                         (p[2] << 8) | p[3];
 724                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 725                         (s->inbuf[2] << 8) | s->inbuf[3];
 726                     /* check with high probability that we have a
 727                        valid header */
 728                     if ((header & SAME_HEADER_MASK) ==
 729                         (header1 & SAME_HEADER_MASK)) {
 730                         /* header found: update pointers */
 731                         len = (p + 4) - s->inbuf_ptr;
 732                         buf_ptr += len;
 733                         buf_size -= len;
 734                         s->inbuf_ptr = p;
 735                         /* compute frame size */
 736                         s->free_format_next_header = header;
 737                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 738                         padding = (header1 >> 9) & 1;
 739                         if (s->layer == 1)
 740                             s->free_format_frame_size -= padding * 4;
 741                         else
 742                             s->free_format_frame_size -= padding;
 743                         dprintf("free frame size=%d padding=%d\n",
 744                                 s->free_format_frame_size, padding);
 745                         decode_header(s, header1);
 746                         goto next_data;
 747                     }
 748                     p++;
 749                 }
 750                 /* not found: simply increase pointers */
 751                 buf_ptr += len;
 752                 s->inbuf_ptr += len;
 753                 buf_size -= len;
 754             }
 755         } else
 756 #endif
 757         if (len < s->frame_size) {
 758             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 759                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 760             len = FFMIN(s->frame_size - len, buf_size);
 761             memcpy(s->inbuf_ptr, buf_ptr, len);
 762             buf_ptr += len;
 763             s->inbuf_ptr += len;
 764             buf_size -= len;
 765         }
 766
 767         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
 768            && buf_size + buf_ptr - buf >= s->frame_size){
 769             if(s->header_count > 0){
 770                 *poutbuf = buf;
 771                 *poutbuf_size = s->frame_size;
 772             }
 773             buf_ptr = buf + s->frame_size;
 774             s->inbuf_ptr = s->inbuf;
 775             s->frame_size = 0;
 776             break;
 777         }
 778
 779         //    next_data:
 780         if (s->frame_size > 0 &&
 781             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 782             if(s->header_count > 0){
 783                 *poutbuf = s->inbuf;
 784                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
 785             }
 786             s->inbuf_ptr = s->inbuf;
 787             s->frame_size = 0;
 788             break;
 789         }
 790     }
 791     return buf_ptr - buf;
 792 }
 793 #endif /* CONFIG_MPEGAUDIO_PARSER */
 794
 795 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
 796 /* also used for ADTS AAC */
 797 typedef struct AC3ParseContext {
 798     uint8_t *inbuf_ptr;
 799     int frame_size;
 800     int header_size;
 801     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
 802                 int *bit_rate, int *samples);
 803     uint8_t inbuf[8192]; /* input buffer */
 804 } AC3ParseContext;
 805
 806 #define AC3_HEADER_SIZE 7
 807 #define AAC_HEADER_SIZE 7
 808
 809 #ifdef CONFIG_AC3_PARSER
 810 static const int ac3_sample_rates[4] = {
 811     48000, 44100, 32000, 0
 812 };
 813
 814 static const int ac3_frame_sizes[64][3] = {
 815     { 64,   69,   96   },
 816     { 64,   70,   96   },
 817     { 80,   87,   120  },
 818     { 80,   88,   120  },
 819     { 96,   104,  144  },
 820     { 96,   105,  144  },
 821     { 112,  121,  168  },
 822     { 112,  122,  168  },
 823     { 128,  139,  192  },
 824     { 128,  140,  192  },
 825     { 160,  174,  240  },
 826     { 160,  175,  240  },
 827     { 192,  208,  288  },
 828     { 192,  209,  288  },
 829     { 224,  243,  336  },
 830     { 224,  244,  336  },
 831     { 256,  278,  384  },
 832     { 256,  279,  384  },
 833     { 320,  348,  480  },
 834     { 320,  349,  480  },
 835     { 384,  417,  576  },
 836     { 384,  418,  576  },
 837     { 448,  487,  672  },
 838     { 448,  488,  672  },
 839     { 512,  557,  768  },
 840     { 512,  558,  768  },
 841     { 640,  696,  960  },
 842     { 640,  697,  960  },
 843     { 768,  835,  1152 },
 844     { 768,  836,  1152 },
 845     { 896,  975,  1344 },
 846     { 896,  976,  1344 },
 847     { 1024, 1114, 1536 },
 848     { 1024, 1115, 1536 },
 849     { 1152, 1253, 1728 },
 850     { 1152, 1254, 1728 },
 851     { 1280, 1393, 1920 },
 852     { 1280, 1394, 1920 },
 853 };
 854
 855 static const int ac3_bitrates[64] = {
 856     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
 857     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
 858     384, 448, 448, 512, 512, 576, 576, 640, 640,
 859 };
 860
 861 static const int ac3_channels[8] = {
 862     2, 1, 2, 3, 3, 4, 4, 5
 863 };
 864 #endif /* CONFIG_AC3_PARSER */
 865
 866 #ifdef CONFIG_AAC_PARSER
 867 static const int aac_sample_rates[16] = {
 868     96000, 88200, 64000, 48000, 44100, 32000,
 869     24000, 22050, 16000, 12000, 11025, 8000, 7350
 870 };
 871
 872 static const int aac_channels[8] = {
 873     0, 1, 2, 3, 4, 5, 6, 8
 874 };
 875 #endif
 876
 877 #ifdef CONFIG_AC3_PARSER
 878 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 879                     int *bit_rate, int *samples)
 880 {
 881     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
 882     GetBitContext bits;
 883
 884     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
 885
 886     if(get_bits(&bits, 16) != 0x0b77)
 887         return 0;
 888
 889     skip_bits(&bits, 16);       /* crc */
 890     fscod = get_bits(&bits, 2);
 891     frmsizecod = get_bits(&bits, 6);
 892
 893     if(!ac3_sample_rates[fscod])
 894         return 0;
 895
 896     bsid = get_bits(&bits, 5);
 897     if(bsid > 8)
 898         return 0;
 899     skip_bits(&bits, 3);        /* bsmod */
 900     acmod = get_bits(&bits, 3);
 901     if(acmod & 1 && acmod != 1)
 902         skip_bits(&bits, 2);    /* cmixlev */
 903     if(acmod & 4)
 904         skip_bits(&bits, 2);    /* surmixlev */
 905     if(acmod & 2)
 906         skip_bits(&bits, 2);    /* dsurmod */
 907     lfeon = get_bits1(&bits);
 908
 909     *sample_rate = ac3_sample_rates[fscod];
 910     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
 911     *channels = ac3_channels[acmod] + lfeon;
 912     *samples = 6 * 256;
 913
 914     return ac3_frame_sizes[frmsizecod][fscod] * 2;
 915 }
 916 #endif /* CONFIG_AC3_PARSER */
 917
 918 #ifdef CONFIG_AAC_PARSER
 919 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 920                     int *bit_rate, int *samples)
 921 {
 922     GetBitContext bits;
 923     int size, rdb, ch, sr;
 924
 925     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 926
 927     if(get_bits(&bits, 12) != 0xfff)
 928         return 0;
 929
 930     skip_bits1(&bits);          /* id */
 931     skip_bits(&bits, 2);        /* layer */
 932     skip_bits1(&bits);          /* protection_absent */
 933     skip_bits(&bits, 2);        /* profile_objecttype */
 934     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 935     if(!aac_sample_rates[sr])
 936         return 0;
 937     skip_bits1(&bits);          /* private_bit */
 938     ch = get_bits(&bits, 3);    /* channel_configuration */
 939     if(!aac_channels[ch])
 940         return 0;
 941     skip_bits1(&bits);          /* original/copy */
 942     skip_bits1(&bits);          /* home */
 943
 944     /* adts_variable_header */
 945     skip_bits1(&bits);          /* copyright_identification_bit */
 946     skip_bits1(&bits);          /* copyright_identification_start */
 947     size = get_bits(&bits, 13); /* aac_frame_length */
 948     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 949     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 950
 951     *channels = aac_channels[ch];
 952     *sample_rate = aac_sample_rates[sr];
 953     *samples = (rdb + 1) * 1024;
 954     *bit_rate = size * 8 * *sample_rate / *samples;
 955
 956     return size;
 957 }
 958 #endif /* CONFIG_AAC_PARSER */
 959
 960 #ifdef CONFIG_AC3_PARSER
 961 static int ac3_parse_init(AVCodecParserContext *s1)
 962 {
 963     AC3ParseContext *s = s1->priv_data;
 964     s->inbuf_ptr = s->inbuf;
 965     s->header_size = AC3_HEADER_SIZE;
 966     s->sync = ac3_sync;
 967     return 0;
 968 }
 969 #endif
 970
 971 #ifdef CONFIG_AAC_PARSER
 972 static int aac_parse_init(AVCodecParserContext *s1)
 973 {
 974     AC3ParseContext *s = s1->priv_data;
 975     s->inbuf_ptr = s->inbuf;
 976     s->header_size = AAC_HEADER_SIZE;
 977     s->sync = aac_sync;
 978     return 0;
 979 }
 980 #endif
 981
 982 /* also used for ADTS AAC */
 983 static int ac3_parse(AVCodecParserContext *s1,
 984                      AVCodecContext *avctx,
 985                      uint8_t **poutbuf, int *poutbuf_size,
 986                      const uint8_t *buf, int buf_size)
 987 {
 988     AC3ParseContext *s = s1->priv_data;
 989     const uint8_t *buf_ptr;
 990     int len, sample_rate, bit_rate, channels, samples;
 991
 992     *poutbuf = NULL;
 993     *poutbuf_size = 0;
 994
 995     buf_ptr = buf;
 996     while (buf_size > 0) {
 997         len = s->inbuf_ptr - s->inbuf;
 998         if (s->frame_size == 0) {
 999             /* no header seen : find one. We need at least s->header_size
1000                bytes to parse it */
1001             len = FFMIN(s->header_size - len, buf_size);
1002
1003             memcpy(s->inbuf_ptr, buf_ptr, len);
1004             buf_ptr += len;
1005             s->inbuf_ptr += len;
1006             buf_size -= len;
1007             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
1008                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
1009                               &samples);
1010                 if (len == 0) {
1011                     /* no sync found : move by one byte (inefficient, but simple!) */
1012                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
1013                     s->inbuf_ptr--;
1014                 } else {
1015                     s->frame_size = len;
1016                     /* update codec info */
1017                     avctx->sample_rate = sample_rate;
1018                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
1019                     if(avctx->codec_id == CODEC_ID_AC3){
1020                         if(avctx->channels!=1 && avctx->channels!=2){
1021                             avctx->channels = channels;
1022                         }
1023                     } else {
1024                         avctx->channels = channels;
1025                     }
1026                     avctx->bit_rate = bit_rate;
1027                     avctx->frame_size = samples;
1028                 }
1029             }
1030         } else {
1031             len = FFMIN(s->frame_size - len, buf_size);
1032
1033             memcpy(s->inbuf_ptr, buf_ptr, len);
1034             buf_ptr += len;
1035             s->inbuf_ptr += len;
1036             buf_size -= len;
1037
1038             if(s->inbuf_ptr - s->inbuf == s->frame_size){
1039                 *poutbuf = s->inbuf;
1040                 *poutbuf_size = s->frame_size;
1041                 s->inbuf_ptr = s->inbuf;
1042                 s->frame_size = 0;
1043                 break;
1044             }
1045         }
1046     }
1047     return buf_ptr - buf;
1048 }
1049 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
1050
1051 #ifdef CONFIG_MPEGVIDEO_PARSER
1052 AVCodecParser mpegvideo_parser = {
1053     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
1054     sizeof(ParseContext1),
1055     NULL,
1056     mpegvideo_parse,
1057     parse1_close,
1058     mpegvideo_split,
1059 };
1060 #endif
1061 #ifdef CONFIG_MPEG4VIDEO_PARSER
1062 AVCodecParser mpeg4video_parser = {
1063     { CODEC_ID_MPEG4 },
1064     sizeof(ParseContext1),
1065     mpeg4video_parse_init,
1066     mpeg4video_parse,
1067     parse1_close,
1068     mpeg4video_split,
1069 };
1070 #endif
1071 #ifdef CONFIG_CAVSVIDEO_PARSER
1072 AVCodecParser cavsvideo_parser = {
1073     { CODEC_ID_CAVS },
1074     sizeof(ParseContext1),
1075     NULL,
1076     cavsvideo_parse,
1077     parse1_close,
1078     mpeg4video_split,
1079 };
1080 #endif
1081 #ifdef CONFIG_MPEGAUDIO_PARSER
1082 AVCodecParser mpegaudio_parser = {
1083     { CODEC_ID_MP2, CODEC_ID_MP3 },
1084     sizeof(MpegAudioParseContext),
1085     mpegaudio_parse_init,
1086     mpegaudio_parse,
1087     NULL,
1088 };
1089 #endif
1090 #ifdef CONFIG_AC3_PARSER
1091 AVCodecParser ac3_parser = {
1092     { CODEC_ID_AC3 },
1093     sizeof(AC3ParseContext),
1094     ac3_parse_init,
1095     ac3_parse,
1096     NULL,
1097 };
1098 #endif
1099 #ifdef CONFIG_AAC_PARSER
1100 AVCodecParser aac_parser = {
1101     { CODEC_ID_AAC },
1102     sizeof(AC3ParseContext),
1103     aac_parse_init,
1104     ac3_parse,
1105     NULL,
1106 };
1107 #endif