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

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* Copyright (c) 2003 Fabrice Bellard
		3	*
		4	* This file is part of FFmpeg.
		5	*
		6	* FFmpeg 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.1 of the License, or (at your option) any later version.
		10	*
		11	* FFmpeg 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 FFmpeg; if not, write to the Free Software
		18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		19	*/
		20
		21	/**
		22	* @file
		23	* simple media player based on the FFmpeg libraries
		24	*/
		25
		26	#include "config.h"
		27	#include
		28	#include
		29	#include
		30	#include
		31	#include "libavutil/avstring.h"
		32	#include "libavutil/colorspace.h"
		33	#include "libavutil/mathematics.h"
		34	#include "libavutil/pixdesc.h"
		35	#include "libavutil/imgutils.h"
		36	#include "libavutil/dict.h"
		37	#include "libavutil/parseutils.h"
		38	#include "libavutil/samplefmt.h"
		39	#include "libavutil/avassert.h"
		40	#include "libavutil/time.h"
		41	#include "libavformat/avformat.h"
		42	#include "libavdevice/avdevice.h"
		43	#include "libswscale/swscale.h"
		44	#include "libavutil/opt.h"
		45	#include "libavcodec/avfft.h"
		46	#include "libswresample/swresample.h"
		47
		48	#if CONFIG_AVFILTER
		49	# include "libavfilter/avcodec.h"
		50	# include "libavfilter/avfilter.h"
		51	# include "libavfilter/buffersink.h"
		52	# include "libavfilter/buffersrc.h"
		53	#endif
		54
		55	#include
		56	#include
		57
		58	#include "cmdutils.h"
		59
		60	#include
		61
		62	const char program_name[] = "ffplay";
		63	const int program_birth_year = 2003;
		64
		65	#define MAX_QUEUE_SIZE (15 * 1024 * 1024)
		66	#define MIN_FRAMES 5
		67
		68	/* SDL audio buffer size, in samples. Should be small to have precise
		69	A/V sync as SDL does not have hardware buffer fullness info. */
		70	#define SDL_AUDIO_BUFFER_SIZE 1024
		71
		72	/* no AV sync correction is done if below the minimum AV sync threshold */
		73	#define AV_SYNC_THRESHOLD_MIN 0.01
		74	/* AV sync correction is done if above the maximum AV sync threshold */
		75	#define AV_SYNC_THRESHOLD_MAX 0.1
		76	/* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
		77	#define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
		78	/* no AV correction is done if too big error */
		79	#define AV_NOSYNC_THRESHOLD 10.0
		80
		81	/* maximum audio speed change to get correct sync */
		82	#define SAMPLE_CORRECTION_PERCENT_MAX 10
		83
		84	/* external clock speed adjustment constants for realtime sources based on buffer fullness */
		85	#define EXTERNAL_CLOCK_SPEED_MIN 0.900
		86	#define EXTERNAL_CLOCK_SPEED_MAX 1.010
		87	#define EXTERNAL_CLOCK_SPEED_STEP 0.001
		88
		89	/* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
		90	#define AUDIO_DIFF_AVG_NB 20
		91
		92	/* polls for possible required screen refresh at least this often, should be less than 1/fps */
		93	#define REFRESH_RATE 0.01
		94
		95	/* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
		96	/* TODO: We assume that a decoded and resampled frame fits into this buffer */
		97	#define SAMPLE_ARRAY_SIZE (8 * 65536)
		98
		99	#define CURSOR_HIDE_DELAY 1000000
		100
		101	static int64_t sws_flags = SWS_BICUBIC;
		102
		103	typedef struct MyAVPacketList {
		104	AVPacket pkt;
		105	struct MyAVPacketList *next;
		106	int serial;
		107	} MyAVPacketList;
		108
		109	typedef struct PacketQueue {
		110	MyAVPacketList first_pkt, last_pkt;
		111	int nb_packets;
		112	int size;
		113	int abort_request;
		114	int serial;
		115	SDL_mutex *mutex;
		116	SDL_cond *cond;
		117	} PacketQueue;
		118
		119	#define VIDEO_PICTURE_QUEUE_SIZE 3
		120	#define SUBPICTURE_QUEUE_SIZE 4
		121
		122	typedef struct VideoPicture {
		123	double pts; // presentation timestamp for this picture
		124	int64_t pos; // byte position in file
		125	SDL_Overlay *bmp;
		126	int width, height; /* source height & width */
		127	int allocated;
		128	int reallocate;
		129	int serial;
		130
		131	AVRational sar;
		132	} VideoPicture;
		133
		134	typedef struct SubPicture {
		135	double pts; /* presentation time stamp for this picture */
		136	AVSubtitle sub;
		137	int serial;
		138	} SubPicture;
		139
		140	typedef struct AudioParams {
		141	int freq;
		142	int channels;
		143	int64_t channel_layout;
		144	enum AVSampleFormat fmt;
		145	} AudioParams;
		146
		147	typedef struct Clock {
		148	double pts; /* clock base */
		149	double pts_drift; /* clock base minus time at which we updated the clock */
		150	double last_updated;
		151	double speed;
		152	int serial; /* clock is based on a packet with this serial */
		153	int paused;
		154	int queue_serial; / pointer to the current packet queue serial, used for obsolete clock detection */
		155	} Clock;
		156
		157	enum {
		158	AV_SYNC_AUDIO_MASTER, /* default choice */
		159	AV_SYNC_VIDEO_MASTER,
		160	AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
		161	};
		162
		163	typedef struct VideoState {
		164	SDL_Thread *read_tid;
		165	SDL_Thread *video_tid;
		166	AVInputFormat *iformat;
		167	int no_background;
		168	int abort_request;
		169	int force_refresh;
		170	int paused;
		171	int last_paused;
		172	int queue_attachments_req;
		173	int seek_req;
		174	int seek_flags;
		175	int64_t seek_pos;
		176	int64_t seek_rel;
		177	int read_pause_return;
		178	AVFormatContext *ic;
		179	int realtime;
		180	int audio_finished;
		181	int video_finished;
		182
		183	Clock audclk;
		184	Clock vidclk;
		185	Clock extclk;
		186
		187	int audio_stream;
		188
		189	int av_sync_type;
		190
		191	double audio_clock;
		192	int audio_clock_serial;
		193	double audio_diff_cum; /* used for AV difference average computation */
		194	double audio_diff_avg_coef;
		195	double audio_diff_threshold;
		196	int audio_diff_avg_count;
		197	AVStream *audio_st;
		198	PacketQueue audioq;
		199	int audio_hw_buf_size;
		200	uint8_t silence_buf[SDL_AUDIO_BUFFER_SIZE];
		201	uint8_t *audio_buf;
		202	uint8_t *audio_buf1;
		203	unsigned int audio_buf_size; /* in bytes */
		204	unsigned int audio_buf1_size;
		205	int audio_buf_index; /* in bytes */
		206	int audio_write_buf_size;
		207	int audio_buf_frames_pending;
		208	AVPacket audio_pkt_temp;
		209	AVPacket audio_pkt;
		210	int audio_pkt_temp_serial;
		211	int audio_last_serial;
		212	struct AudioParams audio_src;
		213	#if CONFIG_AVFILTER
		214	struct AudioParams audio_filter_src;
		215	#endif
		216	struct AudioParams audio_tgt;
		217	struct SwrContext *swr_ctx;
		218	int frame_drops_early;
		219	int frame_drops_late;
		220	AVFrame *frame;
		221	int64_t audio_frame_next_pts;
		222
		223	enum ShowMode {
		224	SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
		225	} show_mode;
		226	int16_t sample_array[SAMPLE_ARRAY_SIZE];
		227	int sample_array_index;
		228	int last_i_start;
		229	RDFTContext *rdft;
		230	int rdft_bits;
		231	FFTSample *rdft_data;
		232	int xpos;
		233	double last_vis_time;
		234
		235	SDL_Thread *subtitle_tid;
		236	int subtitle_stream;
		237	AVStream *subtitle_st;
		238	PacketQueue subtitleq;
		239	SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
		240	int subpq_size, subpq_rindex, subpq_windex;
		241	SDL_mutex *subpq_mutex;
		242	SDL_cond *subpq_cond;
		243
		244	double frame_timer;
		245	double frame_last_pts;
		246	double frame_last_duration;
		247	double frame_last_dropped_pts;
		248	double frame_last_returned_time;
		249	double frame_last_filter_delay;
		250	int64_t frame_last_dropped_pos;
		251	int frame_last_dropped_serial;
		252	int video_stream;
		253	AVStream *video_st;
		254	PacketQueue videoq;
		255	int64_t video_current_pos; // current displayed file pos
		256	double max_frame_duration; // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
		257	VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
		258	int pictq_size, pictq_rindex, pictq_windex;
		259	SDL_mutex *pictq_mutex;
		260	SDL_cond *pictq_cond;
		261	#if !CONFIG_AVFILTER
		262	struct SwsContext *img_convert_ctx;
		263	#endif
		264	SDL_Rect last_display_rect;
		265
		266	char filename[1024];
		267	int width, height, xleft, ytop;
		268	int step;
		269
		270	#if CONFIG_AVFILTER
		271	AVFilterContext *in_video_filter; // the first filter in the video chain
		272	AVFilterContext *out_video_filter; // the last filter in the video chain
		273	AVFilterContext *in_audio_filter; // the first filter in the audio chain
		274	AVFilterContext *out_audio_filter; // the last filter in the audio chain
		275	AVFilterGraph *agraph; // audio filter graph
		276	#endif
		277
		278	int last_video_stream, last_audio_stream, last_subtitle_stream;
		279
		280	SDL_cond *continue_read_thread;
		281	} VideoState;
		282
		283	/* options specified by the user */
		284	static AVInputFormat *file_iformat;
		285	static const char *input_filename;
		286	static const char *window_title;
		287	static int fs_screen_width;
		288	static int fs_screen_height;
		289	static int default_width = 640;
		290	static int default_height = 480;
		291	static int screen_width = 0;
		292	static int screen_height = 0;
		293	static int audio_disable;
		294	static int video_disable;
		295	static int subtitle_disable;
		296	static int wanted_stream[AVMEDIA_TYPE_NB] = {
		297	[AVMEDIA_TYPE_AUDIO] = -1,
		298	[AVMEDIA_TYPE_VIDEO] = -1,
		299	[AVMEDIA_TYPE_SUBTITLE] = -1,
		300	};
		301	static int seek_by_bytes = -1;
		302	static int display_disable;
		303	static int show_status = 1;
		304	static int av_sync_type = AV_SYNC_AUDIO_MASTER;
		305	static int64_t start_time = AV_NOPTS_VALUE;
		306	static int64_t duration = AV_NOPTS_VALUE;
		307	static int workaround_bugs = 1;
		308	static int fast = 0;
		309	static int genpts = 0;
		310	static int lowres = 0;
		311	static int error_concealment = 3;
		312	static int decoder_reorder_pts = -1;
		313	static int autoexit;
		314	static int exit_on_keydown;
		315	static int exit_on_mousedown;
		316	static int loop = 1;
		317	static int framedrop = -1;
		318	static int infinite_buffer = -1;
		319	static enum ShowMode show_mode = SHOW_MODE_NONE;
		320	static const char *audio_codec_name;
		321	static const char *subtitle_codec_name;
		322	static const char *video_codec_name;
		323	double rdftspeed = 0.02;
		324	static int64_t cursor_last_shown;
		325	static int cursor_hidden = 0;
		326	#if CONFIG_AVFILTER
		327	static char *vfilters = NULL;
		328	static char *afilters = NULL;
		329	#endif
		330
		331	/* current context */
		332	static int is_full_screen;
		333	static int64_t audio_callback_time;
		334
		335	static AVPacket flush_pkt;
		336
		337	#define FF_ALLOC_EVENT (SDL_USEREVENT)
		338	#define FF_QUIT_EVENT (SDL_USEREVENT + 2)
		339
		340	static SDL_Surface *screen;
		341
		342	static inline
		343	int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
		344	enum AVSampleFormat fmt2, int64_t channel_count2)
		345	{
		346	/* If channel count == 1, planar and non-planar formats are the same */
		347	if (channel_count1 == 1 && channel_count2 == 1)
		348	return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
		349	else
		350	return channel_count1 != channel_count2 \|\| fmt1 != fmt2;
		351	}
		352
		353	static inline
		354	int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
		355	{
		356	if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
		357	return channel_layout;
		358	else
		359	return 0;
		360	}
		361
		362	static int packet_queue_put(PacketQueue q, AVPacket pkt);
		363
		364	static int packet_queue_put_private(PacketQueue q, AVPacket pkt)
		365	{
		366	MyAVPacketList *pkt1;
		367
		368	if (q->abort_request)
		369	return -1;
		370
		371	pkt1 = av_malloc(sizeof(MyAVPacketList));
		372	if (!pkt1)
		373	return -1;
		374	pkt1->pkt = *pkt;
		375	pkt1->next = NULL;
		376	if (pkt == &flush_pkt)
		377	q->serial++;
		378	pkt1->serial = q->serial;
		379
		380	if (!q->last_pkt)
		381	q->first_pkt = pkt1;
		382	else
		383	q->last_pkt->next = pkt1;
		384	q->last_pkt = pkt1;
		385	q->nb_packets++;
		386	q->size += pkt1->pkt.size + sizeof(*pkt1);
		387	/* XXX: should duplicate packet data in DV case */
		388	SDL_CondSignal(q->cond);
		389	return 0;
		390	}
		391
		392	static int packet_queue_put(PacketQueue q, AVPacket pkt)
		393	{
		394	int ret;
		395
		396	/* duplicate the packet */
		397	if (pkt != &flush_pkt && av_dup_packet(pkt) < 0)
		398	return -1;
		399
		400	SDL_LockMutex(q->mutex);
		401	ret = packet_queue_put_private(q, pkt);
		402	SDL_UnlockMutex(q->mutex);
		403
		404	if (pkt != &flush_pkt && ret < 0)
		405	av_free_packet(pkt);
		406
		407	return ret;
		408	}
		409
		410	static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
		411	{
		412	AVPacket pkt1, *pkt = &pkt1;
		413	av_init_packet(pkt);
		414	pkt->data = NULL;
		415	pkt->size = 0;
		416	pkt->stream_index = stream_index;
		417	return packet_queue_put(q, pkt);
		418	}
		419
		420	/* packet queue handling */
		421	static void packet_queue_init(PacketQueue *q)
		422	{
		423	memset(q, 0, sizeof(PacketQueue));
		424	q->mutex = SDL_CreateMutex();
		425	q->cond = SDL_CreateCond();
		426	q->abort_request = 1;
		427	}
		428
		429	static void packet_queue_flush(PacketQueue *q)
		430	{
		431	MyAVPacketList pkt, pkt1;
		432
		433	SDL_LockMutex(q->mutex);
		434	for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
		435	pkt1 = pkt->next;
		436	av_free_packet(&pkt->pkt);
		437	av_freep(&pkt);
		438	}
		439	q->last_pkt = NULL;
		440	q->first_pkt = NULL;
		441	q->nb_packets = 0;
		442	q->size = 0;
		443	SDL_UnlockMutex(q->mutex);
		444	}
		445
		446	static void packet_queue_destroy(PacketQueue *q)
		447	{
		448	packet_queue_flush(q);
		449	SDL_DestroyMutex(q->mutex);
		450	SDL_DestroyCond(q->cond);
		451	}
		452
		453	static void packet_queue_abort(PacketQueue *q)
		454	{
		455	SDL_LockMutex(q->mutex);
		456
		457	q->abort_request = 1;
		458
		459	SDL_CondSignal(q->cond);
		460
		461	SDL_UnlockMutex(q->mutex);
		462	}
		463
		464	static void packet_queue_start(PacketQueue *q)
		465	{
		466	SDL_LockMutex(q->mutex);
		467	q->abort_request = 0;
		468	packet_queue_put_private(q, &flush_pkt);
		469	SDL_UnlockMutex(q->mutex);
		470	}
		471
		472	/* return < 0 if aborted, 0 if no packet and > 0 if packet. */
		473	static int packet_queue_get(PacketQueue q, AVPacket pkt, int block, int *serial)
		474	{
		475	MyAVPacketList *pkt1;
		476	int ret;
		477
		478	SDL_LockMutex(q->mutex);
		479
		480	for (;;) {
		481	if (q->abort_request) {
		482	ret = -1;
		483	break;
		484	}
		485
		486	pkt1 = q->first_pkt;
		487	if (pkt1) {
		488	q->first_pkt = pkt1->next;
		489	if (!q->first_pkt)
		490	q->last_pkt = NULL;
		491	q->nb_packets--;
		492	q->size -= pkt1->pkt.size + sizeof(*pkt1);
		493	*pkt = pkt1->pkt;
		494	if (serial)
		495	*serial = pkt1->serial;
		496	av_free(pkt1);
		497	ret = 1;
		498	break;
		499	} else if (!block) {
		500	ret = 0;
		501	break;
		502	} else {
		503	SDL_CondWait(q->cond, q->mutex);
		504	}
		505	}
		506	SDL_UnlockMutex(q->mutex);
		507	return ret;
		508	}
		509
		510	static inline void fill_rectangle(SDL_Surface *screen,
		511	int x, int y, int w, int h, int color, int update)
		512	{
		513	SDL_Rect rect;
		514	rect.x = x;
		515	rect.y = y;
		516	rect.w = w;
		517	rect.h = h;
		518	SDL_FillRect(screen, &rect, color);
		519	if (update && w > 0 && h > 0)
		520	SDL_UpdateRect(screen, x, y, w, h);
		521	}
		522
		523	/* draw only the border of a rectangle */
		524	static void fill_border(int xleft, int ytop, int width, int height, int x, int y, int w, int h, int color, int update)
		525	{
		526	int w1, w2, h1, h2;
		527
		528	/* fill the background */
		529	w1 = x;
		530	if (w1 < 0)
		531	w1 = 0;
		532	w2 = width - (x + w);
		533	if (w2 < 0)
		534	w2 = 0;
		535	h1 = y;
		536	if (h1 < 0)
		537	h1 = 0;
		538	h2 = height - (y + h);
		539	if (h2 < 0)
		540	h2 = 0;
		541	fill_rectangle(screen,
		542	xleft, ytop,
		543	w1, height,
		544	color, update);
		545	fill_rectangle(screen,
		546	xleft + width - w2, ytop,
		547	w2, height,
		548	color, update);
		549	fill_rectangle(screen,
		550	xleft + w1, ytop,
		551	width - w1 - w2, h1,
		552	color, update);
		553	fill_rectangle(screen,
		554	xleft + w1, ytop + height - h2,
		555	width - w1 - w2, h2,
		556	color, update);
		557	}
		558
		559	#define ALPHA_BLEND(a, oldp, newp, s)\
		560	((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
		561
		562	#define RGBA_IN(r, g, b, a, s)\
		563	{\
		564	unsigned int v = ((const uint32_t *)(s))[0];\
		565	a = (v >> 24) & 0xff;\
		566	r = (v >> 16) & 0xff;\
		567	g = (v >> 8) & 0xff;\
		568	b = v & 0xff;\
		569	}
		570
		571	#define YUVA_IN(y, u, v, a, s, pal)\
		572	{\
		573	unsigned int val = ((const uint32_t )(pal))[(const uint8_t*)(s)];\
		574	a = (val >> 24) & 0xff;\
		575	y = (val >> 16) & 0xff;\
		576	u = (val >> 8) & 0xff;\
		577	v = val & 0xff;\
		578	}
		579
		580	#define YUVA_OUT(d, y, u, v, a)\
		581	{\
		582	((uint32_t *)(d))[0] = (a << 24) \| (y << 16) \| (u << 8) \| v;\
		583	}
		584
		585
		586	#define BPP 1
		587
		588	static void blend_subrect(AVPicture dst, const AVSubtitleRect rect, int imgw, int imgh)
		589	{
		590	int wrap, wrap3, width2, skip2;
		591	int y, u, v, a, u1, v1, a1, w, h;
		592	uint8_t lum, cb, *cr;
		593	const uint8_t *p;
		594	const uint32_t *pal;
		595	int dstx, dsty, dstw, dsth;
		596
		597	dstw = av_clip(rect->w, 0, imgw);
		598	dsth = av_clip(rect->h, 0, imgh);
		599	dstx = av_clip(rect->x, 0, imgw - dstw);
		600	dsty = av_clip(rect->y, 0, imgh - dsth);
		601	lum = dst->data[0] + dsty * dst->linesize[0];
		602	cb = dst->data[1] + (dsty >> 1) * dst->linesize[1];
		603	cr = dst->data[2] + (dsty >> 1) * dst->linesize[2];
		604
		605	width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);
		606	skip2 = dstx >> 1;
		607	wrap = dst->linesize[0];
		608	wrap3 = rect->pict.linesize[0];
		609	p = rect->pict.data[0];
		610	pal = (const uint32_t )rect->pict.data[1]; / Now in YCrCb! */
		611
		612	if (dsty & 1) {
		613	lum += dstx;
		614	cb += skip2;
		615	cr += skip2;
		616
		617	if (dstx & 1) {
		618	YUVA_IN(y, u, v, a, p, pal);
		619	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		620	cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
		621	cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
		622	cb++;
		623	cr++;
		624	lum++;
		625	p += BPP;
		626	}
		627	for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
		628	YUVA_IN(y, u, v, a, p, pal);
		629	u1 = u;
		630	v1 = v;
		631	a1 = a;
		632	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		633
		634	YUVA_IN(y, u, v, a, p + BPP, pal);
		635	u1 += u;
		636	v1 += v;
		637	a1 += a;
		638	lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
		639	cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
		640	cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
		641	cb++;
		642	cr++;
		643	p += 2 * BPP;
		644	lum += 2;
		645	}
		646	if (w) {
		647	YUVA_IN(y, u, v, a, p, pal);
		648	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		649	cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
		650	cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
		651	p++;
		652	lum++;
		653	}
		654	p += wrap3 - dstw * BPP;
		655	lum += wrap - dstw - dstx;
		656	cb += dst->linesize[1] - width2 - skip2;
		657	cr += dst->linesize[2] - width2 - skip2;
		658	}
		659	for (h = dsth - (dsty & 1); h >= 2; h -= 2) {
		660	lum += dstx;
		661	cb += skip2;
		662	cr += skip2;
		663
		664	if (dstx & 1) {
		665	YUVA_IN(y, u, v, a, p, pal);
		666	u1 = u;
		667	v1 = v;
		668	a1 = a;
		669	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		670	p += wrap3;
		671	lum += wrap;
		672	YUVA_IN(y, u, v, a, p, pal);
		673	u1 += u;
		674	v1 += v;
		675	a1 += a;
		676	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		677	cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
		678	cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
		679	cb++;
		680	cr++;
		681	p += -wrap3 + BPP;
		682	lum += -wrap + 1;
		683	}
		684	for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
		685	YUVA_IN(y, u, v, a, p, pal);
		686	u1 = u;
		687	v1 = v;
		688	a1 = a;
		689	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		690
		691	YUVA_IN(y, u, v, a, p + BPP, pal);
		692	u1 += u;
		693	v1 += v;
		694	a1 += a;
		695	lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
		696	p += wrap3;
		697	lum += wrap;
		698
		699	YUVA_IN(y, u, v, a, p, pal);
		700	u1 += u;
		701	v1 += v;
		702	a1 += a;
		703	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		704
		705	YUVA_IN(y, u, v, a, p + BPP, pal);
		706	u1 += u;
		707	v1 += v;
		708	a1 += a;
		709	lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
		710
		711	cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
		712	cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
		713
		714	cb++;
		715	cr++;
		716	p += -wrap3 + 2 * BPP;
		717	lum += -wrap + 2;
		718	}
		719	if (w) {
		720	YUVA_IN(y, u, v, a, p, pal);
		721	u1 = u;
		722	v1 = v;
		723	a1 = a;
		724	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		725	p += wrap3;
		726	lum += wrap;
		727	YUVA_IN(y, u, v, a, p, pal);
		728	u1 += u;
		729	v1 += v;
		730	a1 += a;
		731	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		732	cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
		733	cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
		734	cb++;
		735	cr++;
		736	p += -wrap3 + BPP;
		737	lum += -wrap + 1;
		738	}
		739	p += wrap3 + (wrap3 - dstw * BPP);
		740	lum += wrap + (wrap - dstw - dstx);
		741	cb += dst->linesize[1] - width2 - skip2;
		742	cr += dst->linesize[2] - width2 - skip2;
		743	}
		744	/* handle odd height */
		745	if (h) {
		746	lum += dstx;
		747	cb += skip2;
		748	cr += skip2;
		749
		750	if (dstx & 1) {
		751	YUVA_IN(y, u, v, a, p, pal);
		752	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		753	cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
		754	cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
		755	cb++;
		756	cr++;
		757	lum++;
		758	p += BPP;
		759	}
		760	for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
		761	YUVA_IN(y, u, v, a, p, pal);
		762	u1 = u;
		763	v1 = v;
		764	a1 = a;
		765	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		766
		767	YUVA_IN(y, u, v, a, p + BPP, pal);
		768	u1 += u;
		769	v1 += v;
		770	a1 += a;
		771	lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
		772	cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
		773	cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
		774	cb++;
		775	cr++;
		776	p += 2 * BPP;
		777	lum += 2;
		778	}
		779	if (w) {
		780	YUVA_IN(y, u, v, a, p, pal);
		781	lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
		782	cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
		783	cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
		784	}
		785	}
		786	}
		787
		788	static void free_picture(VideoPicture *vp)
		789	{
		790	if (vp->bmp) {
		791	SDL_FreeYUVOverlay(vp->bmp);
		792	vp->bmp = NULL;
		793	}
		794	}
		795
		796	static void free_subpicture(SubPicture *sp)
		797	{
		798	avsubtitle_free(&sp->sub);
		799	}
		800
		801	static void calculate_display_rect(SDL_Rect rect, int scr_xleft, int scr_ytop, int scr_width, int scr_height, VideoPicture vp)
		802	{
		803	float aspect_ratio;
		804	int width, height, x, y;
		805
		806	if (vp->sar.num == 0)
		807	aspect_ratio = 0;
		808	else
		809	aspect_ratio = av_q2d(vp->sar);
		810
		811	if (aspect_ratio <= 0.0)
		812	aspect_ratio = 1.0;
		813	aspect_ratio *= (float)vp->width / (float)vp->height;
		814
		815	/* XXX: we suppose the screen has a 1.0 pixel ratio */
		816	height = scr_height;
		817	width = ((int)rint(height * aspect_ratio)) & ~1;
		818	if (width > scr_width) {
		819	width = scr_width;
		820	height = ((int)rint(width / aspect_ratio)) & ~1;
		821	}
		822	x = (scr_width - width) / 2;
		823	y = (scr_height - height) / 2;
		824	rect->x = scr_xleft + x;
		825	rect->y = scr_ytop + y;
		826	rect->w = FFMAX(width, 1);
		827	rect->h = FFMAX(height, 1);
		828	}
		829
		830	static void video_image_display(VideoState *is)
		831	{
		832	VideoPicture *vp;
		833	SubPicture *sp;
		834	AVPicture pict;
		835	SDL_Rect rect;
		836	int i;
		837
		838	vp = &is->pictq[is->pictq_rindex];
		839	if (vp->bmp) {
		840	if (is->subtitle_st) {
		841	if (is->subpq_size > 0) {
		842	sp = &is->subpq[is->subpq_rindex];
		843
		844	if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
		845	SDL_LockYUVOverlay (vp->bmp);
		846
		847	pict.data[0] = vp->bmp->pixels[0];
		848	pict.data[1] = vp->bmp->pixels[2];
		849	pict.data[2] = vp->bmp->pixels[1];
		850
		851	pict.linesize[0] = vp->bmp->pitches[0];
		852	pict.linesize[1] = vp->bmp->pitches[2];
		853	pict.linesize[2] = vp->bmp->pitches[1];
		854
		855	for (i = 0; i < sp->sub.num_rects; i++)
		856	blend_subrect(&pict, sp->sub.rects[i],
		857	vp->bmp->w, vp->bmp->h);
		858
		859	SDL_UnlockYUVOverlay (vp->bmp);
		860	}
		861	}
		862	}
		863
		864	calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp);
		865
		866	SDL_DisplayYUVOverlay(vp->bmp, &rect);
		867
		868	if (rect.x != is->last_display_rect.x \|\| rect.y != is->last_display_rect.y \|\| rect.w != is->last_display_rect.w \|\| rect.h != is->last_display_rect.h \|\| is->force_refresh) {
		869	int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
		870	fill_border(is->xleft, is->ytop, is->width, is->height, rect.x, rect.y, rect.w, rect.h, bgcolor, 1);
		871	is->last_display_rect = rect;
		872	}
		873	}
		874	}
		875
		876	static inline int compute_mod(int a, int b)
		877	{
		878	return a < 0 ? a%b + b : a%b;
		879	}
		880
		881	static void video_audio_display(VideoState *s)
		882	{
		883	int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
		884	int ch, channels, h, h2, bgcolor, fgcolor;
		885	int64_t time_diff;
		886	int rdft_bits, nb_freq;
		887
		888	for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
		889	;
		890	nb_freq = 1 << (rdft_bits - 1);
		891
		892	/* compute display index : center on currently output samples */
		893	channels = s->audio_tgt.channels;
		894	nb_display_channels = channels;
		895	if (!s->paused) {
		896	int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
		897	n = 2 * channels;
		898	delay = s->audio_write_buf_size;
		899	delay /= n;
		900
		901	/* to be more precise, we take into account the time spent since
		902	the last buffer computation */
		903	if (audio_callback_time) {
		904	time_diff = av_gettime() - audio_callback_time;
		905	delay -= (time_diff * s->audio_tgt.freq) / 1000000;
		906	}
		907
		908	delay += 2 * data_used;
		909	if (delay < data_used)
		910	delay = data_used;
		911
		912	i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
		913	if (s->show_mode == SHOW_MODE_WAVES) {
		914	h = INT_MIN;
		915	for (i = 0; i < 1000; i += channels) {
		916	int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
		917	int a = s->sample_array[idx];
		918	int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
		919	int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
		920	int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
		921	int score = a - d;
		922	if (h < score && (b ^ c) < 0) {
		923	h = score;
		924	i_start = idx;
		925	}
		926	}
		927	}
		928
		929	s->last_i_start = i_start;
		930	} else {
		931	i_start = s->last_i_start;
		932	}
		933
		934	bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
		935	if (s->show_mode == SHOW_MODE_WAVES) {
		936	fill_rectangle(screen,
		937	s->xleft, s->ytop, s->width, s->height,
		938	bgcolor, 0);
		939
		940	fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
		941
		942	/* total height for one channel */
		943	h = s->height / nb_display_channels;
		944	/* graph height / 2 */
		945	h2 = (h * 9) / 20;
		946	for (ch = 0; ch < nb_display_channels; ch++) {
		947	i = i_start + ch;
		948	y1 = s->ytop + ch * h + (h / 2); /* position of center line */
		949	for (x = 0; x < s->width; x++) {
		950	y = (s->sample_array[i] * h2) >> 15;
		951	if (y < 0) {
		952	y = -y;
		953	ys = y1 - y;
		954	} else {
		955	ys = y1;
		956	}
		957	fill_rectangle(screen,
		958	s->xleft + x, ys, 1, y,
		959	fgcolor, 0);
		960	i += channels;
		961	if (i >= SAMPLE_ARRAY_SIZE)
		962	i -= SAMPLE_ARRAY_SIZE;
		963	}
		964	}
		965
		966	fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
		967
		968	for (ch = 1; ch < nb_display_channels; ch++) {
		969	y = s->ytop + ch * h;
		970	fill_rectangle(screen,
		971	s->xleft, y, s->width, 1,
		972	fgcolor, 0);
		973	}
		974	SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
		975	} else {
		976	nb_display_channels= FFMIN(nb_display_channels, 2);
		977	if (rdft_bits != s->rdft_bits) {
		978	av_rdft_end(s->rdft);
		979	av_free(s->rdft_data);
		980	s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
		981	s->rdft_bits = rdft_bits;
		982	s->rdft_data = av_malloc(4 * nb_freq * sizeof(*s->rdft_data));
		983	}
		984	{
		985	FFTSample *data[2];
		986	for (ch = 0; ch < nb_display_channels; ch++) {
		987	data[ch] = s->rdft_data + 2 * nb_freq * ch;
		988	i = i_start + ch;
		989	for (x = 0; x < 2 * nb_freq; x++) {
		990	double w = (x-nb_freq) * (1.0 / nb_freq);
		991	data[ch][x] = s->sample_array[i] * (1.0 - w * w);
		992	i += channels;
		993	if (i >= SAMPLE_ARRAY_SIZE)
		994	i -= SAMPLE_ARRAY_SIZE;
		995	}
		996	av_rdft_calc(s->rdft, data[ch]);
		997	}
		998	/* Least efficient way to do this, we should of course
		999	* directly access it but it is more than fast enough. */
		1000	for (y = 0; y < s->height; y++) {
		1001	double w = 1 / sqrt(nb_freq);
		1002	int a = sqrt(w * sqrt(data[0][2 * y + 0] * data[0][2 * y + 0] + data[0][2 * y + 1] * data[0][2 * y + 1]));
		1003	int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]
		1004	+ data[1][2 * y + 1] * data[1][2 * y + 1])) : a;
		1005	a = FFMIN(a, 255);
		1006	b = FFMIN(b, 255);
		1007	fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
		1008
		1009	fill_rectangle(screen,
		1010	s->xpos, s->height-y, 1, 1,
		1011	fgcolor, 0);
		1012	}
		1013	}
		1014	SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
		1015	if (!s->paused)
		1016	s->xpos++;
		1017	if (s->xpos >= s->width)
		1018	s->xpos= s->xleft;
		1019	}
		1020	}
		1021
		1022	static void stream_close(VideoState *is)
		1023	{
		1024	int i;
		1025	/* XXX: use a special url_shutdown call to abort parse cleanly */
		1026	is->abort_request = 1;
		1027	SDL_WaitThread(is->read_tid, NULL);
		1028	packet_queue_destroy(&is->videoq);
		1029	packet_queue_destroy(&is->audioq);
		1030	packet_queue_destroy(&is->subtitleq);
		1031
		1032	/* free all pictures */
		1033	for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
		1034	free_picture(&is->pictq[i]);
		1035	for (i = 0; i < SUBPICTURE_QUEUE_SIZE; i++)
		1036	free_subpicture(&is->subpq[i]);
		1037	SDL_DestroyMutex(is->pictq_mutex);
		1038	SDL_DestroyCond(is->pictq_cond);
		1039	SDL_DestroyMutex(is->subpq_mutex);
		1040	SDL_DestroyCond(is->subpq_cond);
		1041	SDL_DestroyCond(is->continue_read_thread);
		1042	#if !CONFIG_AVFILTER
		1043	sws_freeContext(is->img_convert_ctx);
		1044	#endif
		1045	av_free(is);
		1046	}
		1047
		1048	static void do_exit(VideoState *is)
		1049	{
		1050	if (is) {
		1051	stream_close(is);
		1052	}
		1053	av_lockmgr_register(NULL);
		1054	uninit_opts();
		1055	#if CONFIG_AVFILTER
		1056	av_freep(&vfilters);
		1057	#endif
		1058	avformat_network_deinit();
		1059	if (show_status)
		1060	printf("\n");
		1061	SDL_Quit();
		1062	av_log(NULL, AV_LOG_QUIET, "%s", "");
		1063	exit(0);
		1064	}
		1065
		1066	static void sigterm_handler(int sig)
		1067	{
		1068	exit(123);
		1069	}
		1070
		1071	static int video_open(VideoState is, int force_set_video_mode, VideoPicture vp)
		1072	{
		1073	int flags = SDL_HWSURFACE \| SDL_ASYNCBLIT \| SDL_HWACCEL;
		1074	int w,h;
		1075	SDL_Rect rect;
		1076
		1077	if (is_full_screen) flags \|= SDL_FULLSCREEN;
		1078	else flags \|= SDL_RESIZABLE;
		1079
		1080	if (vp && vp->width) {
		1081	calculate_display_rect(&rect, 0, 0, INT_MAX, vp->height, vp);
		1082	default_width = rect.w;
		1083	default_height = rect.h;
		1084	}
		1085
		1086	if (is_full_screen && fs_screen_width) {
		1087	w = fs_screen_width;
		1088	h = fs_screen_height;
		1089	} else if (!is_full_screen && screen_width) {
		1090	w = screen_width;
		1091	h = screen_height;
		1092	} else {
		1093	w = default_width;
		1094	h = default_height;
		1095	}
		1096	w = FFMIN(16383, w);
		1097	if (screen && is->width == screen->w && screen->w == w
		1098	&& is->height== screen->h && screen->h == h && !force_set_video_mode)
		1099	return 0;
		1100	screen = SDL_SetVideoMode(w, h, 0, flags);
		1101	if (!screen) {
		1102	av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
		1103	do_exit(is);
		1104	}
		1105	if (!window_title)
		1106	window_title = input_filename;
		1107	SDL_WM_SetCaption(window_title, window_title);
		1108
		1109	is->width = screen->w;
		1110	is->height = screen->h;
		1111
		1112	return 0;
		1113	}
		1114
		1115	/* display the current picture, if any */
		1116	static void video_display(VideoState *is)
		1117	{
		1118	if (!screen)
		1119	video_open(is, 0, NULL);
		1120	if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
		1121	video_audio_display(is);
		1122	else if (is->video_st)
		1123	video_image_display(is);
		1124	}
		1125
		1126	static double get_clock(Clock *c)
		1127	{
		1128	if (*c->queue_serial != c->serial)
		1129	return NAN;
		1130	if (c->paused) {
		1131	return c->pts;
		1132	} else {
		1133	double time = av_gettime() / 1000000.0;
		1134	return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
		1135	}
		1136	}
		1137
		1138	static void set_clock_at(Clock *c, double pts, int serial, double time)
		1139	{
		1140	c->pts = pts;
		1141	c->last_updated = time;
		1142	c->pts_drift = c->pts - time;
		1143	c->serial = serial;
		1144	}
		1145
		1146	static void set_clock(Clock *c, double pts, int serial)
		1147	{
		1148	double time = av_gettime() / 1000000.0;
		1149	set_clock_at(c, pts, serial, time);
		1150	}
		1151
		1152	static void set_clock_speed(Clock *c, double speed)
		1153	{
		1154	set_clock(c, get_clock(c), c->serial);
		1155	c->speed = speed;
		1156	}
		1157
		1158	static void init_clock(Clock c, int queue_serial)
		1159	{
		1160	c->speed = 1.0;
		1161	c->paused = 0;
		1162	c->queue_serial = queue_serial;
		1163	set_clock(c, NAN, -1);
		1164	}
		1165
		1166	static void sync_clock_to_slave(Clock c, Clock slave)
		1167	{
		1168	double clock = get_clock(c);
		1169	double slave_clock = get_clock(slave);
		1170	if (!isnan(slave_clock) && (isnan(clock) \|\| fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
		1171	set_clock(c, slave_clock, slave->serial);
		1172	}
		1173
		1174	static int get_master_sync_type(VideoState *is) {
		1175	if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
		1176	if (is->video_st)
		1177	return AV_SYNC_VIDEO_MASTER;
		1178	else
		1179	return AV_SYNC_AUDIO_MASTER;
		1180	} else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
		1181	if (is->audio_st)
		1182	return AV_SYNC_AUDIO_MASTER;
		1183	else
		1184	return AV_SYNC_EXTERNAL_CLOCK;
		1185	} else {
		1186	return AV_SYNC_EXTERNAL_CLOCK;
		1187	}
		1188	}
		1189
		1190	/* get the current master clock value */
		1191	static double get_master_clock(VideoState *is)
		1192	{
		1193	double val;
		1194
		1195	switch (get_master_sync_type(is)) {
		1196	case AV_SYNC_VIDEO_MASTER:
		1197	val = get_clock(&is->vidclk);
		1198	break;
		1199	case AV_SYNC_AUDIO_MASTER:
		1200	val = get_clock(&is->audclk);
		1201	break;
		1202	default:
		1203	val = get_clock(&is->extclk);
		1204	break;
		1205	}
		1206	return val;
		1207	}
		1208
		1209	static void check_external_clock_speed(VideoState *is) {
		1210	if (is->video_stream >= 0 && is->videoq.nb_packets <= MIN_FRAMES / 2 \|\|
		1211	is->audio_stream >= 0 && is->audioq.nb_packets <= MIN_FRAMES / 2) {
		1212	set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
		1213	} else if ((is->video_stream < 0 \|\| is->videoq.nb_packets > MIN_FRAMES * 2) &&
		1214	(is->audio_stream < 0 \|\| is->audioq.nb_packets > MIN_FRAMES * 2)) {
		1215	set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
		1216	} else {
		1217	double speed = is->extclk.speed;
		1218	if (speed != 1.0)
		1219	set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
		1220	}
		1221	}
		1222
		1223	/* seek in the stream */
		1224	static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
		1225	{
		1226	if (!is->seek_req) {
		1227	is->seek_pos = pos;
		1228	is->seek_rel = rel;
		1229	is->seek_flags &= ~AVSEEK_FLAG_BYTE;
		1230	if (seek_by_bytes)
		1231	is->seek_flags \|= AVSEEK_FLAG_BYTE;
		1232	is->seek_req = 1;
		1233	SDL_CondSignal(is->continue_read_thread);
		1234	}
		1235	}
		1236
		1237	/* pause or resume the video */
		1238	static void stream_toggle_pause(VideoState *is)
		1239	{
		1240	if (is->paused) {
		1241	is->frame_timer += av_gettime() / 1000000.0 + is->vidclk.pts_drift - is->vidclk.pts;
		1242	if (is->read_pause_return != AVERROR(ENOSYS)) {
		1243	is->vidclk.paused = 0;
		1244	}
		1245	set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
		1246	}
		1247	set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
		1248	is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
		1249	}
		1250
		1251	static void toggle_pause(VideoState *is)
		1252	{
		1253	stream_toggle_pause(is);
		1254	is->step = 0;
		1255	}
		1256
		1257	static void step_to_next_frame(VideoState *is)
		1258	{
		1259	/* if the stream is paused unpause it, then step */
		1260	if (is->paused)
		1261	stream_toggle_pause(is);
		1262	is->step = 1;
		1263	}
		1264
		1265	static double compute_target_delay(double delay, VideoState *is)
		1266	{
		1267	double sync_threshold, diff;
		1268
		1269	/* update delay to follow master synchronisation source */
		1270	if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
		1271	/* if video is slave, we try to correct big delays by
		1272	duplicating or deleting a frame */
		1273	diff = get_clock(&is->vidclk) - get_master_clock(is);
		1274
		1275	/* skip or repeat frame. We take into account the
		1276	delay to compute the threshold. I still don't know
		1277	if it is the best guess */
		1278	sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
		1279	if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
		1280	if (diff <= -sync_threshold)
		1281	delay = FFMAX(0, delay + diff);
		1282	else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
		1283	delay = delay + diff;
		1284	else if (diff >= sync_threshold)
		1285	delay = 2 * delay;
		1286	}
		1287	}
		1288
		1289	av_dlog(NULL, "video: delay=%0.3f A-V=%f\n",
		1290	delay, -diff);
		1291
		1292	return delay;
		1293	}
		1294
		1295	static void pictq_next_picture(VideoState *is) {
		1296	/* update queue size and signal for next picture */
		1297	if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
		1298	is->pictq_rindex = 0;
		1299
		1300	SDL_LockMutex(is->pictq_mutex);
		1301	is->pictq_size--;
		1302	SDL_CondSignal(is->pictq_cond);
		1303	SDL_UnlockMutex(is->pictq_mutex);
		1304	}
		1305
		1306	static int pictq_prev_picture(VideoState *is) {
		1307	VideoPicture *prevvp;
		1308	int ret = 0;
		1309	/* update queue size and signal for the previous picture */
		1310	prevvp = &is->pictq[(is->pictq_rindex + VIDEO_PICTURE_QUEUE_SIZE - 1) % VIDEO_PICTURE_QUEUE_SIZE];
		1311	if (prevvp->allocated && prevvp->serial == is->videoq.serial) {
		1312	SDL_LockMutex(is->pictq_mutex);
		1313	if (is->pictq_size < VIDEO_PICTURE_QUEUE_SIZE) {
		1314	if (--is->pictq_rindex == -1)
		1315	is->pictq_rindex = VIDEO_PICTURE_QUEUE_SIZE - 1;
		1316	is->pictq_size++;
		1317	ret = 1;
		1318	}
		1319	SDL_CondSignal(is->pictq_cond);
		1320	SDL_UnlockMutex(is->pictq_mutex);
		1321	}
		1322	return ret;
		1323	}
		1324
		1325	static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
		1326	/* update current video pts */
		1327	set_clock(&is->vidclk, pts, serial);
		1328	sync_clock_to_slave(&is->extclk, &is->vidclk);
		1329	is->video_current_pos = pos;
		1330	is->frame_last_pts = pts;
		1331	}
		1332
		1333	/* called to display each frame */
		1334	static void video_refresh(void opaque, double remaining_time)
		1335	{
		1336	VideoState *is = opaque;
		1337	VideoPicture *vp;
		1338	double time;
		1339
		1340	SubPicture sp, sp2;
		1341
		1342	if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
		1343	check_external_clock_speed(is);
		1344
		1345	if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
		1346	time = av_gettime() / 1000000.0;
		1347	if (is->force_refresh \|\| is->last_vis_time + rdftspeed < time) {
		1348	video_display(is);
		1349	is->last_vis_time = time;
		1350	}
		1351	remaining_time = FFMIN(remaining_time, is->last_vis_time + rdftspeed - time);
		1352	}
		1353
		1354	if (is->video_st) {
		1355	int redisplay = 0;
		1356	if (is->force_refresh)
		1357	redisplay = pictq_prev_picture(is);
		1358	retry:
		1359	if (is->pictq_size == 0) {
		1360	SDL_LockMutex(is->pictq_mutex);
		1361	if (is->frame_last_dropped_pts != AV_NOPTS_VALUE && is->frame_last_dropped_pts > is->frame_last_pts) {
		1362	update_video_pts(is, is->frame_last_dropped_pts, is->frame_last_dropped_pos, is->frame_last_dropped_serial);
		1363	is->frame_last_dropped_pts = AV_NOPTS_VALUE;
		1364	}
		1365	SDL_UnlockMutex(is->pictq_mutex);
		1366	// nothing to do, no picture to display in the queue
		1367	} else {
		1368	double last_duration, duration, delay;
		1369	/* dequeue the picture */
		1370	vp = &is->pictq[is->pictq_rindex];
		1371
		1372	if (vp->serial != is->videoq.serial) {
		1373	pictq_next_picture(is);
		1374	redisplay = 0;
		1375	goto retry;
		1376	}
		1377
		1378	if (is->paused)
		1379	goto display;
		1380
		1381	/* compute nominal last_duration */
		1382	last_duration = vp->pts - is->frame_last_pts;
		1383	if (!isnan(last_duration) && last_duration > 0 && last_duration < is->max_frame_duration) {
		1384	/* if duration of the last frame was sane, update last_duration in video state */
		1385	is->frame_last_duration = last_duration;
		1386	}
		1387	if (redisplay)
		1388	delay = 0.0;
		1389	else
		1390	delay = compute_target_delay(is->frame_last_duration, is);
		1391
		1392	time= av_gettime()/1000000.0;
		1393	if (time < is->frame_timer + delay && !redisplay) {
		1394	remaining_time = FFMIN(is->frame_timer + delay - time, remaining_time);
		1395	return;
		1396	}
		1397
		1398	is->frame_timer += delay;
		1399	if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
		1400	is->frame_timer = time;
		1401
		1402	SDL_LockMutex(is->pictq_mutex);
		1403	if (!redisplay && !isnan(vp->pts))
		1404	update_video_pts(is, vp->pts, vp->pos, vp->serial);
		1405	SDL_UnlockMutex(is->pictq_mutex);
		1406
		1407	if (is->pictq_size > 1) {
		1408	VideoPicture *nextvp = &is->pictq[(is->pictq_rindex + 1) % VIDEO_PICTURE_QUEUE_SIZE];
		1409	duration = nextvp->pts - vp->pts;
		1410	if(!is->step && (redisplay \|\| framedrop>0 \|\| (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
		1411	if (!redisplay)
		1412	is->frame_drops_late++;
		1413	pictq_next_picture(is);
		1414	redisplay = 0;
		1415	goto retry;
		1416	}
		1417	}
		1418
		1419	if (is->subtitle_st) {
		1420	while (is->subpq_size > 0) {
		1421	sp = &is->subpq[is->subpq_rindex];
		1422
		1423	if (is->subpq_size > 1)
		1424	sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
		1425	else
		1426	sp2 = NULL;
		1427
		1428	if (sp->serial != is->subtitleq.serial
		1429	\|\| (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
		1430	\|\| (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
		1431	{
		1432	free_subpicture(sp);
		1433
		1434	/* update queue size and signal for next picture */
		1435	if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
		1436	is->subpq_rindex = 0;
		1437
		1438	SDL_LockMutex(is->subpq_mutex);
		1439	is->subpq_size--;
		1440	SDL_CondSignal(is->subpq_cond);
		1441	SDL_UnlockMutex(is->subpq_mutex);
		1442	} else {
		1443	break;
		1444	}
		1445	}
		1446	}
		1447
		1448	display:
		1449	/* display picture */
		1450	if (!display_disable && is->show_mode == SHOW_MODE_VIDEO)
		1451	video_display(is);
		1452
		1453	pictq_next_picture(is);
		1454
		1455	if (is->step && !is->paused)
		1456	stream_toggle_pause(is);
		1457	}
		1458	}
		1459	is->force_refresh = 0;
		1460	if (show_status) {
		1461	static int64_t last_time;
		1462	int64_t cur_time;
		1463	int aqsize, vqsize, sqsize;
		1464	double av_diff;
		1465
		1466	cur_time = av_gettime();
		1467	if (!last_time \|\| (cur_time - last_time) >= 30000) {
		1468	aqsize = 0;
		1469	vqsize = 0;
		1470	sqsize = 0;
		1471	if (is->audio_st)
		1472	aqsize = is->audioq.size;
		1473	if (is->video_st)
		1474	vqsize = is->videoq.size;
		1475	if (is->subtitle_st)
		1476	sqsize = is->subtitleq.size;
		1477	av_diff = 0;
		1478	if (is->audio_st && is->video_st)
		1479	av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
		1480	else if (is->video_st)
		1481	av_diff = get_master_clock(is) - get_clock(&is->vidclk);
		1482	else if (is->audio_st)
		1483	av_diff = get_master_clock(is) - get_clock(&is->audclk);
		1484	av_log(NULL, AV_LOG_INFO,
		1485	"%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
		1486	get_master_clock(is),
		1487	(is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
		1488	av_diff,
		1489	is->frame_drops_early + is->frame_drops_late,
		1490	aqsize / 1024,
		1491	vqsize / 1024,
		1492	sqsize,
		1493	is->video_st ? is->video_st->codec->pts_correction_num_faulty_dts : 0,
		1494	is->video_st ? is->video_st->codec->pts_correction_num_faulty_pts : 0);
		1495	fflush(stdout);
		1496	last_time = cur_time;
		1497	}
		1498	}
		1499	}
		1500
		1501	/* allocate a picture (needs to do that in main thread to avoid
		1502	potential locking problems */
		1503	static void alloc_picture(VideoState *is)
		1504	{
		1505	VideoPicture *vp;
		1506	int64_t bufferdiff;
		1507
		1508	vp = &is->pictq[is->pictq_windex];
		1509
		1510	free_picture(vp);
		1511
		1512	video_open(is, 0, vp);
		1513
		1514	vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
		1515	SDL_YV12_OVERLAY,
		1516	screen);
		1517	bufferdiff = vp->bmp ? FFMAX(vp->bmp->pixels[0], vp->bmp->pixels[1]) - FFMIN(vp->bmp->pixels[0], vp->bmp->pixels[1]) : 0;
		1518	if (!vp->bmp \|\| vp->bmp->pitches[0] < vp->width \|\| bufferdiff < (int64_t)vp->height * vp->bmp->pitches[0]) {
		1519	/* SDL allocates a buffer smaller than requested if the video
		1520	* overlay hardware is unable to support the requested size. */
		1521	av_log(NULL, AV_LOG_FATAL,
		1522	"Error: the video system does not support an image\n"
		1523	"size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
		1524	"to reduce the image size.\n", vp->width, vp->height );
		1525	do_exit(is);
		1526	}
		1527
		1528	SDL_LockMutex(is->pictq_mutex);
		1529	vp->allocated = 1;
		1530	SDL_CondSignal(is->pictq_cond);
		1531	SDL_UnlockMutex(is->pictq_mutex);
		1532	}
		1533
		1534	static void duplicate_right_border_pixels(SDL_Overlay *bmp) {
		1535	int i, width, height;
		1536	Uint8 p, maxp;
		1537	for (i = 0; i < 3; i++) {
		1538	width = bmp->w;
		1539	height = bmp->h;
		1540	if (i > 0) {
		1541	width >>= 1;
		1542	height >>= 1;
		1543	}
		1544	if (bmp->pitches[i] > width) {
		1545	maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
		1546	for (p = bmp->pixels[i] + width - 1; p < maxp; p += bmp->pitches[i])
		1547	(p+1) = p;
		1548	}
		1549	}
		1550	}
		1551
		1552	static int queue_picture(VideoState is, AVFrame src_frame, double pts, int64_t pos, int serial)
		1553	{
		1554	VideoPicture *vp;
		1555
		1556	#if defined(DEBUG_SYNC) && 0
		1557	printf("frame_type=%c pts=%0.3f\n",
		1558	av_get_picture_type_char(src_frame->pict_type), pts);
		1559	#endif
		1560
		1561	/* wait until we have space to put a new picture */
		1562	SDL_LockMutex(is->pictq_mutex);
		1563
		1564	/* keep the last already displayed picture in the queue */
		1565	while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE - 1 &&
		1566	!is->videoq.abort_request) {
		1567	SDL_CondWait(is->pictq_cond, is->pictq_mutex);
		1568	}
		1569	SDL_UnlockMutex(is->pictq_mutex);
		1570
		1571	if (is->videoq.abort_request)
		1572	return -1;
		1573
		1574	vp = &is->pictq[is->pictq_windex];
		1575
		1576	vp->sar = src_frame->sample_aspect_ratio;
		1577
		1578	/* alloc or resize hardware picture buffer */
		1579	if (!vp->bmp \|\| vp->reallocate \|\| !vp->allocated \|\|
		1580	vp->width != src_frame->width \|\|
		1581	vp->height != src_frame->height) {
		1582	SDL_Event event;
		1583
		1584	vp->allocated = 0;
		1585	vp->reallocate = 0;
		1586	vp->width = src_frame->width;
		1587	vp->height = src_frame->height;
		1588
		1589	/* the allocation must be done in the main thread to avoid
		1590	locking problems. */
		1591	event.type = FF_ALLOC_EVENT;
		1592	event.user.data1 = is;
		1593	SDL_PushEvent(&event);
		1594
		1595	/* wait until the picture is allocated */
		1596	SDL_LockMutex(is->pictq_mutex);
		1597	while (!vp->allocated && !is->videoq.abort_request) {
		1598	SDL_CondWait(is->pictq_cond, is->pictq_mutex);
		1599	}
		1600	/* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
		1601	if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_EVENTMASK(FF_ALLOC_EVENT)) != 1) {
		1602	while (!vp->allocated) {
		1603	SDL_CondWait(is->pictq_cond, is->pictq_mutex);
		1604	}
		1605	}
		1606	SDL_UnlockMutex(is->pictq_mutex);
		1607
		1608	if (is->videoq.abort_request)
		1609	return -1;
		1610	}
		1611
		1612	/* if the frame is not skipped, then display it */
		1613	if (vp->bmp) {
		1614	AVPicture pict = { { 0 } };
		1615
		1616	/* get a pointer on the bitmap */
		1617	SDL_LockYUVOverlay (vp->bmp);
		1618
		1619	pict.data[0] = vp->bmp->pixels[0];
		1620	pict.data[1] = vp->bmp->pixels[2];
		1621	pict.data[2] = vp->bmp->pixels[1];
		1622
		1623	pict.linesize[0] = vp->bmp->pitches[0];
		1624	pict.linesize[1] = vp->bmp->pitches[2];
		1625	pict.linesize[2] = vp->bmp->pitches[1];
		1626
		1627	#if CONFIG_AVFILTER
		1628	// FIXME use direct rendering
		1629	av_picture_copy(&pict, (AVPicture *)src_frame,
		1630	src_frame->format, vp->width, vp->height);
		1631	#else
		1632	av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
		1633	is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
		1634	vp->width, vp->height, src_frame->format, vp->width, vp->height,
		1635	AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
		1636	if (is->img_convert_ctx == NULL) {
		1637	av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
		1638	exit(1);
		1639	}
		1640	sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize,
		1641	0, vp->height, pict.data, pict.linesize);
		1642	#endif
		1643	/* workaround SDL PITCH_WORKAROUND */
		1644	duplicate_right_border_pixels(vp->bmp);
		1645	/* update the bitmap content */
		1646	SDL_UnlockYUVOverlay(vp->bmp);
		1647
		1648	vp->pts = pts;
		1649	vp->pos = pos;
		1650	vp->serial = serial;
		1651
		1652	/* now we can update the picture count */
		1653	if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
		1654	is->pictq_windex = 0;
		1655	SDL_LockMutex(is->pictq_mutex);
		1656	is->pictq_size++;
		1657	SDL_UnlockMutex(is->pictq_mutex);
		1658	}
		1659	return 0;
		1660	}
		1661
		1662	static int get_video_frame(VideoState is, AVFrame frame, AVPacket pkt, int serial)
		1663	{
		1664	int got_picture;
		1665
		1666	if (packet_queue_get(&is->videoq, pkt, 1, serial) < 0)
		1667	return -1;
		1668
		1669	if (pkt->data == flush_pkt.data) {
		1670	avcodec_flush_buffers(is->video_st->codec);
		1671
		1672	SDL_LockMutex(is->pictq_mutex);
		1673	// Make sure there are no long delay timers (ideally we should just flush the queue but that's harder)
		1674	while (is->pictq_size && !is->videoq.abort_request) {
		1675	SDL_CondWait(is->pictq_cond, is->pictq_mutex);
		1676	}
		1677	is->video_current_pos = -1;
		1678	is->frame_last_pts = AV_NOPTS_VALUE;
		1679	is->frame_last_duration = 0;
		1680	is->frame_timer = (double)av_gettime() / 1000000.0;
		1681	is->frame_last_dropped_pts = AV_NOPTS_VALUE;
		1682	SDL_UnlockMutex(is->pictq_mutex);
		1683	return 0;
		1684	}
		1685
		1686	if(avcodec_decode_video2(is->video_st->codec, frame, &got_picture, pkt) < 0)
		1687	return 0;
		1688
		1689	if (!got_picture && !pkt->data)
		1690	is->video_finished = *serial;
		1691
		1692	if (got_picture) {
		1693	int ret = 1;
		1694	double dpts = NAN;
		1695
		1696	if (decoder_reorder_pts == -1) {
		1697	frame->pts = av_frame_get_best_effort_timestamp(frame);
		1698	} else if (decoder_reorder_pts) {
		1699	frame->pts = frame->pkt_pts;
		1700	} else {
		1701	frame->pts = frame->pkt_dts;
		1702	}
		1703
		1704	if (frame->pts != AV_NOPTS_VALUE)
		1705	dpts = av_q2d(is->video_st->time_base) * frame->pts;
		1706
		1707	frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
		1708
		1709	if (framedrop>0 \|\| (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
		1710	SDL_LockMutex(is->pictq_mutex);
		1711	if (is->frame_last_pts != AV_NOPTS_VALUE && frame->pts != AV_NOPTS_VALUE) {
		1712	double clockdiff = get_clock(&is->vidclk) - get_master_clock(is);
		1713	double ptsdiff = dpts - is->frame_last_pts;
		1714	if (!isnan(clockdiff) && fabs(clockdiff) < AV_NOSYNC_THRESHOLD &&
		1715	!isnan(ptsdiff) && ptsdiff > 0 && ptsdiff < AV_NOSYNC_THRESHOLD &&
		1716	clockdiff + ptsdiff - is->frame_last_filter_delay < 0 &&
		1717	is->videoq.nb_packets) {
		1718	is->frame_last_dropped_pos = av_frame_get_pkt_pos(frame);
		1719	is->frame_last_dropped_pts = dpts;
		1720	is->frame_last_dropped_serial = *serial;
		1721	is->frame_drops_early++;
		1722	av_frame_unref(frame);
		1723	ret = 0;
		1724	}
		1725	}
		1726	SDL_UnlockMutex(is->pictq_mutex);
		1727	}
		1728
		1729	return ret;
		1730	}
		1731	return 0;
		1732	}
		1733
		1734	#if CONFIG_AVFILTER
		1735	static int configure_filtergraph(AVFilterGraph graph, const char filtergraph,
		1736	AVFilterContext source_ctx, AVFilterContext sink_ctx)
		1737	{
		1738	int ret;
		1739	AVFilterInOut outputs = NULL, inputs = NULL;
		1740
		1741	if (filtergraph) {
		1742	outputs = avfilter_inout_alloc();
		1743	inputs = avfilter_inout_alloc();
		1744	if (!outputs \|\| !inputs) {
		1745	ret = AVERROR(ENOMEM);
		1746	goto fail;
		1747	}
		1748
		1749	outputs->name = av_strdup("in");
		1750	outputs->filter_ctx = source_ctx;
		1751	outputs->pad_idx = 0;
		1752	outputs->next = NULL;
		1753
		1754	inputs->name = av_strdup("out");
		1755	inputs->filter_ctx = sink_ctx;
		1756	inputs->pad_idx = 0;
		1757	inputs->next = NULL;
		1758
		1759	if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
		1760	goto fail;
		1761	} else {
		1762	if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
		1763	goto fail;
		1764	}
		1765
		1766	ret = avfilter_graph_config(graph, NULL);
		1767	fail:
		1768	avfilter_inout_free(&outputs);
		1769	avfilter_inout_free(&inputs);
		1770	return ret;
		1771	}
		1772
		1773	static int configure_video_filters(AVFilterGraph graph, VideoState is, const char vfilters, AVFrame frame)
		1774	{
		1775	static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
		1776	char sws_flags_str[128];
		1777	char buffersrc_args[256];
		1778	int ret;
		1779	AVFilterContext filt_src = NULL, filt_out = NULL, *filt_crop;
		1780	AVCodecContext *codec = is->video_st->codec;
		1781	AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
		1782
		1783	av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
		1784	snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%"PRId64, sws_flags);
		1785	graph->scale_sws_opts = av_strdup(sws_flags_str);
		1786
		1787	snprintf(buffersrc_args, sizeof(buffersrc_args),
		1788	"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		1789	frame->width, frame->height, frame->format,
		1790	is->video_st->time_base.num, is->video_st->time_base.den,
		1791	codec->sample_aspect_ratio.num, FFMAX(codec->sample_aspect_ratio.den, 1));
		1792	if (fr.num && fr.den)
		1793	av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
		1794
		1795	if ((ret = avfilter_graph_create_filter(&filt_src,
		1796	avfilter_get_by_name("buffer"),
		1797	"ffplay_buffer", buffersrc_args, NULL,
		1798	graph)) < 0)
		1799	goto fail;
		1800
		1801	ret = avfilter_graph_create_filter(&filt_out,
		1802	avfilter_get_by_name("buffersink"),
		1803	"ffplay_buffersink", NULL, NULL, graph);
		1804	if (ret < 0)
		1805	goto fail;
		1806
		1807	if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
		1808	goto fail;
		1809
		1810	/* SDL YUV code is not handling odd width/height for some driver
		1811	* combinations, therefore we crop the picture to an even width/height. */
		1812	if ((ret = avfilter_graph_create_filter(&filt_crop,
		1813	avfilter_get_by_name("crop"),
		1814	"ffplay_crop", "floor(in_w/2)2:floor(in_h/2)2", NULL, graph)) < 0)
		1815	goto fail;
		1816	if ((ret = avfilter_link(filt_crop, 0, filt_out, 0)) < 0)
		1817	goto fail;
		1818
		1819	if ((ret = configure_filtergraph(graph, vfilters, filt_src, filt_crop)) < 0)
		1820	goto fail;
		1821
		1822	is->in_video_filter = filt_src;
		1823	is->out_video_filter = filt_out;
		1824
		1825	fail:
		1826	return ret;
		1827	}
		1828
		1829	static int configure_audio_filters(VideoState is, const char afilters, int force_output_format)
		1830	{
		1831	static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
		1832	int sample_rates[2] = { 0, -1 };
		1833	int64_t channel_layouts[2] = { 0, -1 };
		1834	int channels[2] = { 0, -1 };
		1835	AVFilterContext filt_asrc = NULL, filt_asink = NULL;
		1836	char aresample_swr_opts[512] = "";
		1837	AVDictionaryEntry *e = NULL;
		1838	char asrc_args[256];
		1839	int ret;
		1840
		1841	avfilter_graph_free(&is->agraph);
		1842	if (!(is->agraph = avfilter_graph_alloc()))
		1843	return AVERROR(ENOMEM);
		1844
		1845	while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
		1846	av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
		1847	if (strlen(aresample_swr_opts))
		1848	aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
		1849	av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
		1850
		1851	ret = snprintf(asrc_args, sizeof(asrc_args),
		1852	"sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
		1853	is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
		1854	is->audio_filter_src.channels,
		1855	1, is->audio_filter_src.freq);
		1856	if (is->audio_filter_src.channel_layout)
		1857	snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
		1858	":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
		1859
		1860	ret = avfilter_graph_create_filter(&filt_asrc,
		1861	avfilter_get_by_name("abuffer"), "ffplay_abuffer",
		1862	asrc_args, NULL, is->agraph);
		1863	if (ret < 0)
		1864	goto end;
		1865
		1866
		1867	ret = avfilter_graph_create_filter(&filt_asink,
		1868	avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
		1869	NULL, NULL, is->agraph);
		1870	if (ret < 0)
		1871	goto end;
		1872
		1873	if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
		1874	goto end;
		1875	if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
		1876	goto end;
		1877
		1878	if (force_output_format) {
		1879	channel_layouts[0] = is->audio_tgt.channel_layout;
		1880	channels [0] = is->audio_tgt.channels;
		1881	sample_rates [0] = is->audio_tgt.freq;
		1882	if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
		1883	goto end;
		1884	if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
		1885	goto end;
		1886	if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
		1887	goto end;
		1888	if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
		1889	goto end;
		1890	}
		1891
		1892
		1893	if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
		1894	goto end;
		1895
		1896	is->in_audio_filter = filt_asrc;
		1897	is->out_audio_filter = filt_asink;
		1898
		1899	end:
		1900	if (ret < 0)
		1901	avfilter_graph_free(&is->agraph);
		1902	return ret;
		1903	}
		1904	#endif /* CONFIG_AVFILTER */
		1905
		1906	static int video_thread(void *arg)
		1907	{
		1908	AVPacket pkt = { 0 };
		1909	VideoState *is = arg;
		1910	AVFrame *frame = av_frame_alloc();
		1911	double pts;
		1912	int ret;
		1913	int serial = 0;
		1914
		1915	#if CONFIG_AVFILTER
		1916	AVFilterGraph *graph = avfilter_graph_alloc();
		1917	AVFilterContext filt_out = NULL, filt_in = NULL;
		1918	int last_w = 0;
		1919	int last_h = 0;
		1920	enum AVPixelFormat last_format = -2;
		1921	int last_serial = -1;
		1922	#endif
		1923
		1924	for (;;) {
		1925	while (is->paused && !is->videoq.abort_request)
		1926	SDL_Delay(10);
		1927
		1928	avcodec_get_frame_defaults(frame);
		1929	av_free_packet(&pkt);
		1930
		1931	ret = get_video_frame(is, frame, &pkt, &serial);
		1932	if (ret < 0)
		1933	goto the_end;
		1934	if (!ret)
		1935	continue;
		1936
		1937	#if CONFIG_AVFILTER
		1938	if ( last_w != frame->width
		1939	\|\| last_h != frame->height
		1940	\|\| last_format != frame->format
		1941	\|\| last_serial != serial) {
		1942	av_log(NULL, AV_LOG_DEBUG,
		1943	"Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
		1944	last_w, last_h,
		1945	(const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
		1946	frame->width, frame->height,
		1947	(const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), serial);
		1948	avfilter_graph_free(&graph);
		1949	graph = avfilter_graph_alloc();
		1950	if ((ret = configure_video_filters(graph, is, vfilters, frame)) < 0) {
		1951	SDL_Event event;
		1952	event.type = FF_QUIT_EVENT;
		1953	event.user.data1 = is;
		1954	SDL_PushEvent(&event);
		1955	av_free_packet(&pkt);
		1956	goto the_end;
		1957	}
		1958	filt_in = is->in_video_filter;
		1959	filt_out = is->out_video_filter;
		1960	last_w = frame->width;
		1961	last_h = frame->height;
		1962	last_format = frame->format;
		1963	last_serial = serial;
		1964	}
		1965
		1966	ret = av_buffersrc_add_frame(filt_in, frame);
		1967	if (ret < 0)
		1968	goto the_end;
		1969	av_frame_unref(frame);
		1970	avcodec_get_frame_defaults(frame);
		1971	av_free_packet(&pkt);
		1972
		1973	while (ret >= 0) {
		1974	is->frame_last_returned_time = av_gettime() / 1000000.0;
		1975
		1976	ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
		1977	if (ret < 0) {
		1978	if (ret == AVERROR_EOF)
		1979	is->video_finished = serial;
		1980	ret = 0;
		1981	break;
		1982	}
		1983
		1984	is->frame_last_filter_delay = av_gettime() / 1000000.0 - is->frame_last_returned_time;
		1985	if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
		1986	is->frame_last_filter_delay = 0;
		1987
		1988	pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(filt_out->inputs[0]->time_base);
		1989	ret = queue_picture(is, frame, pts, av_frame_get_pkt_pos(frame), serial);
		1990	av_frame_unref(frame);
		1991	}
		1992	#else
		1993	pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(is->video_st->time_base);
		1994	ret = queue_picture(is, frame, pts, av_frame_get_pkt_pos(frame), serial);
		1995	av_frame_unref(frame);
		1996	#endif
		1997
		1998	if (ret < 0)
		1999	goto the_end;
		2000	}
		2001	the_end:
		2002	avcodec_flush_buffers(is->video_st->codec);
		2003	#if CONFIG_AVFILTER
		2004	avfilter_graph_free(&graph);
		2005	#endif
		2006	av_free_packet(&pkt);
		2007	av_frame_free(&frame);
		2008	return 0;
		2009	}
		2010
		2011	static int subtitle_thread(void *arg)
		2012	{
		2013	VideoState *is = arg;
		2014	SubPicture *sp;
		2015	AVPacket pkt1, *pkt = &pkt1;
		2016	int got_subtitle;
		2017	int serial;
		2018	double pts;
		2019	int i, j;
		2020	int r, g, b, y, u, v, a;
		2021
		2022	for (;;) {
		2023	while (is->paused && !is->subtitleq.abort_request) {
		2024	SDL_Delay(10);
		2025	}
		2026	if (packet_queue_get(&is->subtitleq, pkt, 1, &serial) < 0)
		2027	break;
		2028
		2029	if (pkt->data == flush_pkt.data) {
		2030	avcodec_flush_buffers(is->subtitle_st->codec);
		2031	continue;
		2032	}
		2033	SDL_LockMutex(is->subpq_mutex);
		2034	while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
		2035	!is->subtitleq.abort_request) {
		2036	SDL_CondWait(is->subpq_cond, is->subpq_mutex);
		2037	}
		2038	SDL_UnlockMutex(is->subpq_mutex);
		2039
		2040	if (is->subtitleq.abort_request)
		2041	return 0;
		2042
		2043	sp = &is->subpq[is->subpq_windex];
		2044
		2045	/* NOTE: ipts is the PTS of the _first_ picture beginning in
		2046	this packet, if any */
		2047	pts = 0;
		2048	if (pkt->pts != AV_NOPTS_VALUE)
		2049	pts = av_q2d(is->subtitle_st->time_base) * pkt->pts;
		2050
		2051	avcodec_decode_subtitle2(is->subtitle_st->codec, &sp->sub,
		2052	&got_subtitle, pkt);
		2053	if (got_subtitle && sp->sub.format == 0) {
		2054	if (sp->sub.pts != AV_NOPTS_VALUE)
		2055	pts = sp->sub.pts / (double)AV_TIME_BASE;
		2056	sp->pts = pts;
		2057	sp->serial = serial;
		2058
		2059	for (i = 0; i < sp->sub.num_rects; i++)
		2060	{
		2061	for (j = 0; j < sp->sub.rects[i]->nb_colors; j++)
		2062	{
		2063	RGBA_IN(r, g, b, a, (uint32_t*)sp->sub.rects[i]->pict.data[1] + j);
		2064	y = RGB_TO_Y_CCIR(r, g, b);
		2065	u = RGB_TO_U_CCIR(r, g, b, 0);
		2066	v = RGB_TO_V_CCIR(r, g, b, 0);
		2067	YUVA_OUT((uint32_t*)sp->sub.rects[i]->pict.data[1] + j, y, u, v, a);
		2068	}
		2069	}
		2070
		2071	/* now we can update the picture count */
		2072	if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
		2073	is->subpq_windex = 0;
		2074	SDL_LockMutex(is->subpq_mutex);
		2075	is->subpq_size++;
		2076	SDL_UnlockMutex(is->subpq_mutex);
		2077	} else if (got_subtitle) {
		2078	avsubtitle_free(&sp->sub);
		2079	}
		2080	av_free_packet(pkt);
		2081	}
		2082	return 0;
		2083	}
		2084
		2085	/* copy samples for viewing in editor window */
		2086	static void update_sample_display(VideoState is, short samples, int samples_size)
		2087	{
		2088	int size, len;
		2089
		2090	size = samples_size / sizeof(short);
		2091	while (size > 0) {
		2092	len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
		2093	if (len > size)
		2094	len = size;
		2095	memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
		2096	samples += len;
		2097	is->sample_array_index += len;
		2098	if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
		2099	is->sample_array_index = 0;
		2100	size -= len;
		2101	}
		2102	}
		2103
		2104	/* return the wanted number of samples to get better sync if sync_type is video
		2105	* or external master clock */
		2106	static int synchronize_audio(VideoState *is, int nb_samples)
		2107	{
		2108	int wanted_nb_samples = nb_samples;
		2109
		2110	/* if not master, then we try to remove or add samples to correct the clock */
		2111	if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
		2112	double diff, avg_diff;
		2113	int min_nb_samples, max_nb_samples;
		2114
		2115	diff = get_clock(&is->audclk) - get_master_clock(is);
		2116
		2117	if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
		2118	is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
		2119	if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
		2120	/* not enough measures to have a correct estimate */
		2121	is->audio_diff_avg_count++;
		2122	} else {
		2123	/* estimate the A-V difference */
		2124	avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
		2125
		2126	if (fabs(avg_diff) >= is->audio_diff_threshold) {
		2127	wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
		2128	min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
		2129	max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
		2130	wanted_nb_samples = FFMIN(FFMAX(wanted_nb_samples, min_nb_samples), max_nb_samples);
		2131	}
		2132	av_dlog(NULL, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
		2133	diff, avg_diff, wanted_nb_samples - nb_samples,
		2134	is->audio_clock, is->audio_diff_threshold);
		2135	}
		2136	} else {
		2137	/* too big difference : may be initial PTS errors, so
		2138	reset A-V filter */
		2139	is->audio_diff_avg_count = 0;
		2140	is->audio_diff_cum = 0;
		2141	}
		2142	}
		2143
		2144	return wanted_nb_samples;
		2145	}
		2146
		2147	/**
		2148	* Decode one audio frame and return its uncompressed size.
		2149	*
		2150	* The processed audio frame is decoded, converted if required, and
		2151	* stored in is->audio_buf, with size in bytes given by the return
		2152	* value.
		2153	*/
		2154	static int audio_decode_frame(VideoState *is)
		2155	{
		2156	AVPacket *pkt_temp = &is->audio_pkt_temp;
		2157	AVPacket *pkt = &is->audio_pkt;
		2158	AVCodecContext *dec = is->audio_st->codec;
		2159	int len1, data_size, resampled_data_size;
		2160	int64_t dec_channel_layout;
		2161	int got_frame;
		2162	av_unused double audio_clock0;
		2163	int wanted_nb_samples;
		2164	AVRational tb;
		2165	int ret;
		2166	int reconfigure;
		2167
		2168	for (;;) {
		2169	/* NOTE: the audio packet can contain several frames */
		2170	while (pkt_temp->stream_index != -1 \|\| is->audio_buf_frames_pending) {
		2171	if (!is->frame) {
		2172	if (!(is->frame = avcodec_alloc_frame()))
		2173	return AVERROR(ENOMEM);
		2174	} else {
		2175	av_frame_unref(is->frame);
		2176	avcodec_get_frame_defaults(is->frame);
		2177	}
		2178
		2179	if (is->audioq.serial != is->audio_pkt_temp_serial)
		2180	break;
		2181
		2182	if (is->paused)
		2183	return -1;
		2184
		2185	if (!is->audio_buf_frames_pending) {
		2186	len1 = avcodec_decode_audio4(dec, is->frame, &got_frame, pkt_temp);
		2187	if (len1 < 0) {
		2188	/* if error, we skip the frame */
		2189	pkt_temp->size = 0;
		2190	break;
		2191	}
		2192
		2193	pkt_temp->dts =
		2194	pkt_temp->pts = AV_NOPTS_VALUE;
		2195	pkt_temp->data += len1;
		2196	pkt_temp->size -= len1;
		2197	if (pkt_temp->data && pkt_temp->size <= 0 \|\| !pkt_temp->data && !got_frame)
		2198	pkt_temp->stream_index = -1;
		2199	if (!pkt_temp->data && !got_frame)
		2200	is->audio_finished = is->audio_pkt_temp_serial;
		2201
		2202	if (!got_frame)
		2203	continue;
		2204
		2205	tb = (AVRational){1, is->frame->sample_rate};
		2206	if (is->frame->pts != AV_NOPTS_VALUE)
		2207	is->frame->pts = av_rescale_q(is->frame->pts, dec->time_base, tb);
		2208	else if (is->frame->pkt_pts != AV_NOPTS_VALUE)
		2209	is->frame->pts = av_rescale_q(is->frame->pkt_pts, is->audio_st->time_base, tb);
		2210	else if (is->audio_frame_next_pts != AV_NOPTS_VALUE)
		2211	#if CONFIG_AVFILTER
		2212	is->frame->pts = av_rescale_q(is->audio_frame_next_pts, (AVRational){1, is->audio_filter_src.freq}, tb);
		2213	#else
		2214	is->frame->pts = av_rescale_q(is->audio_frame_next_pts, (AVRational){1, is->audio_src.freq}, tb);
		2215	#endif
		2216
		2217	if (is->frame->pts != AV_NOPTS_VALUE)
		2218	is->audio_frame_next_pts = is->frame->pts + is->frame->nb_samples;
		2219
		2220	#if CONFIG_AVFILTER
		2221	dec_channel_layout = get_valid_channel_layout(is->frame->channel_layout, av_frame_get_channels(is->frame));
		2222
		2223	reconfigure =
		2224	cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
		2225	is->frame->format, av_frame_get_channels(is->frame)) \|\|
		2226	is->audio_filter_src.channel_layout != dec_channel_layout \|\|
		2227	is->audio_filter_src.freq != is->frame->sample_rate \|\|
		2228	is->audio_pkt_temp_serial != is->audio_last_serial;
		2229
		2230	if (reconfigure) {
		2231	char buf1[1024], buf2[1024];
		2232	av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
		2233	av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
		2234	av_log(NULL, AV_LOG_DEBUG,
		2235	"Audio frame changed from rate:%d ch:%d fmt:%s layout:%s serial:%d to rate:%d ch:%d fmt:%s layout:%s serial:%d\n",
		2236	is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, is->audio_last_serial,
		2237	is->frame->sample_rate, av_frame_get_channels(is->frame), av_get_sample_fmt_name(is->frame->format), buf2, is->audio_pkt_temp_serial);
		2238
		2239	is->audio_filter_src.fmt = is->frame->format;
		2240	is->audio_filter_src.channels = av_frame_get_channels(is->frame);
		2241	is->audio_filter_src.channel_layout = dec_channel_layout;
		2242	is->audio_filter_src.freq = is->frame->sample_rate;
		2243	is->audio_last_serial = is->audio_pkt_temp_serial;
		2244
		2245	if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
		2246	return ret;
		2247	}
		2248
		2249	if ((ret = av_buffersrc_add_frame(is->in_audio_filter, is->frame)) < 0)
		2250	return ret;
		2251	av_frame_unref(is->frame);
		2252	#endif
		2253	}
		2254	#if CONFIG_AVFILTER
		2255	if ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, is->frame, 0)) < 0) {
		2256	if (ret == AVERROR(EAGAIN)) {
		2257	is->audio_buf_frames_pending = 0;
		2258	continue;
		2259	}
		2260	if (ret == AVERROR_EOF)
		2261	is->audio_finished = is->audio_pkt_temp_serial;
		2262	return ret;
		2263	}
		2264	is->audio_buf_frames_pending = 1;
		2265	tb = is->out_audio_filter->inputs[0]->time_base;
		2266	#endif
		2267
		2268	data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(is->frame),
		2269	is->frame->nb_samples,
		2270	is->frame->format, 1);
		2271
		2272	dec_channel_layout =
		2273	(is->frame->channel_layout && av_frame_get_channels(is->frame) == av_get_channel_layout_nb_channels(is->frame->channel_layout)) ?
		2274	is->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(is->frame));
		2275	wanted_nb_samples = synchronize_audio(is, is->frame->nb_samples);
		2276
		2277	if (is->frame->format != is->audio_src.fmt \|\|
		2278	dec_channel_layout != is->audio_src.channel_layout \|\|
		2279	is->frame->sample_rate != is->audio_src.freq \|\|
		2280	(wanted_nb_samples != is->frame->nb_samples && !is->swr_ctx)) {
		2281	swr_free(&is->swr_ctx);
		2282	is->swr_ctx = swr_alloc_set_opts(NULL,
		2283	is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
		2284	dec_channel_layout, is->frame->format, is->frame->sample_rate,
		2285	0, NULL);
		2286	if (!is->swr_ctx \|\| swr_init(is->swr_ctx) < 0) {
		2287	av_log(NULL, AV_LOG_ERROR,
		2288	"Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
		2289	is->frame->sample_rate, av_get_sample_fmt_name(is->frame->format), av_frame_get_channels(is->frame),
		2290	is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
		2291	break;
		2292	}
		2293	is->audio_src.channel_layout = dec_channel_layout;
		2294	is->audio_src.channels = av_frame_get_channels(is->frame);
		2295	is->audio_src.freq = is->frame->sample_rate;
		2296	is->audio_src.fmt = is->frame->format;
		2297	}
		2298
		2299	if (is->swr_ctx) {
		2300	const uint8_t in = (const uint8_t )is->frame->extended_data;
		2301	uint8_t **out = &is->audio_buf1;
		2302	int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate + 256;
		2303	int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
		2304	int len2;
		2305	if (out_size < 0) {
		2306	av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
		2307	break;
		2308	}
		2309	if (wanted_nb_samples != is->frame->nb_samples) {
		2310	if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - is->frame->nb_samples) * is->audio_tgt.freq / is->frame->sample_rate,
		2311	wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate) < 0) {
		2312	av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
		2313	break;
		2314	}
		2315	}
		2316	av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
		2317	if (!is->audio_buf1)
		2318	return AVERROR(ENOMEM);
		2319	len2 = swr_convert(is->swr_ctx, out, out_count, in, is->frame->nb_samples);
		2320	if (len2 < 0) {
		2321	av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
		2322	break;
		2323	}
		2324	if (len2 == out_count) {
		2325	av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
		2326	swr_init(is->swr_ctx);
		2327	}
		2328	is->audio_buf = is->audio_buf1;
		2329	resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
		2330	} else {
		2331	is->audio_buf = is->frame->data[0];
		2332	resampled_data_size = data_size;
		2333	}
		2334
		2335	audio_clock0 = is->audio_clock;
		2336	/* update the audio clock with the pts */
		2337	if (is->frame->pts != AV_NOPTS_VALUE)
		2338	is->audio_clock = is->frame->pts * av_q2d(tb) + (double) is->frame->nb_samples / is->frame->sample_rate;
		2339	else
		2340	is->audio_clock = NAN;
		2341	is->audio_clock_serial = is->audio_pkt_temp_serial;
		2342	#ifdef DEBUG
		2343	{
		2344	static double last_clock;
		2345	printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
		2346	is->audio_clock - last_clock,
		2347	is->audio_clock, audio_clock0);
		2348	last_clock = is->audio_clock;
		2349	}
		2350	#endif
		2351	return resampled_data_size;
		2352	}
		2353
		2354	/* free the current packet */
		2355	if (pkt->data)
		2356	av_free_packet(pkt);
		2357	memset(pkt_temp, 0, sizeof(*pkt_temp));
		2358	pkt_temp->stream_index = -1;
		2359
		2360	if (is->audioq.abort_request) {
		2361	return -1;
		2362	}
		2363
		2364	if (is->audioq.nb_packets == 0)
		2365	SDL_CondSignal(is->continue_read_thread);
		2366
		2367	/* read next packet */
		2368	if ((packet_queue_get(&is->audioq, pkt, 1, &is->audio_pkt_temp_serial)) < 0)
		2369	return -1;
		2370
		2371	if (pkt->data == flush_pkt.data) {
		2372	avcodec_flush_buffers(dec);
		2373	is->audio_buf_frames_pending = 0;
		2374	is->audio_frame_next_pts = AV_NOPTS_VALUE;
		2375	if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH \| AVFMT_NOGENSEARCH \| AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek)
		2376	is->audio_frame_next_pts = is->audio_st->start_time;
		2377	}
		2378
		2379	pkt_temp = pkt;
		2380	}
		2381	}
		2382
		2383	/* prepare a new audio buffer */
		2384	static void sdl_audio_callback(void opaque, Uint8 stream, int len)
		2385	{
		2386	VideoState *is = opaque;
		2387	int audio_size, len1;
		2388	int bytes_per_sec;
		2389	int frame_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, 1, is->audio_tgt.fmt, 1);
		2390
		2391	audio_callback_time = av_gettime();
		2392
		2393	while (len > 0) {
		2394	if (is->audio_buf_index >= is->audio_buf_size) {
		2395	audio_size = audio_decode_frame(is);
		2396	if (audio_size < 0) {
		2397	/* if error, just output silence */
		2398	is->audio_buf = is->silence_buf;
		2399	is->audio_buf_size = sizeof(is->silence_buf) / frame_size * frame_size;
		2400	} else {
		2401	if (is->show_mode != SHOW_MODE_VIDEO)
		2402	update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
		2403	is->audio_buf_size = audio_size;
		2404	}
		2405	is->audio_buf_index = 0;
		2406	}
		2407	len1 = is->audio_buf_size - is->audio_buf_index;
		2408	if (len1 > len)
		2409	len1 = len;
		2410	memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
		2411	len -= len1;
		2412	stream += len1;
		2413	is->audio_buf_index += len1;
		2414	}
		2415	bytes_per_sec = is->audio_tgt.freq * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
		2416	is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
		2417	/* Let's assume the audio driver that is used by SDL has two periods. */
		2418	if (!isnan(is->audio_clock)) {
		2419	set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
		2420	sync_clock_to_slave(&is->extclk, &is->audclk);
		2421	}
		2422	}
		2423
		2424	static int audio_open(void opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams audio_hw_params)
		2425	{
		2426	SDL_AudioSpec wanted_spec, spec;
		2427	const char *env;
		2428	static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
		2429
		2430	env = SDL_getenv("SDL_AUDIO_CHANNELS");
		2431	if (env) {
		2432	wanted_nb_channels = atoi(env);
		2433	wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
		2434	}
		2435	if (!wanted_channel_layout \|\| wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
		2436	wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
		2437	wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
		2438	}
		2439	wanted_spec.channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
		2440	wanted_spec.freq = wanted_sample_rate;
		2441	if (wanted_spec.freq <= 0 \|\| wanted_spec.channels <= 0) {
		2442	av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
		2443	return -1;
		2444	}
		2445	wanted_spec.format = AUDIO_S16SYS;
		2446	wanted_spec.silence = 0;
		2447	wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
		2448	wanted_spec.callback = sdl_audio_callback;
		2449	wanted_spec.userdata = opaque;
		2450	while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
		2451	av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels): %s\n", wanted_spec.channels, SDL_GetError());
		2452	wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
		2453	if (!wanted_spec.channels) {
		2454	av_log(NULL, AV_LOG_ERROR,
		2455	"No more channel combinations to try, audio open failed\n");
		2456	return -1;
		2457	}
		2458	wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
		2459	}
		2460	if (spec.format != AUDIO_S16SYS) {
		2461	av_log(NULL, AV_LOG_ERROR,
		2462	"SDL advised audio format %d is not supported!\n", spec.format);
		2463	return -1;
		2464	}
		2465	if (spec.channels != wanted_spec.channels) {
		2466	wanted_channel_layout = av_get_default_channel_layout(spec.channels);
		2467	if (!wanted_channel_layout) {
		2468	av_log(NULL, AV_LOG_ERROR,
		2469	"SDL advised channel count %d is not supported!\n", spec.channels);
		2470	return -1;
		2471	}
		2472	}
		2473
		2474	audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
		2475	audio_hw_params->freq = spec.freq;
		2476	audio_hw_params->channel_layout = wanted_channel_layout;
		2477	audio_hw_params->channels = spec.channels;
		2478	return spec.size;
		2479	}
		2480
		2481	/* open a given stream. Return 0 if OK */
		2482	static int stream_component_open(VideoState *is, int stream_index)
		2483	{
		2484	AVFormatContext *ic = is->ic;
		2485	AVCodecContext *avctx;
		2486	AVCodec *codec;
		2487	const char *forced_codec_name = NULL;
		2488	AVDictionary *opts;
		2489	AVDictionaryEntry *t = NULL;
		2490	int sample_rate, nb_channels;
		2491	int64_t channel_layout;
		2492	int ret;
		2493	int stream_lowres = lowres;
		2494
		2495	if (stream_index < 0 \|\| stream_index >= ic->nb_streams)
		2496	return -1;
		2497	avctx = ic->streams[stream_index]->codec;
		2498
		2499	codec = avcodec_find_decoder(avctx->codec_id);
		2500
		2501	switch(avctx->codec_type){
		2502	case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
		2503	case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
		2504	case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
		2505	}
		2506	if (forced_codec_name)
		2507	codec = avcodec_find_decoder_by_name(forced_codec_name);
		2508	if (!codec) {
		2509	if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
		2510	"No codec could be found with name '%s'\n", forced_codec_name);
		2511	else av_log(NULL, AV_LOG_WARNING,
		2512	"No codec could be found with id %d\n", avctx->codec_id);
		2513	return -1;
		2514	}
		2515
		2516	avctx->codec_id = codec->id;
		2517	avctx->workaround_bugs = workaround_bugs;
		2518	if(stream_lowres > av_codec_get_max_lowres(codec)){
		2519	av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
		2520	av_codec_get_max_lowres(codec));
		2521	stream_lowres = av_codec_get_max_lowres(codec);
		2522	}
		2523	av_codec_set_lowres(avctx, stream_lowres);
		2524	avctx->error_concealment = error_concealment;
		2525
		2526	if(stream_lowres) avctx->flags \|= CODEC_FLAG_EMU_EDGE;
		2527	if (fast) avctx->flags2 \|= CODEC_FLAG2_FAST;
		2528	if(codec->capabilities & CODEC_CAP_DR1)
		2529	avctx->flags \|= CODEC_FLAG_EMU_EDGE;
		2530
		2531	opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
		2532	if (!av_dict_get(opts, "threads", NULL, 0))
		2533	av_dict_set(&opts, "threads", "auto", 0);
		2534	if (stream_lowres)
		2535	av_dict_set(&opts, "lowres", av_asprintf("%d", stream_lowres), AV_DICT_DONT_STRDUP_VAL);
		2536	if (avctx->codec_type == AVMEDIA_TYPE_VIDEO \|\| avctx->codec_type == AVMEDIA_TYPE_AUDIO)
		2537	av_dict_set(&opts, "refcounted_frames", "1", 0);
		2538	if (avcodec_open2(avctx, codec, &opts) < 0)
		2539	return -1;
		2540	if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
		2541	av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
		2542	return AVERROR_OPTION_NOT_FOUND;
		2543	}
		2544
		2545	ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
		2546	switch (avctx->codec_type) {
		2547	case AVMEDIA_TYPE_AUDIO:
		2548	#if CONFIG_AVFILTER
		2549	{
		2550	AVFilterLink *link;
		2551
		2552	is->audio_filter_src.freq = avctx->sample_rate;
		2553	is->audio_filter_src.channels = avctx->channels;
		2554	is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
		2555	is->audio_filter_src.fmt = avctx->sample_fmt;
		2556	if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
		2557	return ret;
		2558	link = is->out_audio_filter->inputs[0];
		2559	sample_rate = link->sample_rate;
		2560	nb_channels = link->channels;
		2561	channel_layout = link->channel_layout;
		2562	}
		2563	#else
		2564	sample_rate = avctx->sample_rate;
		2565	nb_channels = avctx->channels;
		2566	channel_layout = avctx->channel_layout;
		2567	#endif
		2568
		2569	/* prepare audio output */
		2570	if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
		2571	return ret;
		2572	is->audio_hw_buf_size = ret;
		2573	is->audio_src = is->audio_tgt;
		2574	is->audio_buf_size = 0;
		2575	is->audio_buf_index = 0;
		2576
		2577	/* init averaging filter */
		2578	is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
		2579	is->audio_diff_avg_count = 0;
		2580	/* since we do not have a precise anough audio fifo fullness,
		2581	we correct audio sync only if larger than this threshold */
		2582	is->audio_diff_threshold = 2.0 * is->audio_hw_buf_size / av_samples_get_buffer_size(NULL, is->audio_tgt.channels, is->audio_tgt.freq, is->audio_tgt.fmt, 1);
		2583
		2584	memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
		2585	memset(&is->audio_pkt_temp, 0, sizeof(is->audio_pkt_temp));
		2586	is->audio_pkt_temp.stream_index = -1;
		2587
		2588	is->audio_stream = stream_index;
		2589	is->audio_st = ic->streams[stream_index];
		2590
		2591	packet_queue_start(&is->audioq);
		2592	SDL_PauseAudio(0);
		2593	break;
		2594	case AVMEDIA_TYPE_VIDEO:
		2595	is->video_stream = stream_index;
		2596	is->video_st = ic->streams[stream_index];
		2597
		2598	packet_queue_start(&is->videoq);
		2599	is->video_tid = SDL_CreateThread(video_thread, is);
		2600	is->queue_attachments_req = 1;
		2601	break;
		2602	case AVMEDIA_TYPE_SUBTITLE:
		2603	is->subtitle_stream = stream_index;
		2604	is->subtitle_st = ic->streams[stream_index];
		2605	packet_queue_start(&is->subtitleq);
		2606
		2607	is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
		2608	break;
		2609	default:
		2610	break;
		2611	}
		2612	return 0;
		2613	}
		2614
		2615	static void stream_component_close(VideoState *is, int stream_index)
		2616	{
		2617	AVFormatContext *ic = is->ic;
		2618	AVCodecContext *avctx;
		2619
		2620	if (stream_index < 0 \|\| stream_index >= ic->nb_streams)
		2621	return;
		2622	avctx = ic->streams[stream_index]->codec;
		2623
		2624	switch (avctx->codec_type) {
		2625	case AVMEDIA_TYPE_AUDIO:
		2626	packet_queue_abort(&is->audioq);
		2627
		2628	SDL_CloseAudio();
		2629
		2630	packet_queue_flush(&is->audioq);
		2631	av_free_packet(&is->audio_pkt);
		2632	swr_free(&is->swr_ctx);
		2633	av_freep(&is->audio_buf1);
		2634	is->audio_buf1_size = 0;
		2635	is->audio_buf = NULL;
		2636	av_frame_free(&is->frame);
		2637
		2638	if (is->rdft) {
		2639	av_rdft_end(is->rdft);
		2640	av_freep(&is->rdft_data);
		2641	is->rdft = NULL;
		2642	is->rdft_bits = 0;
		2643	}
		2644	#if CONFIG_AVFILTER
		2645	avfilter_graph_free(&is->agraph);
		2646	#endif
		2647	break;
		2648	case AVMEDIA_TYPE_VIDEO:
		2649	packet_queue_abort(&is->videoq);
		2650
		2651	/* note: we also signal this mutex to make sure we deblock the
		2652	video thread in all cases */
		2653	SDL_LockMutex(is->pictq_mutex);
		2654	SDL_CondSignal(is->pictq_cond);
		2655	SDL_UnlockMutex(is->pictq_mutex);
		2656
		2657	SDL_WaitThread(is->video_tid, NULL);
		2658
		2659	packet_queue_flush(&is->videoq);
		2660	break;
		2661	case AVMEDIA_TYPE_SUBTITLE:
		2662	packet_queue_abort(&is->subtitleq);
		2663
		2664	/* note: we also signal this mutex to make sure we deblock the
		2665	video thread in all cases */
		2666	SDL_LockMutex(is->subpq_mutex);
		2667	SDL_CondSignal(is->subpq_cond);
		2668	SDL_UnlockMutex(is->subpq_mutex);
		2669
		2670	SDL_WaitThread(is->subtitle_tid, NULL);
		2671
		2672	packet_queue_flush(&is->subtitleq);
		2673	break;
		2674	default:
		2675	break;
		2676	}
		2677
		2678	ic->streams[stream_index]->discard = AVDISCARD_ALL;
		2679	avcodec_close(avctx);
		2680	switch (avctx->codec_type) {
		2681	case AVMEDIA_TYPE_AUDIO:
		2682	is->audio_st = NULL;
		2683	is->audio_stream = -1;
		2684	break;
		2685	case AVMEDIA_TYPE_VIDEO:
		2686	is->video_st = NULL;
		2687	is->video_stream = -1;
		2688	break;
		2689	case AVMEDIA_TYPE_SUBTITLE:
		2690	is->subtitle_st = NULL;
		2691	is->subtitle_stream = -1;
		2692	break;
		2693	default:
		2694	break;
		2695	}
		2696	}
		2697
		2698	static int decode_interrupt_cb(void *ctx)
		2699	{
		2700	VideoState *is = ctx;
		2701	return is->abort_request;
		2702	}
		2703
		2704	static int is_realtime(AVFormatContext *s)
		2705	{
		2706	if( !strcmp(s->iformat->name, "rtp")
		2707	\|\| !strcmp(s->iformat->name, "rtsp")
		2708	\|\| !strcmp(s->iformat->name, "sdp")
		2709	)
		2710	return 1;
		2711
		2712	if(s->pb && ( !strncmp(s->filename, "rtp:", 4)
		2713	\|\| !strncmp(s->filename, "udp:", 4)
		2714	)
		2715	)
		2716	return 1;
		2717	return 0;
		2718	}
		2719
		2720	/* this thread gets the stream from the disk or the network */
		2721	static int read_thread(void *arg)
		2722	{
		2723	VideoState *is = arg;
		2724	AVFormatContext *ic = NULL;
		2725	int err, i, ret;
		2726	int st_index[AVMEDIA_TYPE_NB];
		2727	AVPacket pkt1, *pkt = &pkt1;
		2728	int eof = 0;
		2729	int64_t stream_start_time;
		2730	int pkt_in_play_range = 0;
		2731	AVDictionaryEntry *t;
		2732	AVDictionary **opts;
		2733	int orig_nb_streams;
		2734	SDL_mutex *wait_mutex = SDL_CreateMutex();
		2735
		2736	memset(st_index, -1, sizeof(st_index));
		2737	is->last_video_stream = is->video_stream = -1;
		2738	is->last_audio_stream = is->audio_stream = -1;
		2739	is->last_subtitle_stream = is->subtitle_stream = -1;
		2740
		2741	ic = avformat_alloc_context();
		2742	ic->interrupt_callback.callback = decode_interrupt_cb;
		2743	ic->interrupt_callback.opaque = is;
		2744	err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
		2745	if (err < 0) {
		2746	print_error(is->filename, err);
		2747	ret = -1;
		2748	goto fail;
		2749	}
		2750	if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
		2751	av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
		2752	ret = AVERROR_OPTION_NOT_FOUND;
		2753	goto fail;
		2754	}
		2755	is->ic = ic;
		2756
		2757	if (genpts)
		2758	ic->flags \|= AVFMT_FLAG_GENPTS;
		2759
		2760	opts = setup_find_stream_info_opts(ic, codec_opts);
		2761	orig_nb_streams = ic->nb_streams;
		2762
		2763	err = avformat_find_stream_info(ic, opts);
		2764	if (err < 0) {
		2765	av_log(NULL, AV_LOG_WARNING,
		2766	"%s: could not find codec parameters\n", is->filename);
		2767	ret = -1;
		2768	goto fail;
		2769	}
		2770	for (i = 0; i < orig_nb_streams; i++)
		2771	av_dict_free(&opts[i]);
		2772	av_freep(&opts);
		2773
		2774	if (ic->pb)
		2775	ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use url_feof() to test for the end
		2776
		2777	if (seek_by_bytes < 0)
		2778	seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
		2779
		2780	is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
		2781
		2782	if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
		2783	window_title = av_asprintf("%s - %s", t->value, input_filename);
		2784
		2785	/* if seeking requested, we execute it */
		2786	if (start_time != AV_NOPTS_VALUE) {
		2787	int64_t timestamp;
		2788
		2789	timestamp = start_time;
		2790	/* add the stream start time */
		2791	if (ic->start_time != AV_NOPTS_VALUE)
		2792	timestamp += ic->start_time;
		2793	ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
		2794	if (ret < 0) {
		2795	av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
		2796	is->filename, (double)timestamp / AV_TIME_BASE);
		2797	}
		2798	}
		2799
		2800	is->realtime = is_realtime(ic);
		2801
		2802	for (i = 0; i < ic->nb_streams; i++)
		2803	ic->streams[i]->discard = AVDISCARD_ALL;
		2804	if (!video_disable)
		2805	st_index[AVMEDIA_TYPE_VIDEO] =
		2806	av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
		2807	wanted_stream[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
		2808	if (!audio_disable)
		2809	st_index[AVMEDIA_TYPE_AUDIO] =
		2810	av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
		2811	wanted_stream[AVMEDIA_TYPE_AUDIO],
		2812	st_index[AVMEDIA_TYPE_VIDEO],
		2813	NULL, 0);
		2814	if (!video_disable && !subtitle_disable)
		2815	st_index[AVMEDIA_TYPE_SUBTITLE] =
		2816	av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
		2817	wanted_stream[AVMEDIA_TYPE_SUBTITLE],
		2818	(st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
		2819	st_index[AVMEDIA_TYPE_AUDIO] :
		2820	st_index[AVMEDIA_TYPE_VIDEO]),
		2821	NULL, 0);
		2822	if (show_status) {
		2823	av_dump_format(ic, 0, is->filename, 0);
		2824	}
		2825
		2826	is->show_mode = show_mode;
		2827
		2828	/* open the streams */
		2829	if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
		2830	stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
		2831	}
		2832
		2833	ret = -1;
		2834	if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
		2835	ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
		2836	}
		2837	if (is->show_mode == SHOW_MODE_NONE)
		2838	is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
		2839
		2840	if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
		2841	stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
		2842	}
		2843
		2844	if (is->video_stream < 0 && is->audio_stream < 0) {
		2845	av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
		2846	is->filename);
		2847	ret = -1;
		2848	goto fail;
		2849	}
		2850
		2851	if (infinite_buffer < 0 && is->realtime)
		2852	infinite_buffer = 1;
		2853
		2854	for (;;) {
		2855	if (is->abort_request)
		2856	break;
		2857	if (is->paused != is->last_paused) {
		2858	is->last_paused = is->paused;
		2859	if (is->paused)
		2860	is->read_pause_return = av_read_pause(ic);
		2861	else
		2862	av_read_play(ic);
		2863	}
		2864	#if CONFIG_RTSP_DEMUXER \|\| CONFIG_MMSH_PROTOCOL
		2865	if (is->paused &&
		2866	(!strcmp(ic->iformat->name, "rtsp") \|\|
		2867	(ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
		2868	/* wait 10 ms to avoid trying to get another packet */
		2869	/* XXX: horrible */
		2870	SDL_Delay(10);
		2871	continue;
		2872	}
		2873	#endif
		2874	if (is->seek_req) {
		2875	int64_t seek_target = is->seek_pos;
		2876	int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
		2877	int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
		2878	// FIXME the +-2 is due to rounding being not done in the correct direction in generation
		2879	// of the seek_pos/seek_rel variables
		2880
		2881	ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
		2882	if (ret < 0) {
		2883	av_log(NULL, AV_LOG_ERROR,
		2884	"%s: error while seeking\n", is->ic->filename);
		2885	} else {
		2886	if (is->audio_stream >= 0) {
		2887	packet_queue_flush(&is->audioq);
		2888	packet_queue_put(&is->audioq, &flush_pkt);
		2889	}
		2890	if (is->subtitle_stream >= 0) {
		2891	packet_queue_flush(&is->subtitleq);
		2892	packet_queue_put(&is->subtitleq, &flush_pkt);
		2893	}
		2894	if (is->video_stream >= 0) {
		2895	packet_queue_flush(&is->videoq);
		2896	packet_queue_put(&is->videoq, &flush_pkt);
		2897	}
		2898	if (is->seek_flags & AVSEEK_FLAG_BYTE) {
		2899	set_clock(&is->extclk, NAN, 0);
		2900	} else {
		2901	set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
		2902	}
		2903	}
		2904	is->seek_req = 0;
		2905	is->queue_attachments_req = 1;
		2906	eof = 0;
		2907	if (is->paused)
		2908	step_to_next_frame(is);
		2909	}
		2910	if (is->queue_attachments_req) {
		2911	if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
		2912	AVPacket copy;
		2913	if ((ret = av_copy_packet(©, &is->video_st->attached_pic)) < 0)
		2914	goto fail;
		2915	packet_queue_put(&is->videoq, ©);
		2916	packet_queue_put_nullpacket(&is->videoq, is->video_stream);
		2917	}
		2918	is->queue_attachments_req = 0;
		2919	}
		2920
		2921	/* if the queue are full, no need to read more */
		2922	if (infinite_buffer<1 &&
		2923	(is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
		2924	\|\| ( (is->audioq .nb_packets > MIN_FRAMES \|\| is->audio_stream < 0 \|\| is->audioq.abort_request)
		2925	&& (is->videoq .nb_packets > MIN_FRAMES \|\| is->video_stream < 0 \|\| is->videoq.abort_request
		2926	\|\| (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))
		2927	&& (is->subtitleq.nb_packets > MIN_FRAMES \|\| is->subtitle_stream < 0 \|\| is->subtitleq.abort_request)))) {
		2928	/* wait 10 ms */
		2929	SDL_LockMutex(wait_mutex);
		2930	SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
		2931	SDL_UnlockMutex(wait_mutex);
		2932	continue;
		2933	}
		2934	if (!is->paused &&
		2935	(!is->audio_st \|\| is->audio_finished == is->audioq.serial) &&
		2936	(!is->video_st \|\| (is->video_finished == is->videoq.serial && is->pictq_size == 0))) {
		2937	if (loop != 1 && (!loop \|\| --loop)) {
		2938	stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
		2939	} else if (autoexit) {
		2940	ret = AVERROR_EOF;
		2941	goto fail;
		2942	}
		2943	}
		2944	if (eof) {
		2945	if (is->video_stream >= 0)
		2946	packet_queue_put_nullpacket(&is->videoq, is->video_stream);
		2947	if (is->audio_stream >= 0)
		2948	packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
		2949	SDL_Delay(10);
		2950	eof=0;
		2951	continue;
		2952	}
		2953	ret = av_read_frame(ic, pkt);
		2954	if (ret < 0) {
		2955	if (ret == AVERROR_EOF \|\| url_feof(ic->pb))
		2956	eof = 1;
		2957	if (ic->pb && ic->pb->error)
		2958	break;
		2959	SDL_LockMutex(wait_mutex);
		2960	SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
		2961	SDL_UnlockMutex(wait_mutex);
		2962	continue;
		2963	}
		2964	/* check if packet is in play range specified by user, then queue, otherwise discard */
		2965	stream_start_time = ic->streams[pkt->stream_index]->start_time;
		2966	pkt_in_play_range = duration == AV_NOPTS_VALUE \|\|
		2967	(pkt->pts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
		2968	av_q2d(ic->streams[pkt->stream_index]->time_base) -
		2969	(double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
		2970	<= ((double)duration / 1000000);
		2971	if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
		2972	packet_queue_put(&is->audioq, pkt);
		2973	} else if (pkt->stream_index == is->video_stream && pkt_in_play_range
		2974	&& !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
		2975	packet_queue_put(&is->videoq, pkt);
		2976	} else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
		2977	packet_queue_put(&is->subtitleq, pkt);
		2978	} else {
		2979	av_free_packet(pkt);
		2980	}
		2981	}
		2982	/* wait until the end */
		2983	while (!is->abort_request) {
		2984	SDL_Delay(100);
		2985	}
		2986
		2987	ret = 0;
		2988	fail:
		2989	/* close each stream */
		2990	if (is->audio_stream >= 0)
		2991	stream_component_close(is, is->audio_stream);
		2992	if (is->video_stream >= 0)
		2993	stream_component_close(is, is->video_stream);
		2994	if (is->subtitle_stream >= 0)
		2995	stream_component_close(is, is->subtitle_stream);
		2996	if (is->ic) {
		2997	avformat_close_input(&is->ic);
		2998	}
		2999
		3000	if (ret != 0) {
		3001	SDL_Event event;
		3002
		3003	event.type = FF_QUIT_EVENT;
		3004	event.user.data1 = is;
		3005	SDL_PushEvent(&event);
		3006	}
		3007	SDL_DestroyMutex(wait_mutex);
		3008	return 0;
		3009	}
		3010
		3011	static VideoState stream_open(const char filename, AVInputFormat *iformat)
		3012	{
		3013	VideoState *is;
		3014
		3015	is = av_mallocz(sizeof(VideoState));
		3016	if (!is)
		3017	return NULL;
		3018	av_strlcpy(is->filename, filename, sizeof(is->filename));
		3019	is->iformat = iformat;
		3020	is->ytop = 0;
		3021	is->xleft = 0;
		3022
		3023	/* start video display */
		3024	is->pictq_mutex = SDL_CreateMutex();
		3025	is->pictq_cond = SDL_CreateCond();
		3026
		3027	is->subpq_mutex = SDL_CreateMutex();
		3028	is->subpq_cond = SDL_CreateCond();
		3029
		3030	packet_queue_init(&is->videoq);
		3031	packet_queue_init(&is->audioq);
		3032	packet_queue_init(&is->subtitleq);
		3033
		3034	is->continue_read_thread = SDL_CreateCond();
		3035
		3036	init_clock(&is->vidclk, &is->videoq.serial);
		3037	init_clock(&is->audclk, &is->audioq.serial);
		3038	init_clock(&is->extclk, &is->extclk.serial);
		3039	is->audio_clock_serial = -1;
		3040	is->audio_last_serial = -1;
		3041	is->av_sync_type = av_sync_type;
		3042	is->read_tid = SDL_CreateThread(read_thread, is);
		3043	if (!is->read_tid) {
		3044	av_free(is);
		3045	return NULL;
		3046	}
		3047	return is;
		3048	}
		3049
		3050	static void stream_cycle_channel(VideoState *is, int codec_type)
		3051	{
		3052	AVFormatContext *ic = is->ic;
		3053	int start_index, stream_index;
		3054	int old_index;
		3055	AVStream *st;
		3056	AVProgram *p = NULL;
		3057	int nb_streams = is->ic->nb_streams;
		3058
		3059	if (codec_type == AVMEDIA_TYPE_VIDEO) {
		3060	start_index = is->last_video_stream;
		3061	old_index = is->video_stream;
		3062	} else if (codec_type == AVMEDIA_TYPE_AUDIO) {
		3063	start_index = is->last_audio_stream;
		3064	old_index = is->audio_stream;
		3065	} else {
		3066	start_index = is->last_subtitle_stream;
		3067	old_index = is->subtitle_stream;
		3068	}
		3069	stream_index = start_index;
		3070
		3071	if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
		3072	p = av_find_program_from_stream(ic, NULL, is->video_stream);
		3073	if (p) {
		3074	nb_streams = p->nb_stream_indexes;
		3075	for (start_index = 0; start_index < nb_streams; start_index++)
		3076	if (p->stream_index[start_index] == stream_index)
		3077	break;
		3078	if (start_index == nb_streams)
		3079	start_index = -1;
		3080	stream_index = start_index;
		3081	}
		3082	}
		3083
		3084	for (;;) {
		3085	if (++stream_index >= nb_streams)
		3086	{
		3087	if (codec_type == AVMEDIA_TYPE_SUBTITLE)
		3088	{
		3089	stream_index = -1;
		3090	is->last_subtitle_stream = -1;
		3091	goto the_end;
		3092	}
		3093	if (start_index == -1)
		3094	return;
		3095	stream_index = 0;
		3096	}
		3097	if (stream_index == start_index)
		3098	return;
		3099	st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
		3100	if (st->codec->codec_type == codec_type) {
		3101	/* check that parameters are OK */
		3102	switch (codec_type) {
		3103	case AVMEDIA_TYPE_AUDIO:
		3104	if (st->codec->sample_rate != 0 &&
		3105	st->codec->channels != 0)
		3106	goto the_end;
		3107	break;
		3108	case AVMEDIA_TYPE_VIDEO:
		3109	case AVMEDIA_TYPE_SUBTITLE:
		3110	goto the_end;
		3111	default:
		3112	break;
		3113	}
		3114	}
		3115	}
		3116	the_end:
		3117	if (p && stream_index != -1)
		3118	stream_index = p->stream_index[stream_index];
		3119	stream_component_close(is, old_index);
		3120	stream_component_open(is, stream_index);
		3121	}
		3122
		3123
		3124	static void toggle_full_screen(VideoState *is)
		3125	{
		3126	#if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
		3127	/* OS X needs to reallocate the SDL overlays */
		3128	int i;
		3129	for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
		3130	is->pictq[i].reallocate = 1;
		3131	#endif
		3132	is_full_screen = !is_full_screen;
		3133	video_open(is, 1, NULL);
		3134	}
		3135
		3136	static void toggle_audio_display(VideoState *is)
		3137	{
		3138	int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
		3139	int next = is->show_mode;
		3140	do {
		3141	next = (next + 1) % SHOW_MODE_NB;
		3142	} while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st \|\| next != SHOW_MODE_VIDEO && !is->audio_st));
		3143	if (is->show_mode != next) {
		3144	fill_rectangle(screen,
		3145	is->xleft, is->ytop, is->width, is->height,
		3146	bgcolor, 1);
		3147	is->force_refresh = 1;
		3148	is->show_mode = next;
		3149	}
		3150	}
		3151
		3152	static void refresh_loop_wait_event(VideoState is, SDL_Event event) {
		3153	double remaining_time = 0.0;
		3154	SDL_PumpEvents();
		3155	while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
		3156	if (!cursor_hidden && av_gettime() - cursor_last_shown > CURSOR_HIDE_DELAY) {
		3157	SDL_ShowCursor(0);
		3158	cursor_hidden = 1;
		3159	}
		3160	if (remaining_time > 0.0)
		3161	av_usleep((int64_t)(remaining_time * 1000000.0));
		3162	remaining_time = REFRESH_RATE;
		3163	if (is->show_mode != SHOW_MODE_NONE && (!is->paused \|\| is->force_refresh))
		3164	video_refresh(is, &remaining_time);
		3165	SDL_PumpEvents();
		3166	}
		3167	}
		3168
		3169	/* handle an event sent by the GUI */
		3170	static void event_loop(VideoState *cur_stream)
		3171	{
		3172	SDL_Event event;
		3173	double incr, pos, frac;
		3174
		3175	for (;;) {
		3176	double x;
		3177	refresh_loop_wait_event(cur_stream, &event);
		3178	switch (event.type) {
		3179	case SDL_KEYDOWN:
		3180	if (exit_on_keydown) {
		3181	do_exit(cur_stream);
		3182	break;
		3183	}
		3184	switch (event.key.keysym.sym) {
		3185	case SDLK_ESCAPE:
		3186	case SDLK_q:
		3187	do_exit(cur_stream);
		3188	break;
		3189	case SDLK_f:
		3190	toggle_full_screen(cur_stream);
		3191	cur_stream->force_refresh = 1;
		3192	break;
		3193	case SDLK_p:
		3194	case SDLK_SPACE:
		3195	toggle_pause(cur_stream);
		3196	break;
		3197	case SDLK_s: // S: Step to next frame
		3198	step_to_next_frame(cur_stream);
		3199	break;
		3200	case SDLK_a:
		3201	stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
		3202	break;
		3203	case SDLK_v:
		3204	stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
		3205	break;
		3206	case SDLK_c:
		3207	stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
		3208	stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
		3209	stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
		3210	break;
		3211	case SDLK_t:
		3212	stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
		3213	break;
		3214	case SDLK_w:
		3215	toggle_audio_display(cur_stream);
		3216	break;
		3217	case SDLK_PAGEUP:
		3218	incr = 600.0;
		3219	goto do_seek;
		3220	case SDLK_PAGEDOWN:
		3221	incr = -600.0;
		3222	goto do_seek;
		3223	case SDLK_LEFT:
		3224	incr = -10.0;
		3225	goto do_seek;
		3226	case SDLK_RIGHT:
		3227	incr = 10.0;
		3228	goto do_seek;
		3229	case SDLK_UP:
		3230	incr = 60.0;
		3231	goto do_seek;
		3232	case SDLK_DOWN:
		3233	incr = -60.0;
		3234	do_seek:
		3235	if (seek_by_bytes) {
		3236	if (cur_stream->video_stream >= 0 && cur_stream->video_current_pos >= 0) {
		3237	pos = cur_stream->video_current_pos;
		3238	} else if (cur_stream->audio_stream >= 0 && cur_stream->audio_pkt.pos >= 0) {
		3239	pos = cur_stream->audio_pkt.pos;
		3240	} else
		3241	pos = avio_tell(cur_stream->ic->pb);
		3242	if (cur_stream->ic->bit_rate)
		3243	incr *= cur_stream->ic->bit_rate / 8.0;
		3244	else
		3245	incr *= 180000.0;
		3246	pos += incr;
		3247	stream_seek(cur_stream, pos, incr, 1);
		3248	} else {
		3249	pos = get_master_clock(cur_stream);
		3250	if (isnan(pos))
		3251	pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
		3252	pos += incr;
		3253	if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
		3254	pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
		3255	stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
		3256	}
		3257	break;
		3258	default:
		3259	break;
		3260	}
		3261	break;
		3262	case SDL_VIDEOEXPOSE:
		3263	cur_stream->force_refresh = 1;
		3264	break;
		3265	case SDL_MOUSEBUTTONDOWN:
		3266	if (exit_on_mousedown) {
		3267	do_exit(cur_stream);
		3268	break;
		3269	}
		3270	case SDL_MOUSEMOTION:
		3271	if (cursor_hidden) {
		3272	SDL_ShowCursor(1);
		3273	cursor_hidden = 0;
		3274	}
		3275	cursor_last_shown = av_gettime();
		3276	if (event.type == SDL_MOUSEBUTTONDOWN) {
		3277	x = event.button.x;
		3278	} else {
		3279	if (event.motion.state != SDL_PRESSED)
		3280	break;
		3281	x = event.motion.x;
		3282	}
		3283	if (seek_by_bytes \|\| cur_stream->ic->duration <= 0) {
		3284	uint64_t size = avio_size(cur_stream->ic->pb);
		3285	stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
		3286	} else {
		3287	int64_t ts;
		3288	int ns, hh, mm, ss;
		3289	int tns, thh, tmm, tss;
		3290	tns = cur_stream->ic->duration / 1000000LL;
		3291	thh = tns / 3600;
		3292	tmm = (tns % 3600) / 60;
		3293	tss = (tns % 60);
		3294	frac = x / cur_stream->width;
		3295	ns = frac * tns;
		3296	hh = ns / 3600;
		3297	mm = (ns % 3600) / 60;
		3298	ss = (ns % 60);
		3299	av_log(NULL, AV_LOG_INFO,
		3300	"Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
		3301	hh, mm, ss, thh, tmm, tss);
		3302	ts = frac * cur_stream->ic->duration;
		3303	if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
		3304	ts += cur_stream->ic->start_time;
		3305	stream_seek(cur_stream, ts, 0, 0);
		3306	}
		3307	break;
		3308	case SDL_VIDEORESIZE:
		3309	screen = SDL_SetVideoMode(FFMIN(16383, event.resize.w), event.resize.h, 0,
		3310	SDL_HWSURFACE\|SDL_RESIZABLE\|SDL_ASYNCBLIT\|SDL_HWACCEL);
		3311	if (!screen) {
		3312	av_log(NULL, AV_LOG_FATAL, "Failed to set video mode\n");
		3313	do_exit(cur_stream);
		3314	}
		3315	screen_width = cur_stream->width = screen->w;
		3316	screen_height = cur_stream->height = screen->h;
		3317	cur_stream->force_refresh = 1;
		3318	break;
		3319	case SDL_QUIT:
		3320	case FF_QUIT_EVENT:
		3321	do_exit(cur_stream);
		3322	break;
		3323	case FF_ALLOC_EVENT:
		3324	alloc_picture(event.user.data1);
		3325	break;
		3326	default:
		3327	break;
		3328	}
		3329	}
		3330	}
		3331
		3332	static int opt_frame_size(void optctx, const char opt, const char *arg)
		3333	{
		3334	av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
		3335	return opt_default(NULL, "video_size", arg);
		3336	}
		3337
		3338	static int opt_width(void optctx, const char opt, const char *arg)
		3339	{
		3340	screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
		3341	return 0;
		3342	}
		3343
		3344	static int opt_height(void optctx, const char opt, const char *arg)
		3345	{
		3346	screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
		3347	return 0;
		3348	}
		3349
		3350	static int opt_format(void optctx, const char opt, const char *arg)
		3351	{
		3352	file_iformat = av_find_input_format(arg);
		3353	if (!file_iformat) {
		3354	av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
		3355	return AVERROR(EINVAL);
		3356	}
		3357	return 0;
		3358	}
		3359
		3360	static int opt_frame_pix_fmt(void optctx, const char opt, const char *arg)
		3361	{
		3362	av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
		3363	return opt_default(NULL, "pixel_format", arg);
		3364	}
		3365
		3366	static int opt_sync(void optctx, const char opt, const char *arg)
		3367	{
		3368	if (!strcmp(arg, "audio"))
		3369	av_sync_type = AV_SYNC_AUDIO_MASTER;
		3370	else if (!strcmp(arg, "video"))
		3371	av_sync_type = AV_SYNC_VIDEO_MASTER;
		3372	else if (!strcmp(arg, "ext"))
		3373	av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
		3374	else {
		3375	av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
		3376	exit(1);
		3377	}
		3378	return 0;
		3379	}
		3380
		3381	static int opt_seek(void optctx, const char opt, const char *arg)
		3382	{
		3383	start_time = parse_time_or_die(opt, arg, 1);
		3384	return 0;
		3385	}
		3386
		3387	static int opt_duration(void optctx, const char opt, const char *arg)
		3388	{
		3389	duration = parse_time_or_die(opt, arg, 1);
		3390	return 0;
		3391	}
		3392
		3393	static int opt_show_mode(void optctx, const char opt, const char *arg)
		3394	{
		3395	show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
		3396	!strcmp(arg, "waves") ? SHOW_MODE_WAVES :
		3397	!strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
		3398	parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
		3399	return 0;
		3400	}
		3401
		3402	static void opt_input_file(void optctx, const char filename)
		3403	{
		3404	if (input_filename) {
		3405	av_log(NULL, AV_LOG_FATAL,
		3406	"Argument '%s' provided as input filename, but '%s' was already specified.\n",
		3407	filename, input_filename);
		3408	exit(1);
		3409	}
		3410	if (!strcmp(filename, "-"))
		3411	filename = "pipe:";
		3412	input_filename = filename;
		3413	}
		3414
		3415	static int opt_codec(void optctx, const char opt, const char *arg)
		3416	{
		3417	const char *spec = strchr(opt, ':');
		3418	if (!spec) {
		3419	av_log(NULL, AV_LOG_ERROR,
		3420	"No media specifier was specified in '%s' in option '%s'\n",
		3421	arg, opt);
		3422	return AVERROR(EINVAL);
		3423	}
		3424	spec++;
		3425	switch (spec[0]) {
		3426	case 'a' : audio_codec_name = arg; break;
		3427	case 's' : subtitle_codec_name = arg; break;
		3428	case 'v' : video_codec_name = arg; break;
		3429	default:
		3430	av_log(NULL, AV_LOG_ERROR,
		3431	"Invalid media specifier '%s' in option '%s'\n", spec, opt);
		3432	return AVERROR(EINVAL);
		3433	}
		3434	return 0;
		3435	}
		3436
		3437	static int dummy;
		3438
		3439	static const OptionDef options[] = {
		3440	#include "cmdutils_common_opts.h"
		3441	{ "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
		3442	{ "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
		3443	{ "s", HAS_ARG \| OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
		3444	{ "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
		3445	{ "an", OPT_BOOL, { &audio_disable }, "disable audio" },
		3446	{ "vn", OPT_BOOL, { &video_disable }, "disable video" },
		3447	{ "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
		3448	{ "ast", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_number" },
		3449	{ "vst", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_number" },
		3450	{ "sst", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_number" },
		3451	{ "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
		3452	{ "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
		3453	{ "bytes", OPT_INT \| HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
		3454	{ "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
		3455	{ "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
		3456	{ "pix_fmt", HAS_ARG \| OPT_EXPERT \| OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
		3457	{ "stats", OPT_BOOL \| OPT_EXPERT, { &show_status }, "show status", "" },
		3458	{ "bug", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &workaround_bugs }, "workaround bugs", "" },
		3459	{ "fast", OPT_BOOL \| OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
		3460	{ "genpts", OPT_BOOL \| OPT_EXPERT, { &genpts }, "generate pts", "" },
		3461	{ "drp", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
		3462	{ "lowres", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &lowres }, "", "" },
		3463	{ "ec", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &error_concealment }, "set error concealment options", "bit_mask" },
		3464	{ "sync", HAS_ARG \| OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
		3465	{ "autoexit", OPT_BOOL \| OPT_EXPERT, { &autoexit }, "exit at the end", "" },
		3466	{ "exitonkeydown", OPT_BOOL \| OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
		3467	{ "exitonmousedown", OPT_BOOL \| OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
		3468	{ "loop", OPT_INT \| HAS_ARG \| OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
		3469	{ "framedrop", OPT_BOOL \| OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
		3470	{ "infbuf", OPT_BOOL \| OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
		3471	{ "window_title", OPT_STRING \| HAS_ARG, { &window_title }, "set window title", "window title" },
		3472	#if CONFIG_AVFILTER
		3473	{ "vf", OPT_STRING \| HAS_ARG, { &vfilters }, "set video filters", "filter_graph" },
		3474	{ "af", OPT_STRING \| HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
		3475	#endif
		3476	{ "rdftspeed", OPT_INT \| HAS_ARG\| OPT_AUDIO \| OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
		3477	{ "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
		3478	{ "default", HAS_ARG \| OPT_AUDIO \| OPT_VIDEO \| OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
		3479	{ "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
		3480	{ "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
		3481	{ "acodec", HAS_ARG \| OPT_STRING \| OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
		3482	{ "scodec", HAS_ARG \| OPT_STRING \| OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
		3483	{ "vcodec", HAS_ARG \| OPT_STRING \| OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
		3484	{ NULL, },
		3485	};
		3486
		3487	static void show_usage(void)
		3488	{
		3489	av_log(NULL, AV_LOG_INFO, "Simple media player\n");
		3490	av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
		3491	av_log(NULL, AV_LOG_INFO, "\n");
		3492	}
		3493
		3494	void show_help_default(const char opt, const char arg)
		3495	{
		3496	av_log_set_callback(log_callback_help);
		3497	show_usage();
		3498	show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
		3499	show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
		3500	printf("\n");
		3501	show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
		3502	show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
		3503	#if !CONFIG_AVFILTER
		3504	show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
		3505	#else
		3506	show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
		3507	#endif
		3508	printf("\nWhile playing:\n"
		3509	"q, ESC quit\n"
		3510	"f toggle full screen\n"
		3511	"p, SPC pause\n"
		3512	"a cycle audio channel in the current program\n"
		3513	"v cycle video channel\n"
		3514	"t cycle subtitle channel in the current program\n"
		3515	"c cycle program\n"
		3516	"w show audio waves\n"
		3517	"s activate frame-step mode\n"
		3518	"left/right seek backward/forward 10 seconds\n"
		3519	"down/up seek backward/forward 1 minute\n"
		3520	"page down/page up seek backward/forward 10 minutes\n"
		3521	"mouse click seek to percentage in file corresponding to fraction of width\n"
		3522	);
		3523	}
		3524
		3525	static int lockmgr(void **mtx, enum AVLockOp op)
		3526	{
		3527	switch(op) {
		3528	case AV_LOCK_CREATE:
		3529	*mtx = SDL_CreateMutex();
		3530	if(!*mtx)
		3531	return 1;
		3532	return 0;
		3533	case AV_LOCK_OBTAIN:
		3534	return !!SDL_LockMutex(*mtx);
		3535	case AV_LOCK_RELEASE:
		3536	return !!SDL_UnlockMutex(*mtx);
		3537	case AV_LOCK_DESTROY:
		3538	SDL_DestroyMutex(*mtx);
		3539	return 0;
		3540	}
		3541	return 1;
		3542	}
		3543
		3544	/* Called from the main */
		3545	int main(int argc, char **argv)
		3546	{
		3547	int flags;
		3548	VideoState *is;
		3549	char dummy_videodriver[] = "SDL_VIDEODRIVER=dummy";
		3550
		3551	av_log_set_flags(AV_LOG_SKIP_REPEATED);
		3552	parse_loglevel(argc, argv, options);
		3553
		3554	/* register all codecs, demux and protocols */
		3555	avcodec_register_all();
		3556	#if CONFIG_AVDEVICE
		3557	avdevice_register_all();
		3558	#endif
		3559	#if CONFIG_AVFILTER
		3560	avfilter_register_all();
		3561	#endif
		3562	av_register_all();
		3563	avformat_network_init();
		3564
		3565	init_opts();
		3566
		3567	signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
		3568	signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
		3569
		3570	show_banner(argc, argv, options);
		3571
		3572	parse_options(NULL, argc, argv, options, opt_input_file);
		3573
		3574	if (!input_filename) {
		3575	show_usage();
		3576	av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
		3577	av_log(NULL, AV_LOG_FATAL,
		3578	"Use -h to get full help or, even better, run 'man %s'\n", program_name);
		3579	exit(1);
		3580	}
		3581
		3582	if (display_disable) {
		3583	video_disable = 1;
		3584	}
		3585	flags = SDL_INIT_VIDEO \| SDL_INIT_AUDIO \| SDL_INIT_TIMER;
		3586	if (audio_disable)
		3587	flags &= ~SDL_INIT_AUDIO;
		3588	if (display_disable)
		3589	SDL_putenv(dummy_videodriver); /* For the event queue, we always need a video driver. */
		3590	#if !defined(__MINGW32__) && !defined(__APPLE__)
		3591	flags \|= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
		3592	#endif
		3593	if (SDL_Init (flags)) {
		3594	av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
		3595	av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
		3596	exit(1);
		3597	}
		3598
		3599	if (!display_disable) {
		3600	const SDL_VideoInfo *vi = SDL_GetVideoInfo();
		3601	fs_screen_width = vi->current_w;
		3602	fs_screen_height = vi->current_h;
		3603	}
		3604
		3605	SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
		3606	SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
		3607	SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
		3608
		3609	if (av_lockmgr_register(lockmgr)) {
		3610	av_log(NULL, AV_LOG_FATAL, "Could not initialize lock manager!\n");
		3611	do_exit(NULL);
		3612	}
		3613
		3614	av_init_packet(&flush_pkt);
		3615	flush_pkt.data = (uint8_t *)&flush_pkt;
		3616
		3617	is = stream_open(input_filename, file_iformat);
		3618	if (!is) {
		3619	av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
		3620	do_exit(NULL);
		3621	}
		3622
		3623	event_loop(is);
		3624
		3625	/* never returns */
		3626
		3627	return 0;
		3628	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffplay.c @ 4874 – Rev 4349