WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavformat/mpeg.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* MPEG1/2 demuxer
		3	* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
		4	*
		5	* This file is part of FFmpeg.
		6	*
		7	* FFmpeg is free software; you can redistribute it and/or
		8	* modify it under the terms of the GNU Lesser General Public
		9	* License as published by the Free Software Foundation; either
		10	* version 2.1 of the License, or (at your option) any later version.
		11	*
		12	* FFmpeg is distributed in the hope that it will be useful,
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15	* Lesser General Public License for more details.
		16	*
		17	* You should have received a copy of the GNU Lesser General Public
		18	* License along with FFmpeg; if not, write to the Free Software
		19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		20	*/
		21
		22	#include "avformat.h"
		23	#include "internal.h"
		24	#include "mpeg.h"
		25
		26	#if CONFIG_VOBSUB_DEMUXER
		27	# include "subtitles.h"
		28	# include "libavutil/bprint.h"
		29	#endif
		30
		31	#undef NDEBUG
		32	#include
		33	#include "libavutil/avassert.h"
		34
		35	/*********************************************/
		36	/* demux code */
		37
		38	#define MAX_SYNC_SIZE 100000
		39
		40	static int check_pes(const uint8_t p, const uint8_t end){
		41	int pes1;
		42	int pes2= (p[3] & 0xC0) == 0x80
		43	&& (p[4] & 0xC0) != 0x40
		44	&&((p[4] & 0xC0) == 0x00 \|\| (p[4]&0xC0)>>2 == (p[6]&0xF0));
		45
		46	for(p+=3; p
		47	if((*p&0xC0) == 0x40) p+=2;
		48	if((*p&0xF0) == 0x20){
		49	pes1= p[0]&p[2]&p[4]&1;
		50	}else if((*p&0xF0) == 0x30){
		51	pes1= p[0]&p[2]&p[4]&p[5]&p[7]&p[9]&1;
		52	}else
		53	pes1 = *p == 0x0F;
		54
		55	return pes1\|\|pes2;
		56	}
		57
		58	static int check_pack_header(const uint8_t *buf) {
		59	return (buf[1] & 0xC0) == 0x40 \|\| (buf[1] & 0xF0) == 0x20;
		60	}
		61
		62	static int mpegps_probe(AVProbeData *p)
		63	{
		64	uint32_t code= -1;
		65	int sys=0, pspack=0, priv1=0, vid=0, audio=0, invalid=0;
		66	int i;
		67	int score=0;
		68
		69	for(i=0; ibuf_size; i++){
		70	code = (code<<8) + p->buf[i];
		71	if ((code & 0xffffff00) == 0x100) {
		72	int len= p->buf[i+1] << 8 \| p->buf[i+2];
		73	int pes= check_pes(p->buf+i, p->buf+p->buf_size);
		74	int pack = check_pack_header(p->buf+i);
		75
		76	if(code == SYSTEM_HEADER_START_CODE) sys++;
		77	else if(code == PACK_START_CODE && pack) pspack++;
		78	else if((code & 0xf0) == VIDEO_ID && pes) vid++;
		79	// skip pes payload to avoid start code emulation for private
		80	// and audio streams
		81	else if((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}
		82	else if(code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;}
		83	else if(code == 0x1fd && pes) vid++; //VC1
		84
		85	else if((code & 0xf0) == VIDEO_ID && !pes) invalid++;
		86	else if((code & 0xe0) == AUDIO_ID && !pes) invalid++;
		87	else if(code == PRIVATE_STREAM_1 && !pes) invalid++;
		88	}
		89	}
		90
		91	if(vid+audio > invalid+1) /* invalid VDR files nd short PES streams */
		92	score = AVPROBE_SCORE_EXTENSION / 2;
		93
		94	if(sys>invalid && sys9 <= pspack10)
		95	return (audio > 12 \|\| vid > 3 \|\| pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2 : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
		96	if(pspack > invalid && (priv1+vid+audio)10 >= pspack9)
		97	return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2 : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
		98	if((!!vid ^ !!audio) && (audio > 4 \|\| vid > 1) && !sys && !pspack && p->buf_size>2048 && vid + audio > invalid) /* PES stream */
		99	return (audio > 12 \|\| vid > 3 + 2*invalid) ? AVPROBE_SCORE_EXTENSION + 2 : AVPROBE_SCORE_EXTENSION / 2;
		100
		101	//02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
		102	//mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
		103	//Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618
		104	return score;
		105	}
		106
		107
		108	typedef struct MpegDemuxContext {
		109	int32_t header_state;
		110	unsigned char psm_es_type[256];
		111	int sofdec;
		112	int dvd;
		113	int imkh_cctv;
		114	#if CONFIG_VOBSUB_DEMUXER
		115	AVFormatContext *sub_ctx;
		116	FFDemuxSubtitlesQueue q[32];
		117	#endif
		118	} MpegDemuxContext;
		119
		120	static int mpegps_read_header(AVFormatContext *s)
		121	{
		122	MpegDemuxContext *m = s->priv_data;
		123	char buffer[7];
		124	int64_t last_pos = avio_tell(s->pb);
		125
		126	m->header_state = 0xff;
		127	s->ctx_flags \|= AVFMTCTX_NOHEADER;
		128
		129	avio_get_str(s->pb, 6, buffer, sizeof(buffer));
		130	if (!memcmp("IMKH", buffer, 4)) {
		131	m->imkh_cctv = 1;
		132	} else if (!memcmp("Sofdec", buffer, 6)) {
		133	m->sofdec = 1;
		134	} else
		135	avio_seek(s->pb, last_pos, SEEK_SET);
		136
		137	/* no need to do more */
		138	return 0;
		139	}
		140
		141	static int64_t get_pts(AVIOContext *pb, int c)
		142	{
		143	uint8_t buf[5];
		144
		145	buf[0] = c<0 ? avio_r8(pb) : c;
		146	avio_read(pb, buf+1, 4);
		147
		148	return ff_parse_pes_pts(buf);
		149	}
		150
		151	static int find_next_start_code(AVIOContext pb, int size_ptr,
		152	int32_t *header_state)
		153	{
		154	unsigned int state, v;
		155	int val, n;
		156
		157	state = *header_state;
		158	n = *size_ptr;
		159	while (n > 0) {
		160	if (url_feof(pb))
		161	break;
		162	v = avio_r8(pb);
		163	n--;
		164	if (state == 0x000001) {
		165	state = ((state << 8) \| v) & 0xffffff;
		166	val = state;
		167	goto found;
		168	}
		169	state = ((state << 8) \| v) & 0xffffff;
		170	}
		171	val = -1;
		172	found:
		173	*header_state = state;
		174	*size_ptr = n;
		175	return val;
		176	}
		177
		178	/**
		179	* Extract stream types from a program stream map
		180	* According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
		181	*
		182	* @return number of bytes occupied by PSM in the bitstream
		183	*/
		184	static long mpegps_psm_parse(MpegDemuxContext m, AVIOContext pb)
		185	{
		186	int psm_length, ps_info_length, es_map_length;
		187
		188	psm_length = avio_rb16(pb);
		189	avio_r8(pb);
		190	avio_r8(pb);
		191	ps_info_length = avio_rb16(pb);
		192
		193	/* skip program_stream_info */
		194	avio_skip(pb, ps_info_length);
		195	es_map_length = avio_rb16(pb);
		196
		197	/* at least one es available? */
		198	while (es_map_length >= 4){
		199	unsigned char type = avio_r8(pb);
		200	unsigned char es_id = avio_r8(pb);
		201	uint16_t es_info_length = avio_rb16(pb);
		202	/* remember mapping from stream id to stream type */
		203	m->psm_es_type[es_id] = type;
		204	/* skip program_stream_info */
		205	avio_skip(pb, es_info_length);
		206	es_map_length -= 4 + es_info_length;
		207	}
		208	avio_rb32(pb); /* crc32 */
		209	return 2 + psm_length;
		210	}
		211
		212	/* read the next PES header. Return its position in ppos
		213	(if not NULL), and its start code, pts and dts.
		214	*/
		215	static int mpegps_read_pes_header(AVFormatContext *s,
		216	int64_t ppos, int pstart_code,
		217	int64_t ppts, int64_t pdts)
		218	{
		219	MpegDemuxContext *m = s->priv_data;
		220	int len, size, startcode, c, flags, header_len;
		221	int pes_ext, ext2_len, id_ext, skip;
		222	int64_t pts, dts;
		223	int64_t last_sync= avio_tell(s->pb);
		224
		225	error_redo:
		226	avio_seek(s->pb, last_sync, SEEK_SET);
		227	redo:
		228	/* next start code (should be immediately after) */
		229	m->header_state = 0xff;
		230	size = MAX_SYNC_SIZE;
		231	startcode = find_next_start_code(s->pb, &size, &m->header_state);
		232	last_sync = avio_tell(s->pb);
		233	if (startcode < 0){
		234	if(url_feof(s->pb))
		235	return AVERROR_EOF;
		236	//FIXME we should remember header_state
		237	return AVERROR(EAGAIN);
		238	}
		239
		240	if (startcode == PACK_START_CODE)
		241	goto redo;
		242	if (startcode == SYSTEM_HEADER_START_CODE)
		243	goto redo;
		244	if (startcode == PADDING_STREAM) {
		245	avio_skip(s->pb, avio_rb16(s->pb));
		246	goto redo;
		247	}
		248	if (startcode == PRIVATE_STREAM_2) {
		249	if (!m->sofdec) {
		250	/* Need to detect whether this from a DVD or a 'Sofdec' stream */
		251	int len = avio_rb16(s->pb);
		252	int bytesread = 0;
		253	uint8_t *ps2buf = av_malloc(len);
		254
		255	if (ps2buf) {
		256	bytesread = avio_read(s->pb, ps2buf, len);
		257
		258	if (bytesread != len) {
		259	avio_skip(s->pb, len - bytesread);
		260	} else {
		261	uint8_t *p = 0;
		262	if (len >= 6)
		263	p = memchr(ps2buf, 'S', len - 5);
		264
		265	if (p)
		266	m->sofdec = !memcmp(p+1, "ofdec", 5);
		267
		268	m->sofdec -= !m->sofdec;
		269
		270	if (m->sofdec < 0) {
		271	if (len == 980 && ps2buf[0] == 0) {
		272	/* PCI structure? */
		273	uint32_t startpts = AV_RB32(ps2buf + 0x0d);
		274	uint32_t endpts = AV_RB32(ps2buf + 0x11);
		275	uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
		276	uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
		277	uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
		278
		279	m->dvd = (hours <= 23 &&
		280	mins <= 59 &&
		281	secs <= 59 &&
		282	(ps2buf[0x19] & 0x0f) < 10 &&
		283	(ps2buf[0x1a] & 0x0f) < 10 &&
		284	(ps2buf[0x1b] & 0x0f) < 10 &&
		285	endpts >= startpts);
		286	} else if (len == 1018 && ps2buf[0] == 1) {
		287	/* DSI structure? */
		288	uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
		289	uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
		290	uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
		291
		292	m->dvd = (hours <= 23 &&
		293	mins <= 59 &&
		294	secs <= 59 &&
		295	(ps2buf[0x1d] & 0x0f) < 10 &&
		296	(ps2buf[0x1e] & 0x0f) < 10 &&
		297	(ps2buf[0x1f] & 0x0f) < 10);
		298	}
		299	}
		300	}
		301
		302	av_free(ps2buf);
		303
		304	/* If this isn't a DVD packet or no memory
		305	* could be allocated, just ignore it.
		306	* If we did, move back to the start of the
		307	* packet (plus 'length' field) */
		308	if (!m->dvd \|\| avio_skip(s->pb, -(len + 2)) < 0) {
		309	/* Skip back failed.
		310	* This packet will be lost but that can't be helped
		311	* if we can't skip back
		312	*/
		313	goto redo;
		314	}
		315	} else {
		316	/* No memory */
		317	avio_skip(s->pb, len);
		318	goto redo;
		319	}
		320	} else if (!m->dvd) {
		321	int len = avio_rb16(s->pb);
		322	avio_skip(s->pb, len);
		323	goto redo;
		324	}
		325	}
		326	if (startcode == PROGRAM_STREAM_MAP) {
		327	mpegps_psm_parse(m, s->pb);
		328	goto redo;
		329	}
		330
		331	/* find matching stream */
		332	if (!((startcode >= 0x1c0 && startcode <= 0x1df) \|\|
		333	(startcode >= 0x1e0 && startcode <= 0x1ef) \|\|
		334	(startcode == 0x1bd) \|\|
		335	(startcode == PRIVATE_STREAM_2) \|\|
		336	(startcode == 0x1fd)))
		337	goto redo;
		338	if (ppos) {
		339	*ppos = avio_tell(s->pb) - 4;
		340	}
		341	len = avio_rb16(s->pb);
		342	pts =
		343	dts = AV_NOPTS_VALUE;
		344	if (startcode != PRIVATE_STREAM_2)
		345	{
		346	/* stuffing */
		347	for(;;) {
		348	if (len < 1)
		349	goto error_redo;
		350	c = avio_r8(s->pb);
		351	len--;
		352	/* XXX: for mpeg1, should test only bit 7 */
		353	if (c != 0xff)
		354	break;
		355	}
		356	if ((c & 0xc0) == 0x40) {
		357	/* buffer scale & size */
		358	avio_r8(s->pb);
		359	c = avio_r8(s->pb);
		360	len -= 2;
		361	}
		362	if ((c & 0xe0) == 0x20) {
		363	dts = pts = get_pts(s->pb, c);
		364	len -= 4;
		365	if (c & 0x10){
		366	dts = get_pts(s->pb, -1);
		367	len -= 5;
		368	}
		369	} else if ((c & 0xc0) == 0x80) {
		370	/* mpeg 2 PES */
		371	flags = avio_r8(s->pb);
		372	header_len = avio_r8(s->pb);
		373	len -= 2;
		374	if (header_len > len)
		375	goto error_redo;
		376	len -= header_len;
		377	if (flags & 0x80) {
		378	dts = pts = get_pts(s->pb, -1);
		379	header_len -= 5;
		380	if (flags & 0x40) {
		381	dts = get_pts(s->pb, -1);
		382	header_len -= 5;
		383	}
		384	}
		385	if (flags & 0x3f && header_len == 0){
		386	flags &= 0xC0;
		387	av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
		388	}
		389	if (flags & 0x01) { /* PES extension */
		390	pes_ext = avio_r8(s->pb);
		391	header_len--;
		392	/* Skip PES private data, program packet sequence counter and P-STD buffer */
		393	skip = (pes_ext >> 4) & 0xb;
		394	skip += skip & 0x9;
		395	if (pes_ext & 0x40 \|\| skip > header_len){
		396	av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
		397	pes_ext=skip=0;
		398	}
		399	avio_skip(s->pb, skip);
		400	header_len -= skip;
		401
		402	if (pes_ext & 0x01) { /* PES extension 2 */
		403	ext2_len = avio_r8(s->pb);
		404	header_len--;
		405	if ((ext2_len & 0x7f) > 0) {
		406	id_ext = avio_r8(s->pb);
		407	if ((id_ext & 0x80) == 0)
		408	startcode = ((startcode & 0xff) << 8) \| id_ext;
		409	header_len--;
		410	}
		411	}
		412	}
		413	if(header_len < 0)
		414	goto error_redo;
		415	avio_skip(s->pb, header_len);
		416	}
		417	else if( c!= 0xf )
		418	goto redo;
		419	}
		420
		421	if (startcode == PRIVATE_STREAM_1) {
		422	startcode = avio_r8(s->pb);
		423	len--;
		424	}
		425	if(len<0)
		426	goto error_redo;
		427	if(dts != AV_NOPTS_VALUE && ppos){
		428	int i;
		429	for(i=0; inb_streams; i++){
		430	if(startcode == s->streams[i]->id &&
		431	s->pb->seekable /* index useless on streams anyway */) {
		432	ff_reduce_index(s, i);
		433	av_add_index_entry(s->streams[i], ppos, dts, 0, 0, AVINDEX_KEYFRAME / FIXME keyframe? */);
		434	}
		435	}
		436	}
		437
		438	*pstart_code = startcode;
		439	*ppts = pts;
		440	*pdts = dts;
		441	return len;
		442	}
		443
		444	static int mpegps_read_packet(AVFormatContext *s,
		445	AVPacket *pkt)
		446	{
		447	MpegDemuxContext *m = s->priv_data;
		448	AVStream *st;
		449	int len, startcode, i, es_type, ret;
		450	int lpcm_header_len = -1; //Init to supress warning
		451	int request_probe= 0;
		452	enum AVCodecID codec_id = AV_CODEC_ID_NONE;
		453	enum AVMediaType type;
		454	int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
		455
		456	redo:
		457	len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
		458	if (len < 0)
		459	return len;
		460
		461	if (startcode >= 0x80 && startcode <= 0xcf) {
		462	if(len < 4)
		463	goto skip;
		464
		465	/* audio: skip header */
		466	avio_r8(s->pb);
		467	lpcm_header_len = avio_rb16(s->pb);
		468	len -= 3;
		469	if (startcode >= 0xb0 && startcode <= 0xbf) {
		470	/* MLP/TrueHD audio has a 4-byte header */
		471	avio_r8(s->pb);
		472	len--;
		473	}
		474	}
		475
		476	/* now find stream */
		477	for(i=0;inb_streams;i++) {
		478	st = s->streams[i];
		479	if (st->id == startcode)
		480	goto found;
		481	}
		482
		483	es_type = m->psm_es_type[startcode & 0xff];
		484	if(es_type == STREAM_TYPE_VIDEO_MPEG1){
		485	codec_id = AV_CODEC_ID_MPEG2VIDEO;
		486	type = AVMEDIA_TYPE_VIDEO;
		487	} else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
		488	codec_id = AV_CODEC_ID_MPEG2VIDEO;
		489	type = AVMEDIA_TYPE_VIDEO;
		490	} else if(es_type == STREAM_TYPE_AUDIO_MPEG1 \|\|
		491	es_type == STREAM_TYPE_AUDIO_MPEG2){
		492	codec_id = AV_CODEC_ID_MP3;
		493	type = AVMEDIA_TYPE_AUDIO;
		494	} else if(es_type == STREAM_TYPE_AUDIO_AAC){
		495	codec_id = AV_CODEC_ID_AAC;
		496	type = AVMEDIA_TYPE_AUDIO;
		497	} else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
		498	codec_id = AV_CODEC_ID_MPEG4;
		499	type = AVMEDIA_TYPE_VIDEO;
		500	} else if(es_type == STREAM_TYPE_VIDEO_H264){
		501	codec_id = AV_CODEC_ID_H264;
		502	type = AVMEDIA_TYPE_VIDEO;
		503	} else if(es_type == STREAM_TYPE_AUDIO_AC3){
		504	codec_id = AV_CODEC_ID_AC3;
		505	type = AVMEDIA_TYPE_AUDIO;
		506	} else if(m->imkh_cctv && es_type == 0x91){
		507	codec_id = AV_CODEC_ID_PCM_MULAW;
		508	type = AVMEDIA_TYPE_AUDIO;
		509	} else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
		510	static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
		511	unsigned char buf[8];
		512	avio_read(s->pb, buf, 8);
		513	avio_seek(s->pb, -8, SEEK_CUR);
		514	if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 \|\| buf[7] != 1))
		515	codec_id = AV_CODEC_ID_CAVS;
		516	else
		517	request_probe= 1;
		518	type = AVMEDIA_TYPE_VIDEO;
		519	} else if (startcode == PRIVATE_STREAM_2) {
		520	type = AVMEDIA_TYPE_DATA;
		521	codec_id = AV_CODEC_ID_DVD_NAV;
		522	} else if (startcode >= 0x1c0 && startcode <= 0x1df) {
		523	type = AVMEDIA_TYPE_AUDIO;
		524	codec_id = m->sofdec > 0 ? AV_CODEC_ID_ADPCM_ADX : AV_CODEC_ID_MP2;
		525	} else if (startcode >= 0x80 && startcode <= 0x87) {
		526	type = AVMEDIA_TYPE_AUDIO;
		527	codec_id = AV_CODEC_ID_AC3;
		528	} else if ( ( startcode >= 0x88 && startcode <= 0x8f)
		529	\|\|( startcode >= 0x98 && startcode <= 0x9f)) {
		530	/* 0x90 - 0x97 is reserved for SDDS in DVD specs */
		531	type = AVMEDIA_TYPE_AUDIO;
		532	codec_id = AV_CODEC_ID_DTS;
		533	} else if (startcode >= 0xa0 && startcode <= 0xaf) {
		534	type = AVMEDIA_TYPE_AUDIO;
		535	if(lpcm_header_len == 6) {
		536	codec_id = AV_CODEC_ID_MLP;
		537	} else {
		538	codec_id = AV_CODEC_ID_PCM_DVD;
		539	}
		540	} else if (startcode >= 0xb0 && startcode <= 0xbf) {
		541	type = AVMEDIA_TYPE_AUDIO;
		542	codec_id = AV_CODEC_ID_TRUEHD;
		543	} else if (startcode >= 0xc0 && startcode <= 0xcf) {
		544	/* Used for both AC-3 and E-AC-3 in EVOB files */
		545	type = AVMEDIA_TYPE_AUDIO;
		546	codec_id = AV_CODEC_ID_AC3;
		547	} else if (startcode >= 0x20 && startcode <= 0x3f) {
		548	type = AVMEDIA_TYPE_SUBTITLE;
		549	codec_id = AV_CODEC_ID_DVD_SUBTITLE;
		550	} else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
		551	type = AVMEDIA_TYPE_VIDEO;
		552	codec_id = AV_CODEC_ID_VC1;
		553	} else {
		554	skip:
		555	/* skip packet */
		556	avio_skip(s->pb, len);
		557	goto redo;
		558	}
		559	/* no stream found: add a new stream */
		560	st = avformat_new_stream(s, NULL);
		561	if (!st)
		562	goto skip;
		563	st->id = startcode;
		564	st->codec->codec_type = type;
		565	st->codec->codec_id = codec_id;
		566	if (st->codec->codec_id == AV_CODEC_ID_PCM_MULAW) {
		567	st->codec->channels = 1;
		568	st->codec->channel_layout = AV_CH_LAYOUT_MONO;
		569	st->codec->sample_rate = 8000;
		570	}
		571	st->request_probe = request_probe;
		572	st->need_parsing = AVSTREAM_PARSE_FULL;
		573	found:
		574	if(st->discard >= AVDISCARD_ALL)
		575	goto skip;
		576	if (startcode >= 0xa0 && startcode <= 0xaf) {
		577	if (lpcm_header_len == 6 && st->codec->codec_id == AV_CODEC_ID_MLP) {
		578	if (len < 6)
		579	goto skip;
		580	avio_skip(s->pb, 6);
		581	len -=6;
		582	}
		583	}
		584	ret = av_get_packet(s->pb, pkt, len);
		585	pkt->pts = pts;
		586	pkt->dts = dts;
		587	pkt->pos = dummy_pos;
		588	pkt->stream_index = st->index;
		589	av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n",
		590	pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
		591	pkt->size);
		592
		593	return (ret < 0) ? ret : 0;
		594	}
		595
		596	static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
		597	int64_t *ppos, int64_t pos_limit)
		598	{
		599	int len, startcode;
		600	int64_t pos, pts, dts;
		601
		602	pos = *ppos;
		603	if (avio_seek(s->pb, pos, SEEK_SET) < 0)
		604	return AV_NOPTS_VALUE;
		605
		606	for(;;) {
		607	len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
		608	if (len < 0) {
		609	av_dlog(s, "none (ret=%d)\n", len);
		610	return AV_NOPTS_VALUE;
		611	}
		612	if (startcode == s->streams[stream_index]->id &&
		613	dts != AV_NOPTS_VALUE) {
		614	break;
		615	}
		616	avio_skip(s->pb, len);
		617	}
		618	av_dlog(s, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
		619	pos, dts, dts / 90000.0);
		620	*ppos = pos;
		621	return dts;
		622	}
		623
		624	AVInputFormat ff_mpegps_demuxer = {
		625	.name = "mpeg",
		626	.long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
		627	.priv_data_size = sizeof(MpegDemuxContext),
		628	.read_probe = mpegps_probe,
		629	.read_header = mpegps_read_header,
		630	.read_packet = mpegps_read_packet,
		631	.read_timestamp = mpegps_read_dts,
		632	.flags = AVFMT_SHOW_IDS \| AVFMT_TS_DISCONT,
		633	};
		634
		635	#if CONFIG_VOBSUB_DEMUXER
		636
		637	#define REF_STRING "# VobSub index file,"
		638
		639	static int vobsub_probe(AVProbeData *p)
		640	{
		641	if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
		642	return AVPROBE_SCORE_MAX;
		643	return 0;
		644	}
		645
		646	static int vobsub_read_header(AVFormatContext *s)
		647	{
		648	int i, ret = 0, header_parsed = 0, langidx = 0;
		649	MpegDemuxContext *vobsub = s->priv_data;
		650	char *sub_name = NULL;
		651	size_t fname_len;
		652	char ext, header_str;
		653	AVBPrint header;
		654	int64_t delay = 0;
		655	AVStream *st = NULL;
		656
		657	sub_name = av_strdup(s->filename);
		658	fname_len = strlen(sub_name);
		659	ext = sub_name - 3 + fname_len;
		660	if (fname_len < 4 \|\| *(ext - 1) != '.') {
		661	av_log(s, AV_LOG_ERROR, "The input index filename is too short "
		662	"to guess the associated .SUB file\n");
		663	ret = AVERROR_INVALIDDATA;
		664	goto end;
		665	}
		666	memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
		667	av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->filename, sub_name);
		668	ret = avformat_open_input(&vobsub->sub_ctx, sub_name, &ff_mpegps_demuxer, NULL);
		669	if (ret < 0) {
		670	av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", sub_name);
		671	goto end;
		672	}
		673
		674	av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);
		675	while (!url_feof(s->pb)) {
		676	char line[2048];
		677	int len = ff_get_line(s->pb, line, sizeof(line));
		678
		679	if (!len)
		680	break;
		681
		682	line[strcspn(line, "\r\n")] = 0;
		683
		684	if (!strncmp(line, "id:", 3)) {
		685	int n, stream_id = 0;
		686	char id[64] = {0};
		687
		688	n = sscanf(line, "id: %63[^,], index: %u", id, &stream_id);
		689	if (n != 2) {
		690	av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
		691	"assuming 'id: und, index: 0'\n", line);
		692	strcpy(id, "und");
		693	stream_id = 0;
		694	}
		695
		696	if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
		697	av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
		698	ret = AVERROR(EINVAL);
		699	goto end;
		700	}
		701
		702	st = avformat_new_stream(s, NULL);
		703	if (!st) {
		704	ret = AVERROR(ENOMEM);
		705	goto end;
		706	}
		707	st->id = stream_id;
		708	st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
		709	st->codec->codec_id = AV_CODEC_ID_DVD_SUBTITLE;
		710	avpriv_set_pts_info(st, 64, 1, 1000);
		711	av_dict_set(&st->metadata, "language", id, 0);
		712	av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
		713	header_parsed = 1;
		714
		715	} else if (st && !strncmp(line, "timestamp:", 10)) {
		716	AVPacket *sub;
		717	int hh, mm, ss, ms;
		718	int64_t pos, timestamp;
		719	const char *p = line + 10;
		720
		721	if (!s->nb_streams) {
		722	av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
		723	ret = AVERROR_INVALIDDATA;
		724	goto end;
		725	}
		726
		727	if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
		728	&hh, &mm, &ss, &ms, &pos) != 5) {
		729	av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
		730	"abort parsing\n", line);
		731	break;
		732	}
		733	timestamp = (hh3600LL + mm60LL + ss) * 1000LL + ms + delay;
		734	timestamp = av_rescale_q(timestamp, (AVRational){1,1000}, st->time_base);
		735
		736	sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
		737	if (!sub) {
		738	ret = AVERROR(ENOMEM);
		739	goto end;
		740	}
		741	sub->pos = pos;
		742	sub->pts = timestamp;
		743	sub->stream_index = s->nb_streams - 1;
		744
		745	} else if (st && !strncmp(line, "alt:", 4)) {
		746	const char *p = line + 4;
		747
		748	while (*p == ' ')
		749	p++;
		750	av_dict_set(&st->metadata, "title", p, 0);
		751	av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", st->id, p);
		752	header_parsed = 1;
		753
		754	} else if (!strncmp(line, "delay:", 6)) {
		755	int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
		756	const char *p = line + 6;
		757
		758	while (*p == ' ')
		759	p++;
		760	if (p == '-' \|\| p == '+') {
		761	sign = *p == '-' ? -1 : 1;
		762	p++;
		763	}
		764	sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
		765	delay = ((hh3600LL + mm60LL + ss) * 1000LL + ms) * sign;
		766
		767	} else if (!strncmp(line, "langidx:", 8)) {
		768	const char *p = line + 8;
		769
		770	if (sscanf(p, "%d", &langidx) != 1)
		771	av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
		772
		773	} else if (!header_parsed) {
		774	if (line[0] && line[0] != '#')
		775	av_bprintf(&header, "%s\n", line);
		776	}
		777	}
		778
		779	if (langidx < s->nb_streams)
		780	s->streams[langidx]->disposition \|= AV_DISPOSITION_DEFAULT;
		781
		782	for (i = 0; i < s->nb_streams; i++) {
		783	vobsub->q[i].sort = SUB_SORT_POS_TS;
		784	ff_subtitles_queue_finalize(&vobsub->q[i]);
		785	}
		786
		787	if (!av_bprint_is_complete(&header)) {
		788	av_bprint_finalize(&header, NULL);
		789	ret = AVERROR(ENOMEM);
		790	goto end;
		791	}
		792	av_bprint_finalize(&header, &header_str);
		793	for (i = 0; i < s->nb_streams; i++) {
		794	AVStream *sub_st = s->streams[i];
		795	sub_st->codec->extradata = av_strdup(header_str);
		796	sub_st->codec->extradata_size = header.len;
		797	}
		798	av_free(header_str);
		799
		800	end:
		801	av_free(sub_name);
		802	return ret;
		803	}
		804
		805	#define FAIL(r) do { ret = r; goto fail; } while (0)
		806
		807	static int vobsub_read_packet(AVFormatContext s, AVPacket pkt)
		808	{
		809	MpegDemuxContext *vobsub = s->priv_data;
		810	FFDemuxSubtitlesQueue *q;
		811	AVIOContext *pb = vobsub->sub_ctx->pb;
		812	int ret, psize, total_read = 0, i;
		813	AVPacket idx_pkt;
		814
		815	int64_t min_ts = INT64_MAX;
		816	int sid = 0;
		817	for (i = 0; i < s->nb_streams; i++) {
		818	FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
		819	int64_t ts = tmpq->subs[tmpq->current_sub_idx].pts;
		820	if (ts < min_ts) {
		821	min_ts = ts;
		822	sid = i;
		823	}
		824	}
		825	q = &vobsub->q[sid];
		826	ret = ff_subtitles_queue_read_packet(q, &idx_pkt);
		827	if (ret < 0)
		828	return ret;
		829
		830	/* compute maximum packet size using the next packet position. This is
		831	* useful when the len in the header is non-sense */
		832	if (q->current_sub_idx < q->nb_subs) {
		833	psize = q->subs[q->current_sub_idx].pos - idx_pkt.pos;
		834	} else {
		835	int64_t fsize = avio_size(pb);
		836	psize = fsize < 0 ? 0xffff : fsize - idx_pkt.pos;
		837	}
		838
		839	avio_seek(pb, idx_pkt.pos, SEEK_SET);
		840
		841	av_init_packet(pkt);
		842	pkt->size = 0;
		843	pkt->data = NULL;
		844
		845	do {
		846	int n, to_read, startcode;
		847	int64_t pts, dts;
		848	int64_t old_pos = avio_tell(pb), new_pos;
		849	int pkt_size;
		850
		851	ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
		852	if (ret < 0) {
		853	if (pkt->size) // raise packet even if incomplete
		854	break;
		855	FAIL(ret);
		856	}
		857	to_read = ret & 0xffff;
		858	new_pos = avio_tell(pb);
		859	pkt_size = ret + (new_pos - old_pos);
		860
		861	/* this prevents reads above the current packet */
		862	if (total_read + pkt_size > psize)
		863	break;
		864	total_read += pkt_size;
		865
		866	/* the current chunk doesn't match the stream index (unlikely) */
		867	if ((startcode & 0x1f) != idx_pkt.stream_index)
		868	break;
		869
		870	ret = av_grow_packet(pkt, to_read);
		871	if (ret < 0)
		872	FAIL(ret);
		873
		874	n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
		875	if (n < to_read)
		876	pkt->size -= to_read - n;
		877	} while (total_read < psize);
		878
		879	pkt->pts = pkt->dts = idx_pkt.pts;
		880	pkt->pos = idx_pkt.pos;
		881	pkt->stream_index = idx_pkt.stream_index;
		882
		883	av_free_packet(&idx_pkt);
		884	return 0;
		885
		886	fail:
		887	av_free_packet(pkt);
		888	av_free_packet(&idx_pkt);
		889	return ret;
		890	}
		891
		892	static int vobsub_read_seek(AVFormatContext *s, int stream_index,
		893	int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
		894	{
		895	MpegDemuxContext *vobsub = s->priv_data;
		896
		897	/* Rescale requested timestamps based on the first stream (timebase is the
		898	* same for all subtitles stream within a .idx/.sub). Rescaling is done just
		899	* like in avformat_seek_file(). */
		900	if (stream_index == -1 && s->nb_streams != 1) {
		901	int i, ret = 0;
		902	AVRational time_base = s->streams[0]->time_base;
		903	ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
		904	min_ts = av_rescale_rnd(min_ts, time_base.den,
		905	time_base.num * (int64_t)AV_TIME_BASE,
		906	AV_ROUND_UP \| AV_ROUND_PASS_MINMAX);
		907	max_ts = av_rescale_rnd(max_ts, time_base.den,
		908	time_base.num * (int64_t)AV_TIME_BASE,
		909	AV_ROUND_DOWN \| AV_ROUND_PASS_MINMAX);
		910	for (i = 0; i < s->nb_streams; i++) {
		911	int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
		912	min_ts, ts, max_ts, flags);
		913	if (r < 0)
		914	ret = r;
		915	}
		916	return ret;
		917	}
		918
		919	if (stream_index == -1) // only 1 stream
		920	stream_index = 0;
		921	return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
		922	min_ts, ts, max_ts, flags);
		923	}
		924
		925	static int vobsub_read_close(AVFormatContext *s)
		926	{
		927	int i;
		928	MpegDemuxContext *vobsub = s->priv_data;
		929
		930	for (i = 0; i < s->nb_streams; i++)
		931	ff_subtitles_queue_clean(&vobsub->q[i]);
		932	if (vobsub->sub_ctx)
		933	avformat_close_input(&vobsub->sub_ctx);
		934	return 0;
		935	}
		936
		937	AVInputFormat ff_vobsub_demuxer = {
		938	.name = "vobsub",
		939	.long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
		940	.priv_data_size = sizeof(MpegDemuxContext),
		941	.read_probe = vobsub_probe,
		942	.read_header = vobsub_read_header,
		943	.read_packet = vobsub_read_packet,
		944	.read_seek2 = vobsub_read_seek,
		945	.read_close = vobsub_read_close,
		946	.flags = AVFMT_SHOW_IDS,
		947	.extensions = "idx",
		948	};
		949	#endif

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavformat/mpeg.c @ 5068 – Rev