static bool reparse_cmdline(struct gl_priv *p, char *args) { struct m_config *cfg = NULL; struct gl_priv *opts = NULL; int r = 0; // list of options which can be changed at runtime #define OPT_BASE_STRUCT struct gl_priv static const struct m_option change_otps[] = { OPT_SUBSTRUCT("", renderer_opts, gl_video_conf, 0), {0} }; #undef OPT_BASE_STRUCT if (strcmp(args, "-") == 0) { opts = p; } else { const struct gl_priv *vodef = p->vo->driver->priv_defaults; cfg = m_config_new(NULL, p->vo->log, sizeof(*opts), vodef, change_otps); opts = cfg->optstruct; r = m_config_parse_suboptions(cfg, "opengl", args); } if (r >= 0) { gl_video_set_options(p->renderer, opts->renderer_opts); gl_video_configure_queue(p->renderer, p->vo); p->vo->want_redraw = true; } talloc_free(cfg); return r >= 0; }
static bool reparse_cmdline(struct gl_priv *p, char *args) { struct m_config *cfg = NULL; struct gl_video_opts opts; int r = 0; if (strcmp(args, "-") == 0) { opts = *p->renderer_opts; } else { memcpy(&opts, gl_video_conf.defaults, sizeof(opts)); cfg = m_config_simple(&opts); m_config_register_options(cfg, gl_video_conf.opts); const char *init = p->vo->driver->init_option_string; if (init) m_config_parse_suboptions(cfg, "opengl", (char *)init); r = m_config_parse_suboptions(cfg, "opengl", args); } if (r >= 0) { mpgl_lock(p->glctx); gl_video_set_options(p->renderer, &opts); resize(p); mpgl_unlock(p->glctx); } talloc_free(cfg); return r >= 0; }
static int preinit(struct vo *vo) { struct gl_priv *p = vo->priv; p->vo = vo; p->log = vo->log; int vo_flags = 0; if (p->renderer_opts->alpha_mode == 1) vo_flags |= VOFLAG_ALPHA; if (p->use_gl_debug) vo_flags |= VOFLAG_GL_DEBUG; if (p->es == 1) vo_flags |= VOFLAG_GLES; if (p->es == -1) vo_flags |= VOFLAG_NO_GLES; if (p->allow_sw) vo_flags |= VOFLAG_SW; p->glctx = mpgl_init(vo, p->backend, vo_flags); if (!p->glctx) goto err_out; p->gl = p->glctx->gl; p->glctx->dwm_flush_opt = p->dwm_flush; if (p->gl->SwapInterval) { p->gl->SwapInterval(p->swap_interval); } else { MP_VERBOSE(vo, "swap_control extension missing.\n"); } p->cms = gl_lcms_init(p, vo->log, vo->global); if (!p->cms) goto err_out; p->renderer = gl_video_init(p->gl, vo->log, vo->global, p->cms); if (!p->renderer) goto err_out; gl_video_set_osd_source(p->renderer, vo->osd); gl_video_set_options(p->renderer, p->renderer_opts); gl_video_configure_queue(p->renderer, vo); gl_lcms_set_options(p->cms, p->icc_opts); get_and_update_icc_profile(p, &(int){0});
static bool reparse_cmdline(struct vo *vo, char *args) { struct gl_priv *p = vo->priv; int r = 0; struct gl_priv *opts = p; if (strcmp(args, "-") == 0) { opts = p->original_opts; } else { r = m_config_parse_suboptions(vo->config, "opengl", args); } gl_video_set_options(p->renderer, opts->renderer_opts); get_and_update_icc_profile(p); gl_video_configure_queue(p->renderer, p->vo); p->vo->want_redraw = true; return r >= 0; }
static int preinit(struct vo *vo, const char *arg) { struct gl_priv *p = vo->priv; p->vo = vo; p->glctx = mpgl_init(vo, p->backend); if (!p->glctx) goto err_out; p->gl = p->glctx->gl; if (!config_window(p, 320, 200, VOFLAG_HIDDEN)) goto err_out; mpgl_set_context(p->glctx); if (p->gl->SwapInterval) p->gl->SwapInterval(p->swap_interval); p->renderer = gl_video_init(p->gl); gl_video_set_output_depth(p->renderer, p->glctx->depth_r, p->glctx->depth_g, p->glctx->depth_b); gl_video_set_options(p->renderer, p->renderer_opts); if (p->icc_opts->profile) { struct lut3d *lut3d = mp_load_icc(p->icc_opts); if (!lut3d) goto err_out; gl_video_set_lut3d(p->renderer, lut3d); talloc_free(lut3d); } mpgl_unset_context(p->glctx); return 0; err_out: uninit(vo); return -1; }
int mpv_opengl_cb_render(struct mpv_opengl_cb_context *ctx, int fbo, int vp[4]) { assert(ctx->renderer); gl_video_set_gl_state(ctx->renderer); pthread_mutex_lock(&ctx->lock); struct vo *vo = ctx->active; ctx->force_update |= ctx->reconfigured; int h = vp[3]; bool flip = h < 0 && h > INT_MIN; if (flip) h = -h; struct mp_rect wnd = {vp[0], vp[1], vp[0] + vp[2], vp[1] + h}; if (wnd.x0 != ctx->wnd.x0 || wnd.y0 != ctx->wnd.y0 || wnd.x1 != ctx->wnd.x1 || wnd.y1 != ctx->wnd.y1 || ctx->flip != flip) ctx->force_update = true; if (ctx->force_update && vo) { ctx->force_update = false; ctx->wnd = wnd; struct mp_rect src, dst; struct mp_osd_res osd; mp_get_src_dst_rects(ctx->log, &ctx->vo_opts, vo->driver->caps, &ctx->img_params, wnd.x1 - wnd.x0, wnd.y1 - wnd.y0, 1.0, &src, &dst, &osd); gl_video_resize(ctx->renderer, &wnd, &src, &dst, &osd, !ctx->flip); } if (vo) { struct vo_priv *p = vo->priv; if (ctx->reconfigured) gl_video_config(ctx->renderer, &ctx->img_params); if (ctx->reconfigured || ctx->update_new_opts) { struct vo_priv *opts = p->ctx->new_opts ? p->ctx->new_opts : p; gl_video_set_options(ctx->renderer, opts->renderer_opts); ctx->gl->debug_context = opts->use_gl_debug; gl_video_set_debug(ctx->renderer, opts->use_gl_debug); } ctx->reconfigured = false; ctx->update_new_opts = false; } struct mp_image *mpi = ctx->next_frame; ctx->next_frame = NULL; pthread_mutex_unlock(&ctx->lock); if (mpi) gl_video_upload_image(ctx->renderer, mpi); gl_video_render_frame(ctx->renderer, fbo); gl_video_unset_gl_state(ctx->renderer); return 0; }
int mpv_opengl_cb_draw(mpv_opengl_cb_context *ctx, int fbo, int vp_w, int vp_h) { assert(ctx->renderer); gl_video_set_gl_state(ctx->renderer); pthread_mutex_lock(&ctx->lock); struct vo *vo = ctx->active; ctx->force_update |= ctx->reconfigured; if (ctx->vp_w != vp_w || ctx->vp_h != vp_h) ctx->force_update = true; if (ctx->force_update && vo) { ctx->force_update = false; ctx->vp_w = vp_w; ctx->vp_h = vp_h; struct mp_rect src, dst; struct mp_osd_res osd; mp_get_src_dst_rects(ctx->log, &ctx->vo_opts, vo->driver->caps, &ctx->img_params, vp_w, abs(vp_h), 1.0, &src, &dst, &osd); gl_video_resize(ctx->renderer, vp_w, vp_h, &src, &dst, &osd); } if (ctx->reconfigured) { gl_video_set_osd_source(ctx->renderer, vo ? vo->osd : NULL); gl_video_config(ctx->renderer, &ctx->img_params); } if (ctx->update_new_opts) { struct vo_priv *p = vo ? vo->priv : NULL; struct vo_priv *opts = ctx->new_opts ? ctx->new_opts : p; if (opts) { gl_video_set_options(ctx->renderer, opts->renderer_opts, NULL); ctx->gl->debug_context = opts->use_gl_debug; gl_video_set_debug(ctx->renderer, opts->use_gl_debug); frame_queue_shrink(ctx, opts->frame_queue_size); } } ctx->reconfigured = false; ctx->update_new_opts = false; struct mp_csp_equalizer *eq = gl_video_eq_ptr(ctx->renderer); if (ctx->eq_changed) { memcpy(eq->values, ctx->eq.values, sizeof(eq->values)); gl_video_eq_update(ctx->renderer); } ctx->eq_changed = false; ctx->eq = *eq; struct mp_image *mpi = frame_queue_pop(ctx); pthread_mutex_unlock(&ctx->lock); if (mpi) gl_video_set_image(ctx->renderer, mpi); gl_video_render_frame(ctx->renderer, fbo, NULL); gl_video_unset_gl_state(ctx->renderer); pthread_mutex_lock(&ctx->lock); const int left = ctx->queued_frames; if (vo && left > 0) update(vo->priv); pthread_mutex_unlock(&ctx->lock); return left; }
int mpv_opengl_cb_draw(mpv_opengl_cb_context *ctx, int fbo, int vp_w, int vp_h) { assert(ctx->renderer); gl_video_set_gl_state(ctx->renderer); pthread_mutex_lock(&ctx->lock); struct vo *vo = ctx->active; ctx->force_update |= ctx->reconfigured; if (ctx->vp_w != vp_w || ctx->vp_h != vp_h) ctx->force_update = true; if (ctx->force_update && vo) { ctx->force_update = false; ctx->vp_w = vp_w; ctx->vp_h = vp_h; struct mp_rect src, dst; struct mp_osd_res osd; mp_get_src_dst_rects(ctx->log, &ctx->vo_opts, vo->driver->caps, &ctx->img_params, vp_w, abs(vp_h), 1.0, &src, &dst, &osd); gl_video_resize(ctx->renderer, vp_w, vp_h, &src, &dst, &osd); } if (ctx->reconfigured) { gl_video_set_osd_source(ctx->renderer, vo ? vo->osd : NULL); gl_video_config(ctx->renderer, &ctx->img_params); ctx->eq_changed = true; } if (ctx->update_new_opts) { struct vo_priv *p = vo ? vo->priv : NULL; struct vo_priv *opts = ctx->new_opts ? ctx->new_opts : p; if (opts) { gl_video_set_options(ctx->renderer, opts->renderer_opts); if (vo) gl_video_configure_queue(ctx->renderer, vo); ctx->gl->debug_context = opts->use_gl_debug; gl_video_set_debug(ctx->renderer, opts->use_gl_debug); } } ctx->reconfigured = false; ctx->update_new_opts = false; if (ctx->reset) { gl_video_reset(ctx->renderer); ctx->reset = false; if (ctx->cur_frame) ctx->cur_frame->still = true; } struct mp_csp_equalizer *eq = gl_video_eq_ptr(ctx->renderer); if (ctx->eq_changed) { memcpy(eq->values, ctx->eq.values, sizeof(eq->values)); gl_video_eq_update(ctx->renderer); } ctx->eq_changed = false; struct vo_frame *frame = ctx->next_frame; int64_t wait_present_count = ctx->present_count; if (frame) { ctx->next_frame = NULL; wait_present_count += 1; pthread_cond_signal(&ctx->wakeup); talloc_free(ctx->cur_frame); ctx->cur_frame = vo_frame_ref(frame); } else { frame = vo_frame_ref(ctx->cur_frame); if (frame) frame->redraw = true; MP_STATS(ctx, "glcb-noframe"); } struct vo_frame dummy = {0}; if (!frame) frame = &dummy; pthread_mutex_unlock(&ctx->lock); MP_STATS(ctx, "glcb-render"); gl_video_render_frame(ctx->renderer, frame, fbo); gl_video_unset_gl_state(ctx->renderer); if (frame != &dummy) talloc_free(frame); pthread_mutex_lock(&ctx->lock); while (wait_present_count > ctx->present_count) pthread_cond_wait(&ctx->wakeup, &ctx->lock); pthread_mutex_unlock(&ctx->lock); return 0; }
static int preinit(struct vo *vo) { struct gl_priv *p = vo->priv; p->vo = vo; p->log = vo->log; int vo_flags = 0; if (p->renderer_opts->alpha_mode == 1) vo_flags |= VOFLAG_ALPHA; if (p->use_gl_debug) vo_flags |= VOFLAG_GL_DEBUG; if (p->es == 1) vo_flags |= VOFLAG_GLES; if (p->es == -1) vo_flags |= VOFLAG_NO_GLES; if (p->allow_sw) vo_flags |= VOFLAG_SW; p->glctx = mpgl_init(vo, p->backend, vo_flags); if (!p->glctx) goto err_out; p->gl = p->glctx->gl; p->glctx->dwm_flush_opt = p->dwm_flush; if (p->gl->SwapInterval) { p->gl->SwapInterval(p->swap_interval); } else { MP_VERBOSE(vo, "swap_control extension missing.\n"); } p->renderer = gl_video_init(p->gl, vo->log, vo->global); if (!p->renderer) goto err_out; gl_video_set_osd_source(p->renderer, vo->osd); gl_video_set_options(p->renderer, p->renderer_opts); gl_video_configure_queue(p->renderer, vo); get_and_update_icc_profile(p); vo->hwdec_devs = hwdec_devices_create(); hwdec_devices_set_loader(vo->hwdec_devs, call_request_hwdec_api, vo); int hwdec = vo->opts->hwdec_preload_api; if (hwdec == HWDEC_NONE) hwdec = vo->global->opts->hwdec_api; if (hwdec != HWDEC_NONE) { p->hwdec = gl_hwdec_load_api(p->vo->log, p->gl, vo->global, vo->hwdec_devs, hwdec); gl_video_set_hwdec(p->renderer, p->hwdec); } p->original_opts = m_sub_options_copy(p, &opengl_conf, p); return 0; err_out: uninit(vo); return -1; }
int mpv_opengl_cb_draw(mpv_opengl_cb_context *ctx, int fbo, int vp_w, int vp_h) { assert(ctx->renderer); gl_video_set_gl_state(ctx->renderer); pthread_mutex_lock(&ctx->lock); struct vo *vo = ctx->active; ctx->force_update |= ctx->reconfigured; if (ctx->vp_w != vp_w || ctx->vp_h != vp_h) ctx->force_update = true; if (ctx->force_update && vo) { ctx->force_update = false; ctx->vp_w = vp_w; ctx->vp_h = vp_h; struct mp_rect src, dst; struct mp_osd_res osd; mp_get_src_dst_rects(ctx->log, &ctx->vo_opts, vo->driver->caps, &ctx->img_params, vp_w, abs(vp_h), 1.0, &src, &dst, &osd); gl_video_resize(ctx->renderer, vp_w, vp_h, &src, &dst, &osd); } if (ctx->reconfigured) { gl_video_set_osd_source(ctx->renderer, vo ? vo->osd : NULL); gl_video_config(ctx->renderer, &ctx->img_params); } if (ctx->update_new_opts) { struct vo_priv *p = vo ? vo->priv : NULL; struct vo_priv *opts = ctx->new_opts ? ctx->new_opts : p; if (opts) { int queue = 0; gl_video_set_options(ctx->renderer, opts->renderer_opts, &queue); ctx->vsync_timed = opts->renderer_opts->interpolation; if (ctx->vsync_timed) queue += 0.050 * 1e6; // disable video timing vo_set_flip_queue_params(vo, queue, false); ctx->gl->debug_context = opts->use_gl_debug; gl_video_set_debug(ctx->renderer, opts->use_gl_debug); frame_queue_shrink(ctx, opts->frame_queue_size); } } ctx->reconfigured = false; ctx->update_new_opts = false; struct mp_csp_equalizer *eq = gl_video_eq_ptr(ctx->renderer); if (ctx->eq_changed) { memcpy(eq->values, ctx->eq.values, sizeof(eq->values)); gl_video_eq_update(ctx->renderer); } ctx->eq_changed = false; ctx->eq = *eq; struct mp_image *mpi = frame_queue_pop(ctx); if (mpi) { struct frame_timing *t = mpi->priv; // set by draw_image_timed if (t) ctx->cur_pts = t->pts; } struct frame_timing timing = { .pts = ctx->cur_pts, }; if (ctx->approx_vsync > 0) { timing.prev_vsync = prev_sync(ctx, mp_time_us()); timing.next_vsync = timing.prev_vsync + ctx->approx_vsync; } pthread_mutex_unlock(&ctx->lock); if (mpi) gl_video_set_image(ctx->renderer, mpi); gl_video_render_frame(ctx->renderer, fbo, timing.pts ? &timing : NULL); gl_video_unset_gl_state(ctx->renderer); pthread_mutex_lock(&ctx->lock); const int left = ctx->queued_frames; if (vo && (left > 0 || ctx->vsync_timed)) update(vo->priv); pthread_mutex_unlock(&ctx->lock); return left; } int mpv_opengl_cb_report_flip(mpv_opengl_cb_context *ctx, int64_t time) { pthread_mutex_lock(&ctx->lock); int64_t next = time > 0 ? time : mp_time_us(); if (ctx->recent_flip) ctx->approx_vsync = next - ctx->recent_flip; ctx->recent_flip = next; pthread_mutex_unlock(&ctx->lock); return 0; }