libffplay.c

/*
 * Copyright (c) 2003 Fabrice Bellard
 * Copyright (c) 2014 Vasily Khoruzhick <anarsoul@gmail.com>
 *
 * This file is part of libffplay.
 *
 * libffplay is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * libffplay is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with libffplay; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <assert.h>
#include <inttypes.h>
#include <limits.h>
#include <math.h>
#include <pthread.h>
#include <signal.h>
#include <stdint.h>
#include <sys/time.h>

#include <libavutil/avstring.h>
#include <libavutil/mathematics.h>
#include <libavutil/pixdesc.h>
#include <libavutil/imgutils.h>
#include <libavutil/dict.h>
#include <libavutil/parseutils.h>
#include <libavutil/samplefmt.h>
#include <libavutil/avassert.h>
#include <libavutil/time.h>
#include <libavformat/avformat.h>
#include <libavdevice/avdevice.h>
#include <libswscale/swscale.h>
#include <libavutil/opt.h>
#include <libavcodec/avfft.h>
#include <libswresample/swresample.h>

#include <libavfilter/avcodec.h>
#include <libavfilter/avfilter.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>

#include "libffplay.h"

#define MAX_QUEUE_SIZE (15 * 1024 * 1024)
#define MIN_FRAMES 5

#define AUDIO_BUFFER_SIZE 1024

/* no AV sync correction is done if below the minimum AV sync threshold */
#define AV_SYNC_THRESHOLD_MIN 0.01
/* AV sync correction is done if above the maximum AV sync threshold */
#define AV_SYNC_THRESHOLD_MAX 0.1
/* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
#define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
/* no AV correction is done if too big error */
#define AV_NOSYNC_THRESHOLD 10.0

/* maximum audio speed change to get correct sync */
#define SAMPLE_CORRECTION_PERCENT_MAX 10

/* external clock speed adjustment constants for realtime sources based on buffer fullness */
#define EXTERNAL_CLOCK_SPEED_MIN  0.900
#define EXTERNAL_CLOCK_SPEED_MAX  1.010
#define EXTERNAL_CLOCK_SPEED_STEP 0.001

/* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
#define AUDIO_DIFF_AVG_NB   20

/* polls for possible required screen refresh at least this often, should be less than 1/fps */
#define REFRESH_RATE 0.01

/* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
/* TODO: We assume that a decoded and resampled frame fits into this buffer */
#define SAMPLE_ARRAY_SIZE (8 * 65536)

#define CURSOR_HIDE_DELAY 1000000

static int64_t sws_flags = SWS_FAST_BILINEAR;

typedef struct MyAVPacketList {
	AVPacket pkt;
	struct MyAVPacketList *next;
	int serial;
} MyAVPacketList;

typedef struct PacketQueue {
	MyAVPacketList *first_pkt, *last_pkt;
	int nb_packets;
	int size;
	int abort_request;
	int serial;
	pthread_mutex_t mutex;
	pthread_cond_t cond;
} PacketQueue;

#define VIDEO_PICTURE_QUEUE_SIZE 3
#define SUBPICTURE_QUEUE_SIZE 4

#if 0
typedef struct VideoPicture {
	double pts;		/* presentation timestamp for this picture */
	double duration;	/* estimated duration based on frame rate */
	int64_t pos;		/* byte position in file */
	void *bmp;
	int width, height;	/* source height & width */
	int allocated;
	int reallocate;
	int serial;

	AVRational sar;
} VideoPicture;
#endif

typedef struct SubPicture {
	double pts;		/* presentation time stamp for this picture */
	AVSubtitle sub;
	int serial;
} SubPicture;

typedef struct AudioParams {
	int freq;
	int channels;
	int64_t channel_layout;
	enum AVSampleFormat fmt;
	int frame_size;
	int bytes_per_sec;
} AudioParams;

typedef struct Clock {
	double pts;		/* clock base */
	double pts_drift;	/* clock base minus time at which we updated the clock */
	double last_updated;
	double speed;
	int serial;		/* clock is based on a packet with this serial */
	int paused;
	int *queue_serial;	/* pointer to the current packet queue serial, used for obsolete clock detection */
} Clock;

enum {
	AV_SYNC_AUDIO_MASTER,	/* default choice */
	AV_SYNC_VIDEO_MASTER,
	AV_SYNC_EXTERNAL_CLOCK,	/* synchronize to an external clock */
};

typedef struct VideoState {
	pthread_t read_tid;
	pthread_cond_t read_trigger_cond;
	pthread_mutex_t read_trigger_mutex;
	pthread_cond_t container_parsed_cond;
	pthread_mutex_t container_parsed_mutex;
	int container_parsed;
	int read_triggered;
	pthread_t video_tid;
	AVInputFormat *iformat;
	int no_background;
	int abort_request;
	int force_refresh;
	int paused;
	int last_paused;
	int eof_event_sent;
	int queue_attachments_req;
	int seek_req;
	int seek_flags;
	int64_t seek_pos;
	int64_t seek_rel;
	int read_pause_return;
	AVFormatContext *ic;
	int realtime;
	int audio_finished;
	int video_finished;

	Clock audclk;
	Clock vidclk;
	Clock extclk;

	int audio_stream;

	int av_sync_type;

	double audio_clock;
	int audio_clock_serial;
	double audio_diff_cum;	/* used for AV difference average computation */
	double audio_diff_avg_coef;
	double audio_diff_threshold;
	int audio_diff_avg_count;
	AVStream *audio_st;
	PacketQueue audioq;
	int audio_hw_buf_size;
	uint8_t silence_buf[AUDIO_BUFFER_SIZE];
	uint8_t *audio_buf;
	uint8_t *audio_buf1;
	unsigned int audio_buf_size;	/* in bytes */
	unsigned int audio_buf1_size;
	int audio_buf_index;	/* in bytes */
	int audio_write_buf_size;
	int audio_buf_frames_pending;
	AVPacket audio_pkt_temp;
	AVPacket audio_pkt;
	int audio_pkt_temp_serial;
	int audio_last_serial;
	struct AudioParams audio_src;
	struct AudioParams audio_filter_src;
	struct AudioParams audio_tgt;
	struct SwrContext *swr_ctx;
	int frame_drops_early;
	int frame_drops_late;
	AVFrame *frame;
	int64_t audio_frame_next_pts;

	enum ShowMode {
		SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO =
		    0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
	} show_mode;
	int16_t sample_array[SAMPLE_ARRAY_SIZE];
	int sample_array_index;
	int last_i_start;
	RDFTContext *rdft;
	int rdft_bits;
	FFTSample *rdft_data;
	int xpos;
	double last_vis_time;

	pthread_t subtitle_tid;
	int subtitle_stream;
	AVStream *subtitle_st;
	PacketQueue subtitleq;
	SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
	int subpq_size, subpq_rindex, subpq_windex;
	pthread_mutex_t subpq_mutex;
	pthread_cond_t subpq_cond;

	double frame_timer;
	double frame_last_returned_time;
	double frame_last_filter_delay;
	int video_stream;
	AVStream *video_st;
	PacketQueue videoq;
	int64_t video_current_pos;	// current displayed file pos
	double max_frame_duration;	// maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
	libffplay_picture_t pictq[VIDEO_PICTURE_QUEUE_SIZE];
	int pictq_size, pictq_rindex, pictq_windex;
	pthread_mutex_t pictq_mutex;
	pthread_cond_t pictq_cond;
	struct SwsContext *img_convert_ctx;
	libffplay_rect_t last_display_rect;

	char filename[1024];
	int width, height, xleft, ytop;
	int step;

#if 0
	AVFilterContext *in_video_filter;	// the first filter in the video chain
	AVFilterContext *out_video_filter;	// the last filter in the video chain
#endif
	AVFilterContext *in_audio_filter;	// the first filter in the audio chain
	AVFilterContext *out_audio_filter;	// the last filter in the audio chain
	AVFilterGraph *agraph;	// audio filter graph

	int last_video_stream, last_audio_stream, last_subtitle_stream;

	pthread_cond_t continue_read_thread;

	libffplay_audiomgr_t *audiomgr;
	libffplay_videomgr_t *videomgr;
	libffplay_eventmgr_t *eventmgr;
} VideoState;

struct libffplay_ctx {
	struct VideoState is;
};

/* options specified by the user */
static AVInputFormat *file_iformat;
#if 0
static int fs_screen_width;
static int fs_screen_height;
static int default_width = 640;
static int default_height = 480;
static int screen_width = 0;
static int screen_height = 0;
#endif
static int audio_disable;
static int video_disable;
static int subtitle_disable;
static int wanted_stream[AVMEDIA_TYPE_NB] = {
	[AVMEDIA_TYPE_AUDIO] = -1,
	[AVMEDIA_TYPE_VIDEO] = -1,
	[AVMEDIA_TYPE_SUBTITLE] = -1,
};

static int seek_by_bytes = -1;
static int display_disable;
static int show_status = 0;
static int av_sync_type = AV_SYNC_AUDIO_MASTER;
static int64_t start_time = AV_NOPTS_VALUE;
static int64_t duration = AV_NOPTS_VALUE;
static int workaround_bugs = 1;
static int fast = 0;
static int genpts = 0;
static int lowres = 0;
static int error_concealment = 3;
static int decoder_reorder_pts = -1;
static int autoexit;
#if 0
static int exit_on_keydown;
static int exit_on_mousedown;
#endif
static int loop = 1;
static int framedrop = -1;
static int infinite_buffer = -1;
static enum ShowMode show_mode = SHOW_MODE_NONE;
static const char *audio_codec_name;
static const char *subtitle_codec_name;
static const char *video_codec_name;
double rdftspeed = 0.02;
#if 0
static int64_t cursor_last_shown;
static int cursor_hidden = 0;
#endif
static char *vfilters = NULL;
static char *afilters = NULL;

/* current context */
#if 0
static int is_full_screen;
#endif
static int64_t audio_callback_time;

static AVPacket flush_pkt;

static inline
    int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
		       enum AVSampleFormat fmt2, int64_t channel_count2)
{
	/* If channel count == 1, planar and non-planar formats are the same */
	if (channel_count1 == 1 && channel_count2 == 1)
		return av_get_packed_sample_fmt(fmt1) !=
		    av_get_packed_sample_fmt(fmt2);
	else
		return channel_count1 != channel_count2 || fmt1 != fmt2;
}

static inline
    int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
{
	if (channel_layout
	    && av_get_channel_layout_nb_channels(channel_layout) == channels)
		return channel_layout;
	else
		return 0;
}

static int packet_queue_put_private(PacketQueue * q, AVPacket * pkt)
{
	MyAVPacketList *pkt1;

	if (q->abort_request)
		return -1;

	pkt1 = av_malloc(sizeof(MyAVPacketList));
	if (!pkt1)
		return -1;
	pkt1->pkt = *pkt;
	pkt1->next = NULL;
	if (pkt == &flush_pkt)
		q->serial++;
	pkt1->serial = q->serial;

	if (!q->last_pkt)
		q->first_pkt = pkt1;
	else
		q->last_pkt->next = pkt1;
	q->last_pkt = pkt1;
	q->nb_packets++;
	q->size += pkt1->pkt.size + sizeof(*pkt1);
	/* XXX: should duplicate packet data in DV case */
	pthread_cond_signal(&q->cond);
	return 0;
}

static int packet_queue_put(PacketQueue * q, AVPacket * pkt)
{
	int ret;

	/* duplicate the packet */
	if (pkt != &flush_pkt && av_dup_packet(pkt) < 0)
		return -1;

	pthread_mutex_lock(&q->mutex);
	ret = packet_queue_put_private(q, pkt);
	pthread_mutex_unlock(&q->mutex);

	if (pkt != &flush_pkt && ret < 0)
		av_free_packet(pkt);

	return ret;
}

static int packet_queue_put_nullpacket(PacketQueue * q, int stream_index)
{
	AVPacket pkt1, *pkt = &pkt1;
	av_init_packet(pkt);
	pkt->data = NULL;
	pkt->size = 0;
	pkt->stream_index = stream_index;
	return packet_queue_put(q, pkt);
}

/* packet queue handling */
static void packet_queue_init(PacketQueue * q)
{
	memset(q, 0, sizeof(PacketQueue));
	pthread_mutex_init(&q->mutex, NULL);
	pthread_cond_init(&q->cond, NULL);
	q->abort_request = 1;
}

static void packet_queue_flush(PacketQueue * q)
{
	MyAVPacketList *pkt, *pkt1;

	pthread_mutex_lock(&q->mutex);
	for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
		pkt1 = pkt->next;
		av_free_packet(&pkt->pkt);
		av_freep(&pkt);
	}
	q->last_pkt = NULL;
	q->first_pkt = NULL;
	q->nb_packets = 0;
	q->size = 0;
	pthread_mutex_unlock(&q->mutex);
}

static void packet_queue_destroy(PacketQueue * q)
{
	packet_queue_flush(q);
	pthread_mutex_destroy(&q->mutex);
	pthread_cond_destroy(&q->cond);
}

static void packet_queue_abort(PacketQueue * q)
{
	pthread_mutex_lock(&q->mutex);

	q->abort_request = 1;

	pthread_cond_signal(&q->cond);

	pthread_mutex_unlock(&q->mutex);
}

static void packet_queue_start(PacketQueue * q)
{
	pthread_mutex_lock(&q->mutex);
	q->abort_request = 0;
	packet_queue_put_private(q, &flush_pkt);
	pthread_mutex_unlock(&q->mutex);
}

/* return < 0 if aborted, 0 if no packet and > 0 if packet.  */
static int packet_queue_get(PacketQueue * q, AVPacket * pkt, int block,
			    int *serial)
{
	MyAVPacketList *pkt1;
	int ret;

	pthread_mutex_lock(&q->mutex);

	for (;;) {
		if (q->abort_request) {
			ret = -1;
			break;
		}

		pkt1 = q->first_pkt;
		if (pkt1) {
			q->first_pkt = pkt1->next;
			if (!q->first_pkt)
				q->last_pkt = NULL;
			q->nb_packets--;
			q->size -= pkt1->pkt.size + sizeof(*pkt1);
			*pkt = pkt1->pkt;
			if (serial)
				*serial = pkt1->serial;
			av_free(pkt1);
			ret = 1;
			break;
		} else if (!block) {
			ret = 0;
			break;
		} else {
			pthread_cond_wait(&q->cond, &q->mutex);
		}
	}
	pthread_mutex_unlock(&q->mutex);
	return ret;
}

