Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ 7a886063

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

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