MPV is working now

src/main.cpp

@@ -9,8 +9,18 @@
 #include <iostream>
 #include <QQmlEngine>
 
+#include <QObject>
+#include <QtGlobal>
+#include <QOpenGLContext>
+#include <QGuiApplication>
+
+#include <QtGui/QOpenGLFramebufferObject>
+
+#include <QtQuick/QQuickWindow>
+#include <QtQuick/QQuickView>
+
 #include "songlistmodel.h"
-// #include "mpvobject.h"
+#include "mpvobject.h"
 
 int main(int argc, char *argv[])
 {
@@ -21,6 +31,10 @@ int main(int argc, char *argv[])
   QCoreApplication::setOrganizationDomain(QStringLiteral("tfcconnection.org"));
   QCoreApplication::setApplicationName(QStringLiteral("Church Presenter"));
 
+  // apparently mpv needs this class set
+  std::setlocale(LC_NUMERIC, "C");
+  qmlRegisterType<MpvObject>("mpv", 1, 0, "MpvObject");
+
   SongListModel songListModel;
 
   // path = QQmlEngine::importPathList()
@@ -44,3 +58,148 @@ int main(int argc, char *argv[])
 
   return app.exec();
 }
+
+// namespace
+// {
+//   void on_mpv_events(void *ctx)
+//   {
+//     Q_UNUSED(ctx)
+//       }
+
+//   void on_mpv_redraw(void *ctx)
+//   {
+//     MpvObject::on_update(ctx);
+//   }
+
+//   static void *get_proc_address_mpv(void *ctx, const char *name)
+//   {
+//     Q_UNUSED(ctx)
+
+//       QOpenGLContext *glctx = QOpenGLContext::currentContext();
+//     if (!glctx) return nullptr;
+
+//     return reinterpret_cast<void *>(glctx->getProcAddress(QByteArray(name)));
+//   }
+
+// }
+
+// class MpvRenderer : public QQuickFramebufferObject::Renderer
+// {
+//   MpvObject *obj;
+
+// public:
+//   MpvRenderer(MpvObject *new_obj)
+//     : obj{new_obj}
+//   {
+//     mpv_set_wakeup_callback(obj->mpv, on_mpv_events, nullptr);
+//   }
+
+//   virtual ~MpvRenderer()
+//   {}
+
+//   // This function is called when a new FBO is needed.
+//   // This happens on the initial frame.
+//   QOpenGLFramebufferObject * createFramebufferObject(const QSize &size)
+//   {
+//     // init mpv_gl:
+//     if (!obj->mpv_gl)
+//       {
+//         mpv_opengl_init_params gl_init_params{get_proc_address_mpv, nullptr, nullptr};
+//         mpv_render_param params[]{
+//           {MPV_RENDER_PARAM_API_TYPE, const_cast<char *>(MPV_RENDER_API_TYPE_OPENGL)},
+//           {MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, &gl_init_params},
+//           {MPV_RENDER_PARAM_INVALID, nullptr}
+//         };
+
+//         if (mpv_render_context_create(&obj->mpv_gl, obj->mpv, params) < 0)
+//           throw std::runtime_error("failed to initialize mpv GL context");
+//         mpv_render_context_set_update_callback(obj->mpv_gl, on_mpv_redraw, obj);
+//       }
+
+//     return QQuickFramebufferObject::Renderer::createFramebufferObject(size);
+//   }
+
+//   void render()
+//   {
+//     obj->window()->resetOpenGLState();
+
+//     QOpenGLFramebufferObject *fbo = framebufferObject();
+//     mpv_opengl_fbo mpfbo{.fbo = static_cast<int>(fbo->handle()), .w = fbo->width(), .h = fbo->height(), .internal_format = 0};
+//     int flip_y{0};
+
+//     mpv_render_param params[] = {
+//       // Specify the default framebuffer (0) as target. This will
+//       // render onto the entire screen. If you want to show the video
+//       // in a smaller rectangle or apply fancy transformations, you'll
+//       // need to render into a separate FBO and draw it manually.
+//       {MPV_RENDER_PARAM_OPENGL_FBO, &mpfbo},
+//       // Flip rendering (needed due to flipped GL coordinate system).
+//       {MPV_RENDER_PARAM_FLIP_Y, &flip_y},
+//       {MPV_RENDER_PARAM_INVALID, nullptr}
+//     };
+//     // See render_gl.h on what OpenGL environment mpv expects, and
+//     // other API details.
+//     mpv_render_context_render(obj->mpv_gl, params);
+
+//     obj->window()->resetOpenGLState();
+//   }
+// };
+
+
+// MpvObject::MpvObject(QQuickItem * parent)
+//   : QQuickFramebufferObject(parent), mpv{mpv_create()}, mpv_gl(nullptr)
+// {
+//   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");
+
+//   // Request hw decoding, just for testing.
+//   mpv::qt::set_option_variant(mpv, "hwdec", "auto");
+
+//   connect(this, &MpvObject::onUpdate, this, &MpvObject::doUpdate,
+//           Qt::QueuedConnection);
+// }
+
+// MpvObject::~MpvObject()
+// {
+//   if (mpv_gl) // only initialized if something got drawn
+//     {
+//       mpv_render_context_free(mpv_gl);
+//     }
+
+//   mpv_terminate_destroy(mpv);
+// }
+
+// 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()
+// {
+//   update();
+// }
+
+// void MpvObject::command(const QVariant& params)
+// {
+//   mpv::qt::command_variant(mpv, params);
+// }
+
+// void MpvObject::setProperty(const QString& name, const QVariant& value)
+// {
+//   mpv::qt::set_property_variant(mpv, name, value);
+// }
+
+// QQuickFramebufferObject::Renderer *MpvObject::createRenderer() const
+// {
+//   window()->setPersistentOpenGLContext(true);
+//   window()->setPersistentSceneGraph(true);
+//   return new MpvRenderer(const_cast<MpvObject *>(this));
+// }