#if 0
static inline void fill_rectangle(SDL_Surface * screen,
				  int x, int y, int w, int h, int color,
				  int update)
{
	libffplay_rect_t rect;
	rect.x = x;
	rect.y = y;
	rect.w = w;
	rect.h = h;
	SDL_FillRect(screen, &rect, color);
	if (update && w > 0 && h > 0)
		SDL_UpdateRect(screen, x, y, w, h);
}

/* draw only the border of a rectangle */
static void fill_border(int xleft, int ytop, int width, int height, int x,
			int y, int w, int h, int color, int update)
{
	int w1, w2, h1, h2;

	/* fill the background */
	w1 = x;
	if (w1 < 0)
		w1 = 0;
	w2 = width - (x + w);
	if (w2 < 0)
		w2 = 0;
	h1 = y;
	if (h1 < 0)
		h1 = 0;
	h2 = height - (y + h);
	if (h2 < 0)
		h2 = 0;
	fill_rectangle(screen, xleft, ytop, w1, height, color, update);
	fill_rectangle(screen,
		       xleft + width - w2, ytop, w2, height, color, update);
	fill_rectangle(screen,
		       xleft + w1, ytop, width - w1 - w2, h1, color, update);
	fill_rectangle(screen,
		       xleft + w1, ytop + height - h2,
		       width - w1 - w2, h2, color, update);
}
#endif

#define ALPHA_BLEND(a, oldp, newp, s)\
((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))

#define RGBA_IN(r, g, b, a, s)\
{\
    unsigned int v = ((const uint32_t *)(s))[0];\
    a = (v >> 24) & 0xff;\
    r = (v >> 16) & 0xff;\
    g = (v >> 8) & 0xff;\
    b = v & 0xff;\
}

#define YUVA_IN(y, u, v, a, s, pal)\
{\
    unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
    a = (val >> 24) & 0xff;\
    y = (val >> 16) & 0xff;\
    u = (val >> 8) & 0xff;\
    v = val & 0xff;\
}

#define YUVA_OUT(d, y, u, v, a)\
{\
    ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
}

#define BPP 1

#if 0
static void blend_subrect(AVPicture * dst, const AVSubtitleRect * rect,
			  int imgw, int imgh)
{
	int wrap, wrap3, width2, skip2;
	int y, u, v, a, u1, v1, a1, w, h;
	uint8_t *lum, *cb, *cr;
	const uint8_t *p;
	const uint32_t *pal;
	int dstx, dsty, dstw, dsth;

	dstw = av_clip(rect->w, 0, imgw);
	dsth = av_clip(rect->h, 0, imgh);
	dstx = av_clip(rect->x, 0, imgw - dstw);
	dsty = av_clip(rect->y, 0, imgh - dsth);
	lum = dst->data[0] + dsty * dst->linesize[0];
	cb = dst->data[1] + (dsty >> 1) * dst->linesize[1];
	cr = dst->data[2] + (dsty >> 1) * dst->linesize[2];

	width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);
	skip2 = dstx >> 1;
	wrap = dst->linesize[0];
	wrap3 = rect->pict.linesize[0];
	p = rect->pict.data[0];
	pal = (const uint32_t *)rect->pict.data[1];	/* Now in YCrCb! */

	if (dsty & 1) {
		lum += dstx;
		cb += skip2;
		cr += skip2;

		if (dstx & 1) {
			YUVA_IN(y, u, v, a, p, pal);
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
			cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
			cb++;
			cr++;
			lum++;
			p += BPP;
		}
		for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
			YUVA_IN(y, u, v, a, p, pal);
			u1 = u;
			v1 = v;
			a1 = a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

			YUVA_IN(y, u, v, a, p + BPP, pal);
			u1 += u;
			v1 += v;
			a1 += a;
			lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
			cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
			cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
			cb++;
			cr++;
			p += 2 * BPP;
			lum += 2;
		}
		if (w) {
			YUVA_IN(y, u, v, a, p, pal);
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
			cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
			p++;
			lum++;
		}
		p += wrap3 - dstw * BPP;
		lum += wrap - dstw - dstx;
		cb += dst->linesize[1] - width2 - skip2;
		cr += dst->linesize[2] - width2 - skip2;
	}
	for (h = dsth - (dsty & 1); h >= 2; h -= 2) {
		lum += dstx;
		cb += skip2;
		cr += skip2;

		if (dstx & 1) {
			YUVA_IN(y, u, v, a, p, pal);
			u1 = u;
			v1 = v;
			a1 = a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			p += wrap3;
			lum += wrap;
			YUVA_IN(y, u, v, a, p, pal);
			u1 += u;
			v1 += v;
			a1 += a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
			cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
			cb++;
			cr++;
			p += -wrap3 + BPP;
			lum += -wrap + 1;
		}
		for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
			YUVA_IN(y, u, v, a, p, pal);
			u1 = u;
			v1 = v;
			a1 = a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

			YUVA_IN(y, u, v, a, p + BPP, pal);
			u1 += u;
			v1 += v;
			a1 += a;
			lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
			p += wrap3;
			lum += wrap;

			YUVA_IN(y, u, v, a, p, pal);
			u1 += u;
			v1 += v;
			a1 += a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

			YUVA_IN(y, u, v, a, p + BPP, pal);
			u1 += u;
			v1 += v;
			a1 += a;
			lum[1] = ALPHA_BLEND(a, lum[1], y, 0);

			cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
			cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);

			cb++;
			cr++;
			p += -wrap3 + 2 * BPP;
			lum += -wrap + 2;
		}
		if (w) {
			YUVA_IN(y, u, v, a, p, pal);
			u1 = u;
			v1 = v;
			a1 = a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			p += wrap3;
			lum += wrap;
			YUVA_IN(y, u, v, a, p, pal);
			u1 += u;
			v1 += v;
			a1 += a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
			cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
			cb++;
			cr++;
			p += -wrap3 + BPP;
			lum += -wrap + 1;
		}
		p += wrap3 + (wrap3 - dstw * BPP);
		lum += wrap + (wrap - dstw - dstx);
		cb += dst->linesize[1] - width2 - skip2;
		cr += dst->linesize[2] - width2 - skip2;
	}
	/* handle odd height */
	if (h) {
		lum += dstx;
		cb += skip2;
		cr += skip2;

		if (dstx & 1) {
			YUVA_IN(y, u, v, a, p, pal);
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
			cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
			cb++;
			cr++;
			lum++;
			p += BPP;
		}
		for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
			YUVA_IN(y, u, v, a, p, pal);
			u1 = u;
			v1 = v;
			a1 = a;
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

			YUVA_IN(y, u, v, a, p + BPP, pal);
			u1 += u;
			v1 += v;
			a1 += a;
			lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
			cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
			cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
			cb++;
			cr++;
			p += 2 * BPP;
			lum += 2;
		}
		if (w) {
			YUVA_IN(y, u, v, a, p, pal);
			lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
			cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
			cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
		}
	}
}
#endif

static void free_picture(VideoState *is, libffplay_picture_t * vp)
{
	if (vp->allocated)
		is->videomgr->free_picture_planes(is->videomgr, vp);
}

static void free_subpicture(SubPicture * sp)
{
	avsubtitle_free(&sp->sub);
}

#if 0
static void calculate_display_rect(libffplay_rect_t * rect, int scr_xleft,
				   int scr_ytop, int scr_width, int scr_height,
				   libffplay_picture_t * vp)
{
	AVRational sar;
	float aspect_ratio;
	int width, height, x, y;

	sar.num = vp->sar_num;
	sar.den = vp->sar_den;
	if (sar.num == 0)
		aspect_ratio = 0;
	else
		aspect_ratio = av_q2d(sar);

	if (aspect_ratio <= 0.0)
		aspect_ratio = 1.0;
	aspect_ratio *= (float)vp->width / (float)vp->height;

	/* XXX: we suppose the screen has a 1.0 pixel ratio */
	height = scr_height;
	width = ((int)rint(height * aspect_ratio)) & ~1;
	if (width > scr_width) {
		width = scr_width;
		height = ((int)rint(width / aspect_ratio)) & ~1;
	}
	x = (scr_width - width) / 2;
	y = (scr_height - height) / 2;
	rect->x = scr_xleft + x;
	rect->y = scr_ytop + y;
	rect->w = FFMAX(width, 1);
	rect->h = FFMAX(height, 1);
}
#endif

static void video_image_display(VideoState * is)
{
	libffplay_picture_t *vp;
	/* SubPicture *sp;
	int i;
	AVPicture pict; */

	vp = &is->pictq[is->pictq_rindex];
	if (vp->allocated) {
		is->videomgr->display_picture(is->videomgr, vp);

#if 0
		if (rect.x != is->last_display_rect.x
		    || rect.y != is->last_display_rect.y
		    || rect.w != is->last_display_rect.w
		    || rect.h != is->last_display_rect.h || is->force_refresh) {
			int bgcolor =
			    SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
			fill_border(is->xleft, is->ytop, is->width, is->height,
				    rect.x, rect.y, rect.w, rect.h, bgcolor, 1);
			is->last_display_rect = rect;
		}
#endif
	}
}

static inline int compute_mod(int a, int b)
{
	return a < 0 ? a % b + b : a % b;
}

#if 0
static void video_audio_display(VideoState * s)
{
	int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
	int ch, channels, h, h2, bgcolor, fgcolor;
	int64_t time_diff;
	int rdft_bits, nb_freq;

	for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++) ;
	nb_freq = 1 << (rdft_bits - 1);

	/* compute display index : center on currently output samples */
	channels = s->audio_tgt.channels;
	nb_display_channels = channels;
	if (!s->paused) {
		int data_used =
		    s->show_mode == SHOW_MODE_WAVES ? s->width : (2 * nb_freq);
		n = 2 * channels;
		delay = s->audio_write_buf_size;
		delay /= n;

		/* to be more precise, we take into account the time spent since
		   the last buffer computation */
		if (audio_callback_time) {
			time_diff = av_gettime() - audio_callback_time;
			delay -= (time_diff * s->audio_tgt.freq) / 1000000;
		}

		delay += 2 * data_used;
		if (delay < data_used)
			delay = data_used;

		i_start = x =
		    compute_mod(s->sample_array_index - delay * channels,
				SAMPLE_ARRAY_SIZE);
		if (s->show_mode == SHOW_MODE_WAVES) {
			h = INT_MIN;
			for (i = 0; i < 1000; i += channels) {
				int idx =
				    (SAMPLE_ARRAY_SIZE + x -
				     i) % SAMPLE_ARRAY_SIZE;
				int a = s->sample_array[idx];
				int b =
				    s->sample_array[(idx + 4 * channels) %
						    SAMPLE_ARRAY_SIZE];
				int c =
				    s->sample_array[(idx + 5 * channels) %
						    SAMPLE_ARRAY_SIZE];
				int d =
				    s->sample_array[(idx + 9 * channels) %
						    SAMPLE_ARRAY_SIZE];
				int score = a - d;
				if (h < score && (b ^ c) < 0) {
					h = score;
					i_start = idx;
				}
			}
		}

		s->last_i_start = i_start;
	} else {
		i_start = s->last_i_start;
	}

	bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
	if (s->show_mode == SHOW_MODE_WAVES) {
		fill_rectangle(screen,
			       s->xleft, s->ytop, s->width, s->height,
			       bgcolor, 0);

		fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);

		/* total height for one channel */
		h = s->height / nb_display_channels;
		/* graph height / 2 */
		h2 = (h * 9) / 20;
		for (ch = 0; ch < nb_display_channels; ch++) {
			i = i_start + ch;
			y1 = s->ytop + ch * h + (h / 2);	/* position of center line */
			for (x = 0; x < s->width; x++) {
				y = (s->sample_array[i] * h2) >> 15;
				if (y < 0) {
					y = -y;
					ys = y1 - y;
				} else {
					ys = y1;
				}
				fill_rectangle(screen,
					       s->xleft + x, ys, 1, y,
					       fgcolor, 0);
				i += channels;
				if (i >= SAMPLE_ARRAY_SIZE)
					i -= SAMPLE_ARRAY_SIZE;
			}
		}

		fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);

		for (ch = 1; ch < nb_display_channels; ch++) {
			y = s->ytop + ch * h;
			fill_rectangle(screen,
				       s->xleft, y, s->width, 1, fgcolor, 0);
		}
		SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
	} else {
		nb_display_channels = FFMIN(nb_display_channels, 2);
		if (rdft_bits != s->rdft_bits) {
			av_rdft_end(s->rdft);
			av_free(s->rdft_data);
			s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
			s->rdft_bits = rdft_bits;
			s->rdft_data =
			    av_malloc(4 * nb_freq * sizeof(*s->rdft_data));
		}
		{
			FFTSample *data[2];
			for (ch = 0; ch < nb_display_channels; ch++) {
				data[ch] = s->rdft_data + 2 * nb_freq * ch;
				i = i_start + ch;
				for (x = 0; x < 2 * nb_freq; x++) {
					double w =
					    (x - nb_freq) * (1.0 / nb_freq);
					data[ch][x] =
					    s->sample_array[i] * (1.0 - w * w);
					i += channels;
					if (i >= SAMPLE_ARRAY_SIZE)
						i -= SAMPLE_ARRAY_SIZE;
				}
				av_rdft_calc(s->rdft, data[ch]);
			}
			/* Least efficient way to do this, we should of course
			 * directly access it but it is more than fast enough. */
			for (y = 0; y < s->height; y++) {
				double w = 1 / sqrt(nb_freq);
				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]));
				int b =
				    (nb_display_channels ==
				     2) ? sqrt(w * sqrt(data[1][2 * y + 0] *
							data[1][2 * y + 0]
							+ data[1][2 * y +
								  1] *
							data[1][2 * y +
								1])) : a;
				a = FFMIN(a, 255);
				b = FFMIN(b, 255);
				fgcolor =
				    SDL_MapRGB(screen->format, a, b,
					       (a + b) / 2);

				fill_rectangle(screen,
					       s->xpos, s->height - y, 1, 1,
					       fgcolor, 0);
			}
		}
		SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
		if (!s->paused)
			s->xpos++;
		if (s->xpos >= s->width)
			s->xpos = s->xleft;
	}
}
#endif

