parser.c@ 9441

Last change on this file since 9441 was 5776, checked in by vboxsync, 17 years ago
ffmpeg: exported to OSE
File size: 33.5 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/ffmpeg-20060710/libavcodec/parser.c@ 9441

Download in other formats: