Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ adcb72b5

History | View | Annotate | Download (25.8 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 "ac3.h"
26
#include "parser.h"
27

    
28
AVCodecParser *av_first_parser = NULL;
29

    
30
void av_register_codec_parser(AVCodecParser *parser)
31
{
32
    parser->next = av_first_parser;
33
    av_first_parser = parser;
34
}
35

    
36
AVCodecParserContext *av_parser_init(int codec_id)
37
{
38
    AVCodecParserContext *s;
39
    AVCodecParser *parser;
40
    int ret;
41

    
42
    if(codec_id == CODEC_ID_NONE)
43
        return NULL;
44

    
45
    for(parser = av_first_parser; parser != NULL; parser = parser->next) {
46
        if (parser->codec_ids[0] == codec_id ||
47
            parser->codec_ids[1] == codec_id ||
48
            parser->codec_ids[2] == codec_id ||
49
            parser->codec_ids[3] == codec_id ||
50
            parser->codec_ids[4] == codec_id)
51
            goto found;
52
    }
53
    return NULL;
54
 found:
55
    s = av_mallocz(sizeof(AVCodecParserContext));
56
    if (!s)
57
        return NULL;
58
    s->parser = parser;
59
    s->priv_data = av_mallocz(parser->priv_data_size);
60
    if (!s->priv_data) {
61
        av_free(s);
62
        return NULL;
63
    }
64
    if (parser->parser_init) {
65
        ret = parser->parser_init(s);
66
        if (ret != 0) {
67
            av_free(s->priv_data);
68
            av_free(s);
69
            return NULL;
70
        }
71
    }
72
    s->fetch_timestamp=1;
73
    s->pict_type = FF_I_TYPE;
74
    return s;
75
}
76

    
77
/**
78
 *
79
 * @param buf           input
80
 * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
81
 * @param pts           input presentation timestamp
82
 * @param dts           input decoding timestamp
83
 * @param poutbuf       will contain a pointer to the first byte of the output frame
84
 * @param poutbuf_size  will contain the length of the output frame
85
 * @return the number of bytes of the input bitstream used
86
 *
87
 * Example:
88
 * @code
89
 *   while(in_len){
90
 *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
91
 *                                       in_data, in_len,
92
 *                                       pts, dts);
93
 *       in_data += len;
94
 *       in_len  -= len;
95
 *
96
 *       if(size)
97
 *          decode_frame(data, size);
98
 *   }
99
 * @endcode
100
 */
101
int av_parser_parse(AVCodecParserContext *s,
102
                    AVCodecContext *avctx,
103
                    uint8_t **poutbuf, int *poutbuf_size,
104
                    const uint8_t *buf, int buf_size,
105
                    int64_t pts, int64_t dts)
106
{
107
    int index, i, k;
108
    uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
109

    
110
    if (buf_size == 0) {
111
        /* padding is always necessary even if EOF, so we add it here */
112
        memset(dummy_buf, 0, sizeof(dummy_buf));
113
        buf = dummy_buf;
114
    } else {
115
        /* add a new packet descriptor */
116
        k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
117
        s->cur_frame_start_index = k;
118
        s->cur_frame_offset[k] = s->cur_offset;
119
        s->cur_frame_pts[k] = pts;
120
        s->cur_frame_dts[k] = dts;
121

    
122
        /* fill first PTS/DTS */
123
        if (s->fetch_timestamp){
124
            s->fetch_timestamp=0;
125
            s->last_pts = pts;
126
            s->last_dts = dts;
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

    
142
        /* offset of the next frame */
143
        s->last_frame_offset = s->cur_offset + index;
144
        /* find the packet in which the new frame starts. It
145
           is tricky because of MPEG video start codes
146
           which can begin in one packet and finish in
147
           another packet. In the worst case, an MPEG
148
           video start code could be in 4 different
149
           packets. */
150
        k = s->cur_frame_start_index;
151
        for(i = 0; i < AV_PARSER_PTS_NB; i++) {
152
            if (s->last_frame_offset >= s->cur_frame_offset[k])
153
                break;
154
            k = (k - 1) & (AV_PARSER_PTS_NB - 1);
155
        }
156

    
157
        s->last_pts = s->cur_frame_pts[k];
158
        s->last_dts = s->cur_frame_dts[k];
159

    
160
        /* some parsers tell us the packet size even before seeing the first byte of the next packet,
161
           so the next pts/dts is in the next chunk */
162
        if(index == buf_size){
163
            s->fetch_timestamp=1;
164
        }
165
    }
166
    if (index < 0)
167
        index = 0;
168
    s->cur_offset += index;
169
    return index;
170
}
171

    
172
/**
173
 *
174
 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
175
 * @deprecated use AVBitstreamFilter
176
 */
177
int av_parser_change(AVCodecParserContext *s,
178
                     AVCodecContext *avctx,
179
                     uint8_t **poutbuf, int *poutbuf_size,
180
                     const uint8_t *buf, int buf_size, int keyframe){
181

    
182
    if(s && s->parser->split){
183
        if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
184
            int i= s->parser->split(avctx, buf, buf_size);
185
            buf += i;
186
            buf_size -= i;
187
        }
188
    }
189

    
190
    /* cast to avoid warning about discarding qualifiers */
191
    *poutbuf= (uint8_t *) buf;
192
    *poutbuf_size= buf_size;
193
    if(avctx->extradata){
194
        if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
195
            /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
196
            /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
197
            int size= buf_size + avctx->extradata_size;
198
            *poutbuf_size= size;
199
            *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
200

    
201
            memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
202
            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
203
            return 1;
204
        }
205
    }
206

    
207
    return 0;
208
}
209

    
210
void av_parser_close(AVCodecParserContext *s)
211
{
212
    if (s->parser->parser_close)
213
        s->parser->parser_close(s);
214
    av_free(s->priv_data);
215
    av_free(s);
216
}
217

    
218
/*****************************************************/
219

    
220
/**
221
 * combines the (truncated) bitstream to a complete frame
222
 * @returns -1 if no complete frame could be created
223
 */
