malloc padding to avoid reading past the malloc()ed area.
[libav.git] / libavcodec / parser.c
CommitLineData
8424cf50
FB
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20#include "avcodec.h"
21#include "mpegvideo.h"
22#include "mpegaudio.h"
23
24AVCodecParser *av_first_parser = NULL;
25
26void av_register_codec_parser(AVCodecParser *parser)
27{
28 parser->next = av_first_parser;
29 av_first_parser = parser;
30}
31
32AVCodecParserContext *av_parser_init(int codec_id)
33{
34 AVCodecParserContext *s;
35 AVCodecParser *parser;
36 int ret;
8845e427
MN
37
38 if(codec_id == CODEC_ID_NONE)
39 return NULL;
8424cf50
FB
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 ||
99f06236
MN
44 parser->codec_ids[2] == codec_id ||
45 parser->codec_ids[3] == codec_id ||
46 parser->codec_ids[4] == codec_id)
8424cf50
FB
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 }
a62aecce 68 s->fetch_timestamp=1;
8424cf50
FB
69 return s;
70}
71
6e45e928
FB
72/* NOTE: buf_size == 0 is used to signal EOF so that the last frame
73 can be returned if necessary */
8424cf50
FB
74int av_parser_parse(AVCodecParserContext *s,
75 AVCodecContext *avctx,
76 uint8_t **poutbuf, int *poutbuf_size,
b84f2a35
FB
77 const uint8_t *buf, int buf_size,
78 int64_t pts, int64_t dts)
8424cf50 79{
b84f2a35 80 int index, i, k;
6e45e928
FB
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;
b84f2a35
FB
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 */
a62aecce
MN
96 if (s->fetch_timestamp){
97 s->fetch_timestamp=0;
b84f2a35
FB
98 s->last_pts = pts;
99 s->last_dts = dts;
c77a9a0e
MN
100 s->cur_frame_pts[k] =
101 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
b84f2a35 102 }
6e45e928
FB
103 }
104
8424cf50
FB
105 /* WARNING: the returned index can be negative */
106 index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
c77a9a0e 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);
8424cf50
FB
108 /* update the file pointer */
109 if (*poutbuf_size) {
b84f2a35 110 /* fill the data for the current frame */
8424cf50 111 s->frame_offset = s->last_frame_offset;
b84f2a35
FB
112 s->pts = s->last_pts;
113 s->dts = s->last_dts;
114
115 /* offset of the next frame */
8424cf50 116 s->last_frame_offset = s->cur_offset + index;
b84f2a35
FB
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 }
a62aecce 129
b84f2a35
FB
130 s->last_pts = s->cur_frame_pts[k];
131 s->last_dts = s->cur_frame_dts[k];
a62aecce
MN
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 }
8424cf50
FB
138 }
139 if (index < 0)
140 index = 0;
141 s->cur_offset += index;
142 return index;
143}
144
73480a15
MN
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 */
90ad92b3
MN
149int av_parser_change(AVCodecParserContext *s,
150 AVCodecContext *avctx,
151 uint8_t **poutbuf, int *poutbuf_size,
152 const uint8_t *buf, int buf_size, int keyframe){
153
154 if(s && s->parser->split){
73480a15 155 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
90ad92b3
MN
156 int i= s->parser->split(avctx, buf, buf_size);
157 buf += i;
158 buf_size -= i;
159 }
160 }
161
79396ac6
MR
162 /* cast to avoid warning about discarding qualifiers */
163 *poutbuf= (uint8_t *) buf;
90ad92b3
MN
164 *poutbuf_size= buf_size;
165 if(avctx->extradata){
166 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
167 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
168 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
169 int size= buf_size + avctx->extradata_size;
170 *poutbuf_size= size;
171 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
172
173 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
73480a15 174 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
90ad92b3
MN
175 return 1;
176 }
177 }
178
179 return 0;
180}
181
8424cf50
FB
182void av_parser_close(AVCodecParserContext *s)
183{
184 if (s->parser->parser_close)
185 s->parser->parser_close(s);
186 av_free(s->priv_data);
187 av_free(s);
188}
189
190/*****************************************************/
191
192//#define END_NOT_FOUND (-100)
193
194#define PICTURE_START_CODE 0x00000100
195#define SEQ_START_CODE 0x000001b3
196#define EXT_START_CODE 0x000001b5
197#define SLICE_MIN_START_CODE 0x00000101
198#define SLICE_MAX_START_CODE 0x000001af
199
200typedef struct ParseContext1{
e4cb187d
MN
201 ParseContext pc;
202/* XXX/FIXME PC1 vs. PC */
8424cf50
FB
203 /* MPEG2 specific */
204 int frame_rate;
205 int progressive_sequence;
206 int width, height;
c6f353ff 207
8424cf50
FB
208 /* XXX: suppress that, needed by MPEG4 */
209 MpegEncContext *enc;
c6f353ff 210 int first_picture;
8424cf50
FB
211} ParseContext1;
212
213/**
214 * combines the (truncated) bitstream to a complete frame
215 * @returns -1 if no complete frame could be created
216 */
e4cb187d 217int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
8424cf50
FB
218{
219#if 0
220 if(pc->overread){
221 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
222 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
223 }
224#endif
225
226 /* copy overreaded bytes from last frame into buffer */
227 for(; pc->overread>0; pc->overread--){
228 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
229 }
f48c0551
MN
230
231 /* flush remaining if EOF */
232 if(!*buf_size && next == END_NOT_FOUND){
233 next= 0;
234 }
235
8424cf50
FB
236 pc->last_index= pc->index;
237
238 /* copy into buffer end return */
239 if(next == END_NOT_FOUND){
240 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
241
242 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
243 pc->index += *buf_size;
244 return -1;
245 }
246
247 *buf_size=
248 pc->overread_index= pc->index + next;
249
250 /* append to buffer */
251 if(pc->index){
252 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
253
254 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
255 pc->index = 0;
256 *buf= pc->buffer;
257 }
258
259 /* store overread bytes */
260 for(;next < 0; next++){
261 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
262 pc->overread++;
263 }
264
265#if 0
266 if(pc->overread){
267 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
268 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
269 }
270#endif
271
272 return 0;
273}
274
8424cf50
FB
275static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
276{
277 const uint8_t *buf_ptr;
278 unsigned int state=0xFFFFFFFF, v;
279 int val;
280
281 buf_ptr = *pbuf_ptr;
282 while (buf_ptr < buf_end) {
283 v = *buf_ptr++;
284 if (state == 0x000001) {
285 state = ((state << 8) | v) & 0xffffff;
286 val = state;
287 goto found;
288 }
289 state = ((state << 8) | v) & 0xffffff;
290 }
291 val = -1;
292 found:
293 *pbuf_ptr = buf_ptr;
294 return val;
295}
296
297/* XXX: merge with libavcodec ? */
298#define MPEG1_FRAME_RATE_BASE 1001
299
300static const int frame_rate_tab[16] = {
301 0,
302 24000,
303 24024,
304 25025,
305 30000,
306 30030,
307 50050,
308 60000,
309 60060,
310 // Xing's 15fps: (9)
311 15015,
312 // libmpeg3's "Unofficial economy rates": (10-13)
313 5005,
314 10010,
315 12012,
316 15015,
317 // random, just to avoid segfault !never encode these
318 25025,
319 25025,
320};
321
c0df9d75 322//FIXME move into mpeg12.c
8424cf50
FB
323static void mpegvideo_extract_headers(AVCodecParserContext *s,
324 AVCodecContext *avctx,
325 const uint8_t *buf, int buf_size)
326{
327 ParseContext1 *pc = s->priv_data;
328 const uint8_t *buf_end;
329 int32_t start_code;
330 int frame_rate_index, ext_type, bytes_left;
331 int frame_rate_ext_n, frame_rate_ext_d;
8dab64b6 332 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
8c787559 333 int horiz_size_ext, vert_size_ext, bit_rate_ext;
90ad92b3 334//FIXME replace the crap with get_bits()
8424cf50
FB
335 s->repeat_pict = 0;
336 buf_end = buf + buf_size;
337 while (buf < buf_end) {
338 start_code = find_start_code(&buf, buf_end);
339 bytes_left = buf_end - buf;
340 switch(start_code) {
341 case PICTURE_START_CODE:
342 if (bytes_left >= 2) {
343 s->pict_type = (buf[1] >> 3) & 7;
344 }
345 break;
346 case SEQ_START_CODE:
8c787559 347 if (bytes_left >= 7) {
0b2346d3
MN
348 pc->width = (buf[0] << 4) | (buf[1] >> 4);
349 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
21adafec 350 avcodec_set_dimensions(avctx, pc->width, pc->height);
8424cf50 351 frame_rate_index = buf[3] & 0xf;
c0df9d75
MN
352 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
353 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
8c787559 354 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
3e9d718e
FB
355 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
356 avctx->sub_id = 1;
8424cf50
FB
357 }
358 break;
359 case EXT_START_CODE:
360 if (bytes_left >= 1) {
361 ext_type = (buf[0] >> 4);
362 switch(ext_type) {
363 case 0x1: /* sequence extension */
364 if (bytes_left >= 6) {
365 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
366 vert_size_ext = (buf[2] >> 5) & 3;
8c787559 367 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
8424cf50
FB
368 frame_rate_ext_n = (buf[5] >> 5) & 3;
369 frame_rate_ext_d = (buf[5] & 0x1f);
370 pc->progressive_sequence = buf[1] & (1 << 3);
8ca5d3bb 371 avctx->has_b_frames= !(buf[5] >> 7);
8424cf50 372
0b2346d3
MN
373 pc->width |=(horiz_size_ext << 12);
374 pc->height |=( vert_size_ext << 12);
8c787559 375 avctx->bit_rate += (bit_rate_ext << 18) * 400;
21adafec 376 avcodec_set_dimensions(avctx, pc->width, pc->height);
c0df9d75
MN
377 avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
378 avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
3e9d718e 379 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
8424cf50
FB
380 avctx->sub_id = 2; /* forces MPEG2 */
381 }
382 break;
383 case 0x8: /* picture coding extension */
384 if (bytes_left >= 5) {
5bb994e2 385 picture_structure = buf[2]&3;
8424cf50
FB
386 top_field_first = buf[3] & (1 << 7);
387 repeat_first_field = buf[3] & (1 << 1);
388 progressive_frame = buf[4] & (1 << 7);
389
390 /* check if we must repeat the frame */
391 if (repeat_first_field) {
392 if (pc->progressive_sequence) {
393 if (top_field_first)
394 s->repeat_pict = 4;
395 else
396 s->repeat_pict = 2;
397 } else if (progressive_frame) {
398 s->repeat_pict = 1;
399 }
400 }
8dab64b6
MN
401
402 /* the packet only represents half a frame
403 XXX,FIXME maybe find a different solution */
404 if(picture_structure != 3)
405 s->repeat_pict = -1;
8424cf50
FB
406 }
407 break;
408 }
409 }
410 break;
411 case -1:
412 goto the_end;
413 default:
414 /* we stop parsing when we encounter a slice. It ensures
415 that this function takes a negligible amount of time */
416 if (start_code >= SLICE_MIN_START_CODE &&
417 start_code <= SLICE_MAX_START_CODE)
418 goto the_end;
419 break;
420 }
421 }
422 the_end: ;
423}
424
425static int mpegvideo_parse(AVCodecParserContext *s,
426 AVCodecContext *avctx,
427 uint8_t **poutbuf, int *poutbuf_size,
428 const uint8_t *buf, int buf_size)
429{
e4cb187d
MN
430 ParseContext1 *pc1 = s->priv_data;
431 ParseContext *pc= &pc1->pc;
8424cf50 432 int next;
7cbaa7ba
MN
433
434 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
435 next= buf_size;
436 }else{
437 next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
438
439 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
440 *poutbuf = NULL;
441 *poutbuf_size = 0;
442 return buf_size;
443 }
444
8424cf50
FB
445 }
446 /* we have a full frame : we just parse the first few MPEG headers
447 to have the full timing information. The time take by this
448 function should be negligible for uncorrupted streams */
449 mpegvideo_extract_headers(s, avctx, buf, buf_size);
450#if 0
451 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
c0df9d75 452 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
8424cf50
FB
453#endif
454
455 *poutbuf = (uint8_t *)buf;
456 *poutbuf_size = buf_size;
457 return next;
458}
459
90ad92b3
MN
460static int mpegvideo_split(AVCodecContext *avctx,
461 const uint8_t *buf, int buf_size)
462{
463 int i;
464 uint32_t state= -1;
465
466 for(i=0; i<buf_size; i++){
467 state= (state<<8) | buf[i];
468 if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
73480a15 469 return i-3;
90ad92b3
MN
470 }
471 return 0;
472}
473
e4cb187d 474void ff_parse_close(AVCodecParserContext *s)
8424cf50 475{
e4cb187d 476 ParseContext *pc = s->priv_data;
8424cf50
FB
477
478 av_free(pc->buffer);
8424cf50
FB
479}
480
e4cb187d 481static void parse1_close(AVCodecParserContext *s)
8424cf50 482{
e4cb187d 483 ParseContext1 *pc1 = s->priv_data;
8424cf50 484
e4cb187d
MN
485 av_free(pc1->pc.buffer);
486 av_free(pc1->enc);
8424cf50
FB
487}
488
e4cb187d
MN
489/*************************/
490
8424cf50
FB
491/* used by parser */
492/* XXX: make it use less memory */
493static int av_mpeg4_decode_header(AVCodecParserContext *s1,
494 AVCodecContext *avctx,
495 const uint8_t *buf, int buf_size)
496{
497 ParseContext1 *pc = s1->priv_data;
498 MpegEncContext *s = pc->enc;
499 GetBitContext gb1, *gb = &gb1;
500 int ret;
501
502 s->avctx = avctx;
c6f353ff
FB
503 s->current_picture_ptr = &s->current_picture;
504
505 if (avctx->extradata_size && pc->first_picture){
506 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
507 ret = ff_mpeg4_decode_picture_header(s, gb);
508 }
509
8424cf50
FB
510 init_get_bits(gb, buf, 8 * buf_size);
511 ret = ff_mpeg4_decode_picture_header(s, gb);
512 if (s->width) {
21adafec 513 avcodec_set_dimensions(avctx, s->width, s->height);
8424cf50 514 }
7cbaa7ba 515 s1->pict_type= s->pict_type;
c6f353ff 516 pc->first_picture = 0;
8424cf50
FB
517 return ret;
518}
519
e96682e6 520static int mpeg4video_parse_init(AVCodecParserContext *s)
8424cf50
FB
521{
522 ParseContext1 *pc = s->priv_data;
c6f353ff 523
8424cf50
FB
524 pc->enc = av_mallocz(sizeof(MpegEncContext));
525 if (!pc->enc)
526 return -1;
c6f353ff 527 pc->first_picture = 1;
8424cf50
FB
528 return 0;
529}
530
531static int mpeg4video_parse(AVCodecParserContext *s,
532 AVCodecContext *avctx,
533 uint8_t **poutbuf, int *poutbuf_size,
534 const uint8_t *buf, int buf_size)
535{
e4cb187d 536 ParseContext *pc = s->priv_data;
8424cf50
FB
537 int next;
538
7cbaa7ba
MN
539 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
540 next= buf_size;
541 }else{
542 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
543
544 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
545 *poutbuf = NULL;
546 *poutbuf_size = 0;
547 return buf_size;
548 }
8424cf50
FB
549 }
550 av_mpeg4_decode_header(s, avctx, buf, buf_size);
551
552 *poutbuf = (uint8_t *)buf;
553 *poutbuf_size = buf_size;
554 return next;
555}
556
90ad92b3
MN
557static int mpeg4video_split(AVCodecContext *avctx,
558 const uint8_t *buf, int buf_size)
559{
560 int i;
561 uint32_t state= -1;
562
563 for(i=0; i<buf_size; i++){
564 state= (state<<8) | buf[i];
565 if(state == 0x1B3 || state == 0x1B6)
73480a15 566 return i-3;
90ad92b3
MN
567 }
568 return 0;
569}
570
8424cf50
FB
571/*************************/
572
8424cf50
FB
573typedef struct MpegAudioParseContext {
574 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
575 uint8_t *inbuf_ptr;
576 int frame_size;
577 int free_format_frame_size;
578 int free_format_next_header;
4b9ac0b5
MN
579 uint32_t header;
580 int header_count;
8424cf50
FB
581} MpegAudioParseContext;
582
583#define MPA_HEADER_SIZE 4
584
585/* header + layer + bitrate + freq + lsf/mpeg25 */
88730be6 586#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
8424cf50 587#define SAME_HEADER_MASK \
e993bc03 588 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
8424cf50
FB
589
590static int mpegaudio_parse_init(AVCodecParserContext *s1)
591{
592 MpegAudioParseContext *s = s1->priv_data;
593 s->inbuf_ptr = s->inbuf;
594 return 0;
595}
596
597static int mpegaudio_parse(AVCodecParserContext *s1,
598 AVCodecContext *avctx,
599 uint8_t **poutbuf, int *poutbuf_size,
600 const uint8_t *buf, int buf_size)
601{
602 MpegAudioParseContext *s = s1->priv_data;
4b9ac0b5 603 int len, ret, sr;
8424cf50
FB
604 uint32_t header;
605 const uint8_t *buf_ptr;
606
607 *poutbuf = NULL;
608 *poutbuf_size = 0;
609 buf_ptr = buf;
610 while (buf_size > 0) {
611 len = s->inbuf_ptr - s->inbuf;
612 if (s->frame_size == 0) {
613 /* special case for next header for first frame in free
614 format case (XXX: find a simpler method) */
615 if (s->free_format_next_header != 0) {
616 s->inbuf[0] = s->free_format_next_header >> 24;
617 s->inbuf[1] = s->free_format_next_header >> 16;
618 s->inbuf[2] = s->free_format_next_header >> 8;
619 s->inbuf[3] = s->free_format_next_header;
620 s->inbuf_ptr = s->inbuf + 4;
621 s->free_format_next_header = 0;
622 goto got_header;
623 }
624 /* no header seen : find one. We need at least MPA_HEADER_SIZE
625 bytes to parse it */
626 len = MPA_HEADER_SIZE - len;
627 if (len > buf_size)
628 len = buf_size;
629 if (len > 0) {
630 memcpy(s->inbuf_ptr, buf_ptr, len);
631 buf_ptr += len;
632 buf_size -= len;
633 s->inbuf_ptr += len;
634 }
635 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
636 got_header:
4b9ac0b5 637 sr= avctx->sample_rate;
8424cf50
FB
638 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
639 (s->inbuf[2] << 8) | s->inbuf[3];
640
641 ret = mpa_decode_header(avctx, header);
642 if (ret < 0) {
4b9ac0b5 643 s->header_count= -2;
8424cf50
FB
644 /* no sync found : move by one byte (inefficient, but simple!) */
645 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
646 s->inbuf_ptr--;
647 dprintf("skip %x\n", header);
648 /* reset free format frame size to give a chance
649 to get a new bitrate */
650 s->free_format_frame_size = 0;
651 } else {
4b9ac0b5
MN
652 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
653 s->header_count= -3;
654 s->header= header;
655 s->header_count++;
8424cf50 656 s->frame_size = ret;
4b9ac0b5 657
8424cf50
FB
658#if 0
659 /* free format: prepare to compute frame size */
660 if (decode_header(s, header) == 1) {
661 s->frame_size = -1;
662 }
663#endif
664 }
4b9ac0b5
MN
665 if(s->header_count <= 0)
666 avctx->sample_rate= sr; //FIXME ugly
8424cf50
FB
667 }
668 } else
669#if 0
670 if (s->frame_size == -1) {
671 /* free format : find next sync to compute frame size */
672 len = MPA_MAX_CODED_FRAME_SIZE - len;
673 if (len > buf_size)
674 len = buf_size;
675 if (len == 0) {
676 /* frame too long: resync */
677 s->frame_size = 0;
678 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
679 s->inbuf_ptr--;
680 } else {
681 uint8_t *p, *pend;
682 uint32_t header1;
683 int padding;
684
685 memcpy(s->inbuf_ptr, buf_ptr, len);
686 /* check for header */
687 p = s->inbuf_ptr - 3;
688 pend = s->inbuf_ptr + len - 4;
689 while (p <= pend) {
690 header = (p[0] << 24) | (p[1] << 16) |
691 (p[2] << 8) | p[3];
692 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
693 (s->inbuf[2] << 8) | s->inbuf[3];
694 /* check with high probability that we have a
695 valid header */
696 if ((header & SAME_HEADER_MASK) ==
697 (header1 & SAME_HEADER_MASK)) {
698 /* header found: update pointers */
699 len = (p + 4) - s->inbuf_ptr;
700 buf_ptr += len;
701 buf_size -= len;
702 s->inbuf_ptr = p;
703 /* compute frame size */
704 s->free_format_next_header = header;
705 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
706 padding = (header1 >> 9) & 1;
707 if (s->layer == 1)
708 s->free_format_frame_size -= padding * 4;
709 else
710 s->free_format_frame_size -= padding;
711 dprintf("free frame size=%d padding=%d\n",
712 s->free_format_frame_size, padding);
713 decode_header(s, header1);
714 goto next_data;
715 }
716 p++;
717 }
718 /* not found: simply increase pointers */
719 buf_ptr += len;
720 s->inbuf_ptr += len;
721 buf_size -= len;
722 }
723 } else
724#endif
725 if (len < s->frame_size) {
726 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
727 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
728 len = s->frame_size - len;
729 if (len > buf_size)
730 len = buf_size;
731 memcpy(s->inbuf_ptr, buf_ptr, len);
732 buf_ptr += len;
733 s->inbuf_ptr += len;
734 buf_size -= len;
735 }
736 // next_data:
737 if (s->frame_size > 0 &&
738 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
4b9ac0b5
MN
739 if(s->header_count > 0){
740 *poutbuf = s->inbuf;
741 *poutbuf_size = s->inbuf_ptr - s->inbuf;
742 }
8424cf50
FB
743 s->inbuf_ptr = s->inbuf;
744 s->frame_size = 0;
745 break;
746 }
747 }
748 return buf_ptr - buf;
749}
750
751#ifdef CONFIG_AC3
95ae72b7
MN
752#ifdef CONFIG_A52BIN
753extern int ff_a52_syncinfo (AVCodecContext * avctx, const uint8_t * buf,
754 int * flags, int * sample_rate, int * bit_rate);
755#else
8424cf50
FB
756extern int a52_syncinfo (const uint8_t * buf, int * flags,
757 int * sample_rate, int * bit_rate);
95ae72b7 758#endif
8424cf50
FB
759
760typedef struct AC3ParseContext {
761 uint8_t inbuf[4096]; /* input buffer */
762 uint8_t *inbuf_ptr;
763 int frame_size;
764 int flags;
765} AC3ParseContext;
766
767#define AC3_HEADER_SIZE 7
768#define A52_LFE 16
769
770static int ac3_parse_init(AVCodecParserContext *s1)
771{
772 AC3ParseContext *s = s1->priv_data;
773 s->inbuf_ptr = s->inbuf;
774 return 0;
775}
776
777static int ac3_parse(AVCodecParserContext *s1,
778 AVCodecContext *avctx,
779 uint8_t **poutbuf, int *poutbuf_size,
780 const uint8_t *buf, int buf_size)
781{
782 AC3ParseContext *s = s1->priv_data;
783 const uint8_t *buf_ptr;
784 int len, sample_rate, bit_rate;
785 static const int ac3_channels[8] = {
786 2, 1, 2, 3, 3, 4, 4, 5
787 };
788
789 *poutbuf = NULL;
790 *poutbuf_size = 0;
791
792 buf_ptr = buf;
793 while (buf_size > 0) {
794 len = s->inbuf_ptr - s->inbuf;
795 if (s->frame_size == 0) {
796 /* no header seen : find one. We need at least 7 bytes to parse it */
797 len = AC3_HEADER_SIZE - len;
798 if (len > buf_size)
799 len = buf_size;
800 memcpy(s->inbuf_ptr, buf_ptr, len);
801 buf_ptr += len;
802 s->inbuf_ptr += len;
803 buf_size -= len;
804 if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
95ae72b7
MN
805#ifdef CONFIG_A52BIN
806 len = ff_a52_syncinfo(avctx, s->inbuf, &s->flags, &sample_rate, &bit_rate);
807#else
8424cf50 808 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
95ae72b7 809#endif
8424cf50
FB
810 if (len == 0) {
811 /* no sync found : move by one byte (inefficient, but simple!) */
812 memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
813 s->inbuf_ptr--;
814 } else {
815 s->frame_size = len;
816 /* update codec info */
817 avctx->sample_rate = sample_rate;
20da3179
MN
818 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
819 if(avctx->channels!=1 && avctx->channels!=2){
820 avctx->channels = ac3_channels[s->flags & 7];
821 if (s->flags & A52_LFE)
822 avctx->channels++;
823 }
8424cf50
FB
824 avctx->bit_rate = bit_rate;
825 avctx->frame_size = 6 * 256;
826 }
827 }
828 } else if (len < s->frame_size) {
829 len = s->frame_size - len;
830 if (len > buf_size)
831 len = buf_size;
832
833 memcpy(s->inbuf_ptr, buf_ptr, len);
834 buf_ptr += len;
835 s->inbuf_ptr += len;
836 buf_size -= len;
837 } else {
838 *poutbuf = s->inbuf;
839 *poutbuf_size = s->frame_size;
840 s->inbuf_ptr = s->inbuf;
841 s->frame_size = 0;
842 break;
843 }
844 }
845 return buf_ptr - buf;
846}
847#endif
848
849AVCodecParser mpegvideo_parser = {
850 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
851 sizeof(ParseContext1),
852 NULL,
853 mpegvideo_parse,
e4cb187d 854 parse1_close,
90ad92b3 855 mpegvideo_split,
8424cf50
FB
856};
857
858AVCodecParser mpeg4video_parser = {
859 { CODEC_ID_MPEG4 },
860 sizeof(ParseContext1),
861 mpeg4video_parse_init,
862 mpeg4video_parse,
e4cb187d 863 parse1_close,
90ad92b3 864 mpeg4video_split,
8424cf50
FB
865};
866
867AVCodecParser mpegaudio_parser = {
868 { CODEC_ID_MP2, CODEC_ID_MP3 },
869 sizeof(MpegAudioParseContext),
870 mpegaudio_parse_init,
871 mpegaudio_parse,
872 NULL,
873};
874
875#ifdef CONFIG_AC3
876AVCodecParser ac3_parser = {
877 { CODEC_ID_AC3 },
878 sizeof(AC3ParseContext),
879 ac3_parse_init,
880 ac3_parse,
881 NULL,
882};
883#endif