Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ a74008a4

History | View | Annotate | Download (26 KB)

1 8424cf50 Fabrice Bellard
/*
2
 * Audio and Video frame extraction
3
 * Copyright (c) 2003 Fabrice Bellard.
4
 * Copyright (c) 2003 Michael Niedermayer.
5
 *
6 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9 8424cf50 Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
12 8424cf50 Fabrice Bellard
 *
13 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
14 8424cf50 Fabrice Bellard
 * 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 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
20 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 8424cf50 Fabrice Bellard
 */
22
#include "avcodec.h"
23
#include "mpegvideo.h"
24
#include "mpegaudio.h"
25 050aa8b9 Justin Ruggles
#include "ac3.h"
26 4067d81b Baptiste Coudurier
#include "parser.h"
27 8424cf50 Fabrice Bellard
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 115329f1 Diego Biurrun
42 8845e427 Michael Niedermayer
    if(codec_id == CODEC_ID_NONE)
43
        return NULL;
44 8424cf50 Fabrice Bellard
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 99f06236 Michael Niedermayer
            parser->codec_ids[2] == codec_id ||
49
            parser->codec_ids[3] == codec_id ||
50
            parser->codec_ids[4] == codec_id)
51 8424cf50 Fabrice Bellard
            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 a62aecce Michael Niedermayer
    s->fetch_timestamp=1;
73 adcb72b5 Michael Niedermayer
    s->pict_type = FF_I_TYPE;
74 8424cf50 Fabrice Bellard
    return s;
75
}
76
77 6ab312da Michael Niedermayer
/**
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 832a7b63 Michael Niedermayer
 *       if(size)
97
 *          decode_frame(data, size);
98 6ab312da Michael Niedermayer
 *   }
99
 * @endcode
100
 */
101 115329f1 Diego Biurrun
int av_parser_parse(AVCodecParserContext *s,
102 8424cf50 Fabrice Bellard
                    AVCodecContext *avctx,
103 115329f1 Diego Biurrun
                    uint8_t **poutbuf, int *poutbuf_size,
104 b84f2a35 Fabrice Bellard
                    const uint8_t *buf, int buf_size,
105
                    int64_t pts, int64_t dts)
106 8424cf50 Fabrice Bellard
{
107 b84f2a35 Fabrice Bellard
    int index, i, k;
108 6e45e928 Fabrice Bellard
    uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
109 115329f1 Diego Biurrun
110 6e45e928 Fabrice Bellard
    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 b84f2a35 Fabrice Bellard
    } 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 a62aecce Michael Niedermayer
        if (s->fetch_timestamp){
124
            s->fetch_timestamp=0;
125 b84f2a35 Fabrice Bellard
            s->last_pts = pts;
126
            s->last_dts = dts;
127 a74008a4 Joakim Plate
            s->last_offset = 0;
128 c77a9a0e Michael Niedermayer
            s->cur_frame_pts[k] =
129
            s->cur_frame_dts[k] = AV_NOPTS_VALUE;
130 b84f2a35 Fabrice Bellard
        }
131 6e45e928 Fabrice Bellard
    }
132
133 8424cf50 Fabrice Bellard
    /* WARNING: the returned index can be negative */
134
    index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
135 949b1a13 Steve L'Homme
//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);
136 8424cf50 Fabrice Bellard
    /* update the file pointer */
137
    if (*poutbuf_size) {
138 b84f2a35 Fabrice Bellard
        /* fill the data for the current frame */
139 8424cf50 Fabrice Bellard
        s->frame_offset = s->last_frame_offset;
140 b84f2a35 Fabrice Bellard
        s->pts = s->last_pts;
141
        s->dts = s->last_dts;
142 a74008a4 Joakim Plate
        s->offset = s->last_offset;
143 115329f1 Diego Biurrun
144 b84f2a35 Fabrice Bellard
        /* offset of the next frame */
145 8424cf50 Fabrice Bellard
        s->last_frame_offset = s->cur_offset + index;
146 b84f2a35 Fabrice Bellard
        /* find the packet in which the new frame starts. It
147
           is tricky because of MPEG video start codes
148
           which can begin in one packet and finish in
149
           another packet. In the worst case, an MPEG
150
           video start code could be in 4 different
151
           packets. */
152
        k = s->cur_frame_start_index;
153
        for(i = 0; i < AV_PARSER_PTS_NB; i++) {
154
            if (s->last_frame_offset >= s->cur_frame_offset[k])
155
                break;
156
            k = (k - 1) & (AV_PARSER_PTS_NB - 1);
157
        }
158 a62aecce Michael Niedermayer
159 b84f2a35 Fabrice Bellard
        s->last_pts = s->cur_frame_pts[k];
160
        s->last_dts = s->cur_frame_dts[k];
161 a74008a4 Joakim Plate
        s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
162 115329f1 Diego Biurrun
163 a62aecce Michael Niedermayer
        /* some parsers tell us the packet size even before seeing the first byte of the next packet,
164
           so the next pts/dts is in the next chunk */
165
        if(index == buf_size){
166
            s->fetch_timestamp=1;
167
        }
168 8424cf50 Fabrice Bellard
    }
