~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/ADM_lavcodec/parser.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-12-15 17:13:20 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215171320-w79pvpehxx2fr217
Tags: 1:2.3.0-0.0ubuntu1
* Merge from debian-multimedia.org, remaining Ubuntu change:
  - desktop file,
  - no support for ccache and make -j.
* Closes Ubuntu: #69614.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * Audio and Video frame extraction
 
3
 * Copyright (c) 2003 Fabrice Bellard.
 
4
 * Copyright (c) 2003 Michael Niedermayer.
 
5
 *
 
6
 * This library is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Lesser General Public
 
8
 * License as published by the Free Software Foundation; either
 
9
 * version 2 of the License, or (at your option) any later version.
 
10
 *
 
11
 * This library is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * Lesser General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU Lesser General Public
 
17
 * License along with this library; if not, write to the Free Software
 
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
19
 */
 
20
#include "avcodec.h"
 
21
#include "mpegvideo.h"
 
22
#include "mpegaudio.h"
 
23
 
 
24
AVCodecParser *av_first_parser = NULL;
 
25
 
 
26
void av_register_codec_parser(AVCodecParser *parser)
 
27
{
 
28
    parser->next = av_first_parser;
 
29
    av_first_parser = parser;
 
30
}
 
31
 
 
32
AVCodecParserContext *av_parser_init(int codec_id)
 
33
{
 
34
    AVCodecParserContext *s;
 
35
    AVCodecParser *parser;
 
36
    int ret;
 
37
 
 
38
    if(codec_id == CODEC_ID_NONE)
 
39
        return NULL;
 
40
 
 
41
    for(parser = av_first_parser; parser != NULL; parser = parser->next) {
 
42
        if (parser->codec_ids[0] == codec_id ||
 
43
            parser->codec_ids[1] == codec_id ||
 
44
            parser->codec_ids[2] == codec_id ||
 
45
            parser->codec_ids[3] == codec_id ||
 
46
            parser->codec_ids[4] == codec_id)
 
47
            goto found;
 
48
    }
 
49
    return NULL;
 
50
 found:
 
51
    s = av_mallocz(sizeof(AVCodecParserContext));
 
52
    if (!s)
 
53
        return NULL;
 
54
    s->parser = parser;
 
55
    s->priv_data = av_mallocz(parser->priv_data_size);
 
56
    if (!s->priv_data) {
 
57
        av_free(s);
 
58
        return NULL;
 
59
    }
 
60
    if (parser->parser_init) {
 
61
        ret = parser->parser_init(s);
 
62
        if (ret != 0) {
 
63
            av_free(s->priv_data);
 
64
            av_free(s);
 
65
            return NULL;
 
66
        }
 
67
    }
 
68
    s->fetch_timestamp=1;
 
69
    return s;
 
70
}
 
71
 
 
72
/* NOTE: buf_size == 0 is used to signal EOF so that the last frame
 
73
   can be returned if necessary */
 
74
int av_parser_parse(AVCodecParserContext *s,
 
75
                    AVCodecContext *avctx,
 
76
                    uint8_t **poutbuf, int *poutbuf_size,
 
77
                    const uint8_t *buf, int buf_size,
 
78
                    int64_t pts, int64_t dts)
 
79
{
 
80
    int index, i, k;
 
81
    uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 
82
 
 
83
    if (buf_size == 0) {
 
84
        /* padding is always necessary even if EOF, so we add it here */
 
85
        memset(dummy_buf, 0, sizeof(dummy_buf));
 
86
        buf = dummy_buf;
 
87
    } else {
 
88
        /* add a new packet descriptor */
 
89
        k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 
90
        s->cur_frame_start_index = k;
 
91
        s->cur_frame_offset[k] = s->cur_offset;
 
92
        s->cur_frame_pts[k] = pts;
 
93
        s->cur_frame_dts[k] = dts;
 
94
 
 
95
        /* fill first PTS/DTS */
 
96
        if (s->fetch_timestamp){
 
97
            s->fetch_timestamp=0;
 
98
            s->last_pts = pts;
 
99
            s->last_dts = dts;
 
100
            s->cur_frame_pts[k] =
 
101
            s->cur_frame_dts[k] = AV_NOPTS_VALUE;
 
102
        }
 
103
    }
 
104
 
 
105
    /* WARNING: the returned index can be negative */
 
106
    index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 
107
//av_log(NULL, AV_LOG_DEBUG, "parser: in:%lld, %lld, out:%lld, %lld, in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
 
108
    /* update the file pointer */
 
109
    if (*poutbuf_size) {
 
110
        /* fill the data for the current frame */
 
111
        s->frame_offset = s->last_frame_offset;
 
112
        s->pts = s->last_pts;
 
113
        s->dts = s->last_dts;
 
114
 
 
115
        /* offset of the next frame */
 
116
        s->last_frame_offset = s->cur_offset + index;
 
117
        /* find the packet in which the new frame starts. It
 
118
           is tricky because of MPEG video start codes
 
119
           which can begin in one packet and finish in
 
120
           another packet. In the worst case, an MPEG
 
121
           video start code could be in 4 different
 
122
           packets. */
 
123
        k = s->cur_frame_start_index;
 
124
        for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 
125
            if (s->last_frame_offset >= s->cur_frame_offset[k])
 
126
                break;
 
127
            k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 
128
        }
 
129
 
 
130
        s->last_pts = s->cur_frame_pts[k];
 
131
        s->last_dts = s->cur_frame_dts[k];
 
132
 
 
133
        /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 
134
           so the next pts/dts is in the next chunk */
 
135
        if(index == buf_size){
 
136
            s->fetch_timestamp=1;
 
137
        }
 
138
    }
 
