Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ c53d2d90

History | View | Annotate | Download (18.1 KB)

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, (const uint8_t **)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, const 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
                     const 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