path: root/ffplay.c (plain)
blob: cf138dc51513eaba4f8392ba3e2288e4ddb64c14

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