139
    if (index < 0)
 
140
        index = 0;
 
141
    s->cur_offset += index;
 
142
    return index;
 
143
}
 
144
 
 
145
/**
 
146
 *
 
147
 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 
148
 * @deprecated use AVBitstreamFilter
 
149
 */
 
150
int av_parser_change(AVCodecParserContext *s,
 
151
                     AVCodecContext *avctx,
 
152
                     uint8_t **poutbuf, int *poutbuf_size,
 
153
                     const uint8_t *buf, int buf_size, int keyframe){
 
154
 
 
155
    if(s && s->parser->split){
 
156
        if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
 
157
            int i= s->parser->split(avctx, buf, buf_size);
 
158
            buf += i;
 
159
            buf_size -= i;
 
160
        }
 
161
    }
 
162
 
 
163
    /* cast to avoid warning about discarding qualifiers */
 
164
    *poutbuf= (uint8_t *) buf;
 
165
    *poutbuf_size= buf_size;
 
166
    if(avctx->extradata){
 
167
        if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 
168
            /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 
169
            /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 
170
            int size= buf_size + avctx->extradata_size;
 
171
            *poutbuf_size= size;
 
172
            *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 
173
 
 
174
            memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 
175
            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 
176
            return 1;
 
177
        }
 
178
    }
 
179
 
 
180
    return 0;
 
181
}
 
182
 
 
183
void av_parser_close(AVCodecParserContext *s)
 
184
{
 
185
    if (s->parser->parser_close)
 
186
        s->parser->parser_close(s);
 
187
    av_free(s->priv_data);
 
188
    av_free(s);
 
189
}
 
190
 
 
191
/*****************************************************/
 
192
 
 
193
//#define END_NOT_FOUND (-100)
 
194
 
 
195
#define PICTURE_START_CODE      0x00000100
 
196
#define SEQ_START_CODE          0x000001b3
 
197
#define EXT_START_CODE          0x000001b5
 
198
#define SLICE_MIN_START_CODE    0x00000101
 
199
#define SLICE_MAX_START_CODE    0x000001af
 
200
 
 
201
typedef struct ParseContext1{
 
202
    ParseContext pc;
 
203
/* XXX/FIXME PC1 vs. PC */
 
204
    /* MPEG2 specific */
 
205
    int frame_rate;
 
206
    int progressive_sequence;
 
207
    int width, height;
 
208
 
 
209
    /* XXX: suppress that, needed by MPEG4 */
 
210
    MpegEncContext *enc;
 
211
    int first_picture;
 
212
} ParseContext1;
 
213
 
 
214
/**
 
215
 * combines the (truncated) bitstream to a complete frame
 
216
 * @returns -1 if no complete frame could be created
 
217
 */
 
218
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 
219
{
 
220
#if 0
 
221
    if(pc->overread){
 
222
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 
223
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 
224
    }
 
225
#endif
 
226
 
 
227
    /* copy overreaded bytes from last frame into buffer */
 
228
    for(; pc->overread>0; pc->overread--){
 
229
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 
230
    }
 
231
 
 
232
    /* flush remaining if EOF */
 
233
    if(!*buf_size && next == END_NOT_FOUND){
 
234
        next= 0;
 
235
    }
 
236
 
 
237
    pc->last_index= pc->index;
 
238
 
 
239
    /* copy into buffer end return */
 
240
    if(next == END_NOT_FOUND){
 
241
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 
242
 
 
243
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 
244
        pc->index += *buf_size;
 
245
        return -1;
 
246
    }
 
247
 
 
248
    *buf_size=
 
249
    pc->overread_index= pc->index + next;
 
250
 
 
251
    /* append to buffer */
 
252
    if(pc->index){
 
253
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 
254
 
 
255
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 
256
        pc->index = 0;
 
257
        *buf= pc->buffer;
 
258
    }
 
259
 
 
260
    /* store overread bytes */
 
261
    for(;next < 0; next++){
 
262
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 
263
        pc->overread++;
 
264
    }
 
265
 
 
266
#if 0
 
267
    if(pc->overread){
 
268
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 
269
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 
270
    }
 
271
#endif
 
272
 
 
273
    return 0;
 
274
}
 
275
 
 
276
/* XXX: merge with libavcodec ? */
 
277
#define MPEG1_FRAME_RATE_BASE 1001
 
278
 
 
279
static const int frame_rate_tab[16] = {
 
280
        0,
 
281
    24000,
 
282
    24024,
 
283
    25025,
 
284
    30000,
 
285
    30030,
 
286
    50050,
 
287
    60000,
 
288
    60060,
 
289
  // Xing's 15fps: (9)
 
290
    15015,
 
291
  // libmpeg3's "Unofficial economy rates": (10-13)
 
292
     5005,
 
293
    10010,
 
294
    12012,
 
295
    15015,
 
296
  // random, just to avoid segfault !never encode these
 
297
    25025,
 
298
    25025,
 
299
};
 