169
    if (index < 0)
170
        index = 0;
171
    s->cur_offset += index;
172
    return index;
173
}
174
175 73480a15 Michael Niedermayer
/**
176
 *
177
 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
178 748c2fca Michael Niedermayer
 * @deprecated use AVBitstreamFilter
179 73480a15 Michael Niedermayer
 */
180 90ad92b3 Michael Niedermayer
int av_parser_change(AVCodecParserContext *s,
181
                     AVCodecContext *avctx,
182 115329f1 Diego Biurrun
                     uint8_t **poutbuf, int *poutbuf_size,
183 90ad92b3 Michael Niedermayer
                     const uint8_t *buf, int buf_size, int keyframe){
184 115329f1 Diego Biurrun
185 90ad92b3 Michael Niedermayer
    if(s && s->parser->split){
186 73480a15 Michael Niedermayer
        if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
187 90ad92b3 Michael Niedermayer
            int i= s->parser->split(avctx, buf, buf_size);
188
            buf += i;
189
            buf_size -= i;
190
        }
191
    }
192
193 79396ac6 Måns Rullgård
    /* cast to avoid warning about discarding qualifiers */
194
    *poutbuf= (uint8_t *) buf;
195 90ad92b3 Michael Niedermayer
    *poutbuf_size= buf_size;
196
    if(avctx->extradata){
197
        if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
198
            /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
199
            /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
200
            int size= buf_size + avctx->extradata_size;
201
            *poutbuf_size= size;
202
            *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
203 115329f1 Diego Biurrun
204 90ad92b3 Michael Niedermayer
            memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
205 73480a15 Michael Niedermayer
            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
206 90ad92b3 Michael Niedermayer
            return 1;
207
        }
208
    }
209
210
    return 0;
211
}
212
213 8424cf50 Fabrice Bellard
void av_parser_close(AVCodecParserContext *s)
214
{
215
    if (s->parser->parser_close)
216
        s->parser->parser_close(s);
217
    av_free(s->priv_data);
218
    av_free(s);
219
}
220
221
/*****************************************************/
222
223
/**
224
 * combines the (truncated) bitstream to a complete frame
225
 * @returns -1 if no complete frame could be created
226
 */
227 e4cb187d Michael Niedermayer
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
228 8424cf50 Fabrice Bellard
{
229
#if 0
230
    if(pc->overread){
231
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
232
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
233
    }
234
#endif
235
236 e42dba48 Diego Biurrun
    /* Copy overread bytes from last frame into buffer. */
237 8424cf50 Fabrice Bellard
    for(; pc->overread>0; pc->overread--){
238
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
239
    }
240 f48c0551 Michael Niedermayer
241
    /* flush remaining if EOF */
242
    if(!*buf_size && next == END_NOT_FOUND){
243
        next= 0;
244
    }
245
246 8424cf50 Fabrice Bellard
    pc->last_index= pc->index;
247
248
    /* copy into buffer end return */
249
    if(next == END_NOT_FOUND){
250
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
251
252
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
253
        pc->index += *buf_size;
254
        return -1;
255
    }
256
257
    *buf_size=
258
    pc->overread_index= pc->index + next;
259 115329f1 Diego Biurrun
260 8424cf50 Fabrice Bellard
    /* append to buffer */
261
    if(pc->index){
262
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
263
264
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
265
        pc->index = 0;
266
        *buf= pc->buffer;
267
    }
268
269
    /* store overread bytes */
270
    for(;next < 0; next++){
271
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
272
        pc->overread++;
273
    }
274
275
#if 0
276
    if(pc->overread){
277
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
278
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
279
    }
280
#endif
281
282
    return 0;
283
}
284
285 e4cb187d Michael Niedermayer
void ff_parse_close(AVCodecParserContext *s)
286 8424cf50 Fabrice Bellard
{
287 e4cb187d Michael Niedermayer
    ParseContext *pc = s->priv_data;
288 8424cf50 Fabrice Bellard
289
    av_free(pc->buffer);
290
}
291
292 4067d81b Baptiste Coudurier
void ff_parse1_close(AVCodecParserContext *s)
293 8424cf50 Fabrice Bellard
{
294 e4cb187d Michael Niedermayer
    ParseContext1 *pc1 = s->priv_data;
295 8424cf50 Fabrice Bellard
296 e4cb187d Michael Niedermayer
    av_free(pc1->pc.buffer);
297
    av_free(pc1->enc);
298 8424cf50 Fabrice Bellard
}
299
300 e4cb187d Michael Niedermayer
/*************************/
301
302 af9e7d18 Måns Rullgård
#ifdef CONFIG_MPEG4VIDEO_PARSER
303 8424cf50 Fabrice Bellard
/* used by parser */
304
/* XXX: make it use less memory */
305 115329f1 Diego Biurrun
static int av_mpeg4_decode_header(AVCodecParserContext *s1,
306 8424cf50 Fabrice Bellard
                                  AVCodecContext *avctx,
307
                                  const uint8_t *buf, int buf_size)
