RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'pause'

This commit is contained in:
Uoti Urpala 2009-01-15 00:29:51 +02:00
parent c1b80dcbbb 38a76f7fdf
commit 02bc48b67d
15 changed files with 620 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
command.c
View File

@ -2,6 +2,7 @@
#include <inttypes.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include "config.h"
#include "command.h"
@ -559,10 +560,31 @@ static int mp_property_metadata(m_option_t *prop, int action, void *arg,
return M_PROPERTY_NOT_IMPLEMENTED;
}
static int mp_property_pause(m_option_t * prop, int action, void *arg,
MPContext * mpctx)
static int mp_property_pause(m_option_t *prop, int action, void *arg,
void *ctx)
{
return m_property_flag_ro(prop, action, arg, mpctx->osd_function == OSD_PAUSE);
MPContext *mpctx = ctx;
switch (action) {
case M_PROPERTY_SET:
if (!arg)
return M_PROPERTY_ERROR;
if (mpctx->paused == (bool)*(int *) arg)
return M_PROPERTY_OK;
case M_PROPERTY_STEP_UP:
case M_PROPERTY_STEP_DOWN:
if (mpctx->paused) {
unpause_player(mpctx);
mpctx->osd_function = OSD_PLAY;
}
else {
pause_player(mpctx);
mpctx->osd_function = OSD_PAUSE;
}
return M_PROPERTY_OK;
default:
return m_property_flag(prop, action, arg, &mpctx->paused);
}
}
@ -2212,6 +2234,7 @@ static struct {
{ "loop", MP_CMD_LOOP, 0, 0, -1, MSGTR_LoopStatus },
{ "chapter", MP_CMD_SEEK_CHAPTER, 0, 0, -1, NULL },
{ "angle", MP_CMD_SWITCH_ANGLE, 0, 0, -1, NULL },
{ "pause", MP_CMD_PAUSE, 0, 0, -1, NULL },
// audio
{ "volume", MP_CMD_VOLUME, 0, OSD_VOLUME, -1, MSGTR_Volume },
{ "mute", MP_CMD_MUTE, 1, 0, -1, MSGTR_MuteStatus },
@ -2348,12 +2371,11 @@ static const struct {
};
#endif
int run_command(MPContext *mpctx, mp_cmd_t *cmd)
void run_command(MPContext *mpctx, mp_cmd_t *cmd)
{
struct MPOpts *opts = &mpctx->opts;
sh_audio_t * const sh_audio = mpctx->sh_audio;
sh_video_t * const sh_video = mpctx->sh_video;
int brk_cmd = 0;
if (!set_property_command(mpctx, cmd))
switch (cmd->id) {
case MP_CMD_SEEK:{
@ -2378,7 +2400,6 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
mpctx->rel_seek_secs += v;
mpctx->osd_function = (v > 0) ? OSD_FFW : OSD_REW;
}
brk_cmd = 1;
}
break;
@ -2503,9 +2524,7 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
} break;
case MP_CMD_FRAME_STEP:
case MP_CMD_PAUSE:
cmd->pausing = 1;
brk_cmd = 1;
add_step_frame(mpctx);
break;
case MP_CMD_FILE_FILTER:
@ -2544,7 +2563,6 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
mpctx->stop_play = (n > 0) ? PT_NEXT_ENTRY : PT_PREV_ENTRY;
if (mpctx->stop_play)
mpctx->play_tree_step = n;
brk_cmd = 1;
}
}
break;
@ -2561,7 +2579,6 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
play_tree_iter_free(i);
} else
mpctx->stop_play = (n > 0) ? PT_UP_NEXT : PT_UP_PREV;
brk_cmd = 1;
}
break;
@ -2575,7 +2592,6 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
else if (v < 0 && mpctx->playtree_iter->file > 1)
mpctx->stop_play = PT_PREV_SRC;
}
brk_cmd = 1;
break;
case MP_CMD_SUB_STEP:
@ -2658,7 +2674,6 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
pt_iter_goto_head(mpctx->playtree_iter);
mpctx->stop_play = PT_NEXT_SRC;
}
brk_cmd = 1;
}
break;
@ -2682,7 +2697,6 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
mpctx->stop_play = PT_NEXT_SRC;
}
}
brk_cmd = 1;
}
break;
@ -2692,7 +2706,6 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
(mpctx->playtree_iter, 0, 1) != PLAY_TREE_ITER_END)
/* NOP */ ;
mpctx->stop_play = PT_STOP;
brk_cmd = 1;
break;
#ifdef CONFIG_RADIO
@ -3215,18 +3228,13 @@ int run_command(MPContext *mpctx, mp_cmd_t *cmd)
switch (cmd->pausing) {
case 1: // "pausing"
mpctx->osd_function = OSD_PAUSE;
pause_player(mpctx);
break;
case 3: // "pausing_toggle"
mpctx->was_paused = !mpctx->was_paused;
if (mpctx->was_paused)
mpctx->osd_function = OSD_PAUSE;
else if (mpctx->osd_function == OSD_PAUSE)
mpctx->osd_function = OSD_PLAY;
if (mpctx->paused)
unpause_player(mpctx);
else
pause_player(mpctx);
break;
case 2: // "pausing_keep"
if (mpctx->was_paused)
mpctx->osd_function = OSD_PAUSE;
}
return brk_cmd;
}

2
command.h
View File

@ -4,7 +4,7 @@
struct MPContext;
struct mp_cmd;
int run_command(struct MPContext *mpctx, struct mp_cmd *cmd);
void run_command(struct MPContext *mpctx, struct mp_cmd *cmd);
char *property_expand_string(struct MPContext *mpctx, char *str);
void property_print_help(void);

9
libmpcodecs/dec_video.c
View File

@ -6,6 +6,7 @@
#include <malloc.h>
#endif
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include "mp_msg.h"
@ -138,6 +139,14 @@ int set_rectangle(sh_video_t *sh_video, int param, int value)
return 0;
}
int redraw_osd(struct sh_video *sh_video, struct osd_state *osd)
{
struct vf_instance *vf = sh_video->vfilter;
if (vf->control(vf, VFCTRL_REDRAW_OSD, osd) == true)
return 0;
return -1;
}
void resync_video_stream(sh_video_t *sh_video)
{
const struct vd_functions *vd = sh_video->vd_driver;

1
libmpcodecs/dec_video.h
View File

@ -21,6 +21,7 @@ void set_video_quality(sh_video_t *sh_video, int quality);
int get_video_colors(sh_video_t *sh_video, const char *item, int *value);
int set_video_colors(sh_video_t *sh_video, const char *item, int value);
int set_rectangle(sh_video_t *sh_video, int param, int value);
int redraw_osd(struct sh_video *sh_video, struct osd_state *osd);
void resync_video_stream(sh_video_t *sh_video);
int get_current_video_decoder_lag(sh_video_t *sh_video);

1
libmpcodecs/vf.h
View File

@ -91,6 +91,7 @@ typedef struct vf_seteq_s
/* Hack to make the OSD state object available to vf_expand which accesses
* the OSD state outside of normal OSD draw time. */
#define VFCTRL_SET_OSD_OBJ 20
#define VFCTRL_REDRAW_OSD 21 /* Change user-visible OSD immediately */
#include "vfcap.h"

6
libmpcodecs/vf_expand.c
View File

@ -3,6 +3,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "config.h"
#include "mp_msg.h"
@ -419,6 +420,11 @@ static int control(struct vf_instance* vf, int request, void* data){
break;
case VFCTRL_DRAW_OSD:
if(vf->priv->osd_enabled) return CONTROL_TRUE;
break;
case VFCTRL_REDRAW_OSD:
if (vf->priv->osd_enabled)
return false;
break;
}
#endif
return vf_next_control(vf,request,data);

9
libmpcodecs/vf_tfields.c
View File

@ -310,9 +310,10 @@ static int put_image(struct vf_instance* vf, mp_image_t *mpi, double pts)
return continue_buffered_image(vf);
}
extern const int under_mencoder;
static int continue_buffered_image(struct vf_instance *vf)
{
struct MPOpts *opts = vf->opts;
int i=vf->priv->buffered_i;
double pts = vf->priv->buffered_pts;
mp_image_t *mpi = vf->priv->buffered_mpi;
@ -363,7 +364,7 @@ static int continue_buffered_image(struct vf_instance *vf)
dmpi->stride[2] = 2*mpi->stride[2];
}
ret |= vf_next_put_image(vf, dmpi, pts);
if (opts->correct_pts)
if (!under_mencoder)
break;
else
if (!i) vf_next_control(vf, VFCTRL_FLIP_PAGE, NULL);
@ -393,7 +394,7 @@ static int continue_buffered_image(struct vf_instance *vf)
mpi->chroma_width, mpi->chroma_height, (i^!tff));
}
ret |= vf_next_put_image(vf, dmpi, pts);
if (opts->correct_pts)
if (!under_mencoder)
break;
else
if (!i) vf_next_control(vf, VFCTRL_FLIP_PAGE, NULL);
@ -419,7 +420,7 @@ static int continue_buffered_image(struct vf_instance *vf)
dmpi->stride[2], mpi->stride[2]*2, (i^!tff));
}
ret |= vf_next_put_image(vf, dmpi, pts);
if (opts->correct_pts)
if (!under_mencoder)
break;
else
if (!i) vf_next_control(vf, VFCTRL_FLIP_PAGE, NULL);

