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

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

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffmpeg-2.8/ffplay.c – Rev 6147