224
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
225
{
226
#if 0
227
    if(pc->overread){
228
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
229
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
230
    }
231
#endif
232

    
233
    /* copy overreaded bytes from last frame into buffer */
234
    for(; pc->overread>0; pc->overread--){
235
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
236
    }
237

    
238
    /* flush remaining if EOF */
239
    if(!*buf_size && next == END_NOT_FOUND){
240
        next= 0;
241
    }
242

    
243
    pc->last_index= pc->index;
244

    
245
    /* copy into buffer end return */
246
    if(next == END_NOT_FOUND){
247
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
248

    
249
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
250
        pc->index += *buf_size;
251
        return -1;
252
    }
253

    
254
    *buf_size=
255
    pc->overread_index= pc->index + next;
256

    
257
    /* append to buffer */
258
    if(pc->index){
259
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
260

    
261
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
262
        pc->index = 0;
263
        *buf= pc->buffer;
264
    }
265

    
266
    /* store overread bytes */
267
    for(;next < 0; next++){
268
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
269
        pc->overread++;
270
    }
271

    
272
#if 0
273
    if(pc->overread){
274
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
275
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
276
    }
277
#endif
278

    
279
    return 0;
280
}
281

    
282
void ff_parse_close(AVCodecParserContext *s)
283
{
284
    ParseContext *pc = s->priv_data;
285

    
286
    av_free(pc->buffer);
287
}
288

    
289
void ff_parse1_close(AVCodecParserContext *s)
290
{
291
    ParseContext1 *pc1 = s->priv_data;
292

    
293
    av_free(pc1->pc.buffer);
294
    av_free(pc1->enc);
295
}
296

    
297
/*************************/
298

    
299
#ifdef CONFIG_MPEG4VIDEO_PARSER
300
/* used by parser */
301
/* XXX: make it use less memory */
302
static int av_mpeg4_decode_header(AVCodecParserContext *s1,
303
                                  AVCodecContext *avctx,
304
                                  const uint8_t *buf, int buf_size)
305
{
306
    ParseContext1 *pc = s1->priv_data;
307
    MpegEncContext *s = pc->enc;
308
    GetBitContext gb1, *gb = &gb1;
309
    int ret;
310

    
311
    s->avctx = avctx;
312
    s->current_picture_ptr = &s->current_picture;
313

    
314
    if (avctx->extradata_size && pc->first_picture){
315
        init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
316
        ret = ff_mpeg4_decode_picture_header(s, gb);
317
    }
318

    
319
    init_get_bits(gb, buf, 8 * buf_size);
320
    ret = ff_mpeg4_decode_picture_header(s, gb);
321
    if (s->width) {
322
        avcodec_set_dimensions(avctx, s->width, s->height);
323
    }
324
    s1->pict_type= s->pict_type;
325
    pc->first_picture = 0;
326
    return ret;
327
}
328

    
329
static int mpeg4video_parse_init(AVCodecParserContext *s)
330
{
331
    ParseContext1 *pc = s->priv_data;
332

    
333
    pc->enc = av_mallocz(sizeof(MpegEncContext));
334
    if (!pc->enc)
335
        return -1;
336
    pc->first_picture = 1;
337
    return 0;
338
}
339

    
340
static int mpeg4video_parse(AVCodecParserContext *s,
341
                           AVCodecContext *avctx,
342
                           uint8_t **poutbuf, int *poutbuf_size,
343
                           const uint8_t *buf, int buf_size)