3
libmpcodecs/vf_vo.c
View File

@ -1,6 +1,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "config.h"
#include "mp_msg.h"
@ -88,6 +89,8 @@ static int control(struct vf_instance* vf, int request, void* data)
if(!video_out->config_ok) return CONTROL_FALSE; // vo not configured?
vo_draw_osd(video_out, data);
return CONTROL_TRUE;
case VFCTRL_REDRAW_OSD:
return vo_control(video_out, VOCTRL_REDRAW_OSD, data) == true;
case VFCTRL_FLIP_PAGE:
{
if(!video_out->config_ok) return CONTROL_FALSE; // vo not configured?

7
libmpcodecs/vf_yadif.c
View File

@ -416,9 +416,10 @@ static int put_image(struct vf_instance* vf, mp_image_t *mpi, double pts){
return continue_buffered_image(vf);
}
extern const int under_mencoder;
static int continue_buffered_image(struct vf_instance *vf)
{
struct MPOpts *opts = vf->opts;
mp_image_t *mpi = vf->priv->buffered_mpi;
int tff = vf->priv->buffered_tff;
double pts = vf->priv->buffered_pts;
@ -435,10 +436,10 @@ static int continue_buffered_image(struct vf_instance *vf)
mpi->width,mpi->height);
vf_clone_mpi_attributes(dmpi, mpi);
filter(vf->priv, dmpi->planes, dmpi->stride, mpi->w, mpi->h, i ^ tff ^ 1, tff);
if (opts->correct_pts && i < (vf->priv->mode & 1))
if (i < (vf->priv->mode & 1) && !under_mencoder)
vf_queue_frame(vf, continue_buffered_image);
ret |= vf_next_put_image(vf, dmpi, pts /*FIXME*/);
if (opts->correct_pts)
if (!under_mencoder)
break;
if(i<(vf->priv->mode&1))
vf_next_control(vf, VFCTRL_FLIP_PAGE, NULL);

2
libvo/video_out.h
View File

@ -87,6 +87,8 @@ typedef struct {
} mp_colorkey_t;
#define VOCTRL_XOVERLAY_SET_WIN 23
#define VOCTRL_REDRAW_OSD 24
typedef struct {
int x,y;
int w,h;

6
libvo/vo_gl.c
View File

@ -1147,6 +1147,12 @@ static int control(uint32_t request, void *data)
case VOCTRL_UPDATE_SCREENINFO:
update_xinerama_info();
return VO_TRUE;
case VOCTRL_REDRAW_OSD:
if (vo_doublebuffering)
do_render();
draw_osd();
flip_page();
return VO_TRUE;
}
return VO_NOTIMPL;
}

567
libvo/vo_xv.c
View File