300
 
 
301
#ifdef CONFIG_MPEGVIDEO_PARSER
 
302
//FIXME move into mpeg12.c
 
303
static void mpegvideo_extract_headers(AVCodecParserContext *s,
 
304
                                      AVCodecContext *avctx,
 
305
                                      const uint8_t *buf, int buf_size)
 
306
{
 
307
    ParseContext1 *pc = s->priv_data;
 
308
    const uint8_t *buf_end;
 
309
    int32_t start_code;
 
310
    int frame_rate_index, ext_type, bytes_left;
 
311
    int frame_rate_ext_n, frame_rate_ext_d;
 
312
    int picture_structure, top_field_first, repeat_first_field, progressive_frame;
 
313
    int horiz_size_ext, vert_size_ext, bit_rate_ext;
 
314
//FIXME replace the crap with get_bits()
 
315
    s->repeat_pict = 0;
 
316
    buf_end = buf + buf_size;
 
317
    while (buf < buf_end) {
 
318
        start_code= -1;
 
319
        buf= ff_find_start_code(buf, buf_end, &start_code);
 
320
        bytes_left = buf_end - buf;
 
321
        switch(start_code) {
 
322
        case PICTURE_START_CODE:
 
323
            if (bytes_left >= 2) {
 
324
                s->pict_type = (buf[1] >> 3) & 7;
 
325
            }
 
326
            break;
 
327
        case SEQ_START_CODE:
 
328
            if (bytes_left >= 7) {
 
329
                pc->width  = (buf[0] << 4) | (buf[1] >> 4);
 
330
                pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
 
331
                avcodec_set_dimensions(avctx, pc->width, pc->height);
 
332
                frame_rate_index = buf[3] & 0xf;
 
333
                pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
 
334
                avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
 
335
                avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
 
336
                avctx->codec_id = CODEC_ID_MPEG1VIDEO;
 
337
                avctx->sub_id = 1;
 
338
            }
 
339
            break;
 
340
        case EXT_START_CODE:
 
341
            if (bytes_left >= 1) {
 
342
                ext_type = (buf[0] >> 4);
 
343
                switch(ext_type) {
 
344
                case 0x1: /* sequence extension */
 
345
                    if (bytes_left >= 6) {
 
346
                        horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
 
347
                        vert_size_ext = (buf[2] >> 5) & 3;
 
348
                        bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
 
349
                        frame_rate_ext_n = (buf[5] >> 5) & 3;
 
350
                        frame_rate_ext_d = (buf[5] & 0x1f);
 
351
                        pc->progressive_sequence = buf[1] & (1 << 3);
 
352
                        avctx->has_b_frames= !(buf[5] >> 7);
 
353
 
 
354
                        pc->width  |=(horiz_size_ext << 12);
 
355
                        pc->height |=( vert_size_ext << 12);
 
356
                        avctx->bit_rate += (bit_rate_ext << 18) * 400;
 
357
                        avcodec_set_dimensions(avctx, pc->width, pc->height);
 
358
                        avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
 
359
                        avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
 
360
                        avctx->codec_id = CODEC_ID_MPEG2VIDEO;
 
361
                        avctx->sub_id = 2; /* forces MPEG2 */
 
362
                    }
 
363
                    break;
 
364
                case 0x8: /* picture coding extension */
 
365
                    if (bytes_left >= 5) {
 
366
                        picture_structure = buf[2]&3;
 
367
                        top_field_first = buf[3] & (1 << 7);
 
368
                        repeat_first_field = buf[3] & (1 << 1);
 
369
                        progressive_frame = buf[4] & (1 << 7);
 
370
 
 
371
                        /* check if we must repeat the frame */
 
372
                        if (repeat_first_field) {
 
373
                            if (pc->progressive_sequence) {
 
374
                                if (top_field_first)
 
375
                                    s->repeat_pict = 4;
 
376
                                else
 
377
                                    s->repeat_pict = 2;
 
378
                            } else if (progressive_frame) {
 
379
                                s->repeat_pict = 1;
 
380
                            }
 
381
                        }
 
382
 
 
383
                        /* the packet only represents half a frame
 
384
                           XXX,FIXME maybe find a different solution */
 
385
                        if(picture_structure != 3)
 
386
                            s->repeat_pict = -1;
 
387
                    }
 
388
                    break;
 
389
                }
 
390
            }
 
391
            break;
 
392
        case -1:
 
393
            goto the_end;
 
394
        default:
 
395
            /* we stop parsing when we encounter a slice. It ensures
 
396
               that this function takes a negligible amount of time */
 
397
            if (start_code >= SLICE_MIN_START_CODE &&
 
398
                start_code <= SLICE_MAX_START_CODE)
 
399
                goto the_end;
 
400
            break;
 
401
        }
 
402
    }
 
403
 the_end: ;
 
404
}
 
405
 
 
406
static int mpegvideo_parse(AVCodecParserContext *s,
 
407
                           AVCodecContext *avctx,
 
408
                           uint8_t **poutbuf, int *poutbuf_size,
 
409
                           const uint8_t *buf, int buf_size)
 
410
{
 
411
    ParseContext1 *pc1 = s->priv_data;
 
412
    ParseContext *pc= &pc1->pc;
 
413
    int next;
 
414
 
 
415
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 
416
        next= buf_size;
 
417
    }else{
 
418
        next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
 
419
 
 
420
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 
421
            *poutbuf = NULL;
 
422
            *poutbuf_size = 0;
 
423
            return buf_size;
 
424
        }
 