static void stream_close(VideoState * is)
{
	int i;
	/* XXX: use a special url_shutdown call to abort parse cleanly */
	is->abort_request = 1;
	pthread_join(is->read_tid, NULL);
	packet_queue_destroy(&is->videoq);
	packet_queue_destroy(&is->audioq);
	packet_queue_destroy(&is->subtitleq);

	/* free all pictures */
	for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
		free_picture(is, &is->pictq[i]);
	for (i = 0; i < SUBPICTURE_QUEUE_SIZE; i++)
		free_subpicture(&is->subpq[i]);
	pthread_mutex_destroy(&is->pictq_mutex);
	pthread_cond_destroy(&is->pictq_cond);
	pthread_mutex_destroy(&is->subpq_mutex);
	pthread_cond_destroy(&is->subpq_cond);
	pthread_cond_destroy(&is->continue_read_thread);
	sws_freeContext(is->img_convert_ctx);
}

static void do_stop(VideoState * is)
{
	if (is) {
		stream_close(is);
	}
}

static void sigterm_handler(int sig)
{
	exit(123);
}

#if 0
static void set_default_window_size(libffplay_picture_t * vp)
{
	libffplay_rect_t rect;
	calculate_display_rect(&rect, 0, 0, INT_MAX, vp->height, vp);
	default_width = rect.w;
	default_height = rect.h;
}
#endif

#if 0
static int video_open(VideoState * is, int force_set_video_mode,
		      libffplay_picture_t * vp)
{
	int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
	int w, h;

	if (is_full_screen)
		flags |= SDL_FULLSCREEN;
	else
		flags |= SDL_RESIZABLE;

	if (vp && vp->width)
		set_default_window_size(vp);

	if (is_full_screen && fs_screen_width) {
		w = fs_screen_width;
		h = fs_screen_height;
	} else if (!is_full_screen && screen_width) {
		w = screen_width;
		h = screen_height;
	} else {
		w = default_width;
		h = default_height;
	}
	w = FFMIN(16383, w);
	if (screen && is->width == screen->w && screen->w == w
	    && is->height == screen->h && screen->h == h
	    && !force_set_video_mode)
		return 0;
	screen = SDL_SetVideoMode(w, h, 0, flags);
	if (!screen) {
		av_log(NULL, AV_LOG_FATAL,
		       "SDL: could not set video mode - exiting\n");
		do_stop(is);
	}
	if (!window_title)
		window_title = input_filename;
	SDL_WM_SetCaption(window_title, window_title);

	is->width = screen->w;
	is->height = screen->h;
	return 0;
}
#endif

/* display the current picture, if any */
static void video_display(VideoState * is)
{
#if 0
	if (!screen)
		video_open(is, 0, NULL);
	if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
		video_audio_display(is);
#endif
	if (is->video_st)
		video_image_display(is);
}

static double get_clock(Clock * c)
{
	if (*c->queue_serial != c->serial)
		return NAN;
	if (c->paused) {
		return c->pts;
	} else {
		double time = av_gettime() / 1000000.0;
		return c->pts_drift + time - (time - c->last_updated) * (1.0 -
									 c->speed);
	}
}

static void set_clock_at(Clock * c, double pts, int serial, double time)
{
	c->pts = pts;
	c->last_updated = time;
	c->pts_drift = c->pts - time;
	c->serial = serial;
}

static void set_clock(Clock * c, double pts, int serial)
{
	double time = av_gettime() / 1000000.0;
	set_clock_at(c, pts, serial, time);
}

static void set_clock_speed(Clock * c, double speed)
{
	set_clock(c, get_clock(c), c->serial);
	c->speed = speed;
}

static void init_clock(Clock * c, int *queue_serial)
{
	c->speed = 1.0;
	c->paused = 0;
	c->queue_serial = queue_serial;
	set_clock(c, NAN, -1);
}

static void sync_clock_to_slave(Clock * c, Clock * slave)
{
	double clock = get_clock(c);
	double slave_clock = get_clock(slave);
	if (!isnan(slave_clock)
	    && (isnan(clock)
		|| fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
		set_clock(c, slave_clock, slave->serial);
}

static int get_master_sync_type(VideoState * is)
{
	if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
		if (is->video_st)
			return AV_SYNC_VIDEO_MASTER;
		else
			return AV_SYNC_AUDIO_MASTER;
	} else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
		if (is->audio_st)
			return AV_SYNC_AUDIO_MASTER;
		else
			return AV_SYNC_EXTERNAL_CLOCK;
	} else {
		return AV_SYNC_EXTERNAL_CLOCK;
	}
}

/* get the current master clock value */
static double get_master_clock(VideoState * is)
{
	double val;

	switch (get_master_sync_type(is)) {
	case AV_SYNC_VIDEO_MASTER:
		val = get_clock(&is->vidclk);
		break;
	case AV_SYNC_AUDIO_MASTER:
		val = get_clock(&is->audclk);
		break;
	default:
		val = get_clock(&is->extclk);
		break;
	}
	return val;
}

static void check_external_clock_speed(VideoState * is)
{
	if ((is->video_stream >= 0 && is->videoq.nb_packets <= MIN_FRAMES / 2)
	    || (is->audio_stream >= 0
		&& is->audioq.nb_packets <= MIN_FRAMES / 2)) {
		set_clock_speed(&is->extclk,
				FFMAX(EXTERNAL_CLOCK_SPEED_MIN,
				      is->extclk.speed -
				      EXTERNAL_CLOCK_SPEED_STEP));
	} else
	    if ((is->video_stream < 0 || is->videoq.nb_packets > MIN_FRAMES * 2)
		&& (is->audio_stream < 0
		    || is->audioq.nb_packets > MIN_FRAMES * 2)) {
		set_clock_speed(&is->extclk,
				FFMIN(EXTERNAL_CLOCK_SPEED_MAX,
				      is->extclk.speed +
				      EXTERNAL_CLOCK_SPEED_STEP));
	} else {
		double speed = is->extclk.speed;
		if (speed != 1.0)
			set_clock_speed(&is->extclk,
					speed +
					EXTERNAL_CLOCK_SPEED_STEP * (1.0 -
								     speed) /
					fabs(1.0 - speed));
	}
}

/* seek in the stream */
static void stream_seek(VideoState * is, int64_t pos, int64_t rel,
			int seek_by_bytes)
{
	if (!is->seek_req) {
		is->seek_pos = pos;
		is->seek_rel = rel;
		is->seek_flags &= ~AVSEEK_FLAG_BYTE;
		if (seek_by_bytes)
			is->seek_flags |= AVSEEK_FLAG_BYTE;
		is->seek_req = 1;
		pthread_cond_signal(&is->continue_read_thread);
	}
}

/* pause or resume the video */
static void stream_toggle_pause(VideoState * is)
{
	if (is->paused) {
		is->frame_timer +=
		    av_gettime() / 1000000.0 + is->vidclk.pts_drift -
		    is->vidclk.pts;
		if (is->read_pause_return != AVERROR(ENOSYS)) {
			is->vidclk.paused = 0;
		}
		set_clock(&is->vidclk, get_clock(&is->vidclk),
			  is->vidclk.serial);
	}
	set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
	is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused =
	    !is->paused;
}

static void toggle_pause(VideoState * is)
{
	stream_toggle_pause(is);
	is->step = 0;
}

static void step_to_next_frame(VideoState * is)
{
	/* if the stream is paused unpause it, then step */
	if (is->paused)
		stream_toggle_pause(is);
	is->step = 1;
}

static double compute_target_delay(double delay, VideoState * is)
{
	double sync_threshold, diff;

	/* update delay to follow master synchronisation source */
	if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
		/* if video is slave, we try to correct big delays by
		   duplicating or deleting a frame */
		diff = get_clock(&is->vidclk) - get_master_clock(is);

		/* skip or repeat frame. We take into account the
		   delay to compute the threshold. I still don't know
		   if it is the best guess */
		sync_threshold =
		    FFMAX(AV_SYNC_THRESHOLD_MIN,
			  FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
		if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
			if (diff <= -sync_threshold)
				delay = FFMAX(0, delay + diff);
			else if (diff >= sync_threshold
				 && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
				delay = delay + diff;
			else if (diff >= sync_threshold)
				delay = 2 * delay;
		}
	}

	av_dlog(NULL, "video: delay=%0.3f A-V=%f\n", delay, -diff);

	return delay;
}

static double vp_duration(VideoState * is, libffplay_picture_t * vp,
			  libffplay_picture_t * nextvp)
{
	if (vp->serial == nextvp->serial) {
		double duration = nextvp->pts - vp->pts;
		if (isnan(duration) || duration <= 0
		    || duration > is->max_frame_duration)
			return vp->duration;
		else
			return duration;
	} else {
		return 0.0;
	}
}

static void pictq_next_picture(VideoState * is)
{
	/* update queue size and signal for next picture */
	if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
		is->pictq_rindex = 0;

	pthread_mutex_lock(&is->pictq_mutex);
	is->pictq_size--;
	pthread_cond_signal(&is->pictq_cond);
	pthread_mutex_unlock(&is->pictq_mutex);
}

static int pictq_prev_picture(VideoState * is)
{
	libffplay_picture_t *prevvp;
	int ret = 0;
	/* update queue size and signal for the previous picture */
	prevvp =
	    &is->pictq[(is->pictq_rindex + VIDEO_PICTURE_QUEUE_SIZE - 1) %
		       VIDEO_PICTURE_QUEUE_SIZE];
	if (prevvp->allocated && prevvp->serial == is->videoq.serial) {
		pthread_mutex_lock(&is->pictq_mutex);
		if (is->pictq_size < VIDEO_PICTURE_QUEUE_SIZE) {
			if (--is->pictq_rindex == -1)
				is->pictq_rindex = VIDEO_PICTURE_QUEUE_SIZE - 1;
			is->pictq_size++;
			ret = 1;
		}
		pthread_cond_signal(&is->pictq_cond);
		pthread_mutex_unlock(&is->pictq_mutex);
	}
	return ret;
}

static void update_video_pts(VideoState * is, double pts, int64_t pos,
			     int serial)
{
	/* update current video pts */
	set_clock(&is->vidclk, pts, serial);
	sync_clock_to_slave(&is->extclk, &is->vidclk);
	is->video_current_pos = pos;
}

/* called to display each frame */
static void video_refresh(void *opaque, double *remaining_time)
{
	VideoState *is = opaque;
	double time;

	/*
	SubPicture *sp, *sp2;
	*/

	if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK
	    && is->realtime)
		check_external_clock_speed(is);

	if (!display_disable && is->show_mode != SHOW_MODE_VIDEO
	    && is->audio_st) {
		time = av_gettime() / 1000000.0;
		if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
			video_display(is);
			is->last_vis_time = time;
		}
		*remaining_time =
		    FFMIN(*remaining_time,
			  is->last_vis_time + rdftspeed - time);
	}

	if (is->video_st) {
		int redisplay = 0;
		if (is->force_refresh)
			redisplay = pictq_prev_picture(is);
retry:
		if (is->pictq_size == 0) {
			// nothing to do, no picture to display in the queue
		} else {
			double last_duration, duration, delay;
			libffplay_picture_t *vp, *lastvp;

			/* dequeue the picture */
			vp = &is->pictq[is->pictq_rindex];
			lastvp =
			    &is->pictq[(is->pictq_rindex +
					VIDEO_PICTURE_QUEUE_SIZE -
					1) % VIDEO_PICTURE_QUEUE_SIZE];

			if (vp->serial != is->videoq.serial) {
				pictq_next_picture(is);
				is->video_current_pos = -1;
				redisplay = 0;
				goto retry;
			}

			if (lastvp->serial != vp->serial && !redisplay)
				is->frame_timer = av_gettime() / 1000000.0;

			if (is->paused)
				goto display;

			/* compute nominal last_duration */
			last_duration = vp_duration(is, lastvp, vp);
			if (redisplay)
				delay = 0.0;
			else
				delay = compute_target_delay(last_duration, is);

			time = av_gettime() / 1000000.0;
			if (time < is->frame_timer + delay && !redisplay) {
				*remaining_time =
				    FFMIN(is->frame_timer + delay - time,
					  *remaining_time);
				return;
			}

			is->frame_timer += delay;
			if (delay > 0
			    && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
				is->frame_timer = time;

			pthread_mutex_lock(&is->pictq_mutex);
			if (!redisplay && !isnan(vp->pts))
				update_video_pts(is, vp->pts, vp->pos,
						 vp->serial);
			pthread_mutex_unlock(&is->pictq_mutex);

			if (is->pictq_size > 1) {
				libffplay_picture_t *nextvp =
				    &is->pictq[(is->pictq_rindex + 1) %
					       VIDEO_PICTURE_QUEUE_SIZE];
				duration = vp_duration(is, vp, nextvp);
				if (!is->step
				    && (redisplay || framedrop > 0
					|| (framedrop
					    && get_master_sync_type(is) !=
					    AV_SYNC_VIDEO_MASTER))
				    && time > is->frame_timer + duration) {
					if (!redisplay)
						is->frame_drops_late++;
					pictq_next_picture(is);
					redisplay = 0;
					goto retry;
				}
			}

#if 0
			if (is->subtitle_st) {
				while (is->subpq_size > 0) {
					sp = &is->subpq[is->subpq_rindex];

					if (is->subpq_size > 1)
						sp2 =
						    &is->subpq[(is->
								subpq_rindex +
								1) %
							       SUBPICTURE_QUEUE_SIZE];
					else
						sp2 = NULL;

					if (sp->serial != is->subtitleq.serial
					    || (is->vidclk.pts >
						(sp->pts +
						 ((float)sp->
						  sub.end_display_time / 1000)))
					    || (sp2
						&& is->vidclk.pts >
						(sp2->pts +
						 ((float)sp2->
						  sub.start_display_time /
						  1000)))) {
						free_subpicture(sp);

						/* update queue size and signal for next picture */
						if (++is->subpq_rindex ==
						    SUBPICTURE_QUEUE_SIZE)
							is->subpq_rindex = 0;

						pthread_mutex_lock(&is->
								   subpq_mutex);
						is->subpq_size--;
						pthread_cond_signal(&is->
								    subpq_cond);
						pthread_mutex_unlock
						    (&is->subpq_mutex);
					} else {
						break;
					}
				}
			}
#endif

display:
			/* display picture */
			if (!display_disable
			    && is->show_mode == SHOW_MODE_VIDEO)
				video_display(is);

			pictq_next_picture(is);

			if (is->step && !is->paused)
				stream_toggle_pause(is);
		}
	}
	is->force_refresh = 0;
#if 0
	if (show_status) {
		static int64_t last_time;
		int64_t cur_time;
		int aqsize, vqsize, sqsize;
		double av_diff;

		cur_time = av_gettime();
		if (!last_time || (cur_time - last_time) >= 30000) {
			aqsize = 0;
			vqsize = 0;
			sqsize = 0;
			if (is->audio_st)
				aqsize = is->audioq.size;
			if (is->video_st)
				vqsize = is->videoq.size;
			if (is->subtitle_st)
				sqsize = is->subtitleq.size;
			av_diff = 0;
			if (is->audio_st && is->video_st)
				av_diff =
				    get_clock(&is->audclk) -
				    get_clock(&is->vidclk);
			else if (is->video_st)
				av_diff =
				    get_master_clock(is) -
				    get_clock(&is->vidclk);
			else if (is->audio_st)
				av_diff =
				    get_master_clock(is) -
				    get_clock(&is->audclk);
			av_log(NULL, AV_LOG_INFO,
			       "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"
			       PRId64 "/%" PRId64 "   \r", get_master_clock(is),
			       (is->audio_st
				&& is->video_st) ? "A-V" : (is->video_st ? "M-V"
							    : (is->audio_st ?
							       "M-A" : "   ")),
			       av_diff,
			       is->frame_drops_early + is->frame_drops_late,
			       aqsize / 1024, vqsize / 1024, sqsize,
			       is->video_st ? is->video_st->
			       codec->pts_correction_num_faulty_dts : 0,
			       is->video_st ? is->video_st->
			       codec->pts_correction_num_faulty_pts : 0);
			fflush(stdout);
			last_time = cur_time;
		}
	}
#endif
}