308
{
309
    ParseContext1 *pc = s1->priv_data;
310
    MpegEncContext *s = pc->enc;
311
    GetBitContext gb1, *gb = &gb1;
312
    int ret;
313
314
    s->avctx = avctx;
315 c6f353ff Fabrice Bellard
    s->current_picture_ptr = &s->current_picture;
316
317
    if (avctx->extradata_size && pc->first_picture){
318
        init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
319
        ret = ff_mpeg4_decode_picture_header(s, gb);
320
    }
321
322 8424cf50 Fabrice Bellard
    init_get_bits(gb, buf, 8 * buf_size);
323
    ret = ff_mpeg4_decode_picture_header(s, gb);
324
    if (s->width) {
325 21adafec Michael Niedermayer
        avcodec_set_dimensions(avctx, s->width, s->height);
326 8424cf50 Fabrice Bellard
    }
327 7cbaa7ba Michael Niedermayer
    s1->pict_type= s->pict_type;
328 c6f353ff Fabrice Bellard
    pc->first_picture = 0;
329 8424cf50 Fabrice Bellard
    return ret;
330
}
331
332 e96682e6 Michael Niedermayer
static int mpeg4video_parse_init(AVCodecParserContext *s)
333 8424cf50 Fabrice Bellard
{
334
    ParseContext1 *pc = s->priv_data;
335 c6f353ff Fabrice Bellard
336 8424cf50 Fabrice Bellard
    pc->enc = av_mallocz(sizeof(MpegEncContext));
337
    if (!pc->enc)
338
        return -1;
339 c6f353ff Fabrice Bellard
    pc->first_picture = 1;
340 8424cf50 Fabrice Bellard
    return 0;
341
}
342
343
static int mpeg4video_parse(AVCodecParserContext *s,
344
                           AVCodecContext *avctx,
345 115329f1 Diego Biurrun
                           uint8_t **poutbuf, int *poutbuf_size,
346 8424cf50 Fabrice Bellard
                           const uint8_t *buf, int buf_size)
347
{
348 e4cb187d Michael Niedermayer
    ParseContext *pc = s->priv_data;
349 8424cf50 Fabrice Bellard
    int next;
350 115329f1 Diego Biurrun
351 7cbaa7ba Michael Niedermayer
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
352
        next= buf_size;
353
    }else{
354
        next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
355 115329f1 Diego Biurrun
356 7cbaa7ba Michael Niedermayer
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
357
            *poutbuf = NULL;
358
            *poutbuf_size = 0;
359
            return buf_size;
360
        }
361 8424cf50 Fabrice Bellard
    }
362
    av_mpeg4_decode_header(s, avctx, buf, buf_size);
363
364
    *poutbuf = (uint8_t *)buf;
365
    *poutbuf_size = buf_size;
366
    return next;
367
}
368 af9e7d18 Måns Rullgård
#endif
369 8424cf50 Fabrice Bellard
370 d136d2fc Stefan Gehrer
int ff_mpeg4video_split(AVCodecContext *avctx,
371 90ad92b3 Michael Niedermayer
                           const uint8_t *buf, int buf_size)
