git.sesse.net Git - ffmpeg/blob - libavcodec/parser.c

   1 /*
   2  * Audio and Video frame extraction
   3  * Copyright (c) 2003 Fabrice Bellard.
   4  * Copyright (c) 2003 Michael Niedermayer.
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22 #include "avcodec.h"
  23 #include "mpegvideo.h"
  24 #include "mpegaudio.h"
  25 #include "parser.h"
  26
  27 AVCodecParser *av_first_parser = NULL;
  28
  29 void av_register_codec_parser(AVCodecParser *parser)
  30 {
  31     parser->next = av_first_parser;
  32     av_first_parser = parser;
  33 }
  34
  35 AVCodecParserContext *av_parser_init(int codec_id)
  36 {
  37     AVCodecParserContext *s;
  38     AVCodecParser *parser;
  39     int ret;
  40
  41     if(codec_id == CODEC_ID_NONE)
  42         return NULL;
  43
  44     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  45         if (parser->codec_ids[0] == codec_id ||
  46             parser->codec_ids[1] == codec_id ||
  47             parser->codec_ids[2] == codec_id ||
  48             parser->codec_ids[3] == codec_id ||
  49             parser->codec_ids[4] == codec_id)
  50             goto found;
  51     }
  52     return NULL;
  53  found:
  54     s = av_mallocz(sizeof(AVCodecParserContext));
  55     if (!s)
  56         return NULL;
  57     s->parser = parser;
  58     s->priv_data = av_mallocz(parser->priv_data_size);
  59     if (!s->priv_data) {
  60         av_free(s);
  61         return NULL;
  62     }
  63     if (parser->parser_init) {
  64         ret = parser->parser_init(s);
  65         if (ret != 0) {
  66             av_free(s->priv_data);
  67             av_free(s);
  68             return NULL;
  69         }
  70     }
  71     s->fetch_timestamp=1;
  72     s->pict_type = FF_I_TYPE;
  73     return s;
  74 }
  75
  76 /**
  77  *
  78  * @param buf           input
  79  * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
  80  * @param pts           input presentation timestamp
  81  * @param dts           input decoding timestamp
  82  * @param poutbuf       will contain a pointer to the first byte of the output frame
  83  * @param poutbuf_size  will contain the length of the output frame
  84  * @return the number of bytes of the input bitstream used
  85  *
  86  * Example:
  87  * @code
  88  *   while(in_len){
  89  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
  90  *                                       in_data, in_len,
  91  *                                       pts, dts);
  92  *       in_data += len;
  93  *       in_len  -= len;
  94  *
  95  *       if(size)
  96  *          decode_frame(data, size);
  97  *   }
  98  * @endcode
  99  */
 100 int av_parser_parse(AVCodecParserContext *s,
 101                     AVCodecContext *avctx,
 102                     uint8_t **poutbuf, int *poutbuf_size,
 103                     const uint8_t *buf, int buf_size,
 104                     int64_t pts, int64_t dts)
 105 {
 106     int index, i, k;
 107     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 108
 109     if (buf_size == 0) {
 110         /* padding is always necessary even if EOF, so we add it here */
 111         memset(dummy_buf, 0, sizeof(dummy_buf));
 112         buf = dummy_buf;
 113     } else {
 114         /* add a new packet descriptor */
 115         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 116         s->cur_frame_start_index = k;
 117         s->cur_frame_offset[k] = s->cur_offset;
 118         s->cur_frame_pts[k] = pts;
 119         s->cur_frame_dts[k] = dts;
 120
 121         /* fill first PTS/DTS */
 122         if (s->fetch_timestamp){
 123             s->fetch_timestamp=0;
 124             s->last_pts = pts;
 125             s->last_dts = dts;
 126             s->last_offset = 0;
 127             s->cur_frame_pts[k] =
 128             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
 129         }
 130     }
 131
 132     /* WARNING: the returned index can be negative */
 133     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 134 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
 135     /* update the file pointer */
 136     if (*poutbuf_size) {
 137         /* fill the data for the current frame */
 138         s->frame_offset = s->last_frame_offset;
 139         s->pts = s->last_pts;
 140         s->dts = s->last_dts;
 141         s->offset = s->last_offset;
 142
 143         /* offset of the next frame */
 144         s->last_frame_offset = s->cur_offset + index;
 145         /* find the packet in which the new frame starts. It
 146            is tricky because of MPEG video start codes
 147            which can begin in one packet and finish in
 148            another packet. In the worst case, an MPEG
 149            video start code could be in 4 different
 150            packets. */
 151         k = s->cur_frame_start_index;
 152         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 153             if (s->last_frame_offset >= s->cur_frame_offset[k])
 154                 break;
 155             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 156         }
 157
 158         s->last_pts = s->cur_frame_pts[k];
 159         s->last_dts = s->cur_frame_dts[k];
 160         s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
 161
 162         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 163            so the next pts/dts is in the next chunk */
 164         if(index == buf_size){
 165             s->fetch_timestamp=1;
 166         }
 167     }
 168     if (index < 0)
 169         index = 0;
 170     s->cur_offset += index;
 171     return index;
 172 }
 173
 174 /**
 175  *
 176  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 177  * @deprecated use AVBitstreamFilter
 178  */
 179 int av_parser_change(AVCodecParserContext *s,
 180                      AVCodecContext *avctx,
 181                      uint8_t **poutbuf, int *poutbuf_size,
 182                      const uint8_t *buf, int buf_size, int keyframe){
 183
 184     if(s && s->parser->split){
 185         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
 186             int i= s->parser->split(avctx, buf, buf_size);
 187             buf += i;
 188             buf_size -= i;
 189         }
 190     }
 191
 192     /* cast to avoid warning about discarding qualifiers */
 193     *poutbuf= (uint8_t *) buf;
 194     *poutbuf_size= buf_size;
 195     if(avctx->extradata){
 196         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 197             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 198             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 199             int size= buf_size + avctx->extradata_size;
 200             *poutbuf_size= size;
 201             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 202
 203             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 204             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 205             return 1;
 206         }
 207     }
 208
 209     return 0;
 210 }
 211
 212 void av_parser_close(AVCodecParserContext *s)
 213 {
 214     if (s->parser->parser_close)
 215         s->parser->parser_close(s);
 216     av_free(s->priv_data);
 217     av_free(s);
 218 }
 219
 220 /*****************************************************/
 221
 222 /**
 223  * combines the (truncated) bitstream to a complete frame
 224  * @returns -1 if no complete frame could be created
 225  */
 226 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 227 {
 228 #if 0
 229     if(pc->overread){
 230         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 231         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 232     }
 233 #endif
 234
 235     /* Copy overread bytes from last frame into buffer. */
 236     for(; pc->overread>0; pc->overread--){
 237         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 238     }
 239
 240     /* flush remaining if EOF */
 241     if(!*buf_size && next == END_NOT_FOUND){
 242         next= 0;
 243     }
 244
 245     pc->last_index= pc->index;
 246
 247     /* copy into buffer end return */
 248     if(next == END_NOT_FOUND){
 249         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 250
 251         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 252         pc->index += *buf_size;
 253         return -1;
 254     }
 255
 256     *buf_size=
 257     pc->overread_index= pc->index + next;
 258
 259     /* append to buffer */
 260     if(pc->index){
 261         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 262
 263         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 264         pc->index = 0;
 265         *buf= pc->buffer;
 266     }
 267
 268     /* store overread bytes */
 269     for(;next < 0; next++){
 270         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 271         pc->overread++;
 272     }
 273
 274 #if 0
 275     if(pc->overread){
 276         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 277         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 278     }
 279 #endif
 280
 281     return 0;
 282 }
 283
 284 void ff_parse_close(AVCodecParserContext *s)
 285 {
 286     ParseContext *pc = s->priv_data;
 287
 288     av_free(pc->buffer);
 289 }
 290
 291 void ff_parse1_close(AVCodecParserContext *s)
 292 {
 293     ParseContext1 *pc1 = s->priv_data;
 294
 295     av_free(pc1->pc.buffer);
 296     av_free(pc1->enc);
 297 }
 298
 299 /*************************/
 300
 301 int ff_mpeg4video_split(AVCodecContext *avctx,
 302                            const uint8_t *buf, int buf_size)
 303 {
 304     int i;
 305     uint32_t state= -1;
 306
 307     for(i=0; i<buf_size; i++){
 308         state= (state<<8) | buf[i];
 309         if(state == 0x1B3 || state == 0x1B6)
 310             return i-3;
 311     }
 312     return 0;
 313 }
 314
 315 /*************************/
 316
 317 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
 318 /* also used for ADTS AAC */
 319 typedef struct AC3ParseContext {
 320     uint8_t *inbuf_ptr;
 321     int frame_size;
 322     int header_size;
 323     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
 324                 int *bit_rate, int *samples);
 325     uint8_t inbuf[8192]; /* input buffer */
 326 } AC3ParseContext;
 327
 328 #define AC3_HEADER_SIZE 7
 329 #define AAC_HEADER_SIZE 7
 330
 331 #ifdef CONFIG_AC3_PARSER
 332
 333 static const uint8_t eac3_blocks[4] = {
 334     1, 2, 3, 6
 335 };
 336
 337 #endif /* CONFIG_AC3_PARSER */
 338
 339 #ifdef CONFIG_AAC_PARSER
 340 static const int aac_sample_rates[16] = {
 341     96000, 88200, 64000, 48000, 44100, 32000,
 342     24000, 22050, 16000, 12000, 11025, 8000, 7350
 343 };
 344
 345 static const int aac_channels[8] = {
 346     0, 1, 2, 3, 4, 5, 6, 8
 347 };
 348 #endif
 349
 350 #ifdef CONFIG_AC3_PARSER
 351 int ff_ac3_parse_header(const uint8_t buf[7], AC3HeaderInfo *hdr)
 352 {
 353     GetBitContext gbc;
 354
 355     memset(hdr, 0, sizeof(*hdr));
 356
 357     init_get_bits(&gbc, buf, 54);
 358
 359     hdr->sync_word = get_bits(&gbc, 16);
 360     if(hdr->sync_word != 0x0B77)
 361         return -1;
 362
 363     /* read ahead to bsid to make sure this is AC-3, not E-AC-3 */
 364     hdr->bsid = show_bits_long(&gbc, 29) & 0x1F;
 365     if(hdr->bsid > 10)
 366         return -2;
 367
 368     hdr->crc1 = get_bits(&gbc, 16);
 369     hdr->fscod = get_bits(&gbc, 2);
 370     if(hdr->fscod == 3)
 371         return -3;
 372
 373     hdr->frmsizecod = get_bits(&gbc, 6);
 374     if(hdr->frmsizecod > 37)
 375         return -4;
 376
 377     skip_bits(&gbc, 5); // skip bsid, already got it
 378
 379     hdr->bsmod = get_bits(&gbc, 3);
 380     hdr->acmod = get_bits(&gbc, 3);
 381     if((hdr->acmod & 1) && hdr->acmod != 1) {
 382         hdr->cmixlev = get_bits(&gbc, 2);
 383     }
 384     if(hdr->acmod & 4) {
 385         hdr->surmixlev = get_bits(&gbc, 2);
 386     }
 387     if(hdr->acmod == 2) {
 388         hdr->dsurmod = get_bits(&gbc, 2);
 389     }
 390     hdr->lfeon = get_bits1(&gbc);
 391
 392     hdr->halfratecod = FFMAX(hdr->bsid, 8) - 8;
 393     hdr->sample_rate = ff_ac3_freqs[hdr->fscod] >> hdr->halfratecod;
 394     hdr->bit_rate = (ff_ac3_bitratetab[hdr->frmsizecod>>1] * 1000) >> hdr->halfratecod;
 395     hdr->channels = ff_ac3_channels[hdr->acmod] + hdr->lfeon;
 396     hdr->frame_size = ff_ac3_frame_sizes[hdr->frmsizecod][hdr->fscod] * 2;
 397
 398     return 0;
 399 }
 400
 401 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 402                     int *bit_rate, int *samples)
 403 {
 404     int err;
 405     unsigned int fscod, acmod, bsid, lfeon;
 406     unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
 407     GetBitContext bits;
 408     AC3HeaderInfo hdr;
 409
 410     err = ff_ac3_parse_header(buf, &hdr);
 411
 412     if(err < 0 && err != -2)
 413         return 0;
 414
 415     bsid = hdr.bsid;
 416     if(bsid <= 10) {             /* Normal AC-3 */
 417         *sample_rate = hdr.sample_rate;
 418         *bit_rate = hdr.bit_rate;
 419         *channels = hdr.channels;
 420         *samples = AC3_FRAME_SIZE;
 421         return hdr.frame_size;
 422     } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
 423         init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
 424         strmtyp = get_bits(&bits, 2);
 425         substreamid = get_bits(&bits, 3);
 426
 427         if (strmtyp != 0 || substreamid != 0)
 428             return 0;   /* Currently don't support additional streams */
 429
 430         frmsiz = get_bits(&bits, 11) + 1;
 431         fscod = get_bits(&bits, 2);
 432         if (fscod == 3) {
 433             fscod2 = get_bits(&bits, 2);
 434             numblkscod = 3;
 435
 436             if(fscod2 == 3)
 437                 return 0;
 438
 439             *sample_rate = ff_ac3_freqs[fscod2] / 2;
 440         } else {
 441             numblkscod = get_bits(&bits, 2);
 442
 443             *sample_rate = ff_ac3_freqs[fscod];
 444         }
 445
 446         acmod = get_bits(&bits, 3);
 447         lfeon = get_bits1(&bits);
 448
 449         *samples = eac3_blocks[numblkscod] * 256;
 450         *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
 451         *channels = ff_ac3_channels[acmod] + lfeon;
 452
 453         return frmsiz * 2;
 454     }
 455
 456     /* Unsupported bitstream version */
 457     return 0;
 458 }
 459 #endif /* CONFIG_AC3_PARSER */
 460
 461 #ifdef CONFIG_AAC_PARSER
 462 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 463                     int *bit_rate, int *samples)
 464 {
 465     GetBitContext bits;
 466     int size, rdb, ch, sr;
 467
 468     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 469
 470     if(get_bits(&bits, 12) != 0xfff)
 471         return 0;
 472
 473     skip_bits1(&bits);          /* id */
 474     skip_bits(&bits, 2);        /* layer */
 475     skip_bits1(&bits);          /* protection_absent */
 476     skip_bits(&bits, 2);        /* profile_objecttype */
 477     sr = get_bits(&bits, 4);    /* sample_frequency_index */
 478     if(!aac_sample_rates[sr])
 479         return 0;
 480     skip_bits1(&bits);          /* private_bit */
 481     ch = get_bits(&bits, 3);    /* channel_configuration */
 482     if(!aac_channels[ch])
 483         return 0;
 484     skip_bits1(&bits);          /* original/copy */
 485     skip_bits1(&bits);          /* home */
 486
 487     /* adts_variable_header */
 488     skip_bits1(&bits);          /* copyright_identification_bit */
 489     skip_bits1(&bits);          /* copyright_identification_start */
 490     size = get_bits(&bits, 13); /* aac_frame_length */
 491     skip_bits(&bits, 11);       /* adts_buffer_fullness */
 492     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 493
 494     *channels = aac_channels[ch];
 495     *sample_rate = aac_sample_rates[sr];
 496     *samples = (rdb + 1) * 1024;
 497     *bit_rate = size * 8 * *sample_rate / *samples;
 498
 499     return size;
 500 }
 501 #endif /* CONFIG_AAC_PARSER */
 502
 503 #ifdef CONFIG_AC3_PARSER
 504 static int ac3_parse_init(AVCodecParserContext *s1)
 505 {
 506     AC3ParseContext *s = s1->priv_data;
 507     s->inbuf_ptr = s->inbuf;
 508     s->header_size = AC3_HEADER_SIZE;
 509     s->sync = ac3_sync;
 510     return 0;
 511 }
 512 #endif
 513
 514 #ifdef CONFIG_AAC_PARSER
 515 static int aac_parse_init(AVCodecParserContext *s1)
 516 {
 517     AC3ParseContext *s = s1->priv_data;
 518     s->inbuf_ptr = s->inbuf;
 519     s->header_size = AAC_HEADER_SIZE;
 520     s->sync = aac_sync;
 521     return 0;
 522 }
 523 #endif
 524
 525 /* also used for ADTS AAC */
 526 static int ac3_parse(AVCodecParserContext *s1,
 527                      AVCodecContext *avctx,
 528                      uint8_t **poutbuf, int *poutbuf_size,
 529                      const uint8_t *buf, int buf_size)
 530 {
 531     AC3ParseContext *s = s1->priv_data;
 532     const uint8_t *buf_ptr;
 533     int len, sample_rate, bit_rate, channels, samples;
 534
 535     *poutbuf = NULL;
 536     *poutbuf_size = 0;
 537
 538     buf_ptr = buf;
 539     while (buf_size > 0) {
 540         len = s->inbuf_ptr - s->inbuf;
 541         if (s->frame_size == 0) {
 542             /* no header seen : find one. We need at least s->header_size
 543                bytes to parse it */
 544             len = FFMIN(s->header_size - len, buf_size);
 545
 546             memcpy(s->inbuf_ptr, buf_ptr, len);
 547             buf_ptr += len;
 548             s->inbuf_ptr += len;
 549             buf_size -= len;
 550             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 551                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 552                               &samples);
 553                 if (len == 0) {
 554                     /* no sync found : move by one byte (inefficient, but simple!) */
 555                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 556                     s->inbuf_ptr--;
 557                 } else {
 558                     s->frame_size = len;
 559                     /* update codec info */
 560                     avctx->sample_rate = sample_rate;
 561                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 562                     if(avctx->codec_id == CODEC_ID_AC3){
 563                         if(avctx->channels!=1 && avctx->channels!=2){
 564                             avctx->channels = channels;
 565                         }
 566                     } else {
 567                         avctx->channels = channels;
 568                     }
 569                     avctx->bit_rate = bit_rate;
 570                     avctx->frame_size = samples;
 571                 }
 572             }
 573         } else {
 574             len = FFMIN(s->frame_size - len, buf_size);
 575
 576             memcpy(s->inbuf_ptr, buf_ptr, len);
 577             buf_ptr += len;
 578             s->inbuf_ptr += len;
 579             buf_size -= len;
 580
 581             if(s->inbuf_ptr - s->inbuf == s->frame_size){
 582                 *poutbuf = s->inbuf;
 583                 *poutbuf_size = s->frame_size;
 584                 s->inbuf_ptr = s->inbuf;
 585                 s->frame_size = 0;
 586                 break;
 587             }
 588         }
 589     }
 590     return buf_ptr - buf;
 591 }
 592 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
 593
 594 #ifdef CONFIG_AC3_PARSER
 595 AVCodecParser ac3_parser = {
 596     { CODEC_ID_AC3 },
 597     sizeof(AC3ParseContext),
 598     ac3_parse_init,
 599     ac3_parse,
 600     NULL,
 601 };
 602 #endif
 603 #ifdef CONFIG_AAC_PARSER
 604 AVCodecParser aac_parser = {
 605     { CODEC_ID_AAC },
 606     sizeof(AC3ParseContext),
 607     aac_parse_init,
 608     ac3_parse,
 609     NULL,
 610 };
 611 #endif