#if 0
/* allocate a picture (needs to do that in main thread to avoid
   potential locking problems */
static void alloc_picture(VideoState * is)
{
	libffplay_picture_t *vp;
	int64_t bufferdiff;

	vp = &is->pictq[is->pictq_windex];

	free_picture(vp);

	video_open(is, 0, vp);

	vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
				       SDL_YV12_OVERLAY, screen);
	bufferdiff =
	    vp->bmp ? FFMAX(vp->bmp->pixels[0],
			    vp->bmp->pixels[1]) - FFMIN(vp->bmp->pixels[0],
							vp->bmp->pixels[1]) : 0;
	if (!vp->bmp || vp->bmp->pitches[0] < vp->width
	    || bufferdiff < (int64_t) vp->height * vp->bmp->pitches[0]) {
		/* SDL allocates a buffer smaller than requested if the video
		 * overlay hardware is unable to support the requested size. */
		av_log(NULL, AV_LOG_FATAL,
		       "Error: the video system does not support an image\n"
		       "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
		       "to reduce the image size.\n", vp->width, vp->height);
		do_stop(is);
	}

	pthread_mutex_lock(&is->pictq_mutex);
	vp->allocated = 1;
	pthread_cond_signal(&is->pictq_cond);
	pthread_mutex_unlock(&is->pictq_mutex);
}
#endif

#if 0
static void duplicate_right_border_pixels(SDL_Overlay * bmp)
{
	int i, width, height;
	Uint8 *p, *maxp;
	for (i = 0; i < 3; i++) {
		width = bmp->w;
		height = bmp->h;
		if (i > 0) {
			width >>= 1;
			height >>= 1;
		}
		if (bmp->pitches[i] > width) {
			maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
			for (p = bmp->pixels[i] + width - 1; p < maxp;
			     p += bmp->pitches[i])
				*(p + 1) = *p;
		}
	}
}
#endif

static int queue_picture(VideoState * is, AVFrame * src_frame, double pts,
			 double duration, int64_t pos, int serial)
{
	int res;
	libffplay_picture_t *vp;

	/* wait until we have space to put a new picture */
	pthread_mutex_lock(&is->pictq_mutex);

	/* keep the last already displayed picture in the queue */
	while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE - 1 &&
	       !is->videoq.abort_request) {
		pthread_cond_wait(&is->pictq_cond, &is->pictq_mutex);
	}
	pthread_mutex_unlock(&is->pictq_mutex);

	if (is->videoq.abort_request)
		return -1;

	vp = &is->pictq[is->pictq_windex];

	vp->sar_den = src_frame->sample_aspect_ratio.den;
	vp->sar_num = src_frame->sample_aspect_ratio.num;

	/* alloc or resize hardware picture buffer */
	if (!vp->allocated) {
		res = is->videomgr->alloc_picture_planes(is->videomgr, vp,
			src_frame->width, src_frame->height);
		if (res) {
			av_log(NULL, AV_LOG_ERROR, "Failed to allocate picture\n");
			return res;
		}
	}

	/* if the frame is not skipped, then display it */
	AVPicture pict = { {0}
	};

	/* get a pointer on the bitmap */
	is->videomgr->lock_picture(is->videomgr, vp);

	pict.data[0] = vp->planes[0];
	pict.data[1] = vp->planes[1];
	pict.data[2] = vp->planes[2];

	pict.linesize[0] = vp->pitches[0];
	pict.linesize[1] = vp->pitches[1];
	pict.linesize[2] = vp->pitches[2];

	is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
						   src_frame->width,
						   src_frame->height,
						   src_frame->format,
						   vp->width,
						   vp->height,
						   AV_PIX_FMT_YUV420P,
						   sws_flags, NULL,
						   NULL, NULL);
	if (is->img_convert_ctx == NULL) {
		av_log(NULL, AV_LOG_FATAL,
		       "Cannot initialize the conversion context\n");
		exit(1);
	}
	sws_scale(is->img_convert_ctx, (const uint8_t * const *)src_frame->data,
		  src_frame->linesize, 0, src_frame->height, pict.data,
		  pict.linesize);

	/* workaround SDL PITCH_WORKAROUND */
	/* FIXME: duplicate_right_border_pixels(vp->bmp); */
	/* update the bitmap content */
	is->videomgr->unlock_picture(is->videomgr, vp);

	vp->pts = pts;
	vp->duration = duration;
	vp->pos = pos;
	vp->serial = serial;

	/* now we can update the picture count */
	if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
		is->pictq_windex = 0;
	pthread_mutex_lock(&is->pictq_mutex);
	is->pictq_size++;
	pthread_mutex_unlock(&is->pictq_mutex);
	return 0;
}

static int get_video_frame(VideoState * is, AVFrame * frame, AVPacket * pkt,
			   int *serial)
{
	int got_picture;

	if (packet_queue_get(&is->videoq, pkt, 1, serial) < 0)
		return -1;

	if (pkt->data == NULL && pkt->size == 0 && !is->audio_st
	    && !is->eof_event_sent) {
		is->eof_event_sent = 1;
		is->eventmgr->send_event(is->eventmgr, LFP_EVENT_EOF, NULL);
	}

	if (pkt->data == flush_pkt.data) {
		avcodec_flush_buffers(is->video_st->codec);
		return 0;
	}

	if (avcodec_decode_video2(is->video_st->codec, frame, &got_picture, pkt)
	    < 0)
		return 0;

	if (!got_picture && !pkt->data)
		is->video_finished = *serial;

	if (got_picture) {
		int ret = 1;
		double dpts = NAN;

		if (decoder_reorder_pts == -1) {
			frame->pts = av_frame_get_best_effort_timestamp(frame);
		} else if (decoder_reorder_pts) {
			frame->pts = frame->pkt_pts;
		} else {
			frame->pts = frame->pkt_dts;
		}

		if (frame->pts != AV_NOPTS_VALUE)
			dpts = av_q2d(is->video_st->time_base) * frame->pts;

		frame->sample_aspect_ratio =
		    av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);

		if (framedrop > 0
		    || (framedrop
			&& get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
			if (frame->pts != AV_NOPTS_VALUE) {
				double diff = dpts - get_master_clock(is);
				if (!isnan(diff)
				    && fabs(diff) < AV_NOSYNC_THRESHOLD
				    && diff - is->frame_last_filter_delay < 0
				    && *serial == is->vidclk.serial
				    && is->videoq.nb_packets) {
					is->frame_drops_early++;
					av_frame_unref(frame);
					ret = 0;
				}
			}
		}

		return ret;
	}
	return 0;
}

static int configure_filtergraph(AVFilterGraph * graph, const char *filtergraph,
				 AVFilterContext * source_ctx,
				 AVFilterContext * sink_ctx)
{
	int ret, i;
	int nb_filters = graph->nb_filters;
	AVFilterInOut *outputs = NULL, *inputs = NULL;

	if (filtergraph) {
		outputs = avfilter_inout_alloc();
		inputs = avfilter_inout_alloc();
		if (!outputs || !inputs) {
			ret = AVERROR(ENOMEM);
			goto fail;
		}

		outputs->name = av_strdup("in");
		outputs->filter_ctx = source_ctx;
		outputs->pad_idx = 0;
		outputs->next = NULL;

		inputs->name = av_strdup("out");
		inputs->filter_ctx = sink_ctx;
		inputs->pad_idx = 0;
		inputs->next = NULL;

		if ((ret =
		     avfilter_graph_parse_ptr(graph, filtergraph, &inputs,
					      &outputs, NULL)) < 0)
			goto fail;
	} else {
		if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
			goto fail;
	}

	/* Reorder the filters to ensure that inputs of the custom filters are merged first */
	for (i = 0; i < graph->nb_filters - nb_filters; i++)
		FFSWAP(AVFilterContext *, graph->filters[i],
		       graph->filters[i + nb_filters]);

	ret = avfilter_graph_config(graph, NULL);
fail:
	avfilter_inout_free(&outputs);
	avfilter_inout_free(&inputs);
	return ret;
}

#if 0
static int configure_video_filters(AVFilterGraph * graph, VideoState * is,
				   const char *vfilters, AVFrame * frame)
{
	static const enum AVPixelFormat pix_fmts[] =
	    { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
	char buffersrc_args[256];
	int ret;
	AVFilterContext *filt_src = NULL, *filt_out = NULL, *filt_crop;
	AVCodecContext *codec = is->video_st->codec;
	AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);

	snprintf(buffersrc_args, sizeof(buffersrc_args),
		 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		 frame->width, frame->height, frame->format,
		 is->video_st->time_base.num, is->video_st->time_base.den,
		 codec->sample_aspect_ratio.num,
		 FFMAX(codec->sample_aspect_ratio.den, 1));
	if (fr.num && fr.den)
		av_strlcatf(buffersrc_args, sizeof(buffersrc_args),
			    ":frame_rate=%d/%d", fr.num, fr.den);

	if ((ret = avfilter_graph_create_filter(&filt_src,
						avfilter_get_by_name("buffer"),
						"ffplay_buffer", buffersrc_args,
						NULL, graph)) < 0)
		goto fail;

	ret = avfilter_graph_create_filter(&filt_out,
					   avfilter_get_by_name("buffersink"),
					   "ffplay_buffersink", NULL, NULL,
					   graph);
	if (ret < 0)
		goto fail;

	if ((ret =
	     av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts,
				 AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
		goto fail;

	/* SDL YUV code is not handling odd width/height for some driver
	 * combinations, therefore we crop the picture to an even width/height. */
	if ((ret = avfilter_graph_create_filter(&filt_crop,
						avfilter_get_by_name("crop"),
						"ffplay_crop",
						"floor(in_w/2)*2:floor(in_h/2)*2",
						NULL, graph)) < 0)
		goto fail;
	if ((ret = avfilter_link(filt_crop, 0, filt_out, 0)) < 0)
		goto fail;

	if ((ret =
	     configure_filtergraph(graph, vfilters, filt_src, filt_crop)) < 0)
		goto fail;

	is->in_video_filter = filt_src;
	is->out_video_filter = filt_out;

fail:
	return ret;
}
#endif

static int configure_audio_filters(VideoState * is, const char *afilters,
				   int force_output_format)
{
	static const enum AVSampleFormat sample_fmts[] =
	    { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
	int sample_rates[2] = { 0, -1 };
	int64_t channel_layouts[2] = { 0, -1 };
	int channels[2] = { 0, -1 };
	AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
	char aresample_swr_opts[512] = "";
	char asrc_args[256];
	int ret;

	avfilter_graph_free(&is->agraph);
	if (!(is->agraph = avfilter_graph_alloc()))
		return AVERROR(ENOMEM);

	//while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
	//    av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
	if (strlen(aresample_swr_opts))
		aresample_swr_opts[strlen(aresample_swr_opts) - 1] = '\0';
	av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);

	ret = snprintf(asrc_args, sizeof(asrc_args),
		       "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
		       is->audio_filter_src.freq,
		       av_get_sample_fmt_name(is->audio_filter_src.fmt),
		       is->audio_filter_src.channels, 1,
		       is->audio_filter_src.freq);
	if (is->audio_filter_src.channel_layout)
		snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
			 ":channel_layout=0x%" PRIx64,
			 is->audio_filter_src.channel_layout);

	ret = avfilter_graph_create_filter(&filt_asrc,
					   avfilter_get_by_name("abuffer"),
					   "ffplay_abuffer", asrc_args, NULL,
					   is->agraph);
	if (ret < 0)
		goto end;

	ret = avfilter_graph_create_filter(&filt_asink,
					   avfilter_get_by_name("abuffersink"),
					   "ffplay_abuffersink", NULL, NULL,
					   is->agraph);
	if (ret < 0)
		goto end;

	if ((ret =
	     av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts,
				 AV_SAMPLE_FMT_NONE,
				 AV_OPT_SEARCH_CHILDREN)) < 0)
		goto end;
	if ((ret =
	     av_opt_set_int(filt_asink, "all_channel_counts", 1,
			    AV_OPT_SEARCH_CHILDREN)) < 0)
		goto end;

	if (force_output_format) {
		channel_layouts[0] = is->audio_tgt.channel_layout;
		channels[0] = is->audio_tgt.channels;
		sample_rates[0] = is->audio_tgt.freq;
		if ((ret =
		     av_opt_set_int(filt_asink, "all_channel_counts", 0,
				    AV_OPT_SEARCH_CHILDREN)) < 0)
			goto end;
		if ((ret =
		     av_opt_set_int_list(filt_asink, "channel_layouts",
					 channel_layouts, -1,
					 AV_OPT_SEARCH_CHILDREN)) < 0)
			goto end;
		if ((ret =
		     av_opt_set_int_list(filt_asink, "channel_counts", channels,
					 -1, AV_OPT_SEARCH_CHILDREN)) < 0)
			goto end;
		if ((ret =
		     av_opt_set_int_list(filt_asink, "sample_rates",
					 sample_rates, -1,
					 AV_OPT_SEARCH_CHILDREN)) < 0)
			goto end;
	}

	if ((ret =
	     configure_filtergraph(is->agraph, afilters, filt_asrc,
				   filt_asink)) < 0)
		goto end;

	is->in_audio_filter = filt_asrc;
	is->out_audio_filter = filt_asink;

end:
	if (ret < 0)
		avfilter_graph_free(&is->agraph);
	return ret;
}