372
{
373
    int i;
374
    uint32_t state= -1;
375 115329f1 Diego Biurrun
376 90ad92b3 Michael Niedermayer
    for(i=0; i<buf_size; i++){
377
        state= (state<<8) | buf[i];
378
        if(state == 0x1B3 || state == 0x1B6)
379 73480a15 Michael Niedermayer
            return i-3;
380 90ad92b3 Michael Niedermayer
    }
381
    return 0;
382
}
383
384 8424cf50 Fabrice Bellard
/*************************/
385
386 af9e7d18 Måns Rullgård
#ifdef CONFIG_MPEGAUDIO_PARSER
387 8424cf50 Fabrice Bellard
typedef struct MpegAudioParseContext {
388 bb270c08 Diego Biurrun
    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
389 8424cf50 Fabrice Bellard
    uint8_t *inbuf_ptr;
390
    int frame_size;
391
    int free_format_frame_size;
392
    int free_format_next_header;
393 4b9ac0b5 Michael Niedermayer
    uint32_t header;
394
    int header_count;
395 8424cf50 Fabrice Bellard
} MpegAudioParseContext;
396
397
#define MPA_HEADER_SIZE 4
398
399
/* header + layer + bitrate + freq + lsf/mpeg25 */
400 88730be6 Måns Rullgård
#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
401 8424cf50 Fabrice Bellard
#define SAME_HEADER_MASK \
402 e993bc03 Michael Niedermayer
   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
403 8424cf50 Fabrice Bellard
404
static int mpegaudio_parse_init(AVCodecParserContext *s1)
405
{
406
    MpegAudioParseContext *s = s1->priv_data;
407
    s->inbuf_ptr = s->inbuf;
408
    return 0;
409
}
410
411
static int mpegaudio_parse(AVCodecParserContext *s1,
412
                           AVCodecContext *avctx,
413 115329f1 Diego Biurrun
                           uint8_t **poutbuf, int *poutbuf_size,
414 8424cf50 Fabrice Bellard
                           const uint8_t *buf, int buf_size)
