CAVS decoder by (Stefan Gehrer stefan.gehrer gmx.de)
[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
148 */
90ad92b3
MN
149int av_parser_change(AVCodecParserContext *s,
150 AVCodecContext *avctx,
115329f1 151 uint8_t **poutbuf, int *poutbuf_size,
90ad92b3 152 const uint8_t *buf, int buf_size, int keyframe){
115329f1 153
90ad92b3 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);
115329f1 172
90ad92b3 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
bb270c08
DB
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
8424cf50
FB
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;
115329f1 249
8424cf50
FB
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
275/* XXX: merge with libavcodec ? */
276#define MPEG1_FRAME_RATE_BASE 1001
277
278static const int frame_rate_tab[16] = {
115329f1 279 0,
8424cf50
FB
280 24000,
281 24024,
282 25025,
283 30000,
284 30030,
285 50050,
286 60000,
287 60060,
288 // Xing's 15fps: (9)
289 15015,
290 // libmpeg3's "Unofficial economy rates": (10-13)
291 5005,
292 10010,
293 12012,
294 15015,
295 // random, just to avoid segfault !never encode these
296 25025,
297 25025,
298};
299
c0df9d75 300//FIXME move into mpeg12.c
115329f1 301static void mpegvideo_extract_headers(AVCodecParserContext *s,
8424cf50
FB
302 AVCodecContext *avctx,
303 const uint8_t *buf, int buf_size)
304{
305 ParseContext1 *pc = s->priv_data;
306 const uint8_t *buf_end;
307 int32_t start_code;
308 int frame_rate_index, ext_type, bytes_left;
309 int frame_rate_ext_n, frame_rate_ext_d;
8dab64b6 310 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
8c787559 311 int horiz_size_ext, vert_size_ext, bit_rate_ext;
90ad92b3 312//FIXME replace the crap with get_bits()
8424cf50
FB
313 s->repeat_pict = 0;
314 buf_end = buf + buf_size;
315 while (buf < buf_end) {
82fcbc14
MN
316 start_code= -1;
317 buf= ff_find_start_code(buf, buf_end, &start_code);
8424cf50
FB
318 bytes_left = buf_end - buf;
319 switch(start_code) {
320 case PICTURE_START_CODE:
321 if (bytes_left >= 2) {
322 s->pict_type = (buf[1] >> 3) & 7;
323 }
324 break;
325 case SEQ_START_CODE:
8c787559 326 if (bytes_left >= 7) {
0b2346d3
MN
327 pc->width = (buf[0] << 4) | (buf[1] >> 4);
328 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
21adafec 329 avcodec_set_dimensions(avctx, pc->width, pc->height);
8424cf50 330 frame_rate_index = buf[3] & 0xf;
c0df9d75
MN
331 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
332 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
8c787559 333 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
3e9d718e
FB
334 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
335 avctx->sub_id = 1;
8424cf50
FB
336 }
337 break;
338 case EXT_START_CODE:
339 if (bytes_left >= 1) {
340 ext_type = (buf[0] >> 4);
341 switch(ext_type) {
342 case 0x1: /* sequence extension */
343 if (bytes_left >= 6) {
344 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
345 vert_size_ext = (buf[2] >> 5) & 3;
8c787559 346 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
8424cf50
FB
347 frame_rate_ext_n = (buf[5] >> 5) & 3;
348 frame_rate_ext_d = (buf[5] & 0x1f);
349 pc->progressive_sequence = buf[1] & (1 << 3);
8ca5d3bb 350 avctx->has_b_frames= !(buf[5] >> 7);
8424cf50 351
0b2346d3
MN
352 pc->width |=(horiz_size_ext << 12);
353 pc->height |=( vert_size_ext << 12);
8c787559 354 avctx->bit_rate += (bit_rate_ext << 18) * 400;
21adafec 355 avcodec_set_dimensions(avctx, pc->width, pc->height);
c0df9d75
MN
356 avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
357 avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
3e9d718e 358 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
8424cf50
FB
359 avctx->sub_id = 2; /* forces MPEG2 */
360 }
361 break;
362 case 0x8: /* picture coding extension */
363 if (bytes_left >= 5) {
5bb994e2 364 picture_structure = buf[2]&3;
8424cf50
FB
365 top_field_first = buf[3] & (1 << 7);
366 repeat_first_field = buf[3] & (1 << 1);
367 progressive_frame = buf[4] & (1 << 7);
115329f1 368
8424cf50
FB
369 /* check if we must repeat the frame */
370 if (repeat_first_field) {
371 if (pc->progressive_sequence) {
372 if (top_field_first)
373 s->repeat_pict = 4;
374 else
375 s->repeat_pict = 2;
376 } else if (progressive_frame) {
377 s->repeat_pict = 1;
378 }
379 }
115329f1
DB
380
381 /* the packet only represents half a frame
8dab64b6
MN
382 XXX,FIXME maybe find a different solution */
383 if(picture_structure != 3)
384 s->repeat_pict = -1;
8424cf50
FB
385 }
386 break;
387 }
388 }
389 break;
390 case -1:
391 goto the_end;
392 default:
393 /* we stop parsing when we encounter a slice. It ensures
394 that this function takes a negligible amount of time */
115329f1 395 if (start_code >= SLICE_MIN_START_CODE &&
8424cf50
FB
396 start_code <= SLICE_MAX_START_CODE)
397 goto the_end;
398 break;
399 }
400 }
401 the_end: ;
402}
403
404static int mpegvideo_parse(AVCodecParserContext *s,
405 AVCodecContext *avctx,
115329f1 406 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
407 const uint8_t *buf, int buf_size)
408{
e4cb187d
MN
409 ParseContext1 *pc1 = s->priv_data;
410 ParseContext *pc= &pc1->pc;
8424cf50 411 int next;
115329f1 412
7cbaa7ba
MN
413 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
414 next= buf_size;
415 }else{
416 next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
115329f1 417
7cbaa7ba
MN
418 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
419 *poutbuf = NULL;
420 *poutbuf_size = 0;
421 return buf_size;
422 }
115329f1 423
8424cf50
FB
424 }
425 /* we have a full frame : we just parse the first few MPEG headers
426 to have the full timing information. The time take by this
427 function should be negligible for uncorrupted streams */
428 mpegvideo_extract_headers(s, avctx, buf, buf_size);
429#if 0
115329f1 430 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
c0df9d75 431 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
8424cf50
FB
432#endif
433
434 *poutbuf = (uint8_t *)buf;
435 *poutbuf_size = buf_size;
436 return next;
437}
438
90ad92b3
MN
439static int mpegvideo_split(AVCodecContext *avctx,
440 const uint8_t *buf, int buf_size)
441{
442 int i;
443 uint32_t state= -1;
115329f1 444
90ad92b3
MN
445 for(i=0; i<buf_size; i++){
446 state= (state<<8) | buf[i];
447 if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
73480a15 448 return i-3;
90ad92b3
MN
449 }
450 return 0;
451}
452
e4cb187d 453void ff_parse_close(AVCodecParserContext *s)
8424cf50 454{
e4cb187d 455 ParseContext *pc = s->priv_data;
8424cf50
FB
456
457 av_free(pc->buffer);
8424cf50
FB
458}
459
e4cb187d 460static void parse1_close(AVCodecParserContext *s)
8424cf50 461{
e4cb187d 462 ParseContext1 *pc1 = s->priv_data;
8424cf50 463
e4cb187d
MN
464 av_free(pc1->pc.buffer);
465 av_free(pc1->enc);
8424cf50
FB
466}
467
e4cb187d
MN
468/*************************/
469
8424cf50
FB
470/* used by parser */
471/* XXX: make it use less memory */
115329f1 472static int av_mpeg4_decode_header(AVCodecParserContext *s1,
8424cf50
FB
473 AVCodecContext *avctx,
474 const uint8_t *buf, int buf_size)
475{
476 ParseContext1 *pc = s1->priv_data;
477 MpegEncContext *s = pc->enc;
478 GetBitContext gb1, *gb = &gb1;
479 int ret;
480
481 s->avctx = avctx;
c6f353ff
FB
482 s->current_picture_ptr = &s->current_picture;
483
484 if (avctx->extradata_size && pc->first_picture){
485 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
486 ret = ff_mpeg4_decode_picture_header(s, gb);
487 }
488
8424cf50
FB
489 init_get_bits(gb, buf, 8 * buf_size);
490 ret = ff_mpeg4_decode_picture_header(s, gb);
491 if (s->width) {
21adafec 492 avcodec_set_dimensions(avctx, s->width, s->height);
8424cf50 493 }
7cbaa7ba 494 s1->pict_type= s->pict_type;
c6f353ff 495 pc->first_picture = 0;
8424cf50
FB
496 return ret;
497}
498
e96682e6 499static int mpeg4video_parse_init(AVCodecParserContext *s)
8424cf50
FB
500{
501 ParseContext1 *pc = s->priv_data;
c6f353ff 502
8424cf50
FB
503 pc->enc = av_mallocz(sizeof(MpegEncContext));
504 if (!pc->enc)
505 return -1;
c6f353ff 506 pc->first_picture = 1;
8424cf50
FB
507 return 0;
508}
509
510static int mpeg4video_parse(AVCodecParserContext *s,
511 AVCodecContext *avctx,
115329f1 512 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
513 const uint8_t *buf, int buf_size)
514{
e4cb187d 515 ParseContext *pc = s->priv_data;
8424cf50 516 int next;
115329f1 517
7cbaa7ba
MN
518 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
519 next= buf_size;
520 }else{
521 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
115329f1 522
7cbaa7ba
MN
523 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
524 *poutbuf = NULL;
525 *poutbuf_size = 0;
526 return buf_size;
527 }
8424cf50
FB
528 }
529 av_mpeg4_decode_header(s, avctx, buf, buf_size);
530
531 *poutbuf = (uint8_t *)buf;
532 *poutbuf_size = buf_size;
533 return next;
534}
535
b482e2d1
MN
536static int cavsvideo_parse(AVCodecParserContext *s,
537 AVCodecContext *avctx,
538 uint8_t **poutbuf, int *poutbuf_size,
539 const uint8_t *buf, int buf_size)
540{
541 ParseContext *pc = s->priv_data;
542 int next;
543
544 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
545 next= buf_size;
546 }else{
547 next= ff_cavs_find_frame_end(pc, buf, buf_size);
548
549 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
550 *poutbuf = NULL;
551 *poutbuf_size = 0;
552 return buf_size;
553 }
554 }
555 *poutbuf = (uint8_t *)buf;
556 *poutbuf_size = buf_size;
557 return next;
558}
559
90ad92b3
MN
560static int mpeg4video_split(AVCodecContext *avctx,
561 const uint8_t *buf, int buf_size)
562{
563 int i;
564 uint32_t state= -1;
115329f1 565
90ad92b3
MN
566 for(i=0; i<buf_size; i++){
567 state= (state<<8) | buf[i];
568 if(state == 0x1B3 || state == 0x1B6)
73480a15 569 return i-3;
90ad92b3
MN
570 }
571 return 0;
572}
573
8424cf50
FB
574/*************************/
575
8424cf50 576typedef struct MpegAudioParseContext {
bb270c08 577 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
8424cf50
FB
578 uint8_t *inbuf_ptr;
579 int frame_size;
580 int free_format_frame_size;
581 int free_format_next_header;
4b9ac0b5
MN
582 uint32_t header;
583 int header_count;
8424cf50
FB
584} MpegAudioParseContext;
585
586#define MPA_HEADER_SIZE 4
587
588/* header + layer + bitrate + freq + lsf/mpeg25 */
88730be6 589#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
8424cf50 590#define SAME_HEADER_MASK \
e993bc03 591 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
8424cf50
FB
592
593static int mpegaudio_parse_init(AVCodecParserContext *s1)
594{
595 MpegAudioParseContext *s = s1->priv_data;
596 s->inbuf_ptr = s->inbuf;
597 return 0;
598}
599
600static int mpegaudio_parse(AVCodecParserContext *s1,
601 AVCodecContext *avctx,
115329f1 602 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
603 const uint8_t *buf, int buf_size)
604{
605 MpegAudioParseContext *s = s1->priv_data;
4b9ac0b5 606 int len, ret, sr;
8424cf50
FB
607 uint32_t header;
608 const uint8_t *buf_ptr;
609
610 *poutbuf = NULL;
611 *poutbuf_size = 0;
612 buf_ptr = buf;
613 while (buf_size > 0) {
bb270c08
DB
614 len = s->inbuf_ptr - s->inbuf;
615 if (s->frame_size == 0) {
8424cf50
FB
616 /* special case for next header for first frame in free
617 format case (XXX: find a simpler method) */
618 if (s->free_format_next_header != 0) {
619 s->inbuf[0] = s->free_format_next_header >> 24;
620 s->inbuf[1] = s->free_format_next_header >> 16;
621 s->inbuf[2] = s->free_format_next_header >> 8;
622 s->inbuf[3] = s->free_format_next_header;
623 s->inbuf_ptr = s->inbuf + 4;
624 s->free_format_next_header = 0;
625 goto got_header;
626 }
bb270c08 627 /* no header seen : find one. We need at least MPA_HEADER_SIZE
8424cf50 628 bytes to parse it */
bb270c08
DB
629 len = MPA_HEADER_SIZE - len;
630 if (len > buf_size)
631 len = buf_size;
632 if (len > 0) {
633 memcpy(s->inbuf_ptr, buf_ptr, len);
634 buf_ptr += len;
635 buf_size -= len;
636 s->inbuf_ptr += len;
637 }
638 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
8424cf50 639 got_header:
4b9ac0b5 640 sr= avctx->sample_rate;
bb270c08
DB
641 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
642 (s->inbuf[2] << 8) | s->inbuf[3];
8424cf50
FB
643
644 ret = mpa_decode_header(avctx, header);
645 if (ret < 0) {
4b9ac0b5 646 s->header_count= -2;
bb270c08
DB
647 /* no sync found : move by one byte (inefficient, but simple!) */
648 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
649 s->inbuf_ptr--;
8424cf50
FB
650 dprintf("skip %x\n", header);
651 /* reset free format frame size to give a chance
652 to get a new bitrate */
653 s->free_format_frame_size = 0;
bb270c08 654 } else {
4b9ac0b5
MN
655 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
656 s->header_count= -3;
657 s->header= header;
658 s->header_count++;
8424cf50 659 s->frame_size = ret;
115329f1 660
8424cf50
FB
661#if 0
662 /* free format: prepare to compute frame size */
bb270c08
DB
663 if (decode_header(s, header) == 1) {
664 s->frame_size = -1;
8424cf50
FB
665 }
666#endif
bb270c08 667 }
4b9ac0b5
MN
668 if(s->header_count <= 0)
669 avctx->sample_rate= sr; //FIXME ugly
bb270c08 670 }
115329f1 671 } else
8424cf50
FB
672#if 0
673 if (s->frame_size == -1) {
674 /* free format : find next sync to compute frame size */
bb270c08
DB
675 len = MPA_MAX_CODED_FRAME_SIZE - len;
676 if (len > buf_size)
677 len = buf_size;
8424cf50 678 if (len == 0) {
bb270c08 679 /* frame too long: resync */
8424cf50 680 s->frame_size = 0;
bb270c08
DB
681 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
682 s->inbuf_ptr--;
8424cf50
FB
683 } else {
684 uint8_t *p, *pend;
685 uint32_t header1;
686 int padding;
687
688 memcpy(s->inbuf_ptr, buf_ptr, len);
689 /* check for header */
690 p = s->inbuf_ptr - 3;
691 pend = s->inbuf_ptr + len - 4;
692 while (p <= pend) {
693 header = (p[0] << 24) | (p[1] << 16) |
694 (p[2] << 8) | p[3];
695 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
696 (s->inbuf[2] << 8) | s->inbuf[3];
697 /* check with high probability that we have a
698 valid header */
699 if ((header & SAME_HEADER_MASK) ==
700 (header1 & SAME_HEADER_MASK)) {
701 /* header found: update pointers */
702 len = (p + 4) - s->inbuf_ptr;
703 buf_ptr += len;
704 buf_size -= len;
705 s->inbuf_ptr = p;
706 /* compute frame size */
707 s->free_format_next_header = header;
708 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
709 padding = (header1 >> 9) & 1;
710 if (s->layer == 1)
711 s->free_format_frame_size -= padding * 4;
712 else
713 s->free_format_frame_size -= padding;
115329f1 714 dprintf("free frame size=%d padding=%d\n",
8424cf50
FB
715 s->free_format_frame_size, padding);
716 decode_header(s, header1);
717 goto next_data;
718 }
719 p++;
720 }
721 /* not found: simply increase pointers */
722 buf_ptr += len;
723 s->inbuf_ptr += len;
724 buf_size -= len;
725 }
bb270c08 726 } else
8424cf50
FB
727#endif
728 if (len < s->frame_size) {
729 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
730 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
bb270c08
DB
731 len = s->frame_size - len;
732 if (len > buf_size)
733 len = buf_size;
734 memcpy(s->inbuf_ptr, buf_ptr, len);
735 buf_ptr += len;
736 s->inbuf_ptr += len;
737 buf_size -= len;
738 }
8424cf50 739 // next_data:
115329f1 740 if (s->frame_size > 0 &&
8424cf50 741 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
4b9ac0b5
MN
742 if(s->header_count > 0){
743 *poutbuf = s->inbuf;
744 *poutbuf_size = s->inbuf_ptr - s->inbuf;
745 }
bb270c08
DB
746 s->inbuf_ptr = s->inbuf;
747 s->frame_size = 0;
748 break;
749 }
8424cf50
FB
750 }
751 return buf_ptr - buf;
752}
753
da46276f 754/* also used for ADTS AAC */
8424cf50 755typedef struct AC3ParseContext {
8424cf50
FB
756 uint8_t *inbuf_ptr;
757 int frame_size;
da46276f
MR
758 int header_size;
759 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
760 int *bit_rate, int *samples);
4f8ff17e 761 uint8_t inbuf[8192]; /* input buffer */
8424cf50
FB
762} AC3ParseContext;
763
764#define AC3_HEADER_SIZE 7
100a7422 765#define AAC_HEADER_SIZE 7
62327e28
MR
766
767static const int ac3_sample_rates[4] = {
768 48000, 44100, 32000, 0
769};
770
771static const int ac3_frame_sizes[64][3] = {
4f59b684
DB
772 { 64, 69, 96 },
773 { 64, 70, 96 },
774 { 80, 87, 120 },
775 { 80, 88, 120 },
776 { 96, 104, 144 },
777 { 96, 105, 144 },
778 { 112, 121, 168 },
779 { 112, 122, 168 },
780 { 128, 139, 192 },
781 { 128, 140, 192 },
782 { 160, 174, 240 },
783 { 160, 175, 240 },
784 { 192, 208, 288 },
785 { 192, 209, 288 },
786 { 224, 243, 336 },
787 { 224, 244, 336 },
788 { 256, 278, 384 },
789 { 256, 279, 384 },
790 { 320, 348, 480 },
791 { 320, 349, 480 },
792 { 384, 417, 576 },
793 { 384, 418, 576 },
794 { 448, 487, 672 },
795 { 448, 488, 672 },
796 { 512, 557, 768 },
797 { 512, 558, 768 },
798 { 640, 696, 960 },
799 { 640, 697, 960 },
800 { 768, 835, 1152 },
801 { 768, 836, 1152 },
802 { 896, 975, 1344 },
803 { 896, 976, 1344 },
62327e28
MR
804 { 1024, 1114, 1536 },
805 { 1024, 1115, 1536 },
806 { 1152, 1253, 1728 },
807 { 1152, 1254, 1728 },
808 { 1280, 1393, 1920 },
809 { 1280, 1394, 1920 },
810};
811
812static const int ac3_bitrates[64] = {
813 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
814 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
815 384, 448, 448, 512, 512, 576, 576, 640, 640,
816};
817
818static const int ac3_channels[8] = {
819 2, 1, 2, 3, 3, 4, 4, 5
820};
821
da46276f
MR
822static int aac_sample_rates[16] = {
823 96000, 88200, 64000, 48000, 44100, 32000,
824 24000, 22050, 16000, 12000, 11025, 8000, 7350
825};
826
827static int aac_channels[8] = {
828 0, 1, 2, 3, 4, 5, 6, 8
829};
830
62327e28 831static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
da46276f 832 int *bit_rate, int *samples)
62327e28
MR
833{
834 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
835 GetBitContext bits;
836
837 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
838
839 if(get_bits(&bits, 16) != 0x0b77)
4f59b684 840 return 0;
62327e28 841
100a7422 842 skip_bits(&bits, 16); /* crc */
62327e28
MR
843 fscod = get_bits(&bits, 2);
844 frmsizecod = get_bits(&bits, 6);
845
846 if(!ac3_sample_rates[fscod])
4f59b684 847 return 0;
62327e28
MR
848
849 bsid = get_bits(&bits, 5);
850 if(bsid > 8)
4f59b684 851 return 0;
100a7422 852 skip_bits(&bits, 3); /* bsmod */
62327e28
MR
853 acmod = get_bits(&bits, 3);
854 if(acmod & 1 && acmod != 1)
100a7422 855 skip_bits(&bits, 2); /* cmixlev */
62327e28 856 if(acmod & 4)
100a7422 857 skip_bits(&bits, 2); /* surmixlev */
62327e28 858 if(acmod & 2)
100a7422
MR
859 skip_bits(&bits, 2); /* dsurmod */
860 lfeon = get_bits1(&bits);
62327e28
MR
861
862 *sample_rate = ac3_sample_rates[fscod];
863 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
864 *channels = ac3_channels[acmod] + lfeon;
da46276f 865 *samples = 6 * 256;
62327e28
MR
866
867 return ac3_frame_sizes[frmsizecod][fscod] * 2;
868}
8424cf50 869
da46276f
MR
870static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
871 int *bit_rate, int *samples)
872{
873 GetBitContext bits;
874 int size, rdb, ch, sr;
875
876 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
877
878 if(get_bits(&bits, 12) != 0xfff)
879 return 0;
880
100a7422
MR
881 skip_bits1(&bits); /* id */
882 skip_bits(&bits, 2); /* layer */
883 skip_bits1(&bits); /* protection_absent */
884 skip_bits(&bits, 2); /* profile_objecttype */
885 sr = get_bits(&bits, 4); /* sample_frequency_index */
da46276f
MR
886 if(!aac_sample_rates[sr])
887 return 0;
100a7422
MR
888 skip_bits1(&bits); /* private_bit */
889 ch = get_bits(&bits, 3); /* channel_configuration */
da46276f
MR
890 if(!aac_channels[ch])
891 return 0;
100a7422
MR
892 skip_bits1(&bits); /* original/copy */
893 skip_bits1(&bits); /* home */
da46276f
MR
894
895 /* adts_variable_header */
100a7422
MR
896 skip_bits1(&bits); /* copyright_identification_bit */
897 skip_bits1(&bits); /* copyright_identification_start */
898 size = get_bits(&bits, 13); /* aac_frame_length */
899 skip_bits(&bits, 11); /* adts_buffer_fullness */
900 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
da46276f
MR
901
902 *channels = aac_channels[ch];
903 *sample_rate = aac_sample_rates[sr];
904 *samples = (rdb + 1) * 1024;
905 *bit_rate = size * 8 * *sample_rate / *samples;
906
907 return size;
908}
909
8424cf50
FB
910static int ac3_parse_init(AVCodecParserContext *s1)
911{
912 AC3ParseContext *s = s1->priv_data;
913 s->inbuf_ptr = s->inbuf;
da46276f
MR
914 s->header_size = AC3_HEADER_SIZE;
915 s->sync = ac3_sync;
8424cf50
FB
916 return 0;
917}
918
da46276f
MR
919static int aac_parse_init(AVCodecParserContext *s1)
920{
921 AC3ParseContext *s = s1->priv_data;
922 s->inbuf_ptr = s->inbuf;
923 s->header_size = AAC_HEADER_SIZE;
924 s->sync = aac_sync;
925 return 0;
926}
927
928/* also used for ADTS AAC */
8424cf50
FB
929static int ac3_parse(AVCodecParserContext *s1,
930 AVCodecContext *avctx,
115329f1 931 uint8_t **poutbuf, int *poutbuf_size,
8424cf50
FB
932 const uint8_t *buf, int buf_size)
933{
934 AC3ParseContext *s = s1->priv_data;
935 const uint8_t *buf_ptr;
da46276f 936 int len, sample_rate, bit_rate, channels, samples;
8424cf50
FB
937
938 *poutbuf = NULL;
939 *poutbuf_size = 0;
940
941 buf_ptr = buf;
942 while (buf_size > 0) {
943 len = s->inbuf_ptr - s->inbuf;
944 if (s->frame_size == 0) {
da46276f
MR
945 /* no header seen : find one. We need at least s->header_size
946 bytes to parse it */
947 len = FFMIN(s->header_size - len, buf_size);
d8a91afd 948
8424cf50
FB
949 memcpy(s->inbuf_ptr, buf_ptr, len);
950 buf_ptr += len;
951 s->inbuf_ptr += len;
952 buf_size -= len;
da46276f
MR
953 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
954 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
955 &samples);
8424cf50
FB
956 if (len == 0) {
957 /* no sync found : move by one byte (inefficient, but simple!) */
da46276f 958 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
8424cf50
FB
959 s->inbuf_ptr--;
960 } else {
bb270c08 961 s->frame_size = len;
8424cf50
FB
962 /* update codec info */
963 avctx->sample_rate = sample_rate;
20da3179 964 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
da46276f
MR
965 if(avctx->codec_id == CODEC_ID_AC3){
966 if(avctx->channels!=1 && avctx->channels!=2){
967 avctx->channels = channels;
968 }
969 } else {
4f59b684 970 avctx->channels = channels;
20da3179 971 }
bb270c08 972 avctx->bit_rate = bit_rate;
da46276f 973 avctx->frame_size = samples;
8424cf50
FB
974 }
975 }
d8a91afd
MN
976 } else {
977 len = FFMIN(s->frame_size - len, buf_size);
8424cf50
FB
978
979 memcpy(s->inbuf_ptr, buf_ptr, len);
980 buf_ptr += len;
981 s->inbuf_ptr += len;
982 buf_size -= len;
d8a91afd
MN
983
984 if(s->inbuf_ptr - s->inbuf == s->frame_size){
985 *poutbuf = s->inbuf;
986 *poutbuf_size = s->frame_size;
987 s->inbuf_ptr = s->inbuf;
988 s->frame_size = 0;
989 break;
990 }
8424cf50
FB
991 }
992 }
993 return buf_ptr - buf;
994}
8424cf50
FB
995
996AVCodecParser mpegvideo_parser = {
997 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
998 sizeof(ParseContext1),
999 NULL,
1000 mpegvideo_parse,
e4cb187d 1001 parse1_close,
90ad92b3 1002 mpegvideo_split,
8424cf50
FB
1003};
1004
1005AVCodecParser mpeg4video_parser = {
1006 { CODEC_ID_MPEG4 },
1007 sizeof(ParseContext1),
1008 mpeg4video_parse_init,
1009 mpeg4video_parse,
e4cb187d 1010 parse1_close,
90ad92b3 1011 mpeg4video_split,
8424cf50
FB
1012};
1013
b482e2d1
MN
1014AVCodecParser cavsvideo_parser = {
1015 { CODEC_ID_CAVS },
1016 sizeof(ParseContext1),
1017 NULL,
1018 cavsvideo_parse,
1019 parse1_close,
1020 mpeg4video_split,
1021};
1022
8424cf50
FB
1023AVCodecParser mpegaudio_parser = {
1024 { CODEC_ID_MP2, CODEC_ID_MP3 },
1025 sizeof(MpegAudioParseContext),
1026 mpegaudio_parse_init,
1027 mpegaudio_parse,
1028 NULL,
1029};
1030
8424cf50
FB
1031AVCodecParser ac3_parser = {
1032 { CODEC_ID_AC3 },
1033 sizeof(AC3ParseContext),
1034 ac3_parse_init,
1035 ac3_parse,
1036 NULL,
1037};
da46276f
MR
1038
1039AVCodecParser aac_parser = {
1040 { CODEC_ID_AAC },
1041 sizeof(AC3ParseContext),
1042 aac_parse_init,
1043 ac3_parse,
1044 NULL,
1045};