static gboolean vid_area_render_handler( GtkGLArea *area,
GdkGLContext *context,
gpointer data )
{
gmpv_handle *ctx = data;
int width;
int height;
int fbo;
if(!ctx->opengl_ready)
{
mpv_check_error(mpv_opengl_cb_init_gl( ctx->opengl_ctx,
NULL,
get_proc_address,
NULL ));
ctx->opengl_ready = TRUE;
}
width = gtk_widget_get_allocated_width(GTK_WIDGET(area));
height = (-1)*gtk_widget_get_allocated_height(GTK_WIDGET(area));
fbo = -1;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo);
mpv_opengl_cb_draw(ctx->opengl_ctx, fbo, width, height);
return TRUE;
}
static gboolean
render_cb(GtkGLArea* area,
GdkGLContext* ctxt,
gpointer udata)
{
GtPlayerMpv* self = GT_PLAYER_MPV(udata);
GtPlayerMpvPrivate* priv = gt_player_mpv_get_instance_private(self);
int width;
int height;
int fbo;
if (!priv->opengl_ready)
{
check_mpv_error(mpv_opengl_cb_init_gl(priv->mpv_opengl, NULL,
get_proc_address, NULL));
priv->opengl_ready = TRUE;
}
width = gtk_widget_get_allocated_height(priv->opengl_area);
height = (-1)*gtk_widget_get_allocated_width(priv->opengl_area);
fbo = -1;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo);
mpv_opengl_cb_draw(priv->mpv_opengl, fbo, width, height);
return TRUE;
}
bool PlayerRenderer::init()
{
const char *extensions = "";
#ifdef Q_OS_WIN32
// For the custom IDirect3DDevice9 hack above.
extensions = "GL_MP_D3D_interfaces";
#endif
return mpv_opengl_cb_init_gl(m_mpvGL, extensions, get_proc_address, NULL) >= 0;
}
bool PlayerRenderer::init()
{
#ifdef Q_OS_WIN32
// Request Multimedia Class Schedule Service.
DwmEnableMMCSS(TRUE);
#endif
// Signals presence of MPGetNativeDisplay().
const char *extensions = "GL_MP_MPGetNativeDisplay";
return mpv_opengl_cb_init_gl(m_mpvGL, extensions, get_proc_address, NULL) >= 0;
}
static void
realise_oneshot_cb(GtkWidget* widget,
gpointer udata)
{
GtPlayerBackendMpvOpenGL* self = GT_PLAYER_BACKEND_MPV_OPENGL(udata);
GtPlayerBackendMpvOpenGLPrivate* priv = gt_player_backend_mpv_opengl_get_instance_private(self);
gtk_gl_area_make_current(GTK_GL_AREA(priv->widget));
check_mpv_error(mpv_opengl_cb_init_gl(priv->mpv_opengl, NULL,
get_proc_address, NULL));
g_signal_handlers_disconnect_by_func(widget, realise_oneshot_cb, udata);
}
void gmpv_mpv_obj_init_gl(GmpvMpvObj *mpv)
{
mpv_opengl_cb_context *opengl_ctx;
gint rc;
opengl_ctx = gmpv_mpv_obj_get_opengl_cb_context(mpv);
rc = mpv_opengl_cb_init_gl( opengl_ctx,
"GL_MP_MPGetNativeDisplay",
get_proc_address,
NULL );
if(rc >= 0)
{
g_debug("Initialized opengl-cb");
}
else
{
g_critical("Failed to initialize opengl-cb");
}
}
void VideoPlayer::initializeGL()
{
int r = mpv_opengl_cb_init_gl(mpv_gl, nullptr, get_proc_address, nullptr);
if(r < 0)
throw std::runtime_error("could not initialize OpenGL");
}
static void *render_thread_run(void *data) {
struct render_thread *render_thread = data;
EGLDisplay egl_display = NULL;
EGLSurface egl_surface = NULL;
EGLContext egl_context = NULL;
// Gather egl params and bind to mpv opengl_cb
{
pthread_mutex_lock(&render_thread->lock);
egl_display = render_thread->egl_display;
egl_surface = render_thread->egl_surface;
egl_context = render_thread->egl_context;
eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
eglSwapInterval(egl_display, 0);
int res = mpv_opengl_cb_init_gl(render_thread->opengl_cb_context, NULL,
mpv_get_proc_address, NULL);
if (res < 0) {
log_mpv_error("mpv_opengl_cb_init_gl failed", res);
}
mpv_opengl_cb_set_update_callback(render_thread->opengl_cb_context,
update_callback, render_thread);
// TODO: after the first uninit the video track is reset to 0 (none)
// Setting this to 1 restarts the playback though and messes up the time the video
// was playing at.
uint64_t on = 1;
mpv_set_property(render_thread->mpv, "vid", MPV_FORMAT_INT64, &on);
render_thread->running = 1;
pthread_cond_broadcast(&render_thread->ready);
pthread_mutex_unlock(&render_thread->lock);
}
int64_t last_time = mpv_get_time_us(render_thread->mpv);
int frames = 0;
while (1) {
// Wait for available frames
{
pthread_mutex_lock(&render_thread->frame_wait_lock);
while (!render_thread->frame_available) {
pthread_cond_wait(&render_thread->frame_wait, &render_thread->frame_wait_lock);
}
render_thread->frame_available = 0;
pthread_mutex_unlock(&render_thread->frame_wait_lock);
}
// Check if still running
int run, width, height;
{
pthread_mutex_lock(&render_thread->lock);
run = render_thread->running;
width = render_thread->width;
height = render_thread->height;
pthread_mutex_unlock(&render_thread->lock);
}
if (!run) {
break;
}
// int64_t draw_start = mpv_get_time_us(render_thread->mpv);
mpv_opengl_cb_draw(render_thread->opengl_cb_context, 0, width, -height);
// LOGI("Render time %ld", (mpv_get_time_us(render_thread->mpv) - draw_start));
if (!eglSwapBuffers(egl_display, egl_surface)) {
LOGE("eglSwapBuffers failed %d", eglGetError());
}
// mpv_opengl_cb_report_flip(render_thread->opengl_cb_context, 0);
frames++;
int64_t now = mpv_get_time_us(render_thread->mpv);
if (now - last_time >= 1000 * 1000) {
// last_time += 1000 * 1000;
last_time = now; // Don't play catch-up
LOGI("Render fps %d", frames);
frames = 0;
}
}
// Release egl params and unbind from mpv opengl_cb
{
pthread_mutex_lock(&render_thread->lock);
int res = mpv_opengl_cb_uninit_gl(render_thread->opengl_cb_context);
if (res < 0) {
log_mpv_error("mpv_opengl_cb_uninit_gl failed", res);
}
eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
pthread_mutex_unlock(&render_thread->lock);
}
return NULL;
}
void MpvWidget::initializeGL()
{
int r = mpv_opengl_cb_init_gl(mpv_gl, NULL, get_proc_address, NULL);
if (r < 0)
throw std::runtime_error("could not initialize OpenGL");
}