425
 
 
426
    }
 
427
    /* we have a full frame : we just parse the first few MPEG headers
 
428
       to have the full timing information. The time take by this
 
429
       function should be negligible for uncorrupted streams */
 
430
    mpegvideo_extract_headers(s, avctx, buf, buf_size);
 
431
#if 0
 
432
    printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
 
433
           s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
 
434
#endif
 
435
 
 
436
    *poutbuf = (uint8_t *)buf;
 
437
    *poutbuf_size = buf_size;
 
438
    return next;
 
439
}
 
440
 
 
441
static int mpegvideo_split(AVCodecContext *avctx,
 
442
                           const uint8_t *buf, int buf_size)
 
443
{
 
444
    int i;
 
445
    uint32_t state= -1;
 
446
 
 
447
    for(i=0; i<buf_size; i++){
 
448
        state= (state<<8) | buf[i];
 
449
        if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
 
450
            return i-3;
 
451
    }
 
452
    return 0;
 
453
}
 
454
#endif /* CONFIG_MPEGVIDEO_PARSER */
 
455
 
 
456
void ff_parse_close(AVCodecParserContext *s)
 
457
{
 
458
    ParseContext *pc = s->priv_data;
 
459
 
 
460
    av_free(pc->buffer);
 
461
}
 
462
 
 
463
static void parse1_close(AVCodecParserContext *s)
 
464
{
 
465
    ParseContext1 *pc1 = s->priv_data;
 
466
 
 
467
    av_free(pc1->pc.buffer);
 
468
    av_free(pc1->enc);
 
469
}
 
470
 
 
471
/*************************/
 
472
 
 
473
#ifdef CONFIG_MPEG4VIDEO_PARSER
 
474
/* used by parser */
 
475
/* XXX: make it use less memory */
 
476
static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 
477
                                  AVCodecContext *avctx,
 
478
                                  const uint8_t *buf, int buf_size)
 
479
{
 
480
    ParseContext1 *pc = s1->priv_data;
 
481
    MpegEncContext *s = pc->enc;
 
482
    GetBitContext gb1, *gb = &gb1;
 
483
    int ret;
 
484
 
 
485
    s->avctx = avctx;
 
486
    s->current_picture_ptr = &s->current_picture;
 
487
 
 
488
    if (avctx->extradata_size && pc->first_picture){
 
489
        init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 
490
        ret = ff_mpeg4_decode_picture_header(s, gb);
 
491
    }
 
492
 
 
493
    init_get_bits(gb, buf, 8 * buf_size);
 
494
    ret = ff_mpeg4_decode_picture_header(s, gb);
 
495
    if (s->width) {
 
496
        avcodec_set_dimensions(avctx, s->width, s->height);
 
497
    }
 
498
    s1->pict_type= s->pict_type;
 
499
    pc->first_picture = 0;
 
500
    return ret;
 
501
}
 
502
 
 
503
static int mpeg4video_parse_init(AVCodecParserContext *s)
 
504
{
 
505
    ParseContext1 *pc = s->priv_data;
 
506
 
 
507
    pc->enc = av_mallocz(sizeof(MpegEncContext));
 
508
    if (!pc->enc)
 
509
        return -1;
 
510
    pc->first_picture = 1;
 
511
    return 0;
 
512
}
 
513
 
 
514
static int mpeg4video_parse(AVCodecParserContext *s,
 
515
                           AVCodecContext *avctx,
 
516
                           uint8_t **poutbuf, int *poutbuf_size,
 
517
                           const uint8_t *buf, int buf_size)
 
518
{
 
519
    ParseContext *pc = s->priv_data;
 
520
    int next;
 
521
 
 
522
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 
523
        next= buf_size;
 
524
    }else{
 
525
        next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 
526
 
 
527
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 
528
            *poutbuf = NULL;
 
529
            *poutbuf_size = 0;
 
530
            return buf_size;
 
531
        }
 
532
    }
 
533
    av_mpeg4_decode_header(s, avctx, buf, buf_size);
 
534
 
 
535
    *poutbuf = (uint8_t *)buf;
 
536
    *poutbuf_size = buf_size;
 
537
    return next;
 
538
}
 
539
#endif
 
540
 
 
541
#ifdef CONFIG_CAVSVIDEO_PARSER
 
542
static int cavsvideo_parse(AVCodecParserContext *s,
 
543
                           AVCodecContext *avctx,
 
544
                           uint8_t **poutbuf, int *poutbuf_size,
 
545
                           const uint8_t *buf, int buf_size)
 
546
{
 
547
    ParseContext *pc = s->priv_data;
 
548
    int next;
 
549
 
 
550
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
 
551
        next= buf_size;
 
552
    }else{
 
553
        next= ff_cavs_find_frame_end(pc, buf, buf_size);
 
554
 
 
555
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 
556
            *poutbuf = NULL;
 
557
            *poutbuf_size = 0;
 
558
            return buf_size;
 
559
        }
 
560
    }
 
561
    *poutbuf = (uint8_t *)buf;
 
562
    *poutbuf_size = buf_size;
 
563
    return next;
 
564
}
 