static void *video_thread(void *arg)
{
	AVPacket pkt = { 0 };
	VideoState *is = arg;
	AVFrame *frame = av_frame_alloc();
	double pts;
	double duration;
	int ret;
	int serial = 0;
	AVRational tb = is->video_st->time_base;
	AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);

#if 0
	AVFilterGraph *graph = avfilter_graph_alloc();
	AVFilterContext *filt_out = NULL, *filt_in = NULL;
	int last_w = 0;
	int last_h = 0;
	enum AVPixelFormat last_format = -2;
	int last_serial = -1;
#endif

	for (;;) {
		while (is->paused && !is->videoq.abort_request) {
			av_usleep(10000);
		}

		av_free_packet(&pkt);

		ret = get_video_frame(is, frame, &pkt, &serial);
		if (ret < 0) {
			goto the_end;
		}
		if (!ret) {
			continue;
		}

#if 0
		if (last_w != frame->width
		    || last_h != frame->height
		    || last_format != frame->format || last_serial != serial) {
			av_log(NULL, AV_LOG_DEBUG,
			       "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
			       last_w, last_h, (const char *)
			       av_x_if_null(av_get_pix_fmt_name(last_format),
					    "none"), last_serial, frame->width,
			       frame->height, (const char *)
			       av_x_if_null(av_get_pix_fmt_name(frame->format),
					    "none"), serial);
			avfilter_graph_free(&graph);
			graph = avfilter_graph_alloc();
			if ((ret =
			     configure_video_filters(graph, is, vfilters,
						     frame)) < 0) {
				if (!is->eof_event_sent) {
					is->eof_event_sent = 1;
					is->eventmgr->send_event(is->eventmgr,
								 LFP_EVENT_EOF,
								 NULL);
				}
				goto the_end;
			}
			filt_in = is->in_video_filter;
			filt_out = is->out_video_filter;
			last_w = frame->width;
			last_h = frame->height;
			last_format = frame->format;
			last_serial = serial;
			frame_rate = filt_out->inputs[0]->frame_rate;
		}

		ret = av_buffersrc_add_frame(filt_in, frame);
		if (ret < 0)
			goto the_end;

		while (ret >= 0) {
			is->frame_last_returned_time = av_gettime() / 1000000.0;

			ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
			if (ret < 0) {
				if (ret == AVERROR_EOF)
					is->video_finished = serial;
				ret = 0;
				break;
			}

			is->frame_last_filter_delay =
			    av_gettime() / 1000000.0 -
			    is->frame_last_returned_time;
			if (fabs(is->frame_last_filter_delay) >
			    AV_NOSYNC_THRESHOLD / 10.0)
				is->frame_last_filter_delay = 0;
			tb = filt_out->inputs[0]->time_base;
#endif
			duration = (frame_rate.num
				    && frame_rate.den ? av_q2d((AVRational) {
							       frame_rate.den,
							       frame_rate.num}
				    ) : 0);
			pts =
			    (frame->pts ==
			     AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
			ret =
			    queue_picture(is, frame, pts, duration,
					  av_frame_get_pkt_pos(frame), serial);
			av_frame_unref(frame);
#if 0
		}
#endif

		if (ret < 0)
			goto the_end;
	}
the_end:
#if 0
	avfilter_graph_free(&graph);
#endif
	av_free_packet(&pkt);
	av_frame_free(&frame);
	return NULL;
}

#if 0
static void *subtitle_thread(void *arg)
{
	VideoState *is = arg;
	SubPicture *sp;
	AVPacket pkt1, *pkt = &pkt1;
	int got_subtitle;
	int serial;
	double pts;
	int i, j;
	int r, g, b, y, u, v, a;

	for (;;) {
		while (is->paused && !is->subtitleq.abort_request) {
			av_usleep(10000);
		}
		if (packet_queue_get(&is->subtitleq, pkt, 1, &serial) < 0)
			break;

		if (pkt->data == flush_pkt.data) {
			avcodec_flush_buffers(is->subtitle_st->codec);
			continue;
		}
		pthread_mutex_lock(&is->subpq_mutex);
		while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
		       !is->subtitleq.abort_request) {
			pthread_cond_wait(&is->subpq_cond, &is->subpq_mutex);
		}
		pthread_mutex_unlock(&is->subpq_mutex);

		if (is->subtitleq.abort_request)
			return NULL;

		sp = &is->subpq[is->subpq_windex];

		/* NOTE: ipts is the PTS of the _first_ picture beginning in
		   this packet, if any */
		pts = 0;
		if (pkt->pts != AV_NOPTS_VALUE)
			pts = av_q2d(is->subtitle_st->time_base) * pkt->pts;

		avcodec_decode_subtitle2(is->subtitle_st->codec, &sp->sub,
					 &got_subtitle, pkt);
		if (got_subtitle && sp->sub.format == 0) {
			if (sp->sub.pts != AV_NOPTS_VALUE)
				pts = sp->sub.pts / (double)AV_TIME_BASE;
			sp->pts = pts;
			sp->serial = serial;

			for (i = 0; i < sp->sub.num_rects; i++) {
				for (j = 0; j < sp->sub.rects[i]->nb_colors;
				     j++) {
					RGBA_IN(r, g, b, a,
						(uint32_t *) sp->sub.
						rects[i]->pict.data[1] + j);
					y = RGB_TO_Y_CCIR(r, g, b);
					u = RGB_TO_U_CCIR(r, g, b, 0);
					v = RGB_TO_V_CCIR(r, g, b, 0);
					YUVA_OUT((uint32_t *) sp->sub.
						 rects[i]->pict.data[1] + j, y,
						 u, v, a);
				}
			}

			/* now we can update the picture count */
			if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
				is->subpq_windex = 0;
			pthread_mutex_lock(&is->subpq_mutex);
			is->subpq_size++;
			pthread_mutex_unlock(&is->subpq_mutex);
		} else if (got_subtitle) {
			avsubtitle_free(&sp->sub);
		}
		av_free_packet(pkt);
	}
	return NULL;
}
#endif

/* copy samples for viewing in editor window */
static void update_sample_display(VideoState * is, short *samples,
				  int samples_size)
{
	int size, len;

	size = samples_size / sizeof(short);
	while (size > 0) {
		len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
		if (len > size)
			len = size;
		memcpy(is->sample_array + is->sample_array_index, samples,
		       len * sizeof(short));
		samples += len;
		is->sample_array_index += len;
		if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
			is->sample_array_index = 0;
		size -= len;
	}
}

/* return the wanted number of samples to get better sync if sync_type is video
 * or external master clock */
static int synchronize_audio(VideoState * is, int nb_samples)
{
	int wanted_nb_samples = nb_samples;

	/* if not master, then we try to remove or add samples to correct the clock */
	if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
		double diff, avg_diff;
		int min_nb_samples, max_nb_samples;

		diff = get_clock(&is->audclk) - get_master_clock(is);

		if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
			is->audio_diff_cum =
			    diff + is->audio_diff_avg_coef * is->audio_diff_cum;
			if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
				/* not enough measures to have a correct estimate */
				is->audio_diff_avg_count++;
			} else {
				/* estimate the A-V difference */
				avg_diff =
				    is->audio_diff_cum * (1.0 -
							  is->audio_diff_avg_coef);

				if (fabs(avg_diff) >= is->audio_diff_threshold) {
					wanted_nb_samples =
					    nb_samples +
					    (int)(diff * is->audio_src.freq);
					min_nb_samples =
					    ((nb_samples *
					      (100 -
					       SAMPLE_CORRECTION_PERCENT_MAX) /
					      100));
					max_nb_samples =
					    ((nb_samples *
					      (100 +
					       SAMPLE_CORRECTION_PERCENT_MAX) /
					      100));
					wanted_nb_samples =
					    FFMIN(FFMAX
						  (wanted_nb_samples,
						   min_nb_samples),
						  max_nb_samples);
				}
				av_dlog(NULL,
					"diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
					diff, avg_diff,
					wanted_nb_samples - nb_samples,
					is->audio_clock,
					is->audio_diff_threshold);
			}
		} else {
			/* too big difference : may be initial PTS errors, so
			   reset A-V filter */
			is->audio_diff_avg_count = 0;
			is->audio_diff_cum = 0;
		}
	}

	return wanted_nb_samples;
}

/**
 * Decode one audio frame and return its uncompressed size.
 *
 * The processed audio frame is decoded, converted if required, and
 * stored in is->audio_buf, with size in bytes given by the return
 * value.
 */