415
{
416
    MpegAudioParseContext *s = s1->priv_data;
417 4b9ac0b5 Michael Niedermayer
    int len, ret, sr;
418 8424cf50 Fabrice Bellard
    uint32_t header;
419
    const uint8_t *buf_ptr;
420
421
    *poutbuf = NULL;
422
    *poutbuf_size = 0;
423
    buf_ptr = buf;
424
    while (buf_size > 0) {
425 bb270c08 Diego Biurrun
        len = s->inbuf_ptr - s->inbuf;
426
        if (s->frame_size == 0) {
427 8424cf50 Fabrice Bellard
            /* special case for next header for first frame in free
428
               format case (XXX: find a simpler method) */
429
            if (s->free_format_next_header != 0) {
430
                s->inbuf[0] = s->free_format_next_header >> 24;
431
                s->inbuf[1] = s->free_format_next_header >> 16;
432
                s->inbuf[2] = s->free_format_next_header >> 8;
433
                s->inbuf[3] = s->free_format_next_header;
434
                s->inbuf_ptr = s->inbuf + 4;
435
                s->free_format_next_header = 0;
436
                goto got_header;
437
            }
438 bb270c08 Diego Biurrun
            /* no header seen : find one. We need at least MPA_HEADER_SIZE
439 8424cf50 Fabrice Bellard
               bytes to parse it */
440 4e2d6a45 Michael Niedermayer
            len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
441 bb270c08 Diego Biurrun
            if (len > 0) {
442
                memcpy(s->inbuf_ptr, buf_ptr, len);
443
                buf_ptr += len;
444
                buf_size -= len;
445
                s->inbuf_ptr += len;
446
            }
447
            if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
448 8424cf50 Fabrice Bellard
            got_header:
449 bb270c08 Diego Biurrun
                header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
450
                    (s->inbuf[2] << 8) | s->inbuf[3];
451 8424cf50 Fabrice Bellard
452 498c544a Michael Niedermayer
                ret = mpa_decode_header(avctx, header, &sr);
453 8424cf50 Fabrice Bellard
                if (ret < 0) {
454 4b9ac0b5 Michael Niedermayer
                    s->header_count= -2;
455 bb270c08 Diego Biurrun
                    /* no sync found : move by one byte (inefficient, but simple!) */
456
                    memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
457
                    s->inbuf_ptr--;
458 318c5e05 Michel Bardiaux
                    dprintf(avctx, "skip %x\n", header);
459 8424cf50 Fabrice Bellard
                    /* reset free format frame size to give a chance
460
                       to get a new bitrate */
461
                    s->free_format_frame_size = 0;
462 bb270c08 Diego Biurrun
                } else {
463 4b9ac0b5 Michael Niedermayer
                    if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
464
                        s->header_count= -3;
465
                    s->header= header;
466
                    s->header_count++;
467 8424cf50 Fabrice Bellard
                    s->frame_size = ret;
468 115329f1 Diego Biurrun
469 8424cf50 Fabrice Bellard
#if 0
470
                    /* free format: prepare to compute frame size */
471 bb270c08 Diego Biurrun
                    if (decode_header(s, header) == 1) {
472
                        s->frame_size = -1;
473 8424cf50 Fabrice Bellard
                    }
474
#endif
475 bb270c08 Diego Biurrun
                }
476 498c544a Michael Niedermayer
                if(s->header_count > 1)
477
                    avctx->sample_rate= sr;
478 bb270c08 Diego Biurrun
            }
479 115329f1 Diego Biurrun
        } else
480 8424cf50 Fabrice Bellard
#if 0
481
        if (s->frame_size == -1) {
482
            /* free format : find next sync to compute frame size */
483 bb270c08 Diego Biurrun
            len = MPA_MAX_CODED_FRAME_SIZE - len;
484
            if (len > buf_size)
485
                len = buf_size;
486 8424cf50 Fabrice Bellard
            if (len == 0) {
487 bb270c08 Diego Biurrun
                /* frame too long: resync */
488 8424cf50 Fabrice Bellard
                s->frame_size = 0;
489 bb270c08 Diego Biurrun
                memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
490
                s->inbuf_ptr--;
491 8424cf50 Fabrice Bellard
            } else {
492
                uint8_t *p, *pend;
493
                uint32_t header1;
494
                int padding;
495

496
                memcpy(s->inbuf_ptr, buf_ptr, len);
497
                /* check for header */
498
                p = s->inbuf_ptr - 3;
499
                pend = s->inbuf_ptr + len - 4;
500
                while (p <= pend) {
501
                    header = (p[0] << 24) | (p[1] << 16) |
502
                        (p[2] << 8) | p[3];
503
                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
504
                        (s->inbuf[2] << 8) | s->inbuf[3];
505
                    /* check with high probability that we have a
506
                       valid header */
507
                    if ((header & SAME_HEADER_MASK) ==
508
                        (header1 & SAME_HEADER_MASK)) {
509
                        /* header found: update pointers */
510
                        len = (p + 4) - s->inbuf_ptr;
511
                        buf_ptr += len;
512
                        buf_size -= len;
513
                        s->inbuf_ptr = p;
514
                        /* compute frame size */
515
                        s->free_format_next_header = header;
516
                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
517
                        padding = (header1 >> 9) & 1;
518
                        if (s->layer == 1)
519
                            s->free_format_frame_size -= padding * 4;
520
                        else
521
                            s->free_format_frame_size -= padding;
522 318c5e05 Michel Bardiaux
                        dprintf(avctx, "free frame size=%d padding=%d\n",
523 8424cf50 Fabrice Bellard
                                s->free_format_frame_size, padding);
524
                        decode_header(s, header1);
525
                        goto next_data;
526
                    }
527
                    p++;
528
                }
529
                /* not found: simply increase pointers */
530
                buf_ptr += len;
531
                s->inbuf_ptr += len;
532
                buf_size -= len;
533
            }
534 bb270c08 Diego Biurrun
        } else
535 8424cf50 Fabrice Bellard
#endif
536
        if (len < s->frame_size) {
537
            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
538
                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
539 4e2d6a45 Michael Niedermayer
            len = FFMIN(s->frame_size - len, buf_size);
540 bb270c08 Diego Biurrun
            memcpy(s->inbuf_ptr, buf_ptr, len);
541
            buf_ptr += len;
542
            s->inbuf_ptr += len;
543
            buf_size -= len;
544
        }
545 4e2d6a45 Michael Niedermayer
546
        if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
547
           && buf_size + buf_ptr - buf >= s->frame_size){
548
            if(s->header_count > 0){
549
                *poutbuf = buf;
550
                *poutbuf_size = s->frame_size;
551
            }
552
            buf_ptr = buf + s->frame_size;
553
            s->inbuf_ptr = s->inbuf;
554
            s->frame_size = 0;
555
            break;
556
        }
557
558 8424cf50 Fabrice Bellard
        //    next_data:
559 115329f1 Diego Biurrun
        if (s->frame_size > 0 &&
560 8424cf50 Fabrice Bellard
            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
561 4b9ac0b5 Michael Niedermayer
            if(s->header_count > 0){
562
                *poutbuf = s->inbuf;
563
                *poutbuf_size = s->inbuf_ptr - s->inbuf;
564
            }
565 bb270c08 Diego Biurrun
            s->inbuf_ptr = s->inbuf;
566
            s->frame_size = 0;
567
            break;
568
        }