344
{
345
    ParseContext *pc = s->priv_data;
346
    int next;
347

    
348
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
349
        next= buf_size;
350
    }else{
351
        next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
352

    
353
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
354
            *poutbuf = NULL;
355
            *poutbuf_size = 0;
356
            return buf_size;
357
        }
358
    }
359
    av_mpeg4_decode_header(s, avctx, buf, buf_size);
360

    
361
    *poutbuf = (uint8_t *)buf;
362
    *poutbuf_size = buf_size;
363
    return next;
364
}
365
#endif
366

    
367
int ff_mpeg4video_split(AVCodecContext *avctx,
368
                           const uint8_t *buf, int buf_size)
369
{
370
    int i;
371
    uint32_t state= -1;
372

    
373
    for(i=0; i<buf_size; i++){
374
        state= (state<<8) | buf[i];
375
        if(state == 0x1B3 || state == 0x1B6)
376
            return i-3;
377
    }
378
    return 0;
379
}
380

    
381
/*************************/
382

    
383
#ifdef CONFIG_MPEGAUDIO_PARSER
384
typedef struct MpegAudioParseContext {
385
    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
386
    uint8_t *inbuf_ptr;
387
    int frame_size;
388
    int free_format_frame_size;
389
    int free_format_next_header;
390
    uint32_t header;
391
    int header_count;
392
} MpegAudioParseContext;
393

    
394
#define MPA_HEADER_SIZE 4
395

    
396
/* header + layer + bitrate + freq + lsf/mpeg25 */
397
#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
398
#define SAME_HEADER_MASK \
399
   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
400

    
401
static int mpegaudio_parse_init(AVCodecParserContext *s1)
402
{
403
    MpegAudioParseContext *s = s1->priv_data;
404
    s->inbuf_ptr = s->inbuf;
405
    return 0;
406
}
407

    
408
static int mpegaudio_parse(AVCodecParserContext *s1,
409
                           AVCodecContext *avctx,
410
                           uint8_t **poutbuf, int *poutbuf_size,
411
                           const uint8_t *buf, int buf_size)