static int audio_decode_frame(VideoState * is)
{
	AVPacket *pkt_temp = &is->audio_pkt_temp;
	AVPacket *pkt = &is->audio_pkt;
	AVCodecContext *dec = is->audio_st->codec;
	int len1, data_size, resampled_data_size;
	int64_t dec_channel_layout;
	int got_frame;
	av_unused double audio_clock0;
	int wanted_nb_samples;
	AVRational tb;
	int ret;
	int reconfigure;

	for (;;) {
		/* NOTE: the audio packet can contain several frames */
		while (pkt_temp->stream_index != -1
		       || is->audio_buf_frames_pending) {
			if (!is->frame) {
				if (!(is->frame = av_frame_alloc()))
					return AVERROR(ENOMEM);
			} else {
				av_frame_unref(is->frame);
			}

			if (is->audioq.serial != is->audio_pkt_temp_serial)
				break;

			if (is->paused)
				return -1;

			if (!is->audio_buf_frames_pending) {
				len1 =
				    avcodec_decode_audio4(dec, is->frame,
							  &got_frame, pkt_temp);
				if (len1 < 0) {
					/* if error, we skip the frame */
					pkt_temp->size = 0;
					break;
				}

				pkt_temp->dts = pkt_temp->pts = AV_NOPTS_VALUE;
				pkt_temp->data += len1;
				pkt_temp->size -= len1;
				if ((pkt_temp->data && pkt_temp->size <= 0)
				    || (!pkt_temp->data && !got_frame))
					pkt_temp->stream_index = -1;
				if (!pkt_temp->data && !got_frame)
					is->audio_finished =
					    is->audio_pkt_temp_serial;

				if (!got_frame)
					continue;

				tb = (AVRational) {
				1, is->frame->sample_rate};
				if (is->frame->pts != AV_NOPTS_VALUE)
					is->frame->pts =
					    av_rescale_q(is->frame->pts,
							 dec->time_base, tb);
				else if (is->frame->pkt_pts != AV_NOPTS_VALUE)
					is->frame->pts =
					    av_rescale_q(is->frame->pkt_pts,
							 is->
							 audio_st->time_base,
							 tb);
				else if (is->audio_frame_next_pts !=
					 AV_NOPTS_VALUE)
					is->frame->pts =
					    av_rescale_q
					    (is->audio_frame_next_pts,
					     (AVRational) {
					     1, is->audio_filter_src.freq}
					     , tb);

				if (is->frame->pts != AV_NOPTS_VALUE)
					is->audio_frame_next_pts =
					    is->frame->pts +
					    is->frame->nb_samples;

				dec_channel_layout =
				    get_valid_channel_layout(is->
							     frame->channel_layout,
							     av_frame_get_channels
							     (is->frame));

				reconfigure =
				    cmp_audio_fmts(is->audio_filter_src.fmt,
						   is->
						   audio_filter_src.channels,
						   is->frame->format,
						   av_frame_get_channels
						   (is->frame))
				    || is->audio_filter_src.channel_layout !=
				    dec_channel_layout
				    || is->audio_filter_src.freq !=
				    is->frame->sample_rate
				    || is->audio_pkt_temp_serial !=
				    is->audio_last_serial;

				if (reconfigure) {
					char buf1[1024], buf2[1024];
					av_get_channel_layout_string(buf1,
								     sizeof
								     (buf1), -1,
								     is->audio_filter_src.channel_layout);
					av_get_channel_layout_string(buf2,
								     sizeof
								     (buf2), -1,
								     dec_channel_layout);
					av_log(NULL, AV_LOG_DEBUG,
					       "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",
					       is->audio_filter_src.freq,
					       is->audio_filter_src.channels,
					       av_get_sample_fmt_name
					       (is->audio_filter_src.fmt), buf1,
					       is->audio_last_serial,
					       is->frame->sample_rate,
					       av_frame_get_channels(is->frame),
					       av_get_sample_fmt_name
					       (is->frame->format), buf2,
					       is->audio_pkt_temp_serial);

					is->audio_filter_src.fmt =
					    is->frame->format;
					is->audio_filter_src.channels =
					    av_frame_get_channels(is->frame);
					is->audio_filter_src.channel_layout =
					    dec_channel_layout;
					is->audio_filter_src.freq =
					    is->frame->sample_rate;
					is->audio_last_serial =
					    is->audio_pkt_temp_serial;

					if ((ret =
					     configure_audio_filters(is,
								     afilters,
								     1)) < 0)
						return ret;
				}

				if ((ret =
				     av_buffersrc_add_frame(is->in_audio_filter,
							    is->frame)) < 0)
					return ret;
			}
			if ((ret =
			     av_buffersink_get_frame_flags(is->out_audio_filter,
							   is->frame, 0)) < 0) {
				if (ret == AVERROR(EAGAIN)) {
					is->audio_buf_frames_pending = 0;
					continue;
				}
				if (ret == AVERROR_EOF)
					is->audio_finished =
					    is->audio_pkt_temp_serial;
				return ret;
			}
			is->audio_buf_frames_pending = 1;
			tb = is->out_audio_filter->inputs[0]->time_base;

			data_size =
			    av_samples_get_buffer_size(NULL,
						       av_frame_get_channels
						       (is->frame),
						       is->frame->nb_samples,
						       is->frame->format, 1);

			dec_channel_layout =
			    (is->frame->channel_layout
			     && av_frame_get_channels(is->frame) ==
			     av_get_channel_layout_nb_channels(is->
							       frame->channel_layout))
			    ? is->
			    frame->channel_layout :
			    av_get_default_channel_layout(av_frame_get_channels
							  (is->frame));
			wanted_nb_samples =
			    synchronize_audio(is, is->frame->nb_samples);

			if (is->frame->format != is->audio_src.fmt ||
			    dec_channel_layout != is->audio_src.channel_layout
			    || is->frame->sample_rate != is->audio_src.freq
			    || (wanted_nb_samples != is->frame->nb_samples
				&& !is->swr_ctx)) {
				swr_free(&is->swr_ctx);
				is->swr_ctx = swr_alloc_set_opts(NULL,
								 is->
								 audio_tgt.channel_layout,
								 is->
								 audio_tgt.fmt,
								 is->
								 audio_tgt.freq,
								 dec_channel_layout,
								 is->
								 frame->format,
								 is->
								 frame->sample_rate,
								 0, NULL);
				if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
					av_log(NULL, AV_LOG_ERROR,
					       "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
					       is->frame->sample_rate,
					       av_get_sample_fmt_name
					       (is->frame->format),
					       av_frame_get_channels(is->frame),
					       is->audio_tgt.freq,
					       av_get_sample_fmt_name
					       (is->audio_tgt.fmt),
					       is->audio_tgt.channels);
					break;
				}
				is->audio_src.channel_layout =
				    dec_channel_layout;
				is->audio_src.channels =
				    av_frame_get_channels(is->frame);
				is->audio_src.freq = is->frame->sample_rate;
				is->audio_src.fmt = is->frame->format;
			}

			if (is->swr_ctx) {
				const uint8_t **in =
				    (const uint8_t **)is->frame->extended_data;
				uint8_t **out = &is->audio_buf1;
				int out_count =
				    (int64_t) wanted_nb_samples *
				    is->audio_tgt.freq /
				    is->frame->sample_rate + 256;
				int out_size = av_samples_get_buffer_size(NULL,
									  is->
									  audio_tgt.channels,
									  out_count,
									  is->
									  audio_tgt.fmt,
									  0);
				int len2;
				if (out_size < 0) {
					av_log(NULL, AV_LOG_ERROR,
					       "av_samples_get_buffer_size() failed\n");
					break;
				}
				if (wanted_nb_samples != is->frame->nb_samples) {
					if (swr_set_compensation
					    (is->swr_ctx,
					     (wanted_nb_samples -
					      is->frame->nb_samples) *
					     is->audio_tgt.freq /
					     is->frame->sample_rate,
					     wanted_nb_samples *
					     is->audio_tgt.freq /
					     is->frame->sample_rate) < 0) {
						av_log(NULL, AV_LOG_ERROR,
						       "swr_set_compensation() failed\n");
						break;
					}
				}
				av_fast_malloc(&is->audio_buf1,
					       &is->audio_buf1_size, out_size);
				if (!is->audio_buf1)
					return AVERROR(ENOMEM);
				len2 =
				    swr_convert(is->swr_ctx, out, out_count, in,
						is->frame->nb_samples);
				if (len2 < 0) {
					av_log(NULL, AV_LOG_ERROR,
					       "swr_convert() failed\n");
					break;
				}
				if (len2 == out_count) {
					av_log(NULL, AV_LOG_WARNING,
					       "audio buffer is probably too small\n");
					swr_init(is->swr_ctx);
				}
				is->audio_buf = is->audio_buf1;
				resampled_data_size =
				    len2 * is->audio_tgt.channels *
				    av_get_bytes_per_sample(is->audio_tgt.fmt);
			} else {
				is->audio_buf = is->frame->data[0];
				resampled_data_size = data_size;
			}

			audio_clock0 = is->audio_clock;
			/* update the audio clock with the pts */
			if (is->frame->pts != AV_NOPTS_VALUE)
				is->audio_clock =
				    is->frame->pts * av_q2d(tb) +
				    (double)is->frame->nb_samples /
				    is->frame->sample_rate;
			else
				is->audio_clock = NAN;
			is->audio_clock_serial = is->audio_pkt_temp_serial;
#ifdef DEBUG
			{
				static double last_clock;
				printf
				    ("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
				     is->audio_clock - last_clock,
				     is->audio_clock, audio_clock0);
				last_clock = is->audio_clock;
			}
#endif
			return resampled_data_size;
		}

		/* free the current packet */
		if (pkt->data)
			av_free_packet(pkt);
		memset(pkt_temp, 0, sizeof(*pkt_temp));
		pkt_temp->stream_index = -1;

		if (is->audioq.abort_request) {
			return -1;
		}

		if (is->audioq.nb_packets == 0)
			pthread_cond_signal(&is->continue_read_thread);

		/* read next packet */
		if ((packet_queue_get
		     (&is->audioq, pkt, 1, &is->audio_pkt_temp_serial)) < 0)
			return -1;

		/* XXX: is it right time to do it? */
		if (pkt->data == NULL && pkt->size == 0 && !is->eof_event_sent) {
			is->eof_event_sent = 1;
			is->eventmgr->send_event(is->eventmgr, LFP_EVENT_EOF,
						 NULL);
		}

		if (pkt->data == flush_pkt.data) {
			avcodec_flush_buffers(dec);
			is->audio_buf_frames_pending = 0;
			is->audio_frame_next_pts = AV_NOPTS_VALUE;
			if ((is->ic->
			     iformat->flags & (AVFMT_NOBINSEARCH |
					       AVFMT_NOGENSEARCH |
					       AVFMT_NO_BYTE_SEEK))
			    && !is->ic->iformat->read_seek)
				is->audio_frame_next_pts =
				    is->audio_st->start_time;
		}

		*pkt_temp = *pkt;
	}
}

/* prepare a new audio buffer */
static void libffplay_audio_callback(void *opaque, void *stream, size_t len)
{
	VideoState *is = opaque;
	int audio_size, len1;
	double ts = libffplay_tell(opaque);

	audio_callback_time = av_gettime();

	is->eventmgr->send_event(is->eventmgr, LFP_EVENT_TIMESTAMP,
				 (void *)&ts);

	while (len > 0) {
		if (is->audio_buf_index >= is->audio_buf_size) {
			audio_size = audio_decode_frame(is);
			if (audio_size < 0) {
				/* if error, just output silence */
				is->audio_buf = is->silence_buf;
				is->audio_buf_size =
				    sizeof(is->silence_buf) /
				    is->audio_tgt.frame_size *
				    is->audio_tgt.frame_size;
			} else {
				if (is->show_mode != SHOW_MODE_VIDEO)
					update_sample_display(is,
							      (int16_t *)
							      is->audio_buf,
							      audio_size);
				is->audio_buf_size = audio_size;
			}
			is->audio_buf_index = 0;
		}
		len1 = is->audio_buf_size - is->audio_buf_index;
		if (len1 > len)
			len1 = len;
		memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index,
		       len1);
		len -= len1;
		stream += len1;
		is->audio_buf_index += len1;
	}
	is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
	/* Let's assume the audio driver that is used by SDL has two periods. */
	if (!isnan(is->audio_clock)) {
		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);
		sync_clock_to_slave(&is->extclk, &is->audclk);
	}
}

static int audio_open(void *opaque, int64_t wanted_channel_layout,
		      int wanted_nb_channels, int wanted_sample_rate,
		      struct AudioParams *audio_hw_params)
{
	int res;
	VideoState *is = opaque;

	/* TODO: using stereo, 16 bit for now */
	res = is->audiomgr->open_device(is->audiomgr, wanted_sample_rate, 2,
					16, opaque, libffplay_audio_callback);
	if (res < 0) {
		av_log(NULL, AV_LOG_ERROR, "Failed to open audio device: %d\n",
		       res);
		return res;
	}

	audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
	audio_hw_params->freq = wanted_sample_rate;
	audio_hw_params->channel_layout = av_get_default_channel_layout(2);
	audio_hw_params->channels = 2;
	audio_hw_params->frame_size =
	    av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1,
				       audio_hw_params->fmt, 1);
	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);
	if (audio_hw_params->bytes_per_sec <= 0
	    || audio_hw_params->frame_size <= 0) {
		av_log(NULL, AV_LOG_ERROR,
		       "av_samples_get_buffer_size failed\n");
		return -1;
	}
	return res;
}

/* open a given stream. Return 0 if OK */
static int stream_component_open(VideoState * is, int stream_index)
{
	AVFormatContext *ic = is->ic;
	AVCodecContext *avctx;
	AVCodec *codec;
	const char *forced_codec_name = NULL;
	int sample_rate, nb_channels;
	int64_t channel_layout;
	int ret;
	int stream_lowres = lowres;

	if (stream_index < 0 || stream_index >= ic->nb_streams)
		return -1;
	avctx = ic->streams[stream_index]->codec;

	codec = avcodec_find_decoder(avctx->codec_id);

	switch (avctx->codec_type) {
	case AVMEDIA_TYPE_AUDIO:
		is->last_audio_stream = stream_index;
		forced_codec_name = audio_codec_name;
		break;
	case AVMEDIA_TYPE_SUBTITLE:
		is->last_subtitle_stream = stream_index;
		forced_codec_name = subtitle_codec_name;
		break;
	case AVMEDIA_TYPE_VIDEO:
		is->last_video_stream = stream_index;
		forced_codec_name = video_codec_name;
		break;
	default:
		break;
	}
	if (forced_codec_name)
		codec = avcodec_find_decoder_by_name(forced_codec_name);
	if (!codec) {
		if (forced_codec_name)
			av_log(NULL, AV_LOG_WARNING,
			       "No codec could be found with name '%s'\n",
			       forced_codec_name);
		else
			av_log(NULL, AV_LOG_WARNING,
			       "No codec could be found with id %d\n",
			       avctx->codec_id);
		return -1;
	}

	avctx->codec_id = codec->id;
	avctx->workaround_bugs = workaround_bugs;
	if (stream_lowres > av_codec_get_max_lowres(codec)) {
		av_log(avctx, AV_LOG_WARNING,
		       "The maximum value for lowres supported by the decoder is %d\n",
		       av_codec_get_max_lowres(codec));
		stream_lowres = av_codec_get_max_lowres(codec);
	}
	av_codec_set_lowres(avctx, stream_lowres);
	avctx->error_concealment = error_concealment;

	if (stream_lowres)
		avctx->flags |= CODEC_FLAG_EMU_EDGE;
	if (fast)
		avctx->flags2 |= CODEC_FLAG2_FAST;
	if (codec->capabilities & CODEC_CAP_DR1)
		avctx->flags |= CODEC_FLAG_EMU_EDGE;

	//opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
	//if (!av_dict_get(opts, "threads", NULL, 0))
	//    av_dict_set(&opts, "threads", "auto", 0);
	//if (stream_lowres)
	//    av_dict_set(&opts, "lowres", av_asprintf("%d", stream_lowres), AV_DICT_DONT_STRDUP_VAL);
	//if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
	//    av_dict_set(&opts, "refcounted_frames", "1", 0);
	if (avcodec_open2(avctx, codec, NULL) < 0)
		return -1;
	//if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
	//    av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
	//    return AVERROR_OPTION_NOT_FOUND;
	//}

	ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
	switch (avctx->codec_type) {
	case AVMEDIA_TYPE_AUDIO:
		{
			AVFilterLink *link;

			is->audio_filter_src.freq = avctx->sample_rate;
			is->audio_filter_src.channels = avctx->channels;
			is->audio_filter_src.channel_layout =
			    get_valid_channel_layout(avctx->channel_layout,
						     avctx->channels);
			is->audio_filter_src.fmt = avctx->sample_fmt;
			if ((ret =
			     configure_audio_filters(is, afilters, 0)) < 0)
				return ret;
			link = is->out_audio_filter->inputs[0];
			sample_rate = link->sample_rate;
			nb_channels = link->channels;
			channel_layout = link->channel_layout;
		}

		/* prepare audio output */
		if ((ret =
		     audio_open(is, channel_layout, nb_channels, sample_rate,
				&is->audio_tgt)) < 0)
			return ret;
		is->audio_hw_buf_size = ret;
		is->audio_src = is->audio_tgt;
		is->audio_buf_size = 0;
		is->audio_buf_index = 0;

		/* init averaging filter */
		is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
		is->audio_diff_avg_count = 0;
		/* since we do not have a precise anough audio fifo fullness,
		   we correct audio sync only if larger than this threshold */
		is->audio_diff_threshold =
		    2.0 * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec;

		memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
		memset(&is->audio_pkt_temp, 0, sizeof(is->audio_pkt_temp));
		is->audio_pkt_temp.stream_index = -1;

		is->audio_stream = stream_index;
		is->audio_st = ic->streams[stream_index];

		packet_queue_start(&is->audioq);
		break;
	case AVMEDIA_TYPE_VIDEO:
		is->video_stream = stream_index;
		is->video_st = ic->streams[stream_index];

		packet_queue_start(&is->videoq);
		pthread_create(&is->video_tid, NULL, video_thread, is);
		is->queue_attachments_req = 1;
		break;
#if 0
	case AVMEDIA_TYPE_SUBTITLE:
		is->subtitle_stream = stream_index;
		is->subtitle_st = ic->streams[stream_index];
		packet_queue_start(&is->subtitleq);

		pthread_create(&is->subtitle_tid, NULL, subtitle_thread, is);
		break;
#endif
	default:
		break;
	}
	return 0;
}