@ -20,6 +20,7 @@ Buffer allocation:
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include "config.h"
#include "options.h"
@ -76,8 +77,13 @@ struct xvctx {
int current_buf;
int current_ip_buf;
int num_buffers;
int total_buffers;
int have_visible_image_copy;
int have_next_image_copy;
int unchanged_visible_image;
int unchanged_next_image;
int visible_buf;
XvImage *xvimage[NUM_BUFFERS];
XvImage *xvimage[NUM_BUFFERS + 1];
uint32_t image_width;
uint32_t image_height;
uint32_t image_format;
@ -86,6 +92,7 @@ struct xvctx {
uint32_t max_width, max_height; // zero means: not set
int event_fd_registered; // for uninit called from preinit
int mode_switched;
int osd_objects_drawn;
void (*draw_alpha_fnc)(void *ctx, int x0, int y0, int w, int h,
unsigned char *src, unsigned char *srca,
int stride);
@ -95,11 +102,9 @@ struct xvctx {
#endif
};
// FIXME: dynamically allocate this stuff
static void allocate_xvimage(struct vo *, int);
static void draw_alpha_yv12(void *p, int x0, int y0, int w, int h,
unsigned char *src, unsigned char *srca,
int stride)
@ -113,6 +118,7 @@ static void draw_alpha_yv12(void *p, int x0, int y0, int w, int h,
ctx->xvimage[ctx->current_buf]->offsets[0] +
ctx->xvimage[ctx->current_buf]->pitches[0] * y0 + x0,
ctx->xvimage[ctx->current_buf]->pitches[0]);
ctx->osd_objects_drawn++;
}
static void draw_alpha_yuy2(void *p, int x0, int y0, int w, int h,
@ -128,6 +134,7 @@ static void draw_alpha_yuy2(void *p, int x0, int y0, int w, int h,
ctx->xvimage[ctx->current_buf]->offsets[0] +
ctx->xvimage[ctx->current_buf]->pitches[0] * y0 + 2 * x0,
ctx->xvimage[ctx->current_buf]->pitches[0]);
ctx->osd_objects_drawn++;
}
static void draw_alpha_uyvy(void *p, int x0, int y0, int w, int h,
@ -143,6 +150,7 @@ static void draw_alpha_uyvy(void *p, int x0, int y0, int w, int h,
ctx->xvimage[ctx->current_buf]->offsets[0] +
ctx->xvimage[ctx->current_buf]->pitches[0] * y0 + 2 * x0 + 1,
ctx->xvimage[ctx->current_buf]->pitches[0]);
ctx->osd_objects_drawn++;
}
static void draw_alpha_null(void *p, int x0, int y0, int w, int h,
@ -154,21 +162,22 @@ static void draw_alpha_null(void *p, int x0, int y0, int w, int h,
static void deallocate_xvimage(struct vo *vo, int foo);
static void calc_drwXY(struct vo *vo, uint32_t *drwX, uint32_t *drwY) {
static void calc_drwXY(struct vo *vo, uint32_t *drwX, uint32_t *drwY)
{
struct MPOpts *opts = vo->opts;
*drwX = *drwY = 0;
if (vo_fs) {
aspect(vo, &vo->dwidth, &vo->dheight, A_ZOOM);
vo->dwidth = FFMIN(vo->dwidth, opts->vo_screenwidth);
vo->dheight = FFMIN(vo->dheight, opts->vo_screenheight);
*drwX = (opts->vo_screenwidth - vo->dwidth) / 2;
*drwY = (opts->vo_screenheight - vo->dheight) / 2;
mp_msg(MSGT_VO, MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n",
*drwX, *drwY, vo->dwidth, vo->dheight);
} else if (WinID == 0) {
*drwX = vo->dx;
*drwY = vo->dy;
}
*drwX = *drwY = 0;
if (vo_fs) {
aspect(vo, &vo->dwidth, &vo->dheight, A_ZOOM);
vo->dwidth = FFMIN(vo->dwidth, opts->vo_screenwidth);
vo->dheight = FFMIN(vo->dheight, opts->vo_screenheight);
*drwX = (opts->vo_screenwidth - vo->dwidth) / 2;
*drwY = (opts->vo_screenheight - vo->dheight) / 2;
mp_msg(MSGT_VO, MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n", *drwX,
*drwY, vo->dwidth, vo->dheight);
} else if (WinID == 0) {
*drwX = vo->dx;
*drwY = vo->dy;
}
}
/*
@ -193,23 +202,25 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
ctx->image_width = width;
ctx->image_format = format;
if ((ctx->max_width != 0 && ctx->max_height != 0) &&
(ctx->image_width > ctx->max_width || ctx->image_height > ctx->max_height))
{
mp_msg( MSGT_VO, MSGL_ERR, MSGTR_VO_XV_ImagedimTooHigh,
ctx->image_width, ctx->image_height, ctx->max_width, ctx->max_height);
if ((ctx->max_width != 0 && ctx->max_height != 0)
&& (ctx->image_width > ctx->max_width
|| ctx->image_height > ctx->max_height)) {
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_VO_XV_ImagedimTooHigh,
ctx->image_width, ctx->image_height, ctx->max_width,
ctx->max_height);
return -1;
}
ctx->is_paused = 0;
ctx->visible_buf = -1;
ctx->have_visible_image_copy = false;
ctx->have_next_image_copy = false;
/* check image formats */
ctx->xv_format = 0;
for (i = 0; i < ctx->formats; i++) {
mp_msg(MSGT_VO, MSGL_V,
"Xvideo image format: 0x%x (%4.4s) %s\n", ctx->fo[i].id,
(char *) &ctx->fo[i].id,
mp_msg(MSGT_VO, MSGL_V, "Xvideo image format: 0x%x (%4.4s) %s\n",
ctx->fo[i].id, (char *) &ctx->fo[i].id,
(ctx->fo[i].format == XvPacked) ? "packed" : "planar");
if (ctx->fo[i].id == format)
ctx->xv_format = ctx->fo[i].id;
@ -225,8 +236,7 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
{
#ifdef CONFIG_XF86VM
int vm = flags & VOFLAG_MODESWITCHING;
if (vm)
{
if (vm) {
vo_vm_switch(vo);
ctx->mode_switched = 1;
}
@ -240,25 +250,23 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
xswa.background_pixel = 0;
if (x11->xv_ck_info.method == CK_METHOD_BACKGROUND)
{
xswa.background_pixel = x11->xv_colorkey;
}
xswa.background_pixel = x11->xv_colorkey;
xswa.border_pixel = 0;
xswamask = CWBackPixel | CWBorderPixel;
vo_x11_create_vo_window(vo, &vinfo, vo->dx, vo->dy, vo->dwidth, vo->dheight,
flags, CopyFromParent, "xv", title);
XChangeWindowAttributes(x11->display, x11->window, xswamask, &xswa);
vo_x11_create_vo_window(vo, &vinfo, vo->dx, vo->dy, vo->dwidth,
vo->dheight, flags, CopyFromParent, "xv",
title);
XChangeWindowAttributes(x11->display, x11->window, xswamask, &xswa);
#ifdef CONFIG_XF86VM
if (vm)
{
if (vm) {
/* Grab the mouse pointer in our window */
if (vo_grabpointer)
XGrabPointer(x11->display, x11->window, True, 0,
GrabModeAsync, GrabModeAsync,
x11->window, None, CurrentTime);
XSetInputFocus(x11->display, x11->window, RevertToNone, CurrentTime);
XGrabPointer(x11->display, x11->window, True, 0, GrabModeAsync,
GrabModeAsync, x11->window, None, CurrentTime);
XSetInputFocus(x11->display, x11->window, RevertToNone,
CurrentTime);
}
#endif
}
@ -266,42 +274,43 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
mp_msg(MSGT_VO, MSGL_V, "using Xvideo port %d for hw scaling\n",
x11->xv_port);
switch (ctx->xv_format)
{
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
ctx->draw_alpha_fnc = draw_alpha_yv12;
break;
case IMGFMT_YUY2:
case IMGFMT_YVYU:
ctx->draw_alpha_fnc = draw_alpha_yuy2;
break;
case IMGFMT_UYVY:
ctx->draw_alpha_fnc = draw_alpha_uyvy;
break;
default:
ctx->draw_alpha_fnc = draw_alpha_null;
switch (ctx->xv_format) {
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
ctx->draw_alpha_fnc = draw_alpha_yv12;
break;
case IMGFMT_YUY2:
case IMGFMT_YVYU:
ctx->draw_alpha_fnc = draw_alpha_yuy2;
break;
case IMGFMT_UYVY:
ctx->draw_alpha_fnc = draw_alpha_uyvy;
break;
default:
ctx->draw_alpha_fnc = draw_alpha_null;
}
// In case config has been called before
for (i = 0; i < ctx->num_buffers; i++)
for (i = 0; i < ctx->total_buffers; i++)
deallocate_xvimage(vo, i);
ctx->num_buffers =
vo_doublebuffering ? (vo_directrendering ? NUM_BUFFERS : 2) : 1;
ctx->total_buffers = ctx->num_buffers + 1;
for (i = 0; i < ctx->num_buffers; i++)
for (i = 0; i < ctx->total_buffers; i++)
allocate_xvimage(vo, i);
ctx->current_buf = 0;
ctx->current_ip_buf = 0;
if ((flags & VOFLAG_FULLSCREEN) && WinID <= 0) vo_fs = 1;
if ((flags & VOFLAG_FULLSCREEN) && WinID <= 0)
vo_fs = 1;
calc_drwXY(vo, &ctx->drwX, &ctx->drwY);
panscan_calc(vo);
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
@ -324,22 +333,22 @@ static void allocate_xvimage(struct vo *vo, int foo)
#ifdef HAVE_SHM
if (x11->display_is_local && XShmQueryExtension(x11->display))
ctx->Shmem_Flag = 1;
else
{
else {
ctx->Shmem_Flag = 0;
mp_msg(MSGT_VO, MSGL_INFO,
MSGTR_LIBVO_XV_SharedMemoryNotSupported);
mp_msg(MSGT_VO, MSGL_INFO, MSGTR_LIBVO_XV_SharedMemoryNotSupported);
}
if (ctx->Shmem_Flag)
{
if (ctx->Shmem_Flag) {
ctx->xvimage[foo] =
(XvImage *) XvShmCreateImage(x11->display, x11->xv_port, ctx->xv_format,
NULL, ctx->image_width, ctx->image_height,
(XvImage *) XvShmCreateImage(x11->display, x11->xv_port,
ctx->xv_format, NULL,
ctx->image_width, ctx->image_height,
&ctx->Shminfo[foo]);
ctx->Shminfo[foo].shmid =
shmget(IPC_PRIVATE, ctx->xvimage[foo]->data_size, IPC_CREAT | 0777);
ctx->Shminfo[foo].shmaddr = (char *) shmat(ctx->Shminfo[foo].shmid, 0, 0);
ctx->Shminfo[foo].shmid = shmget(IPC_PRIVATE,
ctx->xvimage[foo]->data_size,
IPC_CREAT | 0777);
ctx->Shminfo[foo].shmaddr = (char *) shmat(ctx->Shminfo[foo].shmid, 0,
0);
ctx->Shminfo[foo].readOnly = False;
ctx->xvimage[foo]->data = ctx->Shminfo[foo].shmaddr;
@ -350,8 +359,9 @@ static void allocate_xvimage(struct vo *vo, int foo)
#endif
{
ctx->xvimage[foo] =
(XvImage *) XvCreateImage(x11->display, x11->xv_port, ctx->xv_format, NULL,
ctx->image_width, ctx->image_height);
(XvImage *) XvCreateImage(x11->display, x11->xv_port,
ctx->xv_format, NULL, ctx->image_width,
ctx->image_height);
ctx->xvimage[foo]->data = malloc(ctx->xvimage[foo]->data_size);
XSync(x11->display, False);
}
@ -363,8 +373,7 @@ static void deallocate_xvimage(struct vo *vo, int foo)
{
struct xvctx *ctx = vo->priv;
#ifdef HAVE_SHM
if (ctx->Shmem_Flag)
{
if (ctx->Shmem_Flag) {
XShmDetach(vo->x11->display, &ctx->Shminfo[foo]);
shmdt(ctx->Shminfo[foo].shmaddr);
} else
@ -383,25 +392,36 @@ static inline void put_xvimage(struct vo *vo, XvImage *xvi)
struct xvctx *ctx = vo->priv;
struct vo_x11_state *x11 = vo->x11;
#ifdef HAVE_SHM
if (ctx->Shmem_Flag)
{
XvShmPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc,
xvi, 0, 0, ctx->image_width,
ctx->image_height, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1), vo->dwidth + vo->panscan_x,
vo->dheight + vo->panscan_y,
if (ctx->Shmem_Flag) {
XvShmPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc, xvi,
0, 0, ctx->image_width, ctx->image_height,
ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x, vo->dheight + vo->panscan_y,
False);
} else
#endif
{
XvPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc,
xvi, 0, 0, ctx->image_width, ctx->image_height,
ctx->drwX - (vo->panscan_x >> 1), ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x,
vo->dheight + vo->panscan_y);
XvPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc, xvi, 0,
0, ctx->image_width, ctx->image_height,
ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x, vo->dheight + vo->panscan_y);
}
}
// Only copies luma for planar formats as draw_alpha doesn't change others */
void copy_backup_image(struct vo *vo, int dest, int src)
{
struct xvctx *ctx = vo->priv;
XvImage *vb = ctx->xvimage[dest];
XvImage *cp = ctx->xvimage[src];
memcpy_pic(vb->data + vb->offsets[0], cp->data + cp->offsets[0],
vb->width, vb->height,
vb->pitches[0], cp->pitches[0]);
}
static void check_events(struct vo *vo)
{
struct xvctx *ctx = vo->priv;
@ -411,21 +431,18 @@ static void check_events(struct vo *vo)
if (e & VO_EVENT_RESIZE)
calc_drwXY(vo, &ctx->drwX, &ctx->drwY);
if (e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE)
{
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
if (e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) {
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
}
if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && ctx->is_paused)
{
if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && ctx->is_paused) {
/* did we already draw a buffer */
if ( ctx->visible_buf != -1 )
{
/* redraw the last visible buffer */
put_xvimage(vo, ctx->xvimage[ctx->visible_buf]);
if (ctx->visible_buf != -1) {
/* redraw the last visible buffer */
put_xvimage(vo, ctx->xvimage[ctx->visible_buf]);
}
}
}
@ -434,9 +451,34 @@ static void draw_osd(struct vo *vo, struct osd_state *osd)
{
struct xvctx *ctx = vo->priv;
osd_draw_text(osd, ctx->image_width -
ctx->image_width * vo->panscan_x / (vo->dwidth + vo->panscan_x),
ctx->osd_objects_drawn = 0;
osd_draw_text(osd,
ctx->image_width -
ctx->image_width * vo->panscan_x / (vo->dwidth +
vo->panscan_x),
ctx->image_height, ctx->draw_alpha_fnc, vo);
if (ctx->osd_objects_drawn)
ctx->unchanged_next_image = false;
}
static int redraw_osd(struct vo *vo, struct osd_state *osd)
{
struct xvctx *ctx = vo->priv;
if (ctx->have_visible_image_copy)
copy_backup_image(vo, ctx->visible_buf, ctx->num_buffers);
else if (ctx->unchanged_visible_image) {
copy_backup_image(vo, ctx->num_buffers, ctx->visible_buf);
ctx->have_visible_image_copy = true;
}
else
return false;
int temp = ctx->current_buf;
ctx->current_buf = ctx->visible_buf;
draw_osd(vo, osd);
ctx->current_buf = temp;
put_xvimage(vo, ctx->xvimage[ctx->visible_buf]);
return true;
}
static void flip_page(struct vo *vo)
@ -447,99 +489,99 @@ static void flip_page(struct vo *vo)
/* remember the currently visible buffer */
ctx->visible_buf = ctx->current_buf;
if (ctx->num_buffers > 1)
{
ctx->current_buf =
vo_directrendering ? 0 : ((ctx->current_buf + 1) % ctx->num_buffers);
ctx->have_visible_image_copy = ctx->have_next_image_copy;
ctx->have_next_image_copy = false;
ctx->unchanged_visible_image = ctx->unchanged_next_image;
ctx->unchanged_next_image = false;
if (ctx->num_buffers > 1) {
ctx->current_buf = vo_directrendering ? 0 : ((ctx->current_buf + 1) %
ctx->num_buffers);
XFlush(vo->x11->display);
} else
XSync(vo->x11->display, False);
return;
}
static int draw_slice(struct vo *vo, uint8_t * image[], int stride[], int w,
static int draw_slice(struct vo *vo, uint8_t *image[], int stride[], int w,
int h, int x, int y)
{
struct xvctx *ctx = vo->priv;
uint8_t *dst;
XvImage *current_image = ctx->xvimage[ctx->current_buf];
dst = current_image->data + current_image->offsets[0] +
current_image->pitches[0] * y + x;
memcpy_pic(dst, image[0], w, h, current_image->pitches[0],
stride[0]);
dst = current_image->data + current_image->offsets[0]
+ current_image->pitches[0] * y + x;
memcpy_pic(dst, image[0], w, h, current_image->pitches[0], stride[0]);
x /= 2;
y /= 2;
w /= 2;
h /= 2;
dst = current_image->data + current_image->offsets[1] +
current_image->pitches[1] * y + x;
dst = current_image->data + current_image->offsets[1]
+ current_image->pitches[1] * y + x;
if (ctx->image_format != IMGFMT_YV12)
memcpy_pic(dst, image[1], w, h, current_image->pitches[1],
stride[1]);
memcpy_pic(dst, image[1], w, h, current_image->pitches[1], stride[1]);
else
memcpy_pic(dst, image[2], w, h, current_image->pitches[1],
stride[2]);
memcpy_pic(dst, image[2], w, h, current_image->pitches[1], stride[2]);
dst = current_image->data + current_image->offsets[2] +
current_image->pitches[2] * y + x;
dst = current_image->data + current_image->offsets[2]
+ current_image->pitches[2] * y + x;
if (ctx->image_format == IMGFMT_YV12)
memcpy_pic(dst, image[1], w, h, current_image->pitches[1],
stride[1]);
memcpy_pic(dst, image[1], w, h, current_image->pitches[1], stride[1]);
else
memcpy_pic(dst, image[2], w, h, current_image->pitches[1],
stride[2]);
memcpy_pic(dst, image[2], w, h, current_image->pitches[1], stride[2]);
return 0;
}
static int draw_frame(struct vo *vo, uint8_t * src[])
static int draw_frame(struct vo *vo, uint8_t *src[])
{
return VO_ERROR;
}
static uint32_t draw_image(struct vo *vo, mp_image_t * mpi)
static uint32_t draw_image(struct vo *vo, mp_image_t *mpi)
{
struct xvctx *ctx = vo->priv;
ctx->have_next_image_copy = false;
if (mpi->flags & MP_IMGFLAG_DIRECT)
{
// direct rendering:
ctx->current_buf = (int) (mpi->priv); // hack!
return VO_TRUE;
}
if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
return VO_TRUE; // done
if (mpi->flags & MP_IMGFLAG_PLANAR)
{
else if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
; // done
else if (mpi->flags & MP_IMGFLAG_PLANAR)
draw_slice(vo, mpi->planes, mpi->stride, mpi->w, mpi->h, 0, 0);
return VO_TRUE;
}
if (mpi->flags & MP_IMGFLAG_YUV)
{
else if (mpi->flags & MP_IMGFLAG_YUV)
// packed YUV:
memcpy_pic(ctx->xvimage[ctx->current_buf]->data +
ctx->xvimage[ctx->current_buf]->offsets[0], mpi->planes[0],
mpi->w * (mpi->bpp / 8), mpi->h,
ctx->xvimage[ctx->current_buf]->pitches[0], mpi->stride[0]);
return VO_TRUE;
else
return false;
if (ctx->is_paused) {
copy_backup_image(vo, ctx->num_buffers, ctx->current_buf);
ctx->have_next_image_copy = true;
}
return VO_FALSE; // not (yet) supported
ctx->unchanged_next_image = true;
return true;
}
static uint32_t get_image(struct xvctx *ctx, mp_image_t * mpi)
static uint32_t get_image(struct xvctx *ctx, mp_image_t *mpi)
{
int buf = ctx->current_buf; // we shouldn't change current_buf unless we do DR!
// we shouldn't change current_buf unless we do DR!
int buf = ctx->current_buf;
if (mpi->type == MP_IMGTYPE_STATIC && ctx->num_buffers > 1)
return VO_FALSE; // it is not static
if (mpi->imgfmt != ctx->image_format)
return VO_FALSE; // needs conversion :(
// if(mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE; // slow video ram
if (mpi->flags & MP_IMGFLAG_READABLE &&
(mpi->type == MP_IMGTYPE_IPB || mpi->type == MP_IMGTYPE_IP))
{
if (mpi->flags & MP_IMGFLAG_READABLE
&& (mpi->type == MP_IMGTYPE_IPB || mpi->type == MP_IMGTYPE_IP)) {
// reference (I/P) frame of IP or IPB:
if (ctx->num_buffers < 2)
return VO_FALSE; // not enough
@ -557,42 +599,33 @@ static uint32_t get_image(struct xvctx *ctx, mp_image_t * mpi)
if (mpi->width * (mpi->bpp / 8) > ctx->xvimage[buf]->pitches[0])
return VO_FALSE; //buffer to small
if ((mpi->flags & (MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_ACCEPT_WIDTH))
|| (mpi->width * (mpi->bpp / 8) == ctx->xvimage[buf]->pitches[0]))
{
|| (mpi->width * (mpi->bpp / 8) == ctx->xvimage[buf]->pitches[0])) {
ctx->current_buf = buf;
XvImage *current_image = ctx->xvimage[ctx->current_buf];
mpi->planes[0] = current_image->data + current_image->offsets[0];
mpi->stride[0] = current_image->pitches[0];
mpi->width = mpi->stride[0] / (mpi->bpp / 8);
if (mpi->flags & MP_IMGFLAG_PLANAR)
{
if (mpi->flags & MP_IMGFLAG_SWAPPED)
{
if (mpi->flags & MP_IMGFLAG_PLANAR) {
if (mpi->flags & MP_IMGFLAG_SWAPPED) {
// I420
mpi->planes[1] =
current_image->data +
current_image->offsets[1];
mpi->planes[2] =
current_image->data +
current_image->offsets[2];
mpi->planes[1] = current_image->data
+ current_image->offsets[1];
mpi->planes[2] = current_image->data
+ current_image->offsets[2];
mpi->stride[1] = current_image->pitches[1];
mpi->stride[2] = current_image->pitches[2];
} else
{
} else {
// YV12
mpi->planes[1] =
current_image->data +
current_image->offsets[2];
mpi->planes[2] =
current_image->data +
current_image->offsets[1];
mpi->planes[1] = current_image->data
+ current_image->offsets[2];
mpi->planes[2] = current_image->data
+ current_image->offsets[1];
mpi->stride[1] = current_image->pitches[2];
mpi->stride[2] = current_image->pitches[1];
}
}
mpi->flags |= MP_IMGFLAG_DIRECT;
mpi->priv = (void *) ctx->current_buf;
// printf("mga: get_image() SUCCESS -> Direct Rendering ENABLED\n");
return VO_TRUE;
}
return VO_FALSE;
@ -604,8 +637,7 @@ static int query_format(struct xvctx *ctx, uint32_t format)
int flag = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_OSD | VFCAP_ACCEPT_STRIDE; // FIXME! check for DOWN
/* check image formats */
for (i = 0; i < ctx->formats; i++)
{
for (i = 0; i < ctx->formats; i++) {
if (ctx->fo[i].id == format)
return flag; //xv_format = fo[i].id;
}
@ -625,7 +657,7 @@ static void uninit(struct vo *vo)
XFree(ctx->fo);
ctx->fo = NULL;
}
for (i = 0; i < ctx->num_buffers; i++)
for (i = 0; i < ctx->total_buffers; i++)
deallocate_xvimage(vo, i);
#ifdef CONFIG_XF86VM
if (ctx->mode_switched)
@ -656,22 +688,20 @@ static int preinit(struct vo *vo, const char *arg)
struct vo_x11_state *x11 = vo->x11;
int xv_adaptor = -1;
opt_t subopts[] =
{
/* name arg type arg var test */
{ "port", OPT_ARG_INT, &x11->xv_port, (opt_test_f)int_pos },
{ "adaptor", OPT_ARG_INT, &xv_adaptor, (opt_test_f)int_non_neg },
{ "ck", OPT_ARG_STR, &ck_src_arg, xv_test_ck },
{ "ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm },
{ NULL }
opt_t subopts[] = {
/* name arg type arg var test */
{"port", OPT_ARG_INT, &x11->xv_port, (opt_test_f) int_pos},
{"adaptor", OPT_ARG_INT, &xv_adaptor, (opt_test_f) int_non_neg},
{"ck", OPT_ARG_STR, &ck_src_arg, xv_test_ck},
{"ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm},
{NULL}
};
x11->xv_port = 0;
/* parse suboptions */
if ( subopt_parse( arg, subopts ) != 0 )
{
return -1;
if (subopt_parse(arg, subopts) != 0) {
return -1;
}
/* modify colorkey settings according to the given options */
@ -682,105 +712,90 @@ static int preinit(struct vo *vo, const char *arg)
/* check for Xvideo extension */
unsigned int ver, rel, req, ev, err;
if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err))
{
mp_msg(MSGT_VO, MSGL_ERR,
MSGTR_LIBVO_XV_XvNotSupportedByX11);
if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err)) {
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_XvNotSupportedByX11);
goto error;
}
/* check for Xvideo support */
if (Success !=
XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display), &ctx->adaptors,
&ctx->ai))
{
XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display),
&ctx->adaptors, &ctx->ai)) {
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_XvQueryAdaptorsFailed);
goto error;
}
/* check adaptors */
if (x11->xv_port)
{
if (x11->xv_port) {
int port_found;
for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++)
{
if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask))
{
for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) {
if ((ctx->ai[i].type & XvInputMask)
&& (ctx->ai[i].type & XvImageMask)) {
for (xv_p = ctx->ai[i].base_id;
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p)
{
if (xv_p == x11->xv_port)
{
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports;
++xv_p) {
if (xv_p == x11->xv_port) {
port_found = 1;
break;
}
}
}
}
if (port_found)
{
if (port_found) {
if (XvGrabPort(x11->display, x11->xv_port, CurrentTime))
x11->xv_port = 0;
} else
{
mp_msg(MSGT_VO, MSGL_WARN,
MSGTR_LIBVO_XV_InvalidPortParameter);
} else {
mp_msg(MSGT_VO, MSGL_WARN, MSGTR_LIBVO_XV_InvalidPortParameter);
x11->xv_port = 0;
}
}
for (i = 0; i < ctx->adaptors && x11->xv_port == 0; i++)
{
for (i = 0; i < ctx->adaptors && x11->xv_port == 0; i++) {
/* check if adaptor number has been specified */
if (xv_adaptor != -1 && xv_adaptor != i)
continue;
continue;
if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask))
{
if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) {
for (xv_p = ctx->ai[i].base_id;
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p)
if (!XvGrabPort(x11->display, xv_p, CurrentTime))
{
if (!XvGrabPort(x11->display, xv_p, CurrentTime)) {
x11->xv_port = xv_p;
mp_msg(MSGT_VO, MSGL_V,
"[VO_XV] Using Xv Adapter #%d (%s)\n",
i, ctx->ai[i].name);
break;
} else
{
mp_msg(MSGT_VO, MSGL_WARN,
MSGTR_LIBVO_XV_CouldNotGrabPort, (int) xv_p);
} else {
mp_msg(MSGT_VO, MSGL_WARN, MSGTR_LIBVO_XV_CouldNotGrabPort,
(int) xv_p);
++busy_ports;
}
}
}
if (!x11->xv_port)
{
if (!x11->xv_port) {
if (busy_ports)
mp_msg(MSGT_VO, MSGL_ERR,
MSGTR_LIBVO_XV_CouldNotFindFreePort);
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_CouldNotFindFreePort);
else
mp_msg(MSGT_VO, MSGL_ERR,
MSGTR_LIBVO_XV_NoXvideoSupport);
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_NoXvideoSupport);
goto error;
}
if (!vo_xv_init_colorkey(vo)) {
goto error; // bail out, colorkey setup failed
goto error; // bail out, colorkey setup failed
}
vo_xv_enable_vsync(vo);
vo_xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height);
ctx->fo = XvListImageFormats(x11->display, x11->xv_port, (int *) &ctx->formats);
ctx->fo = XvListImageFormats(x11->display, x11->xv_port,
(int *) &ctx->formats);
mp_input_add_key_fd(vo->input_ctx, ConnectionNumber(x11->display), 1,
x11_fd_callback, NULL, vo);
ctx->event_fd_registered = 1;
return 0;
error:
uninit(vo); // free resources
error:
uninit(vo); // free resources
return -1;
}
@ -788,65 +803,63 @@ static int control(struct vo *vo, uint32_t request, void *data)
{
struct xvctx *ctx = vo->priv;
struct vo_x11_state *x11 = vo->x11;
switch (request)
{
case VOCTRL_PAUSE:
return (ctx->is_paused = 1);
case VOCTRL_RESUME:
return (ctx->is_paused = 0);
case VOCTRL_QUERY_FORMAT:
return query_format(ctx, *((uint32_t *) data));
case VOCTRL_GET_IMAGE:
return get_image(ctx, data);
case VOCTRL_DRAW_IMAGE:
return draw_image(vo, data);
case VOCTRL_GUISUPPORT:
return VO_TRUE;
case VOCTRL_GET_PANSCAN:
if (!vo->config_ok || !vo_fs)
return VO_FALSE;
return VO_TRUE;
case VOCTRL_FULLSCREEN:
vo_x11_fullscreen(vo);
/* indended, fallthrough to update panscan on fullscreen/windowed switch */
case VOCTRL_SET_PANSCAN:
if ((vo_fs && (vo_panscan != vo->panscan_amount))
|| (!vo_fs && vo->panscan_amount))
{
int old_y = vo->panscan_y;
switch (request) {
case VOCTRL_PAUSE:
return (ctx->is_paused = 1);
case VOCTRL_RESUME:
return (ctx->is_paused = 0);
case VOCTRL_QUERY_FORMAT:
return query_format(ctx, *((uint32_t *) data));
case VOCTRL_GET_IMAGE:
return get_image(ctx, data);
case VOCTRL_DRAW_IMAGE:
return draw_image(vo, data);
case VOCTRL_GUISUPPORT:
return VO_TRUE;
case VOCTRL_GET_PANSCAN:
if (!vo->config_ok || !vo_fs)
return VO_FALSE;
return VO_TRUE;
case VOCTRL_FULLSCREEN:
vo_x11_fullscreen(vo);
/* indended, fallthrough to update panscan on fullscreen/windowed switch */
case VOCTRL_SET_PANSCAN:
if ((vo_fs && (vo_panscan != vo->panscan_amount))
|| (!vo_fs && vo->panscan_amount)) {
int old_y = vo->panscan_y;
panscan_calc(vo);
panscan_calc(vo);
if (old_y != vo->panscan_y)
{
vo_x11_clearwindow_part(vo, x11->window,
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1,
1);
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
flip_page(vo);
}
if (old_y != vo->panscan_y) {
vo_x11_clearwindow_part(vo, x11->window,
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1, 1);
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
flip_page(vo);
}
return VO_TRUE;
case VOCTRL_SET_EQUALIZER:
{
struct voctrl_set_equalizer_args *args = data;
return vo_xv_set_eq(vo, x11->xv_port, args->name, args->value);
}
case VOCTRL_GET_EQUALIZER:
{
struct voctrl_get_equalizer_args *args = data;
return vo_xv_get_eq(vo, x11->xv_port, args->name, args->valueptr);
}
case VOCTRL_ONTOP:
vo_x11_ontop(vo);
return VO_TRUE;
case VOCTRL_UPDATE_SCREENINFO:
update_xinerama_info(vo);
return VO_TRUE;
}
return VO_TRUE;
case VOCTRL_SET_EQUALIZER:
{
struct voctrl_set_equalizer_args *args = data;
return vo_xv_set_eq(vo, x11->xv_port, args->name, args->value);
}
case VOCTRL_GET_EQUALIZER:
{
struct voctrl_get_equalizer_args *args = data;
return vo_xv_get_eq(vo, x11->xv_port, args->name, args->valueptr);
}
case VOCTRL_ONTOP:
vo_x11_ontop(vo);
return VO_TRUE;
case VOCTRL_UPDATE_SCREENINFO:
update_xinerama_info(vo);
return VO_TRUE;
case VOCTRL_REDRAW_OSD:
return redraw_osd(vo, data);
}
return VO_NOTIMPL;
}

1
mencoder.c
View File

@ -96,6 +96,7 @@
MPOpts opts;
struct osd_state *osd;
const int under_mencoder = 1;
int vo_doublebuffering=0;
int vo_directrendering=0;
int forced_subs_only=0;

29
mp_core.h
View File

@ -1,6 +1,8 @@
#ifndef MPLAYER_MP_CORE_H
#define MPLAYER_MP_CORE_H
#include <stdbool.h>
#include "options.h"
#include "mixer.h"
#include "subreader.h"
@ -76,12 +78,28 @@ typedef struct MPContext {
// struct.
int num_buffered_frames;
// Show a video frame as quickly as possible without trying to adjust
// for AV sync. Used when starting a file or after seeking.
bool update_video_immediately;
// AV sync: the next frame should be shown when the audio out has this
// much (in seconds) buffered data left. Increased when more data is
// written to the ao, decreased when moving to the next frame.
// In the audio-only case used as a timer since the last seek
// by the audio CPU usage meter.
double delay;
// AV sync: time until next frame should be shown
float time_frame;
// How long the last vo flip() call took. Used to adjust timing with
// the goal of making flip() calls finish (rather than start) at the
// specified time.
float last_vo_flip_duration;
// How much video timing has been changed to make it match the audio
// timeline. Used for status line information only.
double total_avsync_change;
// A-V sync difference when last frame was displayed. Kept to display
// the same value if the status line is updated at a time where no new
// video frame is shown.
double last_av_difference;
// Timestamp from the last time some timing functions read the
// current time, in (occasionally wrapping) microseconds. Used
@ -112,7 +130,13 @@ typedef struct MPContext {
int last_dvb_step;
int dvbin_reopen;
int was_paused;
int paused;
// step this many frames, then pause
int step_frames;
// Set after showing warning about decoding being too slow for realtime
// playback rate. Used to avoid showing it multiple times.
bool drop_message_shown;
#ifdef CONFIG_DVDNAV
struct mp_image *nav_smpi; ///< last decoded dvdnav video image
@ -138,5 +162,8 @@ double playing_audio_pts(struct MPContext *mpctx);
void exit_player_with_rc(struct MPContext *mpctx, exit_reason_t how, int rc);
void add_subtitles(struct MPContext *mpctx, char *filename, float fps, int noerr);
int reinit_video_chain(struct MPContext *mpctx);
void pause_player(struct MPContext *mpctx);
void unpause_player(struct MPContext *mpctx);
void add_step_frame(struct MPContext *mpctx);
#endif /* MPLAYER_MP_CORE_H */

412
mplayer.c
View File

@ -4,6 +4,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "config.h"
#include "talloc.h"
@ -86,6 +87,7 @@
#include "input/input.h"
const int under_mencoder = 0;
int slave_mode=0;
int player_idle_mode=0;
int quiet=0;
@ -259,8 +261,6 @@ static char *stream_dump_name="stream.dump";
// A-V sync:
static float default_max_pts_correction=-1;//0.01f;
static float max_pts_correction=0;//default_max_pts_correction;
static float c_total=0;
float audio_delay=0;
static int ignore_start=0;
@ -1160,16 +1160,25 @@ static void sadd_hhmmssf(char *buf, unsigned *pos, int len, float time) {
saddf(buf, pos, len, "%02d.%1d", ss, f1);
}
/**
* \brief print the status line
* \param a_pos audio position
* \param a_v A-V desynchronization
* \param corr amount out A-V synchronization
*/
static void print_status(struct MPContext *mpctx, float a_pos, float a_v, float corr)
static void print_status(struct MPContext *mpctx, double a_pos, bool at_frame)
{
struct MPOpts *opts = &mpctx->opts;
sh_video_t * const sh_video = mpctx->sh_video;
if (mpctx->sh_audio && a_pos == MP_NOPTS_VALUE)
a_pos = playing_audio_pts(mpctx);
if (mpctx->sh_audio && sh_video && at_frame) {
mpctx->last_av_difference = a_pos - sh_video->pts - audio_delay;
if (mpctx->last_av_difference > 0.5 && drop_frame_cnt > 50
&& !mpctx->drop_message_shown) {
mp_msg(MSGT_AVSYNC,MSGL_WARN,MSGTR_SystemTooSlow);
mpctx->drop_message_shown = true;
}
}
if (quiet)
return;
int width;
char *line;
unsigned pos = 0;
@ -1204,7 +1213,8 @@ static void print_status(struct MPContext *mpctx, float a_pos, float a_v, float
// A-V sync
if (mpctx->sh_audio && sh_video)
saddf(line, &pos, width, "A-V:%7.3f ct:%7.3f ", a_v, corr);
saddf(line, &pos, width, "A-V:%7.3f ct:%7.3f ",
mpctx->last_av_difference, mpctx->total_avsync_change);
// Video stats
if (sh_video)
@ -1412,8 +1422,7 @@ static mp_osd_msg_t* get_osd_msg(struct MPContext *mpctx)
osd_visible = 0;
vo_osd_progbar_type = -1; // disable
vo_osd_changed(OSDTYPE_PROGBAR);
if (mpctx->osd_function != OSD_PAUSE)
mpctx->osd_function = OSD_PLAY;
mpctx->osd_function = mpctx->paused ? OSD_PAUSE : OSD_PLAY;
}
}
@ -1696,8 +1705,8 @@ static int check_framedrop(struct MPContext *mpctx, double frame_time) {
++total_frame_cnt;
// we should avoid dropping too many frames in sequence unless we
// are too late. and we allow 100ms A-V delay here:
if (d < -dropped_frames*frame_time-0.100 &&
mpctx->osd_function != OSD_PAUSE) {
if (d < -dropped_frames*frame_time-0.100 && !mpctx->paused
&& !mpctx->update_video_immediately) {
++drop_frame_cnt;
++dropped_frames;
return frame_dropping;
@ -1922,71 +1931,39 @@ static void mp_dvdnav_save_smpi(struct MPContext *mpctx, int in_size,
}
#endif /* CONFIG_DVDNAV */
static void adjust_sync_and_print_status(struct MPContext *mpctx,
int between_frames,
float timing_error)
/* Modify video timing to match the audio timeline. There are two main
* reasons this is needed. First, video and audio can start from different
* positions at beginning of file or after a seek (MPlayer starts both
* immediately even if they have different pts). Second, the file can have
* audio timestamps that are inconsistent with the duration of the audio
* packets, for example two consecutive timestamp values differing by
* one second but only a packet with enough samples for half a second
* of playback between them.
*/
static void adjust_sync(struct MPContext *mpctx, double frame_time)
{
struct MPOpts *opts = &mpctx->opts;
current_module="av_sync";
current_module = "av_sync";
if(mpctx->sh_audio){
double a_pts, v_pts;
if (!mpctx->sh_audio)
return;
if (autosync)
/*
* If autosync is enabled, the value for delay must be calculated
* a bit differently. It is set only to the difference between
* the audio and video timers. Any attempt to include the real
* or corrected delay causes the pts_correction code below to
* try to correct for the changes in delay which autosync is
* trying to measure. This keeps the two from competing, but still
* allows the code to correct for PTS drift *only*. (Using a delay
* value here, even a "corrected" one, would be incompatible with
* autosync mode.)
*/
a_pts = written_audio_pts(mpctx) - mpctx->delay;
else
a_pts = playing_audio_pts(mpctx);
double a_pts = written_audio_pts(mpctx) - mpctx->delay;
double v_pts = mpctx->sh_video->pts;
double av_delay = a_pts - v_pts;
// Try to sync vo_flip() so it will *finish* at given time
av_delay += mpctx->last_vo_flip_duration;
av_delay -= audio_delay; // This much pts difference is desired
v_pts = mpctx->sh_video->pts;
{
static int drop_message=0;
double AV_delay = a_pts - audio_delay - v_pts;
double x;
if (AV_delay>0.5 && drop_frame_cnt>50 && drop_message==0){
++drop_message;
mp_msg(MSGT_AVSYNC,MSGL_WARN,MSGTR_SystemTooSlow);
}
if (autosync)
x = AV_delay*0.1f;
else
/* Do not correct target time for the next frame if this frame
* was late not because of wrong target time but because the
* target time could not be met */
x = (AV_delay + timing_error * opts->playback_speed) * 0.1f;
if (x < -max_pts_correction)
x = -max_pts_correction;
else if (x> max_pts_correction)
x = max_pts_correction;
if (default_max_pts_correction >= 0)
max_pts_correction = default_max_pts_correction;
else
max_pts_correction = mpctx->sh_video->frametime*0.10; // +-10% of time
if (!between_frames) {
mpctx->delay+=x;
c_total+=x;
}
if(!quiet)
print_status(mpctx, a_pts - audio_delay, AV_delay, c_total);
}
} else {
// No audio:
if (!quiet)
print_status(mpctx, 0, 0, 0);
}
double change = av_delay * 0.1;
double max_change = default_max_pts_correction >= 0 ?
default_max_pts_correction : frame_time * 0.1;
if (change < -max_change)
change = -max_change;
else if (change > max_change)
change = max_change;
mpctx->delay += change;
mpctx->total_avsync_change += change;
}
static int fill_audio_out_buffers(struct MPContext *mpctx)
@ -2233,65 +2210,82 @@ err_out:
return 0;
}
static double update_video_nocorrect_pts(struct MPContext *mpctx,
int *blit_frame)
{
struct sh_video *sh_video = mpctx->sh_video;
*blit_frame = 0;
double frame_time = 0;
while (1) {
current_module = "filter_video";
// In nocorrect-pts mode there is no way to properly time these frames
if (vf_output_queued_frame(sh_video->vfilter))
break;
unsigned char *packet = NULL;
frame_time = sh_video->next_frame_time;
if (mpctx->update_video_immediately)
frame_time = 0;
int in_size = video_read_frame(sh_video, &sh_video->next_frame_time,
&packet, force_fps);
if (in_size < 0) {
#ifdef CONFIG_DVDNAV
if (mpctx->stream->type == STREAMTYPE_DVDNAV) {
if (mp_dvdnav_is_eof(mpctx->stream))
return -1;
if (mpctx->d_video)
mpctx->d_video->eof = 0;
if (mpctx->d_audio)
mpctx->d_audio->eof = 0;
mpctx->stream->eof = 0;
} else
#endif
return -1;
}
if (in_size > max_framesize)
max_framesize = in_size;
sh_video->timer += frame_time;
if (mpctx->sh_audio)
mpctx->delay -= frame_time;
// video_read_frame can change fps (e.g. for ASF video)
vo_fps = sh_video->fps;
int framedrop_type = check_framedrop(mpctx, frame_time);
current_module = "decode video";
void *decoded_frame;
#ifdef CONFIG_DVDNAV
decoded_frame = mp_dvdnav_restore_smpi(mpctx, &in_size, &packet, NULL);
if (in_size >= 0 && !decoded_frame)
#endif
decoded_frame = decode_video(sh_video, packet, in_size, framedrop_type,
sh_video->pts);
#ifdef CONFIG_DVDNAV
// Save last still frame for future display
mp_dvdnav_restore_smpi(mpctx, in_size, packet, decoded_frame);
#endif
if (decoded_frame) {
// These updates are done here for vf_expand OSD/subtitles
update_subtitles(sh_video, mpctx->d_sub, 0);
update_teletext(sh_video, mpctx->demuxer, 0);
update_osd_msg(mpctx);
current_module = "filter video";
if (filter_video(sh_video, decoded_frame, sh_video->pts,
mpctx->osd))
break;
}
}
*blit_frame = 1;
return frame_time;
}
static double update_video(struct MPContext *mpctx, int *blit_frame)
{
struct MPOpts *opts = &mpctx->opts;
sh_video_t * const sh_video = mpctx->sh_video;
//-------------------- Decode a frame: -----------------------
struct sh_video *sh_video = mpctx->sh_video;
double frame_time;
*blit_frame = 0; // Don't blit if we hit EOF
*blit_frame = 0;
sh_video->vfilter->control(sh_video->vfilter, VFCTRL_SET_OSD_OBJ,
mpctx->osd); // hack for vf_expand
if (!opts->correct_pts) {
unsigned char* start=NULL;
void *decoded_frame = NULL;
int drop_frame=0;
int in_size;
current_module = "video_read_frame";
frame_time = sh_video->next_frame_time;
in_size = video_read_frame(sh_video, &sh_video->next_frame_time,
&start, force_fps);
#ifdef CONFIG_DVDNAV
/// wait, still frame or EOF
if (mpctx->stream->type == STREAMTYPE_DVDNAV && in_size < 0) {
if (mp_dvdnav_is_eof(mpctx->stream)) return -1;
if (mpctx->d_video) mpctx->d_video->eof = 0;
if (mpctx->d_audio) mpctx->d_audio->eof = 0;
mpctx->stream->eof = 0;
} else
#endif
if (in_size < 0)
return -1;
if (in_size > max_framesize)
max_framesize = in_size; // stats
sh_video->timer += frame_time;
if (mpctx->sh_audio)
mpctx->delay -= frame_time;
// video_read_frame can change fps (e.g. for ASF video)
vo_fps = sh_video->fps;
drop_frame = check_framedrop(mpctx, frame_time);
update_subtitles(sh_video, mpctx->d_sub, 0);
update_teletext(sh_video, mpctx->demuxer, 0);
update_osd_msg(mpctx);
current_module = "decode_video";
#ifdef CONFIG_DVDNAV
decoded_frame = mp_dvdnav_restore_smpi(mpctx, &in_size,&start,
decoded_frame);
/// still frame has been reached, no need to decode
if (in_size > 0 && !decoded_frame)
#endif
decoded_frame = decode_video(sh_video, start, in_size, drop_frame,
sh_video->pts);
#ifdef CONFIG_DVDNAV
/// save back last still frame for future display
mp_dvdnav_save_smpi(mpctx, in_size, start, decoded_frame);
#endif
current_module = "filter_video";
*blit_frame = (decoded_frame && filter_video(sh_video, decoded_frame,
sh_video->pts,
mpctx->osd));
}
if (!mpctx->opts.correct_pts)
return update_video_nocorrect_pts(mpctx, blit_frame);
else {
int res = generate_video_frame(mpctx);
if (!res)
@ -2318,6 +2312,43 @@ static double update_video(struct MPContext *mpctx, int *blit_frame)
return frame_time;
}
void pause_player(struct MPContext *mpctx)
{
if (mpctx->paused)
return;
mpctx->paused = 1;
mpctx->step_frames = 0;
mpctx->time_frame -= get_relative_time(mpctx);
if (mpctx->video_out && mpctx->sh_video && mpctx->video_out->config_ok)
vo_control(mpctx->video_out, VOCTRL_PAUSE, NULL);
if (mpctx->audio_out && mpctx->sh_audio)
mpctx->audio_out->pause(); // pause audio, keep data if possible
}
void unpause_player(struct MPContext *mpctx)
{
if (!mpctx->paused)
return;
mpctx->paused = 0;
if (mpctx->audio_out && mpctx->sh_audio)
mpctx->audio_out->resume(); // resume audio
if (mpctx->video_out && mpctx->sh_video && mpctx->video_out->config_ok
&& !mpctx->step_frames)
vo_control(mpctx->video_out, VOCTRL_RESUME, NULL); // resume video
(void)get_relative_time(mpctx); // ignore time that passed during pause
}
void add_step_frame(struct MPContext *mpctx)
{
mpctx->step_frames++;
if (mpctx->video_out && mpctx->sh_video && mpctx->video_out->config_ok)
vo_control(mpctx->video_out, VOCTRL_PAUSE, NULL);
unpause_player(mpctx);
}
static void pause_loop(struct MPContext *mpctx)
{
mp_cmd_t* cmd;
@ -2339,11 +2370,6 @@ static void pause_loop(struct MPContext *mpctx)
if (use_gui)
guiGetEvent(guiCEvent, (char *)guiSetPause);
#endif
if (mpctx->video_out && mpctx->sh_video && mpctx->video_out->config_ok)
vo_control(mpctx->video_out, VOCTRL_PAUSE, NULL);
if (mpctx->audio_out && mpctx->sh_audio)
mpctx->audio_out->pause(); // pause audio, keep data if possible
while ( (cmd = mp_input_get_cmd(mpctx->input, 20, 1, 1)) == NULL
|| cmd->id == MP_CMD_SET_MOUSE_POS || cmd->pausing == 4) {
@ -2368,17 +2394,12 @@ static void pause_loop(struct MPContext *mpctx)
vf_menu_pause_update(vf_menu);
#endif
usec_sleep(20000);
update_osd_msg(mpctx);
int hack = vo_osd_changed(0);
vo_osd_changed(hack);
if (hack)
break;
}
if (cmd && cmd->id == MP_CMD_PAUSE) {
cmd = mp_input_get_cmd(mpctx->input, 0,1,0);
mp_cmd_free(cmd);
}
mpctx->osd_function=OSD_PLAY;
if (mpctx->audio_out && mpctx->sh_audio)
mpctx->audio_out->resume(); // resume audio
if (mpctx->video_out && mpctx->sh_video && mpctx->video_out->config_ok)
vo_control(mpctx->video_out, VOCTRL_RESUME, NULL); // resume video
(void)get_relative_time(mpctx); // ignore time that passed during pause
#ifdef CONFIG_GUI
if (use_gui) {
if (guiIntfStruct.Playing == guiSetStop)
@ -2500,6 +2521,8 @@ static int seek(MPContext *mpctx, double amount, int style)
mpctx->sh_video->last_pts = MP_NOPTS_VALUE;
mpctx->num_buffered_frames = 0;
mpctx->delay = 0;
mpctx->time_frame = 0;
mpctx->update_video_immediately = true;
// Not all demuxers set d_video->pts during seek, so this value
// (which is used by at least vobsub and edl code below) may
// be completely wrong (probably 0).
@ -2522,8 +2545,7 @@ static int seek(MPContext *mpctx, double amount, int style)
edl_seek_reset(mpctx);
c_total = 0;
max_pts_correction = 0.1;
mpctx->total_avsync_change = 0;
audio_time_usage = 0; video_time_usage = 0; vout_time_usage = 0;
drop_frame_cnt = 0;
@ -3601,7 +3623,6 @@ if(verbose) term_osd = 0;
{
//int frame_corr_num=0; //
//float v_frame=0; // Video
float time_frame=0; // Timer
//float num_frames=0; // number of frames played
int frame_time_remaining=0; // flag
@ -3711,6 +3732,10 @@ if (mpctx->stream->type == STREAMTYPE_DVDNAV) {
#endif
get_relative_time(mpctx); // reset current delta
mpctx->time_frame = 0;
mpctx->drop_message_shown = 0;
mpctx->update_video_immediately = true;
mpctx->total_avsync_change = 0;
while(!mpctx->stop_play){
float aq_sleep_time=0;
@ -3729,7 +3754,7 @@ if(!mpctx->sh_audio && mpctx->d_audio->sh) {
/*========================== PLAY AUDIO ============================*/
if (mpctx->sh_audio)
if (mpctx->sh_audio && !mpctx->paused)
if (!fill_audio_out_buffers(mpctx))
// at eof, all audio at least written to ao
if (!mpctx->sh_video)
@ -3741,11 +3766,10 @@ if(!mpctx->sh_video) {
double a_pos=0;
// sh_audio can be NULL due to video stream switching
// TODO: handle this better
if(!quiet || end_at.type == END_AT_TIME && mpctx->sh_audio)
if (mpctx->sh_audio)
a_pos = playing_audio_pts(mpctx);
if(!quiet)
print_status(mpctx, a_pos, 0, 0);
print_status(mpctx, a_pos, false);
if(end_at.type == END_AT_TIME && end_at.pos < a_pos)
mpctx->stop_play = PT_NEXT_ENTRY;
@ -3766,12 +3790,20 @@ if(!mpctx->sh_video) {
mpctx->stop_play = PT_NEXT_ENTRY;
goto goto_next_file;
}
if (blit_frame)
vo_osd_changed(0);
if (frame_time < 0)
mpctx->stop_play = AT_END_OF_FILE;
else {
// might return with !eof && !blit_frame if !correct_pts
mpctx->num_buffered_frames += blit_frame;
time_frame += frame_time / opts->playback_speed; // for nosound
if (mpctx->update_video_immediately) {
// Show this frame immediately, rest normally
mpctx->update_video_immediately = false;
} else {
mpctx->time_frame += frame_time / opts->playback_speed;
adjust_sync(mpctx, frame_time);
}
}
}
@ -3802,7 +3834,7 @@ if(!mpctx->sh_video) {
}
}
frame_time_remaining = sleep_until_update(mpctx, &time_frame, &aq_sleep_time);
frame_time_remaining = sleep_until_update(mpctx, &mpctx->time_frame, &aq_sleep_time);
//====================== FLIP PAGE (VIDEO BLT): =========================
@ -3813,11 +3845,12 @@ if(!mpctx->sh_video) {
vo_flip_page(mpctx->video_out);
mpctx->num_buffered_frames--;
vout_time_usage += (GetTimer() - t2) * 0.000001;
mpctx->last_vo_flip_duration = (GetTimer() - t2) * 0.000001;
vout_time_usage += mpctx->last_vo_flip_duration;
print_status(mpctx, MP_NOPTS_VALUE, true);
}
//====================== A-V TIMESTAMP CORRECTION: =========================
adjust_sync_and_print_status(mpctx, frame_time_remaining, time_frame);
else
print_status(mpctx, MP_NOPTS_VALUE, false);
//============================ Auto QUALITY ============================
@ -3839,9 +3872,17 @@ if(auto_quality>0){
set_video_quality(mpctx->sh_video,output_quality);
}
if (play_n_frames >= 0 && !frame_time_remaining && blit_frame) {
--play_n_frames;
if (play_n_frames <= 0) mpctx->stop_play = PT_NEXT_ENTRY;
if (!frame_time_remaining && blit_frame) {
if (play_n_frames >= 0) {
--play_n_frames;
if (play_n_frames <= 0)
mpctx->stop_play = PT_NEXT_ENTRY;
}
if (mpctx->step_frames > 0) {
mpctx->step_frames--;
if (mpctx->step_frames == 0)
pause_player(mpctx);
}
}
@ -3869,38 +3910,45 @@ if(auto_quality>0){
}
#endif
//============================ Handle PAUSE ===============================
current_module="pause";
if (mpctx->osd_function == OSD_PAUSE) {
mpctx->was_paused = 1;
pause_loop(mpctx);
}
// handle -sstep
if(step_sec>0) {
mpctx->osd_function=OSD_FFW;
mpctx->rel_seek_secs+=step_sec;
}
edl_update(mpctx);
//================= Keyboard events, SEEKing ====================
current_module="key_events";
{
while (1) {
mp_cmd_t* cmd;
int brk_cmd = 0;
while( !brk_cmd && (cmd = mp_input_get_cmd(mpctx->input, 0,0,0)) != NULL) {
brk_cmd = run_command(mpctx, cmd);
while ((cmd = mp_input_get_cmd(mpctx->input, 0,0,0)) != NULL) {
run_command(mpctx, cmd);
mp_cmd_free(cmd);
if (brk_cmd == 2)
goto goto_enable_cache;
if (mpctx->stop_play)
break;
}
if (!mpctx->paused || mpctx->stop_play || mpctx->rel_seek_secs
|| mpctx->abs_seek_pos)
break;
if (mpctx->sh_video) {
update_osd_msg(mpctx);
int hack = vo_osd_changed(0);
vo_osd_changed(hack);
if (hack)
if (redraw_osd(mpctx->sh_video, mpctx->osd) < 0) {
add_step_frame(mpctx);
break;
}
else
vo_osd_changed(0);
}
pause_loop(mpctx);
}
}
mpctx->was_paused = 0;
// handle -sstep
if (step_sec > 0 && !mpctx->paused) {
mpctx->osd_function=OSD_FFW;
mpctx->rel_seek_secs+=step_sec;
}
edl_update(mpctx);
/* Looping. */
if(mpctx->stop_play==AT_END_OF_FILE && opts->loop_times>=0) {