412
{
413
    MpegAudioParseContext *s = s1->priv_data;
414
    int len, ret, sr;
415
    uint32_t header;
416
    const uint8_t *buf_ptr;
417

    
418
    *poutbuf = NULL;
419
    *poutbuf_size = 0;
420
    buf_ptr = buf;
421
    while (buf_size > 0) {
422
        len = s->inbuf_ptr - s->inbuf;
423
        if (s->frame_size == 0) {
424
            /* special case for next header for first frame in free
425
               format case (XXX: find a simpler method) */
426
            if (s->free_format_next_header != 0) {
427
                s->inbuf[0] = s->free_format_next_header >> 24;
428
                s->inbuf[1] = s->free_format_next_header >> 16;
429
                s->inbuf[2] = s->free_format_next_header >> 8;
430
                s->inbuf[3] = s->free_format_next_header;
431
                s->inbuf_ptr = s->inbuf + 4;
432
                s->free_format_next_header = 0;
433
                goto got_header;
434
            }
435
            /* no header seen : find one. We need at least MPA_HEADER_SIZE
436
               bytes to parse it */
437
            len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
438
            if (len > 0) {
439
                memcpy(s->inbuf_ptr, buf_ptr, len);
440
                buf_ptr += len;
441
                buf_size -= len;
442
                s->inbuf_ptr += len;
443
            }
444
            if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
445
            got_header:
446
                header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
447
                    (s->inbuf[2] << 8) | s->inbuf[3];
448

    
449
                ret = mpa_decode_header(avctx, header, &sr);
450
                if (ret < 0) {
451
                    s->header_count= -2;
452
                    /* no sync found : move by one byte (inefficient, but simple!) */
453
                    memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
454
                    s->inbuf_ptr--;
455
                    dprintf(avctx, "skip %x\n", header);
456
                    /* reset free format frame size to give a chance
457
                       to get a new bitrate */
458
                    s->free_format_frame_size = 0;
459
                } else {
460
                    if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
461
                        s->header_count= -3;
462
                    s->header= header;
463
                    s->header_count++;
464
                    s->frame_size = ret;
465

    
466
#if 0
467
                    /* free format: prepare to compute frame size */
468
                    if (decode_header(s, header) == 1) {
469
                        s->frame_size = -1;
470
                    }
471
#endif
472
                }
473
                if(s->header_count > 1)
474
                    avctx->sample_rate= sr;
475
            }
476
        } else
477
#if 0
478
        if (s->frame_size == -1) {
479
            /* free format : find next sync to compute frame size */
480
            len = MPA_MAX_CODED_FRAME_SIZE - len;
481
            if (len > buf_size)
482
                len = buf_size;
483
            if (len == 0) {
484
                /* frame too long: resync */
485
                s->frame_size = 0;
486
                memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
487
                s->inbuf_ptr--;
488
            } else {
489
                uint8_t *p, *pend;
490
                uint32_t header1;
491
                int padding;
492

493
                memcpy(s->inbuf_ptr, buf_ptr, len);
494
                /* check for header */
495
                p = s->inbuf_ptr - 3;
496
                pend = s->inbuf_ptr + len - 4;
497
                while (p <= pend) {
498
                    header = (p[0] << 24) | (p[1] << 16) |
499
                        (p[2] << 8) | p[3];
500
                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
501
                        (s->inbuf[2] << 8) | s->inbuf[3];
502
                    /* check with high probability that we have a
503
                       valid header */
504
                    if ((header & SAME_HEADER_MASK) ==
505
                        (header1 & SAME_HEADER_MASK)) {
506
                        /* header found: update pointers */
507
                        len = (p + 4) - s->inbuf_ptr;
508
                        buf_ptr += len;
509
                        buf_size -= len;
510
                        s->inbuf_ptr = p;
511
                        /* compute frame size */
512
                        s->free_format_next_header = header;
513
                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
514
                        padding = (header1 >> 9) & 1;
515
                        if (s->layer == 1)
516
                            s->free_format_frame_size -= padding * 4;
517
                        else
518
                            s->free_format_frame_size -= padding;
519
                        dprintf(avctx, "free frame size=%d padding=%d\n",
520
                                s->free_format_frame_size, padding);
521
                        decode_header(s, header1);
522
                        goto next_data;
523
                    }
524
                    p++;
525
                }
526
                /* not found: simply increase pointers */
527
                buf_ptr += len;
528
                s->inbuf_ptr += len;
529
                buf_size -= len;
530
            }
531
        } else
532
#endif
533
        if (len < s->frame_size) {
534
            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
535
                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
536
            len = FFMIN(s->frame_size - len, buf_size);
537
            memcpy(s->inbuf_ptr, buf_ptr, len);
538
            buf_ptr += len;
539
            s->inbuf_ptr += len;
540
            buf_size -= len;
541
        }
542

    
543
        if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
544
           && buf_size + buf_ptr - buf >= s->frame_size){
545
            if(s->header_count > 0){
546
                *poutbuf = buf;
547
                *poutbuf_size = s->frame_size;
548
            }
549
            buf_ptr = buf + s->frame_size;
550
            s->inbuf_ptr = s->inbuf;
551
            s->frame_size = 0;
552
            break;
553
        }
554

    
555
        //    next_data:
556
        if (s->frame_size > 0 &&
557
            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
558
            if(s->header_count > 0){
559
                *poutbuf = s->inbuf;
560
                *poutbuf_size = s->inbuf_ptr - s->inbuf;
561
            }
562
            s->inbuf_ptr = s->inbuf;
563
            s->frame_size = 0;
564
            break;
565
        }
566
    }
567
    return buf_ptr - buf;
568
}
569
#endif /* CONFIG_MPEGAUDIO_PARSER */
570

    
571
#if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
572
/* also used for ADTS AAC */
573
typedef struct AC3ParseContext {
574
    uint8_t *inbuf_ptr;
575
    int frame_size;
576
    int header_size;
577
    int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
578
                int *bit_rate, int *samples);
579
    uint8_t inbuf[8192]; /* input buffer */
