dont copy frame if the whole mp1/2/3 frame is available in one piece in the input
[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
5509bffa 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
8424cf50
FB
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;
115329f1 37
8845e427
MN
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 */
115329f1 74int av_parser_parse(AVCodecParserContext *s,
8424cf50 75 AVCodecContext *avctx,
115329f1 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 81 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
115329f1 82
6e45e928
FB
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;
115329f1 114
b84f2a35 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];
115329f1 132
a62aecce
MN
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
748c2fca 148 * @deprecated use AVBitstreamFilter
73480a15 149 */
90ad92b3
MN
150int av_parser_change(AVCodecParserContext *s,
151 AVCodecContext *avctx,
115329f1 152 uint8_t **poutbuf, int *poutbuf_size,
90ad92b3 153 const uint8_t *buf, int buf_size, int keyframe){
115329f1 154
90ad92b3 155 if(s && s->parser->split){
73480a15 156 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
90ad92b3
MN
157 int i= s->parser->split(avctx, buf, buf_size);
158 buf += i;
159 buf_size -= i;
160 }
161 }
162
79396ac6
MR
163 /* cast to avoid warning about discarding qualifiers */
164 *poutbuf= (uint8_t *) buf;
90ad92b3
MN
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);
115329f1 173
90ad92b3 174 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
73480a15 175 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
90ad92b3
MN
176 return 1;
177 }
178 }
179
180 return 0;
181}
182
8424cf50
FB
183void 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
bb270c08
DB
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
8424cf50
FB
200
201typedef struct ParseContext1{
e4cb187d
MN
202 ParseContext pc;
203/* XXX/FIXME PC1 vs. PC */
8424cf50
FB
204 /* MPEG2 specific */
205 int frame_rate;
206 int progressive_sequence;
207 int width, height;
c6f353ff 208
8424cf50
FB
209 /* XXX: suppress that, needed by MPEG4 */
210 MpegEncContext *enc;
c6f353ff 211 int first_picture;
8424cf50
FB
212} ParseContext1;
213
214/**
215 * combines the (truncated) bitstream to a complete frame
216 * @returns -1 if no complete frame could be created
217 */
e4cb187d 218int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
8424cf50
FB
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 }
f48c0551
MN
231
232 /* flush remaining if EOF */
233 if(!*buf_size && next == END_NOT_FOUND){
234 next= 0;
235 }
236
8424cf50
FB
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;
115329f1 250
8424cf50
FB
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
8424cf50
FB
276/* XXX: merge with libavcodec ? */
277#define MPEG1_FRAME_RATE_BASE 1001
278
279static const int frame_rate_tab[16] = {
115329f1 280 0,
8424cf50
FB
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
af9e7d18 301#ifdef CONFIG_MPEGVIDEO_PARSER
c0df9d75 302//FIXME move into mpeg12.c
115329f1 303static void mpegvideo_extract_headers(AVCodecParserContext *s,
8424cf50
FB
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;
8dab64b6 312 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
8c787559 313 int horiz_size_ext, vert_size_ext, bit_rate_ext;
90ad92b3 314//FIXME replace the crap with get_bits()
8424cf50
FB
315 s->repeat_pict = 0;
316 buf_end = buf + buf_size;
317 while (buf < buf_end) {
82fcbc14
MN
318 start_code= -1;
319 buf= ff_find_start_code(buf, buf_end, &start_code);
8424cf50
FB
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:
8c787559 328 if (bytes_left >= 7) {
0b2346d3
MN
329 pc->width = (buf[0] << 4) | (buf[1] >> 4);
330 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
21adafec 331 avcodec_set_dimensions(avctx, pc->width, pc->height);
8424cf50 332 frame_rate_index = buf[3] & 0xf;
c0df9d75
MN
333 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
334 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
8c787559 335 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
3e9d718e
FB
336 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
337 avctx->sub_id = 1;
8424cf50
FB
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;
8c787559 348 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
8424cf50
FB
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);
8ca5d3bb 352 avctx->has_b_frames= !(buf[5] >> 7);
8424cf50 353
0b2346d3
MN
354 pc->width |=(horiz_size_ext << 12);
355 pc->height |=( vert_size_ext << 12);
8c787559 356 avctx->bit_rate += (bit_rate_ext << 18) * 400;
21adafec 357 avcodec_set_dimensions(avctx, pc->width, pc->height);
c0df9d75
MN
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);
3e9d718e 360 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
8424cf50
FB
361 avctx->sub_id = 2; /* forces MPEG2 */
362 }
363 break;
364 case 0x8: /* picture coding extension */
365 if (bytes_left >= 5) {
5bb994e2 366 picture_structure = buf[2]&3;
8424cf50
FB
367 top_field_first = buf[3] & (1 << 7);
368 repeat_first_field = buf[3] & (1 << 1);
369 progressive_frame = buf[4] & (1 << 7);
115329f1 370
8424cf50
FB
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 }
115329f1
DB
382
383 /* the packet only represents half a frame
8dab64b6
MN
384 XXX,FIXME maybe find a different solution */
385 if(picture_structure != 3)
386 s->repeat_pict = -1;
8424cf50
FB
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 */
115329f1 397 if (start_code >= SLICE_MIN_START_CODE &&
8424cf50
FB
398 start_code <= SLICE_MAX_START_CODE)
399 goto the_end;
400 break;
401 }
402 }
403 the_end: ;
404}
405
406static int mpegvideo_parse(AVCodecParserContext *s,
407 AVCodecContext *avctx,
115329f1 408 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
409 const uint8_t *buf, int buf_size)
410{
e4cb187d
MN
411 ParseContext1 *pc1 = s->priv_data;
412 ParseContext *pc= &pc1->pc;
8424cf50 413 int next;
115329f1 414
7cbaa7ba
MN
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);
115329f1 419
7cbaa7ba
MN
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 }
115329f1 425
8424cf50
FB
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
115329f1 432 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
c0df9d75 433 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
8424cf50
FB
434#endif
435
436 *poutbuf = (uint8_t *)buf;
437 *poutbuf_size = buf_size;
438 return next;
439}
440
90ad92b3
MN
441static int mpegvideo_split(AVCodecContext *avctx,
442 const uint8_t *buf, int buf_size)
443{
444 int i;
445 uint32_t state= -1;
115329f1 446
90ad92b3
MN
447 for(i=0; i<buf_size; i++){
448 state= (state<<8) | buf[i];
449 if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
73480a15 450 return i-3;
90ad92b3
MN
451 }
452 return 0;
453}
af9e7d18 454#endif /* CONFIG_MPEGVIDEO_PARSER */
90ad92b3 455
e4cb187d 456void ff_parse_close(AVCodecParserContext *s)
8424cf50 457{
e4cb187d 458 ParseContext *pc = s->priv_data;
8424cf50
FB
459
460 av_free(pc->buffer);
8424cf50
FB
461}
462
e4cb187d 463static void parse1_close(AVCodecParserContext *s)
8424cf50 464{
e4cb187d 465 ParseContext1 *pc1 = s->priv_data;
8424cf50 466
e4cb187d
MN
467 av_free(pc1->pc.buffer);
468 av_free(pc1->enc);
8424cf50
FB
469}
470
e4cb187d
MN
471/*************************/
472
af9e7d18 473#ifdef CONFIG_MPEG4VIDEO_PARSER
8424cf50
FB
474/* used by parser */
475/* XXX: make it use less memory */
115329f1 476static int av_mpeg4_decode_header(AVCodecParserContext *s1,
8424cf50
FB
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;
c6f353ff
FB
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
8424cf50
FB
493 init_get_bits(gb, buf, 8 * buf_size);
494 ret = ff_mpeg4_decode_picture_header(s, gb);
495 if (s->width) {
21adafec 496 avcodec_set_dimensions(avctx, s->width, s->height);
8424cf50 497 }
7cbaa7ba 498 s1->pict_type= s->pict_type;
c6f353ff 499 pc->first_picture = 0;
8424cf50
FB
500 return ret;
501}
502
e96682e6 503static int mpeg4video_parse_init(AVCodecParserContext *s)
8424cf50
FB
504{
505 ParseContext1 *pc = s->priv_data;
c6f353ff 506
8424cf50
FB
507 pc->enc = av_mallocz(sizeof(MpegEncContext));
508 if (!pc->enc)
509 return -1;
c6f353ff 510 pc->first_picture = 1;
8424cf50
FB
511 return 0;
512}
513
514static int mpeg4video_parse(AVCodecParserContext *s,
515 AVCodecContext *avctx,
115329f1 516 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
517 const uint8_t *buf, int buf_size)
518{
e4cb187d 519 ParseContext *pc = s->priv_data;
8424cf50 520 int next;
115329f1 521
7cbaa7ba
MN
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);
115329f1 526
7cbaa7ba
MN
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 }
8424cf50
FB
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}
af9e7d18 539#endif
8424cf50 540
af9e7d18 541#ifdef CONFIG_CAVSVIDEO_PARSER
b482e2d1
MN
542static 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}
af9e7d18 565#endif /* CONFIG_CAVSVIDEO_PARSER */
b482e2d1 566
90ad92b3
MN
567static int mpeg4video_split(AVCodecContext *avctx,
568 const uint8_t *buf, int buf_size)
569{
570 int i;
571 uint32_t state= -1;
115329f1 572
90ad92b3
MN
573 for(i=0; i<buf_size; i++){
574 state= (state<<8) | buf[i];
575 if(state == 0x1B3 || state == 0x1B6)
73480a15 576 return i-3;
90ad92b3
MN
577 }
578 return 0;
579}
580
8424cf50
FB
581/*************************/
582
af9e7d18 583#ifdef CONFIG_MPEGAUDIO_PARSER
8424cf50 584typedef struct MpegAudioParseContext {
bb270c08 585 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
8424cf50
FB
586 uint8_t *inbuf_ptr;
587 int frame_size;
588 int free_format_frame_size;
589 int free_format_next_header;
4b9ac0b5
MN
590 uint32_t header;
591 int header_count;
8424cf50
FB
592} MpegAudioParseContext;
593
594#define MPA_HEADER_SIZE 4
595
596/* header + layer + bitrate + freq + lsf/mpeg25 */
88730be6 597#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
8424cf50 598#define SAME_HEADER_MASK \
e993bc03 599 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
8424cf50
FB
600
601static int mpegaudio_parse_init(AVCodecParserContext *s1)
602{
603 MpegAudioParseContext *s = s1->priv_data;
604 s->inbuf_ptr = s->inbuf;
605 return 0;
606}
607
608static int mpegaudio_parse(AVCodecParserContext *s1,
609 AVCodecContext *avctx,
115329f1 610 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
611 const uint8_t *buf, int buf_size)
612{
613 MpegAudioParseContext *s = s1->priv_data;
4b9ac0b5 614 int len, ret, sr;
8424cf50
FB
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) {
bb270c08
DB
622 len = s->inbuf_ptr - s->inbuf;
623 if (s->frame_size == 0) {
8424cf50
FB
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 }
bb270c08 635 /* no header seen : find one. We need at least MPA_HEADER_SIZE
8424cf50 636 bytes to parse it */
4e2d6a45 637 len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
bb270c08
DB
638 if (len > 0) {
639 memcpy(s->inbuf_ptr, buf_ptr, len);
640 buf_ptr += len;
641 buf_size -= len;
642 s->inbuf_ptr += len;
643 }
644 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
8424cf50 645 got_header:
4b9ac0b5 646 sr= avctx->sample_rate;
bb270c08
DB
647 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
648 (s->inbuf[2] << 8) | s->inbuf[3];
8424cf50
FB
649
650 ret = mpa_decode_header(avctx, header);
651 if (ret < 0) {
4b9ac0b5 652 s->header_count= -2;
bb270c08
DB
653 /* no sync found : move by one byte (inefficient, but simple!) */
654 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
655 s->inbuf_ptr--;
8424cf50
FB
656 dprintf("skip %x\n", header);
657 /* reset free format frame size to give a chance
658 to get a new bitrate */
659 s->free_format_frame_size = 0;
bb270c08 660 } else {
4b9ac0b5
MN
661 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
662 s->header_count= -3;
663 s->header= header;
664 s->header_count++;
8424cf50 665 s->frame_size = ret;
115329f1 666
8424cf50
FB
667#if 0
668 /* free format: prepare to compute frame size */
bb270c08
DB
669 if (decode_header(s, header) == 1) {
670 s->frame_size = -1;
8424cf50
FB
671 }
672#endif
bb270c08 673 }
4b9ac0b5
MN
674 if(s->header_count <= 0)
675 avctx->sample_rate= sr; //FIXME ugly
bb270c08 676 }
115329f1 677 } else
8424cf50
FB
678#if 0
679 if (s->frame_size == -1) {
680 /* free format : find next sync to compute frame size */
bb270c08
DB
681 len = MPA_MAX_CODED_FRAME_SIZE - len;
682 if (len > buf_size)
683 len = buf_size;
8424cf50 684 if (len == 0) {
bb270c08 685 /* frame too long: resync */
8424cf50 686 s->frame_size = 0;
bb270c08
DB
687 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
688 s->inbuf_ptr--;
8424cf50
FB
689 } else {
690 uint8_t *p, *pend;
691 uint32_t header1;
692 int padding;
693
694 memcpy(s->inbuf_ptr, buf_ptr, len);
695 /* check for header */
696 p = s->inbuf_ptr - 3;
697 pend = s->inbuf_ptr + len - 4;
698 while (p <= pend) {
699 header = (p[0] << 24) | (p[1] << 16) |
700 (p[2] << 8) | p[3];
701 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
702 (s->inbuf[2] << 8) | s->inbuf[3];
703 /* check with high probability that we have a
704 valid header */
705 if ((header & SAME_HEADER_MASK) ==
706 (header1 & SAME_HEADER_MASK)) {
707 /* header found: update pointers */
708 len = (p + 4) - s->inbuf_ptr;
709 buf_ptr += len;
710 buf_size -= len;
711 s->inbuf_ptr = p;
712 /* compute frame size */
713 s->free_format_next_header = header;
714 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
715 padding = (header1 >> 9) & 1;
716 if (s->layer == 1)
717 s->free_format_frame_size -= padding * 4;
718 else
719 s->free_format_frame_size -= padding;
115329f1 720 dprintf("free frame size=%d padding=%d\n",
8424cf50
FB
721 s->free_format_frame_size, padding);
722 decode_header(s, header1);
723 goto next_data;
724 }
725 p++;
726 }
727 /* not found: simply increase pointers */
728 buf_ptr += len;
729 s->inbuf_ptr += len;
730 buf_size -= len;
731 }
bb270c08 732 } else
8424cf50
FB
733#endif
734 if (len < s->frame_size) {
735 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
736 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
4e2d6a45 737 len = FFMIN(s->frame_size - len, buf_size);
bb270c08
DB
738 memcpy(s->inbuf_ptr, buf_ptr, len);
739 buf_ptr += len;
740 s->inbuf_ptr += len;
741 buf_size -= len;
742 }
4e2d6a45
MN
743
744 if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
745 && buf_size + buf_ptr - buf >= s->frame_size){
746 if(s->header_count > 0){
747 *poutbuf = buf;
748 *poutbuf_size = s->frame_size;
749 }
750 buf_ptr = buf + s->frame_size;
751 s->inbuf_ptr = s->inbuf;
752 s->frame_size = 0;
753 break;
754 }
755
8424cf50 756 // next_data:
115329f1 757 if (s->frame_size > 0 &&
8424cf50 758 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
4b9ac0b5
MN
759 if(s->header_count > 0){
760 *poutbuf = s->inbuf;
761 *poutbuf_size = s->inbuf_ptr - s->inbuf;
762 }
bb270c08
DB
763 s->inbuf_ptr = s->inbuf;
764 s->frame_size = 0;
765 break;
766 }
8424cf50
FB
767 }
768 return buf_ptr - buf;
769}
af9e7d18 770#endif /* CONFIG_MPEGAUDIO_PARSER */
8424cf50 771
af9e7d18 772#if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
da46276f 773/* also used for ADTS AAC */
8424cf50 774typedef struct AC3ParseContext {
8424cf50
FB
775 uint8_t *inbuf_ptr;
776 int frame_size;
da46276f
MR
777 int header_size;
778 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
779 int *bit_rate, int *samples);
4f8ff17e 780 uint8_t inbuf[8192]; /* input buffer */
8424cf50
FB
781} AC3ParseContext;
782
783#define AC3_HEADER_SIZE 7
100a7422 784#define AAC_HEADER_SIZE 7
62327e28 785
af9e7d18 786#ifdef CONFIG_AC3_PARSER
62327e28
MR
787static const int ac3_sample_rates[4] = {
788 48000, 44100, 32000, 0
789};
790
791static const int ac3_frame_sizes[64][3] = {
4f59b684
DB
792 { 64, 69, 96 },
793 { 64, 70, 96 },
794 { 80, 87, 120 },
795 { 80, 88, 120 },
796 { 96, 104, 144 },
797 { 96, 105, 144 },
798 { 112, 121, 168 },
799 { 112, 122, 168 },
800 { 128, 139, 192 },
801 { 128, 140, 192 },
802 { 160, 174, 240 },
803 { 160, 175, 240 },
804 { 192, 208, 288 },
805 { 192, 209, 288 },
806 { 224, 243, 336 },
807 { 224, 244, 336 },
808 { 256, 278, 384 },
809 { 256, 279, 384 },
810 { 320, 348, 480 },
811 { 320, 349, 480 },
812 { 384, 417, 576 },
813 { 384, 418, 576 },
814 { 448, 487, 672 },
815 { 448, 488, 672 },
816 { 512, 557, 768 },
817 { 512, 558, 768 },
818 { 640, 696, 960 },
819 { 640, 697, 960 },
820 { 768, 835, 1152 },
821 { 768, 836, 1152 },
822 { 896, 975, 1344 },
823 { 896, 976, 1344 },
62327e28
MR
824 { 1024, 1114, 1536 },
825 { 1024, 1115, 1536 },
826 { 1152, 1253, 1728 },
827 { 1152, 1254, 1728 },
828 { 1280, 1393, 1920 },
829 { 1280, 1394, 1920 },
830};
831
832static const int ac3_bitrates[64] = {
833 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
834 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
835 384, 448, 448, 512, 512, 576, 576, 640, 640,
836};
837
838static const int ac3_channels[8] = {
839 2, 1, 2, 3, 3, 4, 4, 5
840};
af9e7d18 841#endif /* CONFIG_AC3_PARSER */
62327e28 842
af9e7d18 843#ifdef CONFIG_AAC_PARSER
608bd843 844static const int aac_sample_rates[16] = {
da46276f
MR
845 96000, 88200, 64000, 48000, 44100, 32000,
846 24000, 22050, 16000, 12000, 11025, 8000, 7350
847};
848
608bd843 849static const int aac_channels[8] = {
da46276f
MR
850 0, 1, 2, 3, 4, 5, 6, 8
851};
af9e7d18 852#endif
da46276f 853
af9e7d18 854#ifdef CONFIG_AC3_PARSER
62327e28 855static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
da46276f 856 int *bit_rate, int *samples)
62327e28
MR
857{
858 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
859 GetBitContext bits;
860
861 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
862
863 if(get_bits(&bits, 16) != 0x0b77)
4f59b684 864 return 0;
62327e28 865
100a7422 866 skip_bits(&bits, 16); /* crc */
62327e28
MR
867 fscod = get_bits(&bits, 2);
868 frmsizecod = get_bits(&bits, 6);
869
870 if(!ac3_sample_rates[fscod])
4f59b684 871 return 0;
62327e28
MR
872
873 bsid = get_bits(&bits, 5);
874 if(bsid > 8)
4f59b684 875 return 0;
100a7422 876 skip_bits(&bits, 3); /* bsmod */
62327e28
MR
877 acmod = get_bits(&bits, 3);
878 if(acmod & 1 && acmod != 1)
100a7422 879 skip_bits(&bits, 2); /* cmixlev */
62327e28 880 if(acmod & 4)
100a7422 881 skip_bits(&bits, 2); /* surmixlev */
62327e28 882 if(acmod & 2)
100a7422
MR
883 skip_bits(&bits, 2); /* dsurmod */
884 lfeon = get_bits1(&bits);
62327e28
MR
885
886 *sample_rate = ac3_sample_rates[fscod];
887 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
888 *channels = ac3_channels[acmod] + lfeon;
da46276f 889 *samples = 6 * 256;
62327e28
MR
890
891 return ac3_frame_sizes[frmsizecod][fscod] * 2;
892}
af9e7d18 893#endif /* CONFIG_AC3_PARSER */
8424cf50 894
af9e7d18 895#ifdef CONFIG_AAC_PARSER
da46276f
MR
896static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
897 int *bit_rate, int *samples)
898{
899 GetBitContext bits;
900 int size, rdb, ch, sr;
901
902 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
903
904 if(get_bits(&bits, 12) != 0xfff)
905 return 0;
906
100a7422
MR
907 skip_bits1(&bits); /* id */
908 skip_bits(&bits, 2); /* layer */
909 skip_bits1(&bits); /* protection_absent */
910 skip_bits(&bits, 2); /* profile_objecttype */
911 sr = get_bits(&bits, 4); /* sample_frequency_index */
da46276f
MR
912 if(!aac_sample_rates[sr])
913 return 0;
100a7422
MR
914 skip_bits1(&bits); /* private_bit */
915 ch = get_bits(&bits, 3); /* channel_configuration */
da46276f
MR
916 if(!aac_channels[ch])
917 return 0;
100a7422
MR
918 skip_bits1(&bits); /* original/copy */
919 skip_bits1(&bits); /* home */
da46276f
MR
920
921 /* adts_variable_header */
100a7422
MR
922 skip_bits1(&bits); /* copyright_identification_bit */
923 skip_bits1(&bits); /* copyright_identification_start */
924 size = get_bits(&bits, 13); /* aac_frame_length */
925 skip_bits(&bits, 11); /* adts_buffer_fullness */
926 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
da46276f
MR
927
928 *channels = aac_channels[ch];
929 *sample_rate = aac_sample_rates[sr];
930 *samples = (rdb + 1) * 1024;
931 *bit_rate = size * 8 * *sample_rate / *samples;
932
933 return size;
934}
af9e7d18 935#endif /* CONFIG_AAC_PARSER */
da46276f 936
af9e7d18 937#ifdef CONFIG_AC3_PARSER
8424cf50
FB
938static int ac3_parse_init(AVCodecParserContext *s1)
939{
940 AC3ParseContext *s = s1->priv_data;
941 s->inbuf_ptr = s->inbuf;
da46276f
MR
942 s->header_size = AC3_HEADER_SIZE;
943 s->sync = ac3_sync;
8424cf50
FB
944 return 0;
945}
af9e7d18 946#endif
8424cf50 947
af9e7d18 948#ifdef CONFIG_AAC_PARSER
da46276f
MR
949static int aac_parse_init(AVCodecParserContext *s1)
950{
951 AC3ParseContext *s = s1->priv_data;
952 s->inbuf_ptr = s->inbuf;
953 s->header_size = AAC_HEADER_SIZE;
954 s->sync = aac_sync;
955 return 0;
956}
af9e7d18 957#endif
da46276f
MR
958
959/* also used for ADTS AAC */
8424cf50
FB
960static int ac3_parse(AVCodecParserContext *s1,
961 AVCodecContext *avctx,
115329f1 962 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
963 const uint8_t *buf, int buf_size)
964{
965 AC3ParseContext *s = s1->priv_data;
966 const uint8_t *buf_ptr;
da46276f 967 int len, sample_rate, bit_rate, channels, samples;
8424cf50
FB
968
969 *poutbuf = NULL;
970 *poutbuf_size = 0;
971
972 buf_ptr = buf;
973 while (buf_size > 0) {
974 len = s->inbuf_ptr - s->inbuf;
975 if (s->frame_size == 0) {
da46276f
MR
976 /* no header seen : find one. We need at least s->header_size
977 bytes to parse it */
978 len = FFMIN(s->header_size - len, buf_size);
d8a91afd 979
8424cf50
FB
980 memcpy(s->inbuf_ptr, buf_ptr, len);
981 buf_ptr += len;
982 s->inbuf_ptr += len;
983 buf_size -= len;
da46276f
MR
984 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
985 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
986 &samples);
8424cf50
FB
987 if (len == 0) {
988 /* no sync found : move by one byte (inefficient, but simple!) */
da46276f 989 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
8424cf50
FB
990 s->inbuf_ptr--;
991 } else {
bb270c08 992 s->frame_size = len;
8424cf50
FB
993 /* update codec info */
994 avctx->sample_rate = sample_rate;
20da3179 995 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
da46276f
MR
996 if(avctx->codec_id == CODEC_ID_AC3){
997 if(avctx->channels!=1 && avctx->channels!=2){
998 avctx->channels = channels;
999 }
1000 } else {
4f59b684 1001 avctx->channels = channels;
20da3179 1002 }
bb270c08 1003 avctx->bit_rate = bit_rate;
da46276f 1004 avctx->frame_size = samples;
8424cf50
FB
1005 }
1006 }
d8a91afd
MN
1007 } else {
1008 len = FFMIN(s->frame_size - len, buf_size);
8424cf50
FB
1009
1010 memcpy(s->inbuf_ptr, buf_ptr, len);
1011 buf_ptr += len;
1012 s->inbuf_ptr += len;
1013 buf_size -= len;
d8a91afd
MN
1014
1015 if(s->inbuf_ptr - s->inbuf == s->frame_size){
1016 *poutbuf = s->inbuf;
1017 *poutbuf_size = s->frame_size;
1018 s->inbuf_ptr = s->inbuf;
1019 s->frame_size = 0;
1020 break;
1021 }
8424cf50
FB
1022 }
1023 }
1024 return buf_ptr - buf;
1025}
af9e7d18 1026#endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
8424cf50 1027
af9e7d18 1028#ifdef CONFIG_MPEGVIDEO_PARSER
8424cf50
FB
1029AVCodecParser mpegvideo_parser = {
1030 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
1031 sizeof(ParseContext1),
1032 NULL,
1033 mpegvideo_parse,
e4cb187d 1034 parse1_close,
90ad92b3 1035 mpegvideo_split,
8424cf50 1036};
af9e7d18
MR
1037#endif
1038#ifdef CONFIG_MPEG4VIDEO_PARSER
8424cf50
FB
1039AVCodecParser mpeg4video_parser = {
1040 { CODEC_ID_MPEG4 },
1041 sizeof(ParseContext1),
1042 mpeg4video_parse_init,
1043 mpeg4video_parse,
e4cb187d 1044 parse1_close,
90ad92b3 1045 mpeg4video_split,
8424cf50 1046};
af9e7d18
MR
1047#endif
1048#ifdef CONFIG_CAVSVIDEO_PARSER
b482e2d1
MN
1049AVCodecParser cavsvideo_parser = {
1050 { CODEC_ID_CAVS },
1051 sizeof(ParseContext1),
1052 NULL,
1053 cavsvideo_parse,
1054 parse1_close,
1055 mpeg4video_split,
1056};
29c5cdca 1057#endif
af9e7d18 1058#ifdef CONFIG_MPEGAUDIO_PARSER
8424cf50
FB
1059AVCodecParser mpegaudio_parser = {
1060 { CODEC_ID_MP2, CODEC_ID_MP3 },
1061 sizeof(MpegAudioParseContext),
1062 mpegaudio_parse_init,
1063 mpegaudio_parse,
1064 NULL,
1065};
af9e7d18
MR
1066#endif
1067#ifdef CONFIG_AC3_PARSER
8424cf50
FB
1068AVCodecParser ac3_parser = {
1069 { CODEC_ID_AC3 },
1070 sizeof(AC3ParseContext),
1071 ac3_parse_init,
1072 ac3_parse,
1073 NULL,
1074};
af9e7d18
MR
1075#endif
1076#ifdef CONFIG_AAC_PARSER
da46276f
MR
1077AVCodecParser aac_parser = {
1078 { CODEC_ID_AAC },
1079 sizeof(AC3ParseContext),
1080 aac_parse_init,
1081 ac3_parse,
1082 NULL,
1083};
af9e7d18 1084#endif