static void stream_component_close(VideoState * is, int stream_index)
{
	AVFormatContext *ic = is->ic;
	AVCodecContext *avctx;

	if (stream_index < 0 || stream_index >= ic->nb_streams)
		return;
	avctx = ic->streams[stream_index]->codec;

	switch (avctx->codec_type) {
	case AVMEDIA_TYPE_AUDIO:
		packet_queue_abort(&is->audioq);

		is->audiomgr->close_device(is->audiomgr);

		packet_queue_flush(&is->audioq);
		av_free_packet(&is->audio_pkt);
		swr_free(&is->swr_ctx);
		av_freep(&is->audio_buf1);
		is->audio_buf1_size = 0;
		is->audio_buf = NULL;
		av_frame_free(&is->frame);

		if (is->rdft) {
			av_rdft_end(is->rdft);
			av_freep(&is->rdft_data);
			is->rdft = NULL;
			is->rdft_bits = 0;
		}
		avfilter_graph_free(&is->agraph);
		break;
	case AVMEDIA_TYPE_VIDEO:
		packet_queue_abort(&is->videoq);

		/* note: we also signal this mutex to make sure we deblock the
		   video thread in all cases */
		pthread_mutex_lock(&is->pictq_mutex);
		pthread_cond_signal(&is->pictq_cond);
		pthread_mutex_unlock(&is->pictq_mutex);

		pthread_join(is->video_tid, NULL);

		packet_queue_flush(&is->videoq);
		break;
	case AVMEDIA_TYPE_SUBTITLE:
		packet_queue_abort(&is->subtitleq);

		/* note: we also signal this mutex to make sure we deblock the
		   video thread in all cases */
		pthread_mutex_lock(&is->subpq_mutex);
		pthread_cond_signal(&is->subpq_cond);
		pthread_mutex_unlock(&is->subpq_mutex);

		pthread_join(is->subtitle_tid, NULL);

		packet_queue_flush(&is->subtitleq);
		break;
	default:
		break;
	}

	ic->streams[stream_index]->discard = AVDISCARD_ALL;
	avcodec_close(avctx);
	switch (avctx->codec_type) {
	case AVMEDIA_TYPE_AUDIO:
		is->audio_st = NULL;
		is->audio_stream = -1;
		break;
	case AVMEDIA_TYPE_VIDEO:
		is->video_st = NULL;
		is->video_stream = -1;
		break;
	case AVMEDIA_TYPE_SUBTITLE:
		is->subtitle_st = NULL;
		is->subtitle_stream = -1;
		break;
	default:
		break;
	}
}

static int decode_interrupt_cb(void *ctx)
{
	VideoState *is = ctx;
	return is->abort_request;
}

static int is_realtime(AVFormatContext * s)
{
	if (!strcmp(s->iformat->name, "rtp")
	    || !strcmp(s->iformat->name, "rtsp")
	    || !strcmp(s->iformat->name, "sdp")
	    )
		return 1;

	if (s->pb && (!strncmp(s->filename, "rtp:", 4)
		      || !strncmp(s->filename, "udp:", 4)
	    )
	    )
		return 1;
	return 0;
}

/* this thread gets the stream from the disk or the network */
static void *read_thread(void *arg)
{
	VideoState *is = arg;
	AVFormatContext *ic = NULL;
	int err, i, ret;
	int st_index[AVMEDIA_TYPE_NB];
	AVPacket pkt1, *pkt = &pkt1;
	int eof = 0;
	int64_t stream_start_time;
	int pkt_in_play_range = 0;
	pthread_mutex_t wait_mutex;
	pthread_mutex_init(&wait_mutex, NULL);

	memset(st_index, -1, sizeof(st_index));
	is->last_video_stream = is->video_stream = -1;
	is->last_audio_stream = is->audio_stream = -1;
	is->last_subtitle_stream = is->subtitle_stream = -1;

	ic = avformat_alloc_context();
	ic->interrupt_callback.callback = decode_interrupt_cb;
	ic->interrupt_callback.opaque = is;
	err = avformat_open_input(&ic, is->filename, is->iformat, NULL);
	if (err < 0) {
		av_log(NULL, AV_LOG_ERROR, "Failed to open file %s\n",
		       is->filename);
		ret = -1;
		goto fail;
	}
	is->ic = ic;

	if (genpts)
		ic->flags |= AVFMT_FLAG_GENPTS;

	err = avformat_find_stream_info(ic, NULL);
	if (err < 0) {
		av_log(NULL, AV_LOG_WARNING,
		       "%s: could not find codec parameters\n", is->filename);
		ret = -1;
		goto fail;
	}

	if (ic->pb)
		ic->pb->eof_reached = 0;	// FIXME hack, ffplay maybe should not use url_feof() to test for the end

	if (seek_by_bytes < 0)
		seek_by_bytes = ! !(ic->iformat->flags & AVFMT_TS_DISCONT)
		    && strcmp("ogg", ic->iformat->name);

	is->max_frame_duration =
	    (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;

#if 0
	if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
		window_title = av_asprintf("%s - %s", t->value, is->filename);
#endif

	/* if seeking requested, we execute it */
	if (start_time != AV_NOPTS_VALUE) {
		int64_t timestamp;

		timestamp = start_time;
		/* add the stream start time */
		if (ic->start_time != AV_NOPTS_VALUE)
			timestamp += ic->start_time;
		ret =
		    avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX,
				       0);
		if (ret < 0) {
			av_log(NULL, AV_LOG_WARNING,
			       "%s: could not seek to position %0.3f\n",
			       is->filename, (double)timestamp / AV_TIME_BASE);
		}
	}

	is->realtime = is_realtime(ic);

	for (i = 0; i < ic->nb_streams; i++)
		ic->streams[i]->discard = AVDISCARD_ALL;
	if (!video_disable)
		st_index[AVMEDIA_TYPE_VIDEO] =
		    av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
					wanted_stream[AVMEDIA_TYPE_VIDEO], -1,
					NULL, 0);
	if (!audio_disable)
		st_index[AVMEDIA_TYPE_AUDIO] =
		    av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
					wanted_stream[AVMEDIA_TYPE_AUDIO],
					st_index[AVMEDIA_TYPE_VIDEO], NULL, 0);
	if (!video_disable && !subtitle_disable)
		st_index[AVMEDIA_TYPE_SUBTITLE] =
		    av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
					wanted_stream[AVMEDIA_TYPE_SUBTITLE],
					(st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
					 st_index[AVMEDIA_TYPE_AUDIO] :
					 st_index[AVMEDIA_TYPE_VIDEO]),
					NULL, 0);
	if (show_status) {
		av_dump_format(ic, 0, is->filename, 0);
	}
	/* read completed */
	pthread_mutex_lock(&is->container_parsed_mutex);
	is->container_parsed = 1;
	pthread_cond_signal(&is->container_parsed_cond);
	pthread_mutex_unlock(&is->container_parsed_mutex);

	/* Wait for trigger... */
	pthread_mutex_lock(&is->read_trigger_mutex);
	if (!is->read_triggered)
		pthread_cond_wait(&is->read_trigger_cond, &is->read_trigger_mutex);
	pthread_mutex_unlock(&is->read_trigger_mutex);

	is->show_mode = show_mode;
#if 0
	if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
		AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
		AVCodecContext *avctx = st->codec;
		AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
		libffplay_picture_t vp = {
			.width = avctx->width,
			.height = avctx->height,
			.sar_num = sar.num,
			.sar_den = sar.den,
		};
		if (vp.width)
			set_default_window_size(&vp);
	}
#endif

	/* open the streams */
	if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
		stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
	}

	ret = -1;
	if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
		ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
	}
	if (is->show_mode == SHOW_MODE_NONE)
		is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;

	if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
		stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
	}

	if (is->video_stream < 0 && is->audio_stream < 0) {
		av_log(NULL, AV_LOG_FATAL,
		       "Failed to open file '%s' or configure filtergraph\n",
		       is->filename);
		ret = -1;
		goto fail;
	}

	if (infinite_buffer < 0 && is->realtime)
		infinite_buffer = 1;

	for (;;) {
		if (is->abort_request)
			break;
		if (is->paused != is->last_paused) {
			is->last_paused = is->paused;
			if (is->paused)
				is->read_pause_return = av_read_pause(ic);
			else
				av_read_play(ic);
		}
#if 0				/* CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL */
		if (is->paused &&
		    (!strcmp(ic->iformat->name, "rtsp") ||
		     (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
			/* wait 10 ms to avoid trying to get another packet */
			/* XXX: horrible */
			SDL_Delay(10);
			continue;
		}
#endif
		if (is->seek_req) {
			int64_t seek_target = is->seek_pos;
			int64_t seek_min =
			    is->seek_rel >
			    0 ? seek_target - is->seek_rel + 2 : INT64_MIN;
			int64_t seek_max =
			    is->seek_rel <
			    0 ? seek_target - is->seek_rel - 2 : INT64_MAX;
// FIXME the +-2 is due to rounding being not done in the correct direction in generation
//      of the seek_pos/seek_rel variables

			ret =
			    avformat_seek_file(is->ic, -1, seek_min,
					       seek_target, seek_max,
					       is->seek_flags);
			if (ret < 0) {
				av_log(NULL, AV_LOG_ERROR,
				       "%s: error while seeking\n",
				       is->ic->filename);
			} else {
				if (is->audio_stream >= 0) {
					packet_queue_flush(&is->audioq);
					packet_queue_put(&is->audioq,
							 &flush_pkt);
				}
				if (is->subtitle_stream >= 0) {
					packet_queue_flush(&is->subtitleq);
					packet_queue_put(&is->subtitleq,
							 &flush_pkt);
				}
				if (is->video_stream >= 0) {
					packet_queue_flush(&is->videoq);
					packet_queue_put(&is->videoq,
							 &flush_pkt);
				}
				if (is->seek_flags & AVSEEK_FLAG_BYTE) {
					set_clock(&is->extclk, NAN, 0);
				} else {
					set_clock(&is->extclk,
						  seek_target /
						  (double)AV_TIME_BASE, 0);
				}
			}
			is->seek_req = 0;
			is->queue_attachments_req = 1;
			eof = 0;
			if (is->paused)
				step_to_next_frame(is);
		}
		if (is->queue_attachments_req) {
			if (is->video_st
			    && is->
			    video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)
			{
				AVPacket copy;
				if ((ret =
				     av_copy_packet(&copy,
						    &is->
						    video_st->attached_pic)) <
				    0)
					goto fail;
				packet_queue_put(&is->videoq, &copy);
				packet_queue_put_nullpacket(&is->videoq,
							    is->video_stream);
			}
			is->queue_attachments_req = 0;
		}

		/* if the queue are full, no need to read more */
		if (infinite_buffer < 1 &&
		    (is->audioq.size + is->videoq.size + is->subtitleq.size >
		     MAX_QUEUE_SIZE
		     ||
		     ((is->audioq.nb_packets > MIN_FRAMES
		       || is->audio_stream < 0 || is->audioq.abort_request)
		      && (is->videoq.nb_packets > MIN_FRAMES
			  || is->video_stream < 0 || is->videoq.abort_request
			  || (is->
			      video_st->disposition &
			      AV_DISPOSITION_ATTACHED_PIC))
		      && (is->subtitleq.nb_packets > MIN_FRAMES
			  || is->subtitle_stream < 0
			  || is->subtitleq.abort_request)))) {
			struct timespec ts;
			struct timeval tv;

			gettimeofday(&tv, NULL);
			memset(&ts, 0, sizeof(ts));
			ts.tv_sec = tv.tv_sec;
			ts.tv_nsec = tv.tv_usec * 1000 + 10 * 1000 * 1000;
			/* wait 10 ms */
			pthread_mutex_lock(&wait_mutex);
			pthread_cond_timedwait(&is->continue_read_thread,
					       &wait_mutex, &ts);
			pthread_mutex_unlock(&wait_mutex);
			continue;
		}
		if (!is->paused &&
		    (!is->audio_st || is->audio_finished == is->audioq.serial)
		    && (!is->video_st
			|| (is->video_finished == is->videoq.serial
			    && is->pictq_size == 0))) {
			if (loop != 1 && (!loop || --loop)) {
				stream_seek(is,
					    start_time !=
					    AV_NOPTS_VALUE ? start_time : 0, 0,
					    0);
			} else if (autoexit) {
				ret = AVERROR_EOF;
				goto fail;
			}
		}
		if (eof) {
			if (is->video_stream >= 0)
				packet_queue_put_nullpacket(&is->videoq,
							    is->video_stream);
			if (is->audio_stream >= 0)
				packet_queue_put_nullpacket(&is->audioq,
							    is->audio_stream);
			if (is->subtitle_stream >= 0)
				packet_queue_put_nullpacket(&is->subtitleq,
							    is->subtitle_stream);
			av_usleep(10000);
			eof = 0;
			continue;
		}
		ret = av_read_frame(ic, pkt);
		if (ret < 0) {
			struct timespec ts;
			struct timeval tv;

			gettimeofday(&tv, NULL);
			memset(&ts, 0, sizeof(ts));
			ts.tv_sec = tv.tv_sec;
			ts.tv_nsec = tv.tv_usec * 1000 + 10 * 1000 * 1000;
			if (ret == AVERROR_EOF || url_feof(ic->pb))
				eof = 1;
			if (ic->pb && ic->pb->error)
				break;
			pthread_mutex_lock(&wait_mutex);
			pthread_cond_timedwait(&is->continue_read_thread,
					       &wait_mutex, &ts);
			pthread_mutex_unlock(&wait_mutex);
			continue;
		}
		/* check if packet is in play range specified by user, then queue, otherwise discard */
		stream_start_time = ic->streams[pkt->stream_index]->start_time;
		pkt_in_play_range = duration == AV_NOPTS_VALUE ||
		    (pkt->pts -
		     (stream_start_time !=
		      AV_NOPTS_VALUE ? stream_start_time : 0)) *
		    av_q2d(ic->streams[pkt->stream_index]->time_base) -
		    (double)(start_time !=
			     AV_NOPTS_VALUE ? start_time : 0) / 1000000 <=
		    ((double)duration / 1000000);
		if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
			packet_queue_put(&is->audioq, pkt);
		} else if (pkt->stream_index == is->video_stream
			   && pkt_in_play_range
			   && !(is->
				video_st->disposition &
				AV_DISPOSITION_ATTACHED_PIC)) {
			packet_queue_put(&is->videoq, pkt);
		} else if (pkt->stream_index == is->subtitle_stream
			   && pkt_in_play_range) {
			packet_queue_put(&is->subtitleq, pkt);
		} else {
			av_free_packet(pkt);
		}
	}
	/* wait until the end */
	while (!is->abort_request) {
		av_usleep(10000);
	}

	ret = 0;
fail:
	/* close each stream */
	if (is->audio_stream >= 0)
		stream_component_close(is, is->audio_stream);
	if (is->video_stream >= 0)
		stream_component_close(is, is->video_stream);
	if (is->subtitle_stream >= 0)
		stream_component_close(is, is->subtitle_stream);
	if (is->ic) {
		avformat_close_input(&is->ic);
	}
	if (ret != 0 && is->eof_event_sent) {
		is->eof_event_sent = 1;
		is->eventmgr->send_event(is->eventmgr, LFP_EVENT_EOF, NULL);
	}
	pthread_mutex_destroy(&wait_mutex);
	return 0;
}