565
#endif /* CONFIG_CAVSVIDEO_PARSER */
 
566
 
 
567
static int mpeg4video_split(AVCodecContext *avctx,
 
568
                           const uint8_t *buf, int buf_size)
 
569
{
 
570
    int i;
 
571
    uint32_t state= -1;
 
572
 
 
573
    for(i=0; i<buf_size; i++){
 
574
        state= (state<<8) | buf[i];
 
575
        if(state == 0x1B3 || state == 0x1B6)
 
576
            return i-3;
 
577
    }
 
578
    return 0;
 
579
}
 
580
 
 
581
/*************************/
 
582
 
 
583
#ifdef CONFIG_MPEGAUDIO_PARSER
 
584
typedef struct MpegAudioParseContext {
 
585
    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 
586
    uint8_t *inbuf_ptr;
 
587
    int frame_size;
 
588
    int free_format_frame_size;
 
589
    int free_format_next_header;
 
590
    uint32_t header;
 
591
    int header_count;
 
592
} MpegAudioParseContext;
 
593
 
 
594
#define MPA_HEADER_SIZE 4
 
595
 
 
596
/* header + layer + bitrate + freq + lsf/mpeg25 */
 
597
#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
 
598
#define SAME_HEADER_MASK \
 
599
   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
 
600
 
 
601
static int mpegaudio_parse_init(AVCodecParserContext *s1)
 
602
{
 
603
    MpegAudioParseContext *s = s1->priv_data;
 
604
    s->inbuf_ptr = s->inbuf;
 
605
    return 0;
 
606
}
 
607
 
 
608
static int mpegaudio_parse(AVCodecParserContext *s1,
 
609
                           AVCodecContext *avctx,
 
610
                           uint8_t **poutbuf, int *poutbuf_size,
 
611
                           const uint8_t *buf, int buf_size)
 
612
{
 
613
    MpegAudioParseContext *s = s1->priv_data;
 
614
    int len, ret, sr;
 
615
    uint32_t header;
 
616
    const uint8_t *buf_ptr;
 
617
 
 
618
    *poutbuf = NULL;
 
619
    *poutbuf_size = 0;
 
620
    buf_ptr = buf;
 
621
    while (buf_size > 0) {
 
622
        len = s->inbuf_ptr - s->inbuf;
 
623
        if (s->frame_size == 0) {
 
624
            /* special case for next header for first frame in free
 
625
               format case (XXX: find a simpler method) */
 
626
            if (s->free_format_next_header != 0) {
 
627
                s->inbuf[0] = s->free_format_next_header >> 24;
 
628
                s->inbuf[1] = s->free_format_next_header >> 16;
 
629
                s->inbuf[2] = s->free_format_next_header >> 8;
 
630
                s->inbuf[3] = s->free_format_next_header;
 
631
                s->inbuf_ptr = s->inbuf + 4;
 
632
                s->free_format_next_header = 0;
 
633
                goto got_header;
 
634
            }
 
635
            /* no header seen : find one. We need at least MPA_HEADER_SIZE
 
636
               bytes to parse it */
 
637
            len = MPA_HEADER_SIZE - len;
 
638
            if (len > buf_size)
 
639
                len = buf_size;
 
640
            if (len > 0) {
 
641
                memcpy(s->inbuf_ptr, buf_ptr, len);
 
642
                buf_ptr += len;
 
643
                buf_size -= len;
 
644
                s->inbuf_ptr += len;
 
645
            }
 
646
            if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 
647
            got_header:
 
648
                sr= avctx->sample_rate;
 
649
                header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 
650
                    (s->inbuf[2] << 8) | s->inbuf[3];
 
651
 
 
652
                ret = mpa_decode_header(avctx, header);
 
653
                if (ret < 0) {
 
654
                    s->header_count= -2;
 
655
                    /* no sync found : move by one byte (inefficient, but simple!) */
 
656
                    memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 
657
                    s->inbuf_ptr--;
 
658
                    dprintf("skip %x\n", header);
 
659
                    /* reset free format frame size to give a chance
 
660
                       to get a new bitrate */
 
661
                    s->free_format_frame_size = 0;
 
662
                } else {
 
663
                    if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
 
664
                        s->header_count= -3;
 
665
                    s->header= header;
 
666
                    s->header_count++;
 
667
                    s->frame_size = ret;
 
668
 
 
669
#if 0
 
670
                    /* free format: prepare to compute frame size */
 
671
                    if (decode_header(s, header) == 1) {
 
672
                        s->frame_size = -1;
 
673
                    }
 
674
#endif
 
675
                }
 
676
                if(s->header_count <= 0)
 
677
                    avctx->sample_rate= sr; //FIXME ugly
 
678
            }
 
679
        } else
 
680
#if 0
 
681
        if (s->frame_size == -1) {
 
682
            /* free format : find next sync to compute frame size */
 
683
            len = MPA_MAX_CODED_FRAME_SIZE - len;
 
684
            if (len > buf_size)
 
685
                len = buf_size;
 
686
            if (len == 0) {
 
687
                /* frame too long: resync */
 
688
                s->frame_size = 0;
 
689
                memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 
690
                s->inbuf_ptr--;
 
691
            } else {
 
692
                uint8_t *p, *pend;
 
693
                uint32_t header1;
 
694
                int padding;
 
695
 
 
696
                memcpy(s->inbuf_ptr, buf_ptr, len);
 
697
                /* check for header */
 
698
                p = s->inbuf_ptr - 3;
 
699
                pend = s->inbuf_ptr + len - 4;
 
700
                while (p <= pend) {
 
701
                    header = (p[0] << 24) | (p[1] << 16) |
 
702
                        (p[2] << 8) | p[3];
 
703
                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 
704
                        (s->inbuf[2] << 8) | s->inbuf[3];
 
705
                    /* check with high probability that we have a
 
706
                       valid header */
 
707
                    if ((header & SAME_HEADER_MASK) ==
 
708
                        (header1 & SAME_HEADER_MASK)) {
 
709
                        /* header found: update pointers */
 
710
                        len = (p + 4) - s->inbuf_ptr;
 
711
                        buf_ptr += len;
 
712
                        buf_size -= len;
 
713
                        s->inbuf_ptr = p;
 
714
                        /* compute frame size */
 
715
                        s->free_format_next_header = header;
 
716
                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 
717
                        padding = (header1 >> 9) & 1;
 
718
                        if (s->layer == 1)
 
719
                            s->free_format_frame_size -= padding * 4;
 
720
                        else
 
721
                            s->free_format_frame_size -= padding;
 
722
                        dprintf("free frame size=%d padding=%d\n",
 
723
                                s->free_format_frame_size, padding);
 
724
                        decode_header(s, header1);
 
725
                        goto next_data;
 
726
                    }
 
727
                    p++;
 
728
                }
 
729
                /* not found: simply increase pointers */
 
730
                buf_ptr += len;
 
731
                s->inbuf_ptr += len;
 
732
                buf_size -= len;
 
733
            }
 
734
        } else
 
735
#endif
 
736
        if (len < s->frame_size) {
 
737
            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 
738
                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 
739
            len = s->frame_size - len;
 
740
            if (len > buf_size)
 
741
                len = buf_size;
 
742
            memcpy(s->inbuf_ptr, buf_ptr, len);
 
743
            buf_ptr += len;
 
744
            s->inbuf_ptr += len;
 
745
            buf_size -= len;
 
746
        }
 
747
        //    next_data:
 
748
        if (s->frame_size > 0 &&
 
749
            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 
750
            if(s->header_count > 0){
 
751
                *poutbuf = s->inbuf;
 
752
                *poutbuf_size = s->inbuf_ptr - s->inbuf;
 
753
            }
 
754
            s->inbuf_ptr = s->inbuf;
 
755
            s->frame_size = 0;
 
756
            break;
 
757
        }
 
758
    }
 