569 8424cf50 Fabrice Bellard
    }
570
    return buf_ptr - buf;
571
}
572 af9e7d18 Måns Rullgård
#endif /* CONFIG_MPEGAUDIO_PARSER */
573 8424cf50 Fabrice Bellard
574 af9e7d18 Måns Rullgård
#if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
575 da46276f Måns Rullgård
/* also used for ADTS AAC */
576 8424cf50 Fabrice Bellard
typedef struct AC3ParseContext {
577
    uint8_t *inbuf_ptr;
578
    int frame_size;
579 da46276f Måns Rullgård
    int header_size;
580
    int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
581
                int *bit_rate, int *samples);
582 4f8ff17e Måns Rullgård
    uint8_t inbuf[8192]; /* input buffer */
583 8424cf50 Fabrice Bellard
} AC3ParseContext;
584
585
#define AC3_HEADER_SIZE 7
586 100a7422 Måns Rullgård
#define AAC_HEADER_SIZE 7
587 62327e28 Måns Rullgård
588 af9e7d18 Måns Rullgård
#ifdef CONFIG_AC3_PARSER
589 44a39bd7 Ian Caulfield
590
static const uint8_t eac3_blocks[4] = {
591
    1, 2, 3, 6
592
};
593
594 af9e7d18 Måns Rullgård
#endif /* CONFIG_AC3_PARSER */
595 62327e28 Måns Rullgård
596 af9e7d18 Måns Rullgård
#ifdef CONFIG_AAC_PARSER
597 608bd843 Måns Rullgård
static const int aac_sample_rates[16] = {
598 da46276f Måns Rullgård
    96000, 88200, 64000, 48000, 44100, 32000,
599
    24000, 22050, 16000, 12000, 11025, 8000, 7350
600
};
601
602 608bd843 Måns Rullgård
static const int aac_channels[8] = {
603 da46276f Måns Rullgård
    0, 1, 2, 3, 4, 5, 6, 8
604
};
605 af9e7d18 Måns Rullgård
#endif
606 da46276f Måns Rullgård
607 af9e7d18 Måns Rullgård
#ifdef CONFIG_AC3_PARSER
608 62327e28 Måns Rullgård
static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
609 da46276f Måns Rullgård
                    int *bit_rate, int *samples)
610 62327e28 Måns Rullgård
{
611 24761399 Justin Ruggles
    int err;
612
    unsigned int fscod, acmod, bsid, lfeon;
613 44a39bd7 Ian Caulfield
    unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
614 62327e28 Måns Rullgård
    GetBitContext bits;
615 24761399 Justin Ruggles
    AC3HeaderInfo hdr;
616 62327e28 Måns Rullgård
617 24761399 Justin Ruggles
    err = ff_ac3_parse_header(buf, &hdr);
618 62327e28 Måns Rullgård
619 24761399 Justin Ruggles
    if(err < 0 && err != -2)
620 4f59b684 Diego Biurrun
        return 0;
621 62327e28 Måns Rullgård
622 24761399 Justin Ruggles
    bsid = hdr.bsid;
623 f7a49547 Justin Ruggles
    if(bsid <= 10) {             /* Normal AC-3 */
624 24761399 Justin Ruggles
        *sample_rate = hdr.sample_rate;
625
        *bit_rate = hdr.bit_rate;
626
        *channels = hdr.channels;
627
        *samples = AC3_FRAME_SIZE;
628
        return hdr.frame_size;
629 f7a49547 Justin Ruggles
    } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
630 24761399 Justin Ruggles
        init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
631 44a39bd7 Ian Caulfield
        strmtyp = get_bits(&bits, 2);
632
        substreamid = get_bits(&bits, 3);
633
634
        if (strmtyp != 0 || substreamid != 0)
635
            return 0;   /* Currently don't support additional streams */
636
637
        frmsiz = get_bits(&bits, 11) + 1;
638
        fscod = get_bits(&bits, 2);
639
        if (fscod == 3) {
640
            fscod2 = get_bits(&bits, 2);
641
            numblkscod = 3;
642
643
            if(fscod2 == 3)
644
                return 0;
645
646 050aa8b9 Justin Ruggles
            *sample_rate = ff_ac3_freqs[fscod2] / 2;
647 44a39bd7 Ian Caulfield
        } else {
648
            numblkscod = get_bits(&bits, 2);
649
650 050aa8b9 Justin Ruggles
            *sample_rate = ff_ac3_freqs[fscod];
651 44a39bd7 Ian Caulfield
        }
652
653
        acmod = get_bits(&bits, 3);
654
        lfeon = get_bits1(&bits);
655
656
        *samples = eac3_blocks[numblkscod] * 256;
657
        *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
658 050aa8b9 Justin Ruggles
        *channels = ff_ac3_channels[acmod] + lfeon;
659 44a39bd7 Ian Caulfield
660
        return frmsiz * 2;
661
    }