580
} AC3ParseContext;
581

    
582
#define AC3_HEADER_SIZE 7
583
#define AAC_HEADER_SIZE 7
584

    
585
#ifdef CONFIG_AC3_PARSER
586

    
587
static const uint8_t eac3_blocks[4] = {
588
    1, 2, 3, 6
589
};
590

    
591
#endif /* CONFIG_AC3_PARSER */
592

    
593
#ifdef CONFIG_AAC_PARSER
594
static const int aac_sample_rates[16] = {
595
    96000, 88200, 64000, 48000, 44100, 32000,
596
    24000, 22050, 16000, 12000, 11025, 8000, 7350
597
};
598

    
599
static const int aac_channels[8] = {
600
    0, 1, 2, 3, 4, 5, 6, 8
601
};
602
#endif
603

    
604
#ifdef CONFIG_AC3_PARSER
605
static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
606
                    int *bit_rate, int *samples)
607
{
608
    int err;
609
    unsigned int fscod, acmod, bsid, lfeon;
610
    unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
611
    GetBitContext bits;
612
    AC3HeaderInfo hdr;
613

    
614
    err = ff_ac3_parse_header(buf, &hdr);
615

    
616
    if(err < 0 && err != -2)
617
        return 0;
618

    
619
    bsid = hdr.bsid;
620
    if(bsid <= 10) {             /* Normal AC-3 */
621
        *sample_rate = hdr.sample_rate;
622
        *bit_rate = hdr.bit_rate;
623
        *channels = hdr.channels;
624
        *samples = AC3_FRAME_SIZE;
625
        return hdr.frame_size;
626
    } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
627
        init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
628
        strmtyp = get_bits(&bits, 2);
629
        substreamid = get_bits(&bits, 3);
630

    
631
        if (strmtyp != 0 || substreamid != 0)
632
            return 0;   /* Currently don't support additional streams */
633

    
634
        frmsiz = get_bits(&bits, 11) + 1;
635
        fscod = get_bits(&bits, 2);
636
        if (fscod == 3) {
637
            fscod2 = get_bits(&bits, 2);
638
            numblkscod = 3;
639

    
640
            if(fscod2 == 3)
641
                return 0;
642

    
643
            *sample_rate = ff_ac3_freqs[fscod2] / 2;
644
        } else {
645
            numblkscod = get_bits(&bits, 2);
646

    
647
            *sample_rate = ff_ac3_freqs[fscod];
648
        }
649

    
650
        acmod = get_bits(&bits, 3);
651
        lfeon = get_bits1(&bits);
652

    
653
        *samples = eac3_blocks[numblkscod] * 256;
654
        *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
655
        *channels = ff_ac3_channels[acmod] + lfeon;
656

    
657
        return frmsiz * 2;
658
    }
659

    
660
    /* Unsupported bitstream version */
661
    return 0;
662
}
663
#endif /* CONFIG_AC3_PARSER */
664

    
665
#ifdef CONFIG_AAC_PARSER
666
static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
667
                    int *bit_rate, int *samples)
668
{
669
    GetBitContext bits;
670
    int size, rdb, ch, sr;
671

    
672
    init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
673

    
674
    if(get_bits(&bits, 12) != 0xfff)
675
        return 0;
676

    
677
    skip_bits1(&bits);          /* id */
678
    skip_bits(&bits, 2);        /* layer */
679
    skip_bits1(&bits);          /* protection_absent */
680
    skip_bits(&bits, 2);        /* profile_objecttype */
681
    sr = get_bits(&bits, 4);    /* sample_frequency_index */
682
    if(!aac_sample_rates[sr])
683
        return 0;
684
    skip_bits1(&bits);          /* private_bit */
685
    ch = get_bits(&bits, 3);    /* channel_configuration */
686
    if(!aac_channels[ch])
687
        return 0;
688
    skip_bits1(&bits);          /* original/copy */
689
    skip_bits1(&bits);          /* home */
690

    
691
    /* adts_variable_header */
692
    skip_bits1(&bits);          /* copyright_identification_bit */
693
    skip_bits1(&bits);          /* copyright_identification_start */
694
    size = get_bits(&bits, 13); /* aac_frame_length */
695
    skip_bits(&bits, 11);       /* adts_buffer_fullness */
696
    rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
697

    
698
    *channels = aac_channels[ch];
699
    *sample_rate = aac_sample_rates[sr];
700
    *samples = (rdb + 1) * 1024;
701
    *bit_rate = size * 8 * *sample_rate / *samples;
702

    
703
    return size;
704
}
705
#endif /* CONFIG_AAC_PARSER */
706

    
707
#ifdef CONFIG_AC3_PARSER
708
static int ac3_parse_init(AVCodecParserContext *s1)
709
{
710
    AC3ParseContext *s = s1->priv_data;
711
    s->inbuf_ptr = s->inbuf;
712
    s->header_size = AC3_HEADER_SIZE;
713
    s->sync = ac3_sync;
714
    return 0;
715
}
716
#endif
717

    
718
#ifdef CONFIG_AAC_PARSER
719
static int aac_parse_init(AVCodecParserContext *s1)
720
{
721
    AC3ParseContext *s = s1->priv_data;
722
    s->inbuf_ptr = s->inbuf;
723
    s->header_size = AAC_HEADER_SIZE;
724
    s->sync = aac_sync;
725
    return 0;
726
}
727
#endif
728

    
729
/* also used for ADTS AAC */
730
static int ac3_parse(AVCodecParserContext *s1,
731
                     AVCodecContext *avctx,
732
                     uint8_t **poutbuf, int *poutbuf_size,
733
                     const uint8_t *buf, int buf_size)