759
    return buf_ptr - buf;
 
760
}
 
761
#endif /* CONFIG_MPEGAUDIO_PARSER */
 
762
 
 
763
#if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
 
764
/* also used for ADTS AAC */
 
765
typedef struct AC3ParseContext {
 
766
    uint8_t *inbuf_ptr;
 
767
    int frame_size;
 
768
    int header_size;
 
769
    int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
 
770
                int *bit_rate, int *samples);
 
771
    uint8_t inbuf[8192]; /* input buffer */
 
772
} AC3ParseContext;
 
773
 
 
774
#define AC3_HEADER_SIZE 7
 
775
#define AAC_HEADER_SIZE 7
 
776
 
 
777
#ifdef CONFIG_AC3_PARSER
 
778
static const int ac3_sample_rates[4] = {
 
779
    48000, 44100, 32000, 0
 
780
};
 
781
 
 
782
static const int ac3_frame_sizes[64][3] = {
 
783
    { 64,   69,   96   },
 
784
    { 64,   70,   96   },
 
785
    { 80,   87,   120  },
 
786
    { 80,   88,   120  },
 
787
    { 96,   104,  144  },
 
788
    { 96,   105,  144  },
 
789
    { 112,  121,  168  },
 
790
    { 112,  122,  168  },
 
791
    { 128,  139,  192  },
 
792
    { 128,  140,  192  },
 
793
    { 160,  174,  240  },
 
794
    { 160,  175,  240  },
 
795
    { 192,  208,  288  },
 
796
    { 192,  209,  288  },
 
797
    { 224,  243,  336  },
 
798
    { 224,  244,  336  },
 
799
    { 256,  278,  384  },
 
800
    { 256,  279,  384  },
 
801
    { 320,  348,  480  },
 
802
    { 320,  349,  480  },
 
803
    { 384,  417,  576  },
 
804
    { 384,  418,  576  },
 
805
    { 448,  487,  672  },
 
806
    { 448,  488,  672  },
 
807
    { 512,  557,  768  },
 
808
    { 512,  558,  768  },
 
809
    { 640,  696,  960  },
 
810
    { 640,  697,  960  },
 
811
    { 768,  835,  1152 },
 
812
    { 768,  836,  1152 },
 
813
    { 896,  975,  1344 },
 
814
    { 896,  976,  1344 },
 
815
    { 1024, 1114, 1536 },
 
816
    { 1024, 1115, 1536 },
 
817
    { 1152, 1253, 1728 },
 
818
    { 1152, 1254, 1728 },
 
819
    { 1280, 1393, 1920 },
 
820
    { 1280, 1394, 1920 },
 
821
};
 
822
 
 
823
static const int ac3_bitrates[64] = {
 
824
    32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
 
825
    128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
 
826
    384, 448, 448, 512, 512, 576, 576, 640, 640,
 
827
};
 