662
663
    /* Unsupported bitstream version */
664
    return 0;
665 62327e28 Måns Rullgård
}
666 af9e7d18 Måns Rullgård
#endif /* CONFIG_AC3_PARSER */
667 8424cf50 Fabrice Bellard
668 af9e7d18 Måns Rullgård
#ifdef CONFIG_AAC_PARSER
669 da46276f Måns Rullgård
static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
670
                    int *bit_rate, int *samples)
671
{
672
    GetBitContext bits;
673
    int size, rdb, ch, sr;
674
675
    init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
676
677
    if(get_bits(&bits, 12) != 0xfff)
678
        return 0;
679
680 100a7422 Måns Rullgård
    skip_bits1(&bits);          /* id */
681
    skip_bits(&bits, 2);        /* layer */
682
    skip_bits1(&bits);          /* protection_absent */
683
    skip_bits(&bits, 2);        /* profile_objecttype */
684
    sr = get_bits(&bits, 4);    /* sample_frequency_index */
685 da46276f Måns Rullgård
    if(!aac_sample_rates[sr])
686
        return 0;
687 100a7422 Måns Rullgård
    skip_bits1(&bits);          /* private_bit */
688
    ch = get_bits(&bits, 3);    /* channel_configuration */
689 da46276f Måns Rullgård
    if(!aac_channels[ch])
690
        return 0;
691 100a7422 Måns Rullgård
    skip_bits1(&bits);          /* original/copy */
692
    skip_bits1(&bits);          /* home */
693 da46276f Måns Rullgård
694
    /* adts_variable_header */
695 100a7422 Måns Rullgård
    skip_bits1(&bits);          /* copyright_identification_bit */
696
    skip_bits1(&bits);          /* copyright_identification_start */
697
    size = get_bits(&bits, 13); /* aac_frame_length */
698
    skip_bits(&bits, 11);       /* adts_buffer_fullness */
699
    rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
700 da46276f Måns Rullgård
701
    *channels = aac_channels[ch];
702
    *sample_rate = aac_sample_rates[sr];
703
    *samples = (rdb + 1) * 1024;
704
    *bit_rate = size * 8 * *sample_rate / *samples;
705
706
    return size;
707
}
708 af9e7d18 Måns Rullgård
#endif /* CONFIG_AAC_PARSER */
709 da46276f Måns Rullgård
710 af9e7d18 Måns Rullgård
#ifdef CONFIG_AC3_PARSER
711 8424cf50 Fabrice Bellard
static int ac3_parse_init(AVCodecParserContext *s1)
712
{
713
    AC3ParseContext *s = s1->priv_data;
714
    s->inbuf_ptr = s->inbuf;
715 da46276f Måns Rullgård
    s->header_size = AC3_HEADER_SIZE;
716
    s->sync = ac3_sync;
717 8424cf50 Fabrice Bellard
    return 0;
718
}
719 af9e7d18 Måns Rullgård
#endif
720 8424cf50 Fabrice Bellard
721 af9e7d18 Måns Rullgård
#ifdef CONFIG_AAC_PARSER
722 da46276f Måns Rullgård
static int aac_parse_init(AVCodecParserContext *s1)
723
{
724
    AC3ParseContext *s = s1->priv_data;
725
    s->inbuf_ptr = s->inbuf;
726
    s->header_size = AAC_HEADER_SIZE;
727
    s->sync = aac_sync;
728
    return 0;
729
}
730 af9e7d18 Måns Rullgård
#endif
731 da46276f Måns Rullgård
732
/* also used for ADTS AAC */
733 8424cf50 Fabrice Bellard
static int ac3_parse(AVCodecParserContext *s1,
734
                     AVCodecContext *avctx,
735 115329f1 Diego Biurrun
                     uint8_t **poutbuf, int *poutbuf_size,
736 8424cf50 Fabrice Bellard
                     const uint8_t *buf, int buf_size)