int stream_open(struct VideoState *is, const char *filename,
		AVInputFormat * iformat)
{
	av_strlcpy(is->filename, filename, sizeof(is->filename));
	is->iformat = iformat;
	is->ytop = 0;
	is->xleft = 0;

	pthread_mutex_init(&is->read_trigger_mutex, NULL);
	pthread_cond_init(&is->read_trigger_cond, NULL);
	pthread_mutex_init(&is->container_parsed_mutex, NULL);
	pthread_cond_init(&is->container_parsed_cond, NULL);

	pthread_mutex_init(&is->pictq_mutex, NULL);
	pthread_cond_init(&is->pictq_cond, NULL);

	pthread_mutex_init(&is->subpq_mutex, NULL);
	pthread_cond_init(&is->subpq_cond, NULL);

	packet_queue_init(&is->videoq);
	packet_queue_init(&is->audioq);
	packet_queue_init(&is->subtitleq);

	pthread_cond_init(&is->continue_read_thread, NULL);

	init_clock(&is->vidclk, &is->videoq.serial);
	init_clock(&is->audclk, &is->audioq.serial);
	init_clock(&is->extclk, &is->extclk.serial);
	is->audio_clock_serial = -1;
	is->audio_last_serial = -1;
	is->av_sync_type = av_sync_type;
	pthread_create(&is->read_tid, NULL, read_thread, is);
	if (!is->read_tid) {
		return -ENOMEM;
	}
	return 0;
}

#if 0
static void stream_cycle_channel(VideoState * is, int codec_type)
{
	AVFormatContext *ic = is->ic;
	int start_index, stream_index;
	int old_index;
	AVStream *st;
	AVProgram *p = NULL;
	int nb_streams = is->ic->nb_streams;

	if (codec_type == AVMEDIA_TYPE_VIDEO) {
		start_index = is->last_video_stream;
		old_index = is->video_stream;
	} else if (codec_type == AVMEDIA_TYPE_AUDIO) {
		start_index = is->last_audio_stream;
		old_index = is->audio_stream;
	} else {
		start_index = is->last_subtitle_stream;
		old_index = is->subtitle_stream;
	}
	stream_index = start_index;

	if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
		p = av_find_program_from_stream(ic, NULL, is->video_stream);
		if (p) {
			nb_streams = p->nb_stream_indexes;
			for (start_index = 0; start_index < nb_streams;
			     start_index++)
				if (p->stream_index[start_index] ==
				    stream_index)
					break;
			if (start_index == nb_streams)
				start_index = -1;
			stream_index = start_index;
		}
	}

	for (;;) {
		if (++stream_index >= nb_streams) {
			if (codec_type == AVMEDIA_TYPE_SUBTITLE) {
				stream_index = -1;
				is->last_subtitle_stream = -1;
				goto the_end;
			}
			if (start_index == -1)
				return;
			stream_index = 0;
		}
		if (stream_index == start_index)
			return;
		st = is->ic->
		    streams[p ? p->stream_index[stream_index] : stream_index];
		if (st->codec->codec_type == codec_type) {
			/* check that parameters are OK */
			switch (codec_type) {
			case AVMEDIA_TYPE_AUDIO:
				if (st->codec->sample_rate != 0 &&
				    st->codec->channels != 0)
					goto the_end;
				break;
			case AVMEDIA_TYPE_VIDEO:
			case AVMEDIA_TYPE_SUBTITLE:
				goto the_end;
			default:
				break;
			}
		}
	}
the_end:
	if (p && stream_index != -1)
		stream_index = p->stream_index[stream_index];
	stream_component_close(is, old_index);
	stream_component_open(is, stream_index);
}
#endif

#if 0
static void toggle_full_screen(VideoState * is)
{
#if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
	/* OS X needs to reallocate the SDL overlays */
	int i;
	for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
		is->pictq[i].reallocate = 1;
#endif
	is_full_screen = !is_full_screen;
	video_open(is, 1, NULL);
}

static void toggle_audio_display(VideoState * is)
{
	int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
	int next = is->show_mode;
	do {
		next = (next + 1) % SHOW_MODE_NB;
	} while (next != is->show_mode
		 && (next == SHOW_MODE_VIDEO && !is->video_st
		     || next != SHOW_MODE_VIDEO && !is->audio_st));
	if (is->show_mode != next) {
		fill_rectangle(screen,
			       is->xleft, is->ytop, is->width, is->height,
			       bgcolor, 1);
		is->force_refresh = 1;
		is->show_mode = next;
	}
}
#endif

#if 0
static void refresh_loop_wait_event(VideoState * is, SDL_Event * event)
{
	double remaining_time = 0.0;
	SDL_PumpEvents();
	while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
		if (!cursor_hidden
		    && av_gettime() - cursor_last_shown > CURSOR_HIDE_DELAY) {
			SDL_ShowCursor(0);
			cursor_hidden = 1;
		}
		if (remaining_time > 0.0)
			av_usleep((int64_t) (remaining_time * 1000000.0));
		remaining_time = REFRESH_RATE;
		if (is->show_mode != SHOW_MODE_NONE
		    && (!is->paused || is->force_refresh))
			video_refresh(is, &remaining_time);
		SDL_PumpEvents();
	}
}

static void seek_chapter(VideoState * is, int incr)
{
	int64_t pos = get_master_clock(is) * AV_TIME_BASE;
	int i;

	if (!is->ic->nb_chapters)
		return;

	/* find the current chapter */
	for (i = 0; i < is->ic->nb_chapters; i++) {
		AVChapter *ch = is->ic->chapters[i];
		if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base)
		    < 0) {
			i--;
			break;
		}
	}

	i += incr;
	i = FFMAX(i, 0);
	if (i >= is->ic->nb_chapters)
		return;

	av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
	stream_seek(is,
		    av_rescale_q(is->ic->chapters[i]->start,
				 is->ic->chapters[i]->time_base,
				 AV_TIME_BASE_Q), 0, 0);
}
#endif

static int lockmgr(void **mutex, enum AVLockOp op)
{
	int r;
	switch (op) {
	case AV_LOCK_CREATE:
		{
			pthread_mutex_t *mtx_ptr;
			mtx_ptr = calloc(1, sizeof(*mtx_ptr));
			if (!mtx_ptr) {
				av_log(NULL, AV_LOG_ERROR,
				       "mutex alloc fail\n");
				return 1;
			}
			r = pthread_mutex_init(mtx_ptr, NULL);
			if (r) {
				av_log(NULL, AV_LOG_ERROR,
				       "mutex create fail\n");
				free(mtx_ptr);
				return 1;
			}
			*mutex = mtx_ptr;
			return 0;
		}
	case AV_LOCK_DESTROY:
		pthread_mutex_destroy(*mutex);
		free(*mutex);
		return 0;
	case AV_LOCK_OBTAIN:
		return pthread_mutex_lock(*mutex);
	case AV_LOCK_RELEASE:
		return pthread_mutex_unlock(*mutex);
	default:
		return -EINVAL;
	}
}

/* Called from the main */
libffplay_ctx_t *libffplay_init(void)
{
	VideoState *is;

	av_log_set_flags(AV_LOG_SKIP_REPEATED);

	/* register all codecs, demux and protocols */
	avdevice_register_all();
	avfilter_register_all();
	av_register_all();
	avformat_network_init();

	signal(SIGINT, sigterm_handler);	/* Interrupt (ANSI).    */
	signal(SIGTERM, sigterm_handler);	/* Termination (ANSI).  */

#if 0
	flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
	if (audio_disable)
		flags &= ~SDL_INIT_AUDIO;
	if (display_disable)
		SDL_putenv(dummy_videodriver);	/* For the event queue, we always need a video driver. */
#if !defined(__MINGW32__) && !defined(__APPLE__)
	flags |= SDL_INIT_EVENTTHREAD;	/* Not supported on Windows or Mac OS X */
#endif
	if (SDL_Init(flags)) {
		av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n",
		       SDL_GetError());
		av_log(NULL, AV_LOG_FATAL,
		       "(Did you set the DISPLAY variable?)\n");
		exit(1);
	}

	if (!display_disable) {
		const SDL_VideoInfo *vi = SDL_GetVideoInfo();
		fs_screen_width = vi->current_w;
		fs_screen_height = vi->current_h;
	}

	SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
	SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
	SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
#endif

	if (av_lockmgr_register(lockmgr)) {
		av_log(NULL, AV_LOG_FATAL,
		       "Could not initialize lock manager!\n");
		do_stop(NULL);
	}

	av_init_packet(&flush_pkt);
	flush_pkt.data = (uint8_t *) & flush_pkt;

	is = av_mallocz(sizeof(VideoState));
	if (!is)
		return NULL;

	return (libffplay_ctx_t *) is;
}

int libffplay_open(libffplay_ctx_t * ctx, const char *filename)
{
	int res;
	struct VideoState *is = (struct VideoState *)ctx;

	is->container_parsed = 0;
	is->read_triggered = 0;
	res = stream_open(is, filename, file_iformat);

	return res;
}

void libffplay_start_play(libffplay_ctx_t * ctx)
{
	struct VideoState *is = (struct VideoState *)ctx;

	pthread_mutex_lock(&is->read_trigger_mutex);
	is->read_triggered = 1;
	pthread_cond_signal(&is->read_trigger_cond);
	pthread_mutex_unlock(&is->read_trigger_mutex);
}

void libffplay_set_audiomgr(libffplay_ctx_t * ctx,
			    libffplay_audiomgr_t * audiomgr)
{
	ctx->is.audiomgr = audiomgr;
}

void libffplay_set_videomgr(libffplay_ctx_t * ctx,
			    libffplay_videomgr_t * videomgr)
{
	ctx->is.videomgr = videomgr;
}

void libffplay_set_eventmgr(libffplay_ctx_t * ctx,
			    libffplay_eventmgr_t * eventmgr)
{
	ctx->is.eventmgr = eventmgr;
}

void libffplay_stop(libffplay_ctx_t * ctx)
{
	VideoState *is = (struct VideoState *)ctx;
	do_stop(is);
}

void libffplay_pause(libffplay_ctx_t * ctx)
{
	VideoState *is = (struct VideoState *)ctx;
	if (is->paused)
		return;
	toggle_pause(is);
}

void libffplay_resume(libffplay_ctx_t * ctx)
{
	VideoState *is = (struct VideoState *)ctx;
	if (!is->paused)
		return;
	stream_toggle_pause(is);
}

void libffplay_toggle_pause(libffplay_ctx_t * ctx)
{
	VideoState *is = (struct VideoState *)ctx;
	stream_toggle_pause(is);
}

void libffplay_seek(libffplay_ctx_t * ctx, double wanted_pos, int whence)
{
	VideoState *is = (struct VideoState *)ctx;
	double incr, pos;
	if (seek_by_bytes) {
		/* TODO */
		av_log(NULL, AV_LOG_ERROR,
		       "Stream seek by bytes is not supported yet!\n");
	} else {
		pos = get_master_clock(is);
		switch (whence) {
		case LFP_SEEK_SET:
			incr = wanted_pos - pos;
			break;
		case LFP_SEEK_CUR:
			incr = wanted_pos;
			break;
		default:
			return;
		}
		if (isnan(pos))
			pos = (double)is->seek_pos / AV_TIME_BASE;
		pos += incr;
		if (is->ic->start_time != AV_NOPTS_VALUE
		    && pos < is->ic->start_time / (double)AV_TIME_BASE)
			pos = is->ic->start_time / (double)AV_TIME_BASE;
		stream_seek(is, (int64_t) (pos * AV_TIME_BASE),
			    (int64_t) (incr * AV_TIME_BASE), 0);
	}
}

double libffplay_tell(libffplay_ctx_t * ctx)
{
	double pos;
	VideoState *is = (struct VideoState *)ctx;

	pthread_mutex_lock(&is->container_parsed_mutex);
	if (!is->container_parsed)
		pthread_cond_wait(&is->container_parsed_cond, &is->container_parsed_mutex);
	pthread_mutex_unlock(&is->container_parsed_mutex);

	pos = get_master_clock(is);
	if (isnan(pos))
		pos = (double)is->seek_pos / AV_TIME_BASE;
	return pos;
}

double libffplay_stream_length(libffplay_ctx_t * ctx)
{
	VideoState *is = (struct VideoState *)ctx;

	pthread_mutex_lock(&is->container_parsed_mutex);
	if (!is->container_parsed)
		pthread_cond_wait(&is->container_parsed_cond, &is->container_parsed_mutex);
	pthread_mutex_unlock(&is->container_parsed_mutex);

	return (double)is->ic->duration / AV_TIME_BASE;
}

void libffplay_video_refresh(libffplay_ctx_t *ctx, double *remaining_time)
{
	VideoState *is = (struct VideoState *)ctx;
	if (!is->video_st) {
		if (remaining_time)
			*remaining_time = REFRESH_RATE;
	} else {
		video_refresh(is, remaining_time);
	}
}

void libffplay_deinit(libffplay_ctx_t *ctx)
{
	VideoState *is = (struct VideoState *)ctx;

	av_lockmgr_register(NULL);
	av_freep(&vfilters);
	avformat_network_deinit();
	av_log(NULL, AV_LOG_QUIET, "%s", "");
	av_free(is);
}

const char *libffplay_get_metadata(libffplay_ctx_t *ctx, const char *key)
{
	AVDictionaryEntry *tag;
	VideoState *is = (struct VideoState *)ctx;

	pthread_mutex_lock(&is->container_parsed_mutex);
	if (!is->container_parsed)
		pthread_cond_wait(&is->container_parsed_cond, &is->container_parsed_mutex);
	pthread_mutex_unlock(&is->container_parsed_mutex);

	tag = av_dict_get(is->ic->metadata, key, NULL, 0);
	if (!tag)
		return NULL;

	return tag->value;
}