828
 
 
829
static const int ac3_channels[8] = {
 
830
    2, 1, 2, 3, 3, 4, 4, 5
 
831
};
 
832
#endif /* CONFIG_AC3_PARSER */
 
833
 
 
834
#ifdef CONFIG_AAC_PARSER
 
835
static const int aac_sample_rates[16] = {
 
836
    96000, 88200, 64000, 48000, 44100, 32000,
 
837
    24000, 22050, 16000, 12000, 11025, 8000, 7350
 
838
};
 
839
 
 
840
static const int aac_channels[8] = {
 
841
    0, 1, 2, 3, 4, 5, 6, 8
 
842
};
 
843
#endif
 
844
 
 
845
#ifdef CONFIG_AC3_PARSER
 
846
static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
 
847
                    int *bit_rate, int *samples)
 
848
{
 
849
    unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
 
850
    GetBitContext bits;
 
851
 
 
852
    init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
 
853
 
 
854
    if(get_bits(&bits, 16) != 0x0b77)
 
855
        return 0;
 
856
 
 
857
    skip_bits(&bits, 16);       /* crc */
 
858
    fscod = get_bits(&bits, 2);
 
859
    frmsizecod = get_bits(&bits, 6);
 
860
 
 
861
    if(!ac3_sample_rates[fscod])
 
862
        return 0;
 
863
 
 
864
    bsid = get_bits(&bits, 5);
 
865
    if(bsid > 8)
 
866
        return 0;
 
867
    skip_bits(&bits, 3);        /* bsmod */
 
868
    acmod = get_bits(&bits, 3);
 
869
    if(acmod & 1 && acmod != 1)
 
870
        skip_bits(&bits, 2);    /* cmixlev */
 
871
    if(acmod & 4)
 
872
        skip_bits(&bits, 2);    /* surmixlev */
 
873
    if(acmod & 2)
 
874
        skip_bits(&bits, 2);    /* dsurmod */
 
875
    lfeon = get_bits1(&bits);
 
876
 
 
877
    *sample_rate = ac3_sample_rates[fscod];
 
878
    *bit_rate = ac3_bitrates[frmsizecod] * 1000;
 
879
    *channels = ac3_channels[acmod] + lfeon;
 
880
    *samples = 6 * 256;
 
881
 
 
882
    return ac3_frame_sizes[frmsizecod][fscod] * 2;
 
883
}
 
884
#endif /* CONFIG_AC3_PARSER */
 
885
 
 
886
#ifdef CONFIG_AAC_PARSER
 
887
static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
 
888
                    int *bit_rate, int *samples)
 
889
{
 
890
    GetBitContext bits;
 
891
    int size, rdb, ch, sr;
 
892
 
 
893
    init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
 
894
 
 
895
    if(get_bits(&bits, 12) != 0xfff)
 
896
        return 0;
 
897
 
 
898
    skip_bits1(&bits);          /* id */
 
899
    skip_bits(&bits, 2);        /* layer */
 
900
    skip_bits1(&bits);          /* protection_absent */
 
901
    skip_bits(&bits, 2);        /* profile_objecttype */
 
902
    sr = get_bits(&bits, 4);    /* sample_frequency_index */
 
903
    if(!aac_sample_rates[sr])
 
904
        return 0;
 
905
    skip_bits1(&bits);          /* private_bit */
 
906
    ch = get_bits(&bits, 3);    /* channel_configuration */
 
907
    if(!aac_channels[ch])
 
908
        return 0;
 
909
    skip_bits1(&bits);          /* original/copy */
 
910
    skip_bits1(&bits);          /* home */
 
911
 
 
912
    /* adts_variable_header */
 
913
    skip_bits1(&bits);          /* copyright_identification_bit */
 
914
    skip_bits1(&bits);          /* copyright_identification_start */
 
915
    size = get_bits(&bits, 13); /* aac_frame_length */
 
916
    skip_bits(&bits, 11);       /* adts_buffer_fullness */
 
917
    rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
 
918
 
 
919
    *channels = aac_channels[ch];
 
920
    *sample_rate = aac_sample_rates[sr];
 
921
    *samples = (rdb + 1) * 1024;
 
922
    *bit_rate = size * 8 * *sample_rate / *samples;
 
923
 
 
924
    return size;
 
925
}
 
926
#endif /* CONFIG_AAC_PARSER */
 
927
 
 
928
#ifdef CONFIG_AC3_PARSER
 
929
static int ac3_parse_init(AVCodecParserContext *s1)
 
930
{
 
931
    AC3ParseContext *s = s1->priv_data;
 
932
    s->inbuf_ptr = s->inbuf;
 
933
    s->header_size = AC3_HEADER_SIZE;
 
934
    s->sync = ac3_sync;
 
935
    return 0;
 
936
}
 
937
#endif
 
938
 
 
939
#ifdef CONFIG_AAC_PARSER
 
940
static int aac_parse_init(AVCodecParserContext *s1)
 
941
{
 
942
    AC3ParseContext *s = s1->priv_data;
 
943
    s->inbuf_ptr = s->inbuf;
 
944
    s->header_size = AAC_HEADER_SIZE;
 
945
    s->sync = aac_sync;
 
946
    return 0;
 
947
}
 