737
{
738
    AC3ParseContext *s = s1->priv_data;
739
    const uint8_t *buf_ptr;
740 da46276f Måns Rullgård
    int len, sample_rate, bit_rate, channels, samples;
741 8424cf50 Fabrice Bellard
742
    *poutbuf = NULL;
743
    *poutbuf_size = 0;
744
745
    buf_ptr = buf;
746
    while (buf_size > 0) {
747
        len = s->inbuf_ptr - s->inbuf;
748
        if (s->frame_size == 0) {
749 da46276f Måns Rullgård
            /* no header seen : find one. We need at least s->header_size
750
               bytes to parse it */
751
            len = FFMIN(s->header_size - len, buf_size);
752 d8a91afd Michael Niedermayer
753 8424cf50 Fabrice Bellard
            memcpy(s->inbuf_ptr, buf_ptr, len);
754
            buf_ptr += len;
755
            s->inbuf_ptr += len;
756
            buf_size -= len;
757 da46276f Måns Rullgård
            if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
758
                len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
759
                              &samples);
760 8424cf50 Fabrice Bellard
                if (len == 0) {
761
                    /* no sync found : move by one byte (inefficient, but simple!) */
762 da46276f Måns Rullgård
                    memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
763 8424cf50 Fabrice Bellard
                    s->inbuf_ptr--;
764
                } else {
765 bb270c08 Diego Biurrun
                    s->frame_size = len;
766 8424cf50 Fabrice Bellard
                    /* update codec info */
767
                    avctx->sample_rate = sample_rate;
768 20da3179 Michael Niedermayer
                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
769 da46276f Måns Rullgård
                    if(avctx->codec_id == CODEC_ID_AC3){
770
                        if(avctx->channels!=1 && avctx->channels!=2){
771
                            avctx->channels = channels;
772
                        }
773
                    } else {
774 4f59b684 Diego Biurrun
                        avctx->channels = channels;
775 20da3179 Michael Niedermayer
                    }
776 bb270c08 Diego Biurrun
                    avctx->bit_rate = bit_rate;
777 da46276f Måns Rullgård
                    avctx->frame_size = samples;
778 8424cf50 Fabrice Bellard
                }
779
            }
780 d8a91afd Michael Niedermayer
        } else {
781
            len = FFMIN(s->frame_size - len, buf_size);
782 8424cf50 Fabrice Bellard
783
            memcpy(s->inbuf_ptr, buf_ptr, len);
784
            buf_ptr += len;
785
            s->inbuf_ptr += len;
786
            buf_size -= len;
787 d8a91afd Michael Niedermayer
788
            if(s->inbuf_ptr - s->inbuf == s->frame_size){
789
                *poutbuf = s->inbuf;
790
                *poutbuf_size = s->frame_size;
791
                s->inbuf_ptr = s->inbuf;
792
                s->frame_size = 0;
793
                break;
794
            }
795 8424cf50 Fabrice Bellard
        }
796
    }
797
    return buf_ptr - buf;
798
}
799 af9e7d18 Måns Rullgård
#endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
800 8424cf50 Fabrice Bellard
801 af9e7d18 Måns Rullgård
#ifdef CONFIG_MPEG4VIDEO_PARSER
802 8424cf50 Fabrice Bellard
AVCodecParser mpeg4video_parser = {
803
    { CODEC_ID_MPEG4 },
804
    sizeof(ParseContext1),
805
    mpeg4video_parse_init,
806
    mpeg4video_parse,
807 4067d81b Baptiste Coudurier
    ff_parse1_close,
808 d136d2fc Stefan Gehrer
    ff_mpeg4video_split,
809 8424cf50 Fabrice Bellard
};
810 af9e7d18 Måns Rullgård
#endif
811
#ifdef CONFIG_MPEGAUDIO_PARSER
812 8424cf50 Fabrice Bellard
AVCodecParser mpegaudio_parser = {
813
    { CODEC_ID_MP2, CODEC_ID_MP3 },
814
    sizeof(MpegAudioParseContext),
815
    mpegaudio_parse_init,
816
    mpegaudio_parse,
817
    NULL,
818
};
819 af9e7d18 Måns Rullgård
#endif
820
#ifdef CONFIG_AC3_PARSER
821 8424cf50 Fabrice Bellard
AVCodecParser ac3_parser = {
822
    { CODEC_ID_AC3 },
823
    sizeof(AC3ParseContext),
824
    ac3_parse_init,
825
    ac3_parse,
826
    NULL,
827
};
828 af9e7d18 Måns Rullgård
#endif
829
#ifdef CONFIG_AAC_PARSER
830 da46276f Måns Rullgård
AVCodecParser aac_parser = {
831
    { CODEC_ID_AAC },
832
    sizeof(AC3ParseContext),
833
    aac_parse_init,
834
    ac3_parse,
835
    NULL,
836
};
837 af9e7d18 Måns Rullgård
#endif