mirror of https://github.com/mpv-player/mpv
150 lines
4.2 KiB
C++
150 lines
4.2 KiB
C++
#include "main.h"
|
|
|
|
#include <stdexcept>
|
|
|
|
#include <QObject>
|
|
#include <QtGlobal>
|
|
#include <QOpenGLContext>
|
|
|
|
#include <QGuiApplication>
|
|
#include <QtQuick/QQuickWindow>
|
|
#include <QtQuick/QQuickView>
|
|
|
|
static void *get_proc_address(void *ctx, const char *name) {
|
|
(void)ctx;
|
|
QOpenGLContext *glctx = QOpenGLContext::currentContext();
|
|
if (!glctx)
|
|
return NULL;
|
|
return (void *)glctx->getProcAddress(QByteArray(name));
|
|
}
|
|
|
|
MpvRenderer::MpvRenderer(mpv::qt::Handle a_mpv, mpv_opengl_cb_context *a_mpv_gl)
|
|
: mpv(a_mpv), mpv_gl(a_mpv_gl), window(0), size()
|
|
{
|
|
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");
|
|
}
|
|
|
|
MpvRenderer::~MpvRenderer()
|
|
{
|
|
// Until this call is done, we need to make sure the player remains
|
|
// alive. This is done implicitly with the mpv::qt::Handle instance
|
|
// in this class.
|
|
mpv_opengl_cb_uninit_gl(mpv_gl);
|
|
}
|
|
|
|
void MpvRenderer::paint()
|
|
{
|
|
window->resetOpenGLState();
|
|
|
|
// Render to the whole window.
|
|
int vp[4] = {0, 0, size.width(), -size.height()};
|
|
|
|
// This uses 0 as framebuffer, which indicates that mpv will render directly
|
|
// to the frontbuffer. Note that mpv will always switch framebuffers
|
|
// explicitly. Some QWindow setups (such as using QQuickWidget) actually
|
|
// want you to render into a FBO in the beforeRendering() signal, and this
|
|
// code won't work there.
|
|
mpv_opengl_cb_render(mpv_gl, 0, vp);
|
|
|
|
window->resetOpenGLState();
|
|
}
|
|
|
|
MpvObject::MpvObject(QQuickItem * parent)
|
|
: QQuickItem(parent), mpv_gl(0), renderer(0)
|
|
{
|
|
mpv = mpv::qt::Handle::FromRawHandle(mpv_create());
|
|
if (!mpv)
|
|
throw std::runtime_error("could not create mpv context");
|
|
|
|
mpv_set_option_string(mpv, "terminal", "yes");
|
|
mpv_set_option_string(mpv, "msg-level", "all=v");
|
|
|
|
if (mpv_initialize(mpv) < 0)
|
|
throw std::runtime_error("could not initialize mpv context");
|
|
|
|
// Make use of the MPV_SUB_API_OPENGL_CB API.
|
|
mpv::qt::set_option_variant(mpv, "vo", "opengl-cb");
|
|
|
|
// Setup the callback that will make QtQuick update and redraw if there
|
|
// is a new video frame. Use a queued connection: this makes sure the
|
|
// doUpdate() function is run on the GUI thread.
|
|
mpv_gl = (mpv_opengl_cb_context *)mpv_get_sub_api(mpv, MPV_SUB_API_OPENGL_CB);
|
|
if (!mpv_gl)
|
|
throw std::runtime_error("OpenGL not compiled in");
|
|
mpv_opengl_cb_set_update_callback(mpv_gl, MpvObject::on_update, (void *)this);
|
|
connect(this, &MpvObject::onUpdate, this, &MpvObject::doUpdate,
|
|
Qt::QueuedConnection);
|
|
|
|
connect(this, &QQuickItem::windowChanged,
|
|
this, &MpvObject::handleWindowChanged);
|
|
}
|
|
|
|
MpvObject::~MpvObject()
|
|
{
|
|
if (mpv_gl)
|
|
mpv_opengl_cb_set_update_callback(mpv_gl, NULL, NULL);
|
|
}
|
|
|
|
void MpvObject::handleWindowChanged(QQuickWindow *win)
|
|
{
|
|
if (!win)
|
|
return;
|
|
connect(win, &QQuickWindow::beforeSynchronizing,
|
|
this, &MpvObject::sync, Qt::DirectConnection);
|
|
connect(win, &QQuickWindow::sceneGraphInvalidated,
|
|
this, &MpvObject::cleanup, Qt::DirectConnection);
|
|
win->setClearBeforeRendering(false);
|
|
}
|
|
|
|
void MpvObject::sync()
|
|
{
|
|
if (!renderer) {
|
|
renderer = new MpvRenderer(mpv, mpv_gl);
|
|
connect(window(), &QQuickWindow::beforeRendering,
|
|
renderer, &MpvRenderer::paint, Qt::DirectConnection);
|
|
}
|
|
renderer->window = window();
|
|
renderer->size = window()->size() * window()->devicePixelRatio();
|
|
}
|
|
|
|
void MpvObject::cleanup()
|
|
{
|
|
if (renderer) {
|
|
delete renderer;
|
|
renderer = 0;
|
|
}
|
|
}
|
|
|
|
void MpvObject::on_update(void *ctx)
|
|
{
|
|
MpvObject *self = (MpvObject *)ctx;
|
|
emit self->onUpdate();
|
|
}
|
|
|
|
// connected to onUpdate(); signal makes sure it runs on the GUI thread
|
|
void MpvObject::doUpdate()
|
|
{
|
|
window()->update();
|
|
}
|
|
|
|
void MpvObject::command(const QVariant& params)
|
|
{
|
|
mpv::qt::command_variant(mpv, params);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
QGuiApplication app(argc, argv);
|
|
|
|
qmlRegisterType<MpvObject>("mpvtest", 1, 0, "MpvObject");
|
|
|
|
QQuickView view;
|
|
view.setResizeMode(QQuickView::SizeRootObjectToView);
|
|
view.setSource(QUrl("qrc:///mpvtest/main.qml"));
|
|
view.show();
|
|
|
|
return app.exec();
|
|
}
|