948
#endif
 
949
 
 
950
/* also used for ADTS AAC */
 
951
static int ac3_parse(AVCodecParserContext *s1,
 
952
                     AVCodecContext *avctx,
 
953
                     uint8_t **poutbuf, int *poutbuf_size,
 
954
                     const uint8_t *buf, int buf_size)
 
955
{
 
956
    AC3ParseContext *s = s1->priv_data;
 
957
    const uint8_t *buf_ptr;
 
958
    int len, sample_rate, bit_rate, channels, samples;
 
959
 
 
960
    *poutbuf = NULL;
 
961
    *poutbuf_size = 0;
 
962
 
 
963
    buf_ptr = buf;
 
964
    while (buf_size > 0) {
 
965
        len = s->inbuf_ptr - s->inbuf;
 
966
        if (s->frame_size == 0) {
 
967
            /* no header seen : find one. We need at least s->header_size
 
968
               bytes to parse it */
 
969
            len = FFMIN(s->header_size - len, buf_size);
 
970
 
 
971
            memcpy(s->inbuf_ptr, buf_ptr, len);
 
972
            buf_ptr += len;
 
973
            s->inbuf_ptr += len;
 
974
            buf_size -= len;
 
975
            if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
 
976
                len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
 
977
                              &samples);
 
978
                if (len == 0) {
 
979
                    /* no sync found : move by one byte (inefficient, but simple!) */
 
980
                    memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
 
981
                    s->inbuf_ptr--;
 
982
                } else {
 
983
                    s->frame_size = len;
 
984
                    /* update codec info */
 
985
                    avctx->sample_rate = sample_rate;
 
986
                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 
987
                    if(avctx->codec_id == CODEC_ID_AC3){
 
988
                        if(avctx->channels!=1 && avctx->channels!=2){
 
989
                            avctx->channels = channels;
 
990
                        }
 
991
                    } else {
 
992
                        avctx->channels = channels;
 
993
                    }
 
994
                    avctx->bit_rate = bit_rate;
 
995
                    avctx->frame_size = samples;
 
996
                }
 
997
            }
 
998
        } else {
 
999
            len = FFMIN(s->frame_size - len, buf_size);
 
1000
 
 
1001
            memcpy(s->inbuf_ptr, buf_ptr, len);
 
1002
            buf_ptr += len;
 
1003
            s->inbuf_ptr += len;
 
1004
            buf_size -= len;
 
1005
 
 
1006
            if(s->inbuf_ptr - s->inbuf == s->frame_size){
 
1007
                *poutbuf = s->inbuf;
 
1008
                *poutbuf_size = s->frame_size;
 
1009
                s->inbuf_ptr = s->inbuf;
 
1010
                s->frame_size = 0;
 
1011
                break;
 
1012
            }
 
1013
        }
 
1014
    }
 
1015
    return buf_ptr - buf;
 
1016
}
 
1017
#endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
 
1018
 
 
1019
#ifdef CONFIG_MPEGVIDEO_PARSER
 
1020
AVCodecParser mpegvideo_parser = {
 
1021
    { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
 
1022
    sizeof(ParseContext1),
 
1023
    NULL,
 
1024
    mpegvideo_parse,
 
1025
    parse1_close,
 
1026
    mpegvideo_split,
 
1027
};
 
1028
#endif
 
1029
#ifdef CONFIG_MPEG4VIDEO_PARSER
 
1030
AVCodecParser mpeg4video_parser = {
 
1031
    { CODEC_ID_MPEG4 },
 
1032
    sizeof(ParseContext1),
 
1033
    mpeg4video_parse_init,
 
1034
    mpeg4video_parse,
 
1035
    parse1_close,
 
1036
    mpeg4video_split,
 
1037
};
 
1038
#endif
 
1039
#ifdef CONFIG_CAVSVIDEO_PARSER
 
1040
AVCodecParser cavsvideo_parser = {
 
1041
    { CODEC_ID_CAVS },
 
1042
    sizeof(ParseContext1),
 
1043
    NULL,
 
1044
    cavsvideo_parse,
 
1045
    parse1_close,
 
1046
    mpeg4video_split,
 
1047
};
 
1048
#endif
 
1049
#ifdef CONFIG_MPEGAUDIO_PARSER
 
1050
AVCodecParser mpegaudio_parser = {
 
1051
    { CODEC_ID_MP2, CODEC_ID_MP3 },
 
1052
    sizeof(MpegAudioParseContext),
 
1053
    mpegaudio_parse_init,
 
1054
    mpegaudio_parse,
 
1055
    NULL,
 
1056
};
 
1057
#endif
 
1058
#ifdef CONFIG_AC3_PARSER
 
1059
AVCodecParser ac3_parser = {
 
1060
    { CODEC_ID_AC3 },
 
1061
    sizeof(AC3ParseContext),
 
1062
    ac3_parse_init,
 
1063
    ac3_parse,
 
1064
    NULL,
 
1065
};
 
1066
#endif
 
1067
#ifdef CONFIG_AAC_PARSER
 
1068
AVCodecParser aac_parser = {
 
1069
    { CODEC_ID_AAC },
 
1070
    sizeof(AC3ParseContext),
 
1071
    aac_parse_init,
 
1072
    ac3_parse,
 
1073
    NULL,
 
1074
};
 
1075
#endif