static int sws_flags = SWS_BICUBIC;
+typedef struct MyAVPacketList {
+ AVPacket pkt;
+ struct MyAVPacketList *next;
+ int serial;
+} MyAVPacketList;
+
typedef struct PacketQueue {
- AVPacketList *first_pkt, *last_pkt;
+ MyAVPacketList *first_pkt, *last_pkt;
int nb_packets;
int size;
int abort_request;
+ int serial;
SDL_mutex *mutex;
SDL_cond *cond;
} PacketQueue;
AVRational sample_aspect_ratio;
int allocated;
int reallocate;
+ int serial;
#if CONFIG_AVFILTER
AVFilterBufferRef *picref;
int audio_stream;
int av_sync_type;
- double external_clock; /* external clock base */
- int64_t external_clock_time;
+ double external_clock; ///< external clock base
+ double external_clock_drift; ///< external clock base - time (av_gettime) at which we updated external_clock
+ int64_t external_clock_time; ///< last reference time
double audio_clock;
double audio_diff_cum; /* used for AV difference average computation */
int audio_write_buf_size;
AVPacket audio_pkt_temp;
AVPacket audio_pkt;
+ int audio_pkt_temp_serial;
struct AudioParams audio_src;
struct AudioParams audio_tgt;
struct SwrContext *swr_ctx;
#if !CONFIG_AVFILTER
struct SwsContext *img_convert_ctx;
#endif
+ SDL_Rect last_display_rect;
char filename[1024];
int width, height, xleft, ytop;
static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
{
- AVPacketList *pkt1;
+ MyAVPacketList *pkt1;
if (q->abort_request)
return -1;
- pkt1 = av_malloc(sizeof(AVPacketList));
+ 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;
static void packet_queue_flush(PacketQueue *q)
{
- AVPacketList *pkt, *pkt1;
+ MyAVPacketList *pkt, *pkt1;
SDL_LockMutex(q->mutex);
for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
}
/* return < 0 if aborted, 0 if no packet and > 0 if packet. */
-static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
+static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
{
- AVPacketList *pkt1;
+ MyAVPacketList *pkt1;
int ret;
SDL_LockMutex(q->mutex);
q->nb_packets--;
q->size -= pkt1->pkt.size + sizeof(*pkt1);
*pkt = pkt1->pkt;
+ if (serial)
+ *serial = pkt1->serial;
av_free(pkt1);
ret = 1;
break;
}
static inline void fill_rectangle(SDL_Surface *screen,
- int x, int y, int w, int h, int color)
+ int x, int y, int w, int h, int color, int update)
{
SDL_Rect rect;
rect.x = x;
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);
}
#define ALPHA_BLEND(a, oldp, newp, s)\
calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp);
SDL_DisplayYUVOverlay(vp->bmp, &rect);
+
+ 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;
+ }
}
}
if (s->show_mode == SHOW_MODE_WAVES) {
fill_rectangle(screen,
s->xleft, s->ytop, s->width, s->height,
- bgcolor);
+ bgcolor, 0);
fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
}
fill_rectangle(screen,
s->xleft + x, ys, 1, y,
- fgcolor);
+ fgcolor, 0);
i += channels;
if (i >= SAMPLE_ARRAY_SIZE)
i -= SAMPLE_ARRAY_SIZE;
y = s->ytop + ch * h;
fill_rectangle(screen,
s->xleft, y, s->width, 1,
- fgcolor);
+ fgcolor, 0);
}
SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
} else {
fill_rectangle(screen,
s->xpos, s->height-y, 1, 1,
- fgcolor);
+ fgcolor, 0);
}
}
SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
/* get the current external clock value */
static double get_external_clock(VideoState *is)
{
- int64_t ti;
- ti = av_gettime();
- return is->external_clock + ((ti - is->external_clock_time) * 1e-6);
+ if (is->paused) {
+ return is->external_clock;
+ } else {
+ return is->external_clock_drift + av_gettime() / 1000000.0;
+ }
}
-/* get the current master clock value */
-static double get_master_clock(VideoState *is)
-{
- double val;
-
+static int get_master_sync_type(VideoState *is) {
if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
if (is->video_st)
- val = get_video_clock(is);
+ return AV_SYNC_VIDEO_MASTER;
else
- val = get_audio_clock(is);
+ return AV_SYNC_AUDIO_MASTER;
} else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
if (is->audio_st)
- val = get_audio_clock(is);
+ return AV_SYNC_AUDIO_MASTER;
else
- val = get_video_clock(is);
+ return AV_SYNC_EXTERNAL_CLOCK;
} else {
- val = get_external_clock(is);
+ 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_video_clock(is);
+ break;
+ case AV_SYNC_AUDIO_MASTER:
+ val = get_audio_clock(is);
+ break;
+ default:
+ val = get_external_clock(is);
+ break;
}
return val;
}
+static void update_external_clock_pts(VideoState *is, double pts)
+{
+ is->external_clock_time = av_gettime();
+ is->external_clock = pts;
+ is->external_clock_drift = pts - is->external_clock_time / 1000000.0;
+}
+
+static void check_external_clock_sync(VideoState *is, double pts) {
+ if (fabs(get_external_clock(is) - pts) > AV_NOSYNC_THRESHOLD) {
+ update_external_clock_pts(is, pts);
+ }
+}
+
/* seek in the stream */
static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
{
}
is->video_current_pts_drift = is->video_current_pts - av_gettime() / 1000000.0;
}
+ update_external_clock_pts(is, get_external_clock(is));
is->paused = !is->paused;
}
double sync_threshold, diff;
/* update delay to follow master synchronisation source */
- if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) ||
- is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
+ 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_video_clock(is) - get_master_clock(is);
}
}
-static void update_video_pts(VideoState *is, double pts, int64_t pos) {
+static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
double time = av_gettime() / 1000000.0;
/* update current video pts */
is->video_current_pts = pts;
is->video_current_pts_drift = is->video_current_pts - time;
is->video_current_pos = pos;
is->frame_last_pts = pts;
+ if (is->videoq.serial == serial)
+ check_external_clock_sync(is, is->video_current_pts);
}
/* called to display each frame */
if (is->pictq_size == 0) {
SDL_LockMutex(is->pictq_mutex);
if (is->frame_last_dropped_pts != AV_NOPTS_VALUE && is->frame_last_dropped_pts > is->frame_last_pts) {
- update_video_pts(is, is->frame_last_dropped_pts, is->frame_last_dropped_pos);
+ update_video_pts(is, is->frame_last_dropped_pts, is->frame_last_dropped_pos, 0);
is->frame_last_dropped_pts = AV_NOPTS_VALUE;
}
SDL_UnlockMutex(is->pictq_mutex);
is->frame_timer += delay * FFMAX(1, floor((time-is->frame_timer) / delay));
SDL_LockMutex(is->pictq_mutex);
- update_video_pts(is, vp->pts, vp->pos);
+ update_video_pts(is, vp->pts, vp->pos, vp->serial);
SDL_UnlockMutex(is->pictq_mutex);
if (is->pictq_size > 1) {
VideoPicture *nextvp = &is->pictq[(is->pictq_rindex + 1) % VIDEO_PICTURE_QUEUE_SIZE];
duration = nextvp->pts - vp->pts;
- if((framedrop>0 || (framedrop && is->av_sync_type != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
+ if((framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
is->frame_drops_late++;
pictq_next_picture(is);
goto retry;
SDL_UnlockMutex(is->pictq_mutex);
}
-static int queue_picture(VideoState *is, AVFrame *src_frame, double pts1, int64_t pos)
+static int queue_picture(VideoState *is, AVFrame *src_frame, double pts1, int64_t pos, int serial)
{
VideoPicture *vp;
double frame_delay, pts = pts1;
vp->pts = pts;
vp->pos = pos;
vp->skip = 0;
+ vp->serial = serial;
/* now we can update the picture count */
if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
return 0;
}
-static int get_video_frame(VideoState *is, AVFrame *frame, int64_t *pts, AVPacket *pkt)
+static int get_video_frame(VideoState *is, AVFrame *frame, int64_t *pts, AVPacket *pkt, int *serial)
{
int got_picture, i;
- if (packet_queue_get(&is->videoq, pkt, 1) < 0)
+ if (packet_queue_get(&is->videoq, pkt, 1, serial) < 0)
return -1;
if (pkt->data == flush_pkt.data) {
*pts = 0;
}
- if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) || is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK) &&
- (framedrop>0 || (framedrop && is->av_sync_type != AV_SYNC_VIDEO_MASTER))) {
+ if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
SDL_LockMutex(is->pictq_mutex);
if (is->frame_last_pts != AV_NOPTS_VALUE && *pts) {
double clockdiff = get_video_clock(is) - get_master_clock(is);
goto fail;
}
- return avfilter_graph_config(graph, NULL);
+ ret = avfilter_graph_config(graph, NULL);
fail:
avfilter_inout_free(&outputs);
avfilter_inout_free(&inputs);
char buffersrc_args[256];
int ret;
AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
- AVFilterContext *filt_src = NULL, *filt_out = NULL, *filt_format, *filt_crop;
+ AVFilterContext *filt_src = NULL, *filt_out = NULL, *filt_crop;
AVCodecContext *codec = is->video_st->codec;
+ if (!buffersink_params)
+ return AVERROR(ENOMEM);
+
snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%d", sws_flags);
graph->scale_sws_opts = av_strdup(sws_flags_str);
avfilter_get_by_name("buffer"),
"ffplay_buffer", buffersrc_args, NULL,
graph)) < 0)
- return ret;
+ goto fail;
buffersink_params->pixel_fmts = pix_fmts;
ret = avfilter_graph_create_filter(&filt_out,
avfilter_get_by_name("ffbuffersink"),
"ffplay_buffersink", NULL, buffersink_params, graph);
- av_freep(&buffersink_params);
if (ret < 0)
- return ret;
+ 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)
- return ret;
- if ((ret = avfilter_graph_create_filter(&filt_format,
- avfilter_get_by_name("format"),
- "format", "yuv420p", NULL, graph)) < 0)
- return ret;
- if ((ret = avfilter_link(filt_crop, 0, filt_format, 0)) < 0)
- return ret;
- if ((ret = avfilter_link(filt_format, 0, filt_out, 0)) < 0)
- return ret;
+ 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)
- return ret;
+ goto fail;
is->in_video_filter = filt_src;
is->out_video_filter = filt_out;
+fail:
+ av_freep(&buffersink_params);
return ret;
}
int64_t pts_int = AV_NOPTS_VALUE, pos = -1;
double pts;
int ret;
+ int serial = 0;
#if CONFIG_AVFILTER
AVCodecContext *codec = is->video_st->codec;
avcodec_get_frame_defaults(frame);
av_free_packet(&pkt);
- ret = get_video_frame(is, frame, &pts_int, &pkt);
+ ret = get_video_frame(is, frame, &pts_int, &pkt, &serial);
if (ret < 0)
goto the_end;
is->video_st->time_base.num, is->video_st->time_base.den, pts_int);
}
pts = pts_int * av_q2d(is->video_st->time_base);
- ret = queue_picture(is, frame, pts, pos);
+ ret = queue_picture(is, frame, pts, pos, serial);
}
#else
pts = pts_int * av_q2d(is->video_st->time_base);
- ret = queue_picture(is, frame, pts, pkt.pos);
+ ret = queue_picture(is, frame, pts, pkt.pos, serial);
#endif
if (ret < 0)
while (is->paused && !is->subtitleq.abort_request) {
SDL_Delay(10);
}
- if (packet_queue_get(&is->subtitleq, pkt, 1) < 0)
+ if (packet_queue_get(&is->subtitleq, pkt, 1, NULL) < 0)
break;
if (pkt->data == flush_pkt.data) {
int wanted_nb_samples = nb_samples;
/* if not master, then we try to remove or add samples to correct the clock */
- if (((is->av_sync_type == AV_SYNC_VIDEO_MASTER && is->video_st) ||
- is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
+ if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
double diff, avg_diff;
int min_nb_samples, max_nb_samples;
diff = get_audio_clock(is) - get_master_clock(is);
- if (diff < AV_NOSYNC_THRESHOLD) {
+ if (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 */
SDL_CondSignal(is->continue_read_thread);
/* read next packet */
- if ((new_packet = packet_queue_get(&is->audioq, pkt, 1)) < 0)
+ if ((new_packet = packet_queue_get(&is->audioq, pkt, 1, &is->audio_pkt_temp_serial)) < 0)
return -1;
if (pkt->data == flush_pkt.data) {
/* Let's assume the audio driver that is used by SDL has two periods. */
is->audio_current_pts = is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / bytes_per_sec;
is->audio_current_pts_drift = is->audio_current_pts - audio_callback_time / 1000000.0;
+ if (is->audioq.serial == is->audio_pkt_temp_serial)
+ check_external_clock_sync(is, is->audio_current_pts);
}
static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
avctx = ic->streams[stream_index]->codec;
codec = avcodec_find_decoder(avctx->codec_id);
- opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
switch(avctx->codec_type){
case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; if(audio_codec_name ) codec= avcodec_find_decoder_by_name( audio_codec_name); break;
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 (!codec ||
- avcodec_open2(avctx, codec, &opts) < 0)
+ if (avcodec_open2(avctx, codec, &opts) < 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);
packet_queue_put(&is->videoq, &flush_pkt);
}
}
+ update_external_clock_pts(is, (seek_target + ic->start_time) / (double)AV_TIME_BASE);
is->seek_req = 0;
eof = 0;
}
is->continue_read_thread = SDL_CreateCond();
+ update_external_clock_pts(is, 0.0);
+ is->audio_current_pts_drift = -av_gettime() / 1000000.0;
+ is->video_current_pts_drift = is->audio_current_pts_drift;
is->av_sync_type = av_sync_type;
is->read_tid = SDL_CreateThread(read_thread, is);
if (!is->read_tid) {
is->show_mode = (is->show_mode + 1) % SHOW_MODE_NB;
fill_rectangle(screen,
is->xleft, is->ytop, is->width, is->height,
- bgcolor);
- SDL_UpdateRect(screen, is->xleft, is->ytop, is->width, is->height);
+ bgcolor, 1);
}
/* handle an event sent by the GUI */
projects / ffmpeg / blobdiff