734
{
735
    AC3ParseContext *s = s1->priv_data;
736
    const uint8_t *buf_ptr;
737
    int len, sample_rate, bit_rate, channels, samples;
738

    
739
    *poutbuf = NULL;
740
    *poutbuf_size = 0;
741

    
742
    buf_ptr = buf;
743
    while (buf_size > 0) {
744
        len = s->inbuf_ptr - s->inbuf;
745
        if (s->frame_size == 0) {
746
            /* no header seen : find one. We need at least s->header_size
747
               bytes to parse it */
748
            len = FFMIN(s->header_size - len, buf_size);
749

    
750
            memcpy(s->inbuf_ptr, buf_ptr, len);
751
            buf_ptr += len;
752
            s->inbuf_ptr += len;
753
            buf_size -= len;
754
            if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
755
                len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
756
                              &samples);
757
                if (len == 0) {
758
                    /* no sync found : move by one byte (inefficient, but simple!) */
759
                    memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
760
                    s->inbuf_ptr--;
761
                } else {
762
                    s->frame_size = len;
763
                    /* update codec info */
764
                    avctx->sample_rate = sample_rate;
765
                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
766
                    if(avctx->codec_id == CODEC_ID_AC3){
767
                        if(avctx->channels!=1 && avctx->channels!=2){
768
                            avctx->channels = channels;
769
                        }
770
                    } else {
771
                        avctx->channels = channels;
772
                    }
773
                    avctx->bit_rate = bit_rate;
774
                    avctx->frame_size = samples;
775
                }
776
            }
777
        } else {
778
            len = FFMIN(s->frame_size - len, buf_size);
779

    
780
            memcpy(s->inbuf_ptr, buf_ptr, len);
781
            buf_ptr += len;
782
            s->inbuf_ptr += len;
783
            buf_size -= len;
784

    
785
            if(s->inbuf_ptr - s->inbuf == s->frame_size){
786
                *poutbuf = s->inbuf;
787
                *poutbuf_size = s->frame_size;
788
                s->inbuf_ptr = s->inbuf;
789
                s->frame_size = 0;
790
                break;
791
            }
792
        }
793
    }
794
    return buf_ptr - buf;
795
}
796
#endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
797

    
798
#ifdef CONFIG_MPEG4VIDEO_PARSER
799
AVCodecParser mpeg4video_parser = {
800
    { CODEC_ID_MPEG4 },
801
    sizeof(ParseContext1),
802
    mpeg4video_parse_init,
803
    mpeg4video_parse,
804
    ff_parse1_close,
805
    ff_mpeg4video_split,
806
};
807
#endif
808
#ifdef CONFIG_MPEGAUDIO_PARSER
809
AVCodecParser mpegaudio_parser = {
810
    { CODEC_ID_MP2, CODEC_ID_MP3 },
811
    sizeof(MpegAudioParseContext),
812
    mpegaudio_parse_init,
813
    mpegaudio_parse,
814
    NULL,
815
};
816
#endif
817
#ifdef CONFIG_AC3_PARSER
818
AVCodecParser ac3_parser = {
819
    { CODEC_ID_AC3 },
820
    sizeof(AC3ParseContext),
821
    ac3_parse_init,
822
    ac3_parse,
823
    NULL,
824
};
825
#endif
826
#ifdef CONFIG_AAC_PARSER
827
AVCodecParser aac_parser = {
828
    { CODEC_ID_AAC },
829
    sizeof(AC3ParseContext),
830
    aac_parse_init,
831
    ac3_parse,
832
    NULL,
833
};
834
#endif