From b3aa95372e74764d1eee4d3f20b343d19e8ae1ac Mon Sep 17 00:00:00 2001
From: Unknown <grant.ramsay@hotmail.com>
Date: Fri, 14 Dec 2018 16:53:27 +1300
Subject: [PATCH 1/4] Add video playback (libmpv)

---
 apps/freeablo/CMakeLists.txt           |   2 +-
 apps/freeablo/engine/enginemain.cpp    |  21 +++
 apps/freeablo/engine/enginemain.h      |   1 +
 apps/freeablo/engine/threadmanager.cpp |  65 ++++++++
 apps/freeablo/engine/threadmanager.h   |  14 ++
 cmake/FindMPV.cmake                    |  25 ++++
 components/CMakeLists.txt              |  24 +++
 components/video/mpv_sdl_backend.cpp   | 196 +++++++++++++++++++++++++
 components/video/stubbackend.cpp       |  22 +++
 components/video/video.h               |  21 +++
 components/video/videotest.cpp         |  64 ++++++++
 11 files changed, 454 insertions(+), 1 deletion(-)
 create mode 100644 cmake/FindMPV.cmake
 create mode 100644 components/video/mpv_sdl_backend.cpp
 create mode 100644 components/video/stubbackend.cpp
 create mode 100644 components/video/video.h
 create mode 100644 components/video/videotest.cpp

diff --git a/apps/freeablo/CMakeLists.txt b/apps/freeablo/CMakeLists.txt
index de36797ae..128cfdf62 100644
--- a/apps/freeablo/CMakeLists.txt
+++ b/apps/freeablo/CMakeLists.txt
@@ -133,7 +133,7 @@ add_library(freeablo_lib # split into a library so I can link to it from tests
     fasavegame/gameloader.cpp
 )
 
-target_link_libraries(freeablo_lib PUBLIC NuklearMisc Render Audio Serial Input Random enet::enet)
+target_link_libraries(freeablo_lib PUBLIC NuklearMisc Render Audio Video Serial Input Random enet::enet)
 
 add_executable(freeablo main.cpp)
 target_link_libraries(freeablo freeablo_lib)
diff --git a/apps/freeablo/engine/enginemain.cpp b/apps/freeablo/engine/enginemain.cpp
index 534d38cd3..b014c6c7b 100644
--- a/apps/freeablo/engine/enginemain.cpp
+++ b/apps/freeablo/engine/enginemain.cpp
@@ -64,6 +64,15 @@ namespace Engine
         mainThread.join();
     }
 
+    void EngineMain::playVideo(const std::string& path)
+    {
+        Engine::ThreadManager::get()->playVideo(std::string(path));
+        while (!Engine::ThreadManager::get()->waitForVideoComplete(100))
+        {
+            mInputManager->update(false);
+        }
+    }
+
     void EngineMain::runGameLoop(const bpo::variables_map& variables, const std::string& pathEXE)
     {
         FARender::Renderer& renderer = *FARender::Renderer::get();
@@ -81,6 +90,10 @@ namespace Engine
             return;
         }
 
+        // Play the intro cinematics.
+        playVideo("gendata/logo.smk");
+        playVideo("gendata/diablo1.smk");
+
         FAWorld::ItemFactory itemFactory(*mExe, Random::DummyRng::instance);
         mPlayerFactory = boost::make_unique<FAWorld::PlayerFactory>(*mExe, itemFactory);
         renderer.loadFonts(*mExe);
@@ -243,6 +256,14 @@ namespace Engine
 
     void EngineMain::notify(KeyboardInputAction action)
     {
+        // Only handle the esc key when playing video.
+        if (Engine::ThreadManager::get()->videoInProgress())
+        {
+            if (action == KeyboardInputAction::pause)
+                Engine::ThreadManager::get()->stopVideo();
+            return;
+        }
+
         if (mGuiManager->isPauseBlocked())
             return;
 
diff --git a/apps/freeablo/engine/enginemain.h b/apps/freeablo/engine/enginemain.h
index ff0d4cc65..2b4a9366f 100644
--- a/apps/freeablo/engine/enginemain.h
+++ b/apps/freeablo/engine/enginemain.h
@@ -48,6 +48,7 @@ namespace Engine
 
     private:
         void runGameLoop(const boost::program_options::variables_map& variables, const std::string& pathEXE);
+        void playVideo(const std::string& path);
 
     private:
         static EngineMain* singletonInstance;
diff --git a/apps/freeablo/engine/threadmanager.cpp b/apps/freeablo/engine/threadmanager.cpp
index 4280ac887..9286f3d99 100644
--- a/apps/freeablo/engine/threadmanager.cpp
+++ b/apps/freeablo/engine/threadmanager.cpp
@@ -4,6 +4,7 @@
 #include <iostream>
 
 #include <input/inputmanager.h>
+#include <video/video.h>
 
 #include "../farender/renderer.h"
 
@@ -19,6 +20,7 @@ namespace Engine
         const int MAXIMUM_DURATION_IN_MS = 1000;
         Input::InputManager* inputManager = Input::InputManager::get();
         FARender::Renderer* renderer = FARender::Renderer::get();
+        Video::init();
 
         Message message;
 
@@ -27,6 +29,19 @@ namespace Engine
 
         while (true)
         {
+            if (mvideoQueue.pop(message))
+                handleMessage(message);
+
+            while (videoInProgress())
+            {
+                // Don't render frames, or even pop normal queue messages while video in progress.
+                // However still need to listen for input and messages to start/stop video.
+                Video::update();
+                inputManager->poll();
+                if (mvideoQueue.pop(message))
+                    handleMessage(message);
+            }
+
             mSpritesToPreload.clear();
 
             while (mQueue.pop(message))
@@ -52,6 +67,7 @@ namespace Engine
         }
 
         renderer->cleanup();
+        Video::quit();
     }
 
     void ThreadManager::playMusic(const std::string& path)
@@ -85,6 +101,36 @@ namespace Engine
         mQueue.push(message);
     }
 
+    void ThreadManager::playVideo(const std::string& path)
+    {
+        Message message;
+        message.type = ThreadState::PLAY_VIDEO;
+        message.data.videoPath = new std::string(path);
+        mVideoPending = true;
+
+        mvideoQueue.push(message);
+    }
+
+    void ThreadManager::stopVideo()
+    {
+        Message message;
+        message.type = ThreadState::STOP_VIDEO;
+        mvideoQueue.push(message);
+    }
+
+    bool ThreadManager::waitForVideoComplete(int ms)
+    {
+        auto tWait = std::chrono::milliseconds(ms);
+        std::unique_lock<std::mutex> lk(mVideoPendingMutex);
+        if (mVideoStartedCV.wait_for(lk, tWait, [this] { return !mVideoPending; }))
+        {
+            lk.unlock();
+            if (Video::waitForVideoComplete(ms))
+                return true;
+        }
+        return false;
+    }
+
     void ThreadManager::sendRenderState(FARender::RenderState* state)
     {
         Message message;
@@ -127,6 +173,25 @@ namespace Engine
                 break;
             }
 
+            case ThreadState::PLAY_VIDEO:
+            {
+                mAudioManager.stopSound();
+
+                Video::playVideo(*message.data.videoPath);
+                delete message.data.videoPath;
+
+                std::unique_lock<std::mutex> lk(mVideoPendingMutex);
+                mVideoPending = false;
+                mVideoStartedCV.notify_all();
+                break;
+            }
+
+            case ThreadState::STOP_VIDEO:
+            {
+                Video::stopVideo();
+                break;
+            }
+
             case ThreadState::RENDER_STATE:
             {
                 if (mRenderState && mRenderState != message.data.renderState)
diff --git a/apps/freeablo/engine/threadmanager.h b/apps/freeablo/engine/threadmanager.h
index 9dd74fbcc..c4d118a1d 100644
--- a/apps/freeablo/engine/threadmanager.h
+++ b/apps/freeablo/engine/threadmanager.h
@@ -6,6 +6,8 @@
 #include <boost/next_prior.hpp>
 
 #include <boost/lockfree/spsc_queue.hpp>
+#include <condition_variable>
+#include <mutex>
 #include <string>
 
 #include "../faaudio/audiomanager.h"
@@ -22,6 +24,8 @@ namespace Engine
         PLAY_MUSIC,
         PLAY_SOUND,
         STOP_SOUND,
+        PLAY_VIDEO,
+        STOP_VIDEO,
         RENDER_STATE,
         PRELOAD_SPRITES
     };
@@ -34,6 +38,7 @@ namespace Engine
         {
             std::string* musicPath;
             std::string* soundPath;
+            std::string* videoPath;
             FARender::RenderState* renderState;
             std::vector<uint32_t>* preloadSpriteIds;
         } data;
@@ -48,17 +53,26 @@ namespace Engine
         void playMusic(const std::string& path);
         void playSound(const std::string& path);
         void stopSound();
+        void playVideo(const std::string& path);
+        void stopVideo();
         void sendRenderState(FARender::RenderState* state);
         void sendSpritesForPreload(std::vector<uint32_t> sprites);
+        bool waitForVideoComplete(int ms);
+        bool videoInProgress() { return !waitForVideoComplete(0); }
 
     private:
         void handleMessage(const Message& message);
 
         static ThreadManager* mThreadManager; ///< Singleton instance
         boost::lockfree::spsc_queue<Message, boost::lockfree::capacity<100>> mQueue;
+        boost::lockfree::spsc_queue<Message, boost::lockfree::capacity<10>> mvideoQueue;
         FARender::RenderState* mRenderState;
         FAAudio::AudioManager mAudioManager;
 
         std::vector<uint32_t> mSpritesToPreload;
+
+        std::mutex mVideoPendingMutex;
+        bool mVideoPending = false;
+        std::condition_variable mVideoStartedCV;
     };
 }
diff --git a/cmake/FindMPV.cmake b/cmake/FindMPV.cmake
new file mode 100644
index 000000000..4d98e318b
--- /dev/null
+++ b/cmake/FindMPV.cmake
@@ -0,0 +1,25 @@
+# - Try to find libmpv
+# Once done this will define
+#  MPV_FOUND - System has LibMPV
+#  MPV_VERSION - LibMPV version
+#  MPV_INCLUDE_DIRS - The LibMPV include directories
+#  MPV_LIBRARIES - The libraries needed to use LibMPV
+#  MPV_DEFINITIONS - Compiler switches required for using LibMPV
+
+find_package(PkgConfig)
+pkg_check_modules(PC_MPV QUIET mpv)
+set(MPV_DEFINITIONS ${PC_MPV_CFLAGS_OTHER})
+set(MPV_VERSION ${PC_MPV_VERSION})
+
+find_path(MPV_INCLUDE_DIR mpv/client.h HINTS ${PC_MPV_INCLUDEDIR} ${PC_MPV_INCLUDE_DIRS} PATH_SUFFIXES mpv)
+
+find_library(MPV_LIBRARY NAMES mpv libmpv HINTS ${PC_MPV_LIBDIR} ${PC_MPV_LIBRARY_DIRS})
+
+set(MPV_LIBRARIES ${MPV_LIBRARY})
+set(MPV_INCLUDE_DIRS ${MPV_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set MPV_FOUND to TRUE if all listed variables are TRUE
+find_package_handle_standard_args(MPV DEFAULT_MSG MPV_LIBRARY MPV_INCLUDE_DIR)
+
+mark_as_advanced(MPV_INCLUDE_DIR MPV_LIBRARY)
diff --git a/components/CMakeLists.txt b/components/CMakeLists.txt
index 69a6cd5c5..77d598847 100644
--- a/components/CMakeLists.txt
+++ b/components/CMakeLists.txt
@@ -110,6 +110,30 @@ add_library(Audio
 target_link_libraries(Audio FAIO SDL_mixer::SDL_mixer)
 set_target_properties(Audio PROPERTIES COMPILE_FLAGS "${FA_COMPILER_FLAGS}")
 
+include(FindMPV)
+IF (MPV_FOUND)
+    add_library(Video
+        video/video.h
+        video/mpv_sdl_backend.cpp
+    )
+    target_link_libraries(Video FAIO "${MPV_LIBRARIES}" SDL2::SDL2)
+    target_include_directories(Video PRIVATE "${MPV_INCLUDE_DIRS}")
+    set_target_properties(Video PROPERTIES COMPILE_FLAGS "${FA_COMPILER_FLAGS} ${MPV_DEFINITIONS}")    
+ELSE (MPV_FOUND)
+    message("MPV not found, using stub implemenation, video disabled")
+    add_library(Video
+        video/video.h
+        video/stubbackend.cpp
+    )
+    set_target_properties(Video PROPERTIES COMPILE_FLAGS "${FA_COMPILER_FLAGS}")
+ENDIF (MPV_FOUND)
+
+add_executable(VideoTest
+    video/videotest.cpp
+)
+target_link_libraries(VideoTest Video SDL2::SDL2)
+set_target_properties(VideoTest PROPERTIES COMPILE_FLAGS "${FA_COMPILER_FLAGS}")
+
 add_library(Settings
     settings/settings.h
     settings/settings.cpp
diff --git a/components/video/mpv_sdl_backend.cpp b/components/video/mpv_sdl_backend.cpp
new file mode 100644
index 000000000..8347a4da0
--- /dev/null
+++ b/components/video/mpv_sdl_backend.cpp
@@ -0,0 +1,196 @@
+// Adapted from:
+//  https://github.com/mpv-player/mpv-examples/blob/master/libmpv/sdl/main.c
+//  https://github.com/mpv-player/mpv-examples/blob/master/libmpv/streamcb/simple-streamcb.c
+#include "video.h"
+
+#include <condition_variable>
+#include <faio/fafileobject.h>
+#include <iostream>
+#include <mpv/client.h>
+#include <mpv/render_gl.h>
+#include <mpv/stream_cb.h>
+#include <mutex>
+#include <SDL.h>
+
+namespace Video
+{
+    static mpv_handle *mpv;
+    static mpv_render_context *mpv_gl;
+    static bool redraw;
+    static std::mutex cvMutex;
+    static bool videoPlaying;
+    static std::condition_variable videoCompleteCV;
+
+    static void check_error(int status);
+    static void *get_proc_address_mpv(void *fn_ctx, const char *name);
+    static void on_mpv_redraw(void *ctx);
+    static int media_open_fn(void *user_data, char *uri, mpv_stream_cb_info *info);
+    static int64_t media_read_fn(void *cookie, char *buf, uint64_t nbytes);
+    static int64_t media_seek_fn(void *cookie, int64_t offset);
+    static void media_close_fn(void *cookie);
+
+    void init()
+    {
+        // NOTE: This module does not handle initialising SDL.
+        // SDL_Init, SDL_CreateWindow and SDL_GL_CreateContext should have already been called.
+
+        mpv = mpv_create();
+        if (!mpv)
+            std::cerr << "Failed creating MPV context" << std::endl;
+        check_error(mpv_initialize(mpv));
+
+        mpv_opengl_init_params mpvOpenglInitParams = {};
+        mpvOpenglInitParams.get_proc_address = get_proc_address_mpv;
+        mpv_render_param params[] = {
+                {MPV_RENDER_PARAM_API_TYPE, (void *)MPV_RENDER_API_TYPE_OPENGL},
+                {MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, &mpvOpenglInitParams},
+                {MPV_RENDER_PARAM_INVALID, NULL} // Terminate parameters.
+            };
+
+        // This makes mpv use the currently set GL context. It will use the callback
+        // (passed via params) to resolve GL builtin functions, as well as extensions.
+        if (mpv_render_context_create(&mpv_gl, mpv, params) < 0)
+            std::cerr << "failed to initialize mpv GL context" << std::endl;
+
+        // When a new frame should be drawn with mpv_opengl_cb_draw().
+        // (Separate from the normal event handling mechanism for the sake of
+        //  users which run OpenGL on a different thread.)
+        mpv_render_context_set_update_callback(mpv_gl, on_mpv_redraw, NULL);
+
+        check_error(mpv_stream_cb_add_ro(mpv, "fafile", NULL, media_open_fn));
+    }
+
+    void quit()
+    {
+        mpv_render_context_free(mpv_gl);
+        mpv_terminate_destroy(mpv);
+    }
+
+    void update()
+    {
+        // If this is ever jittery we could make a redraw condition_variable
+        // and wait on it for longer than a frame.
+        if (videoPlaying && redraw)
+        {
+            int w, h;
+            SDL_Window* window = SDL_GL_GetCurrentWindow();
+            SDL_GetWindowSize(window, &w, &h);
+            // 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_opengl_fbo openGlFbo = {};
+            openGlFbo.fbo = 0;
+            openGlFbo.w = w;
+            openGlFbo.h = h;
+            openGlFbo.internal_format = 0;
+            // Flip rendering (needed due to flipped GL coordinate system).
+            int flipY = 1;
+            mpv_render_param params[] = {
+                {MPV_RENDER_PARAM_OPENGL_FBO, &openGlFbo},
+                {MPV_RENDER_PARAM_FLIP_Y, &flipY},
+                {MPV_RENDER_PARAM_INVALID, NULL} // Terminate parameters.
+            };
+            // See render_gl.h on what OpenGL environment mpv expects, and
+            // other API details.
+            mpv_render_context_render(mpv_gl, params);
+            SDL_GL_SwapWindow(window);
+        }
+
+        // Handle mpv events.
+        while (1)
+        {
+            mpv_event *mp_event = mpv_wait_event(mpv, 0);
+            if (mp_event->event_id == MPV_EVENT_NONE)
+                break;
+            if (mp_event->event_id == MPV_EVENT_END_FILE)
+            {
+                // Video playback complete.
+                SDL_ShowCursor(SDL_ENABLE);
+                std::unique_lock<std::mutex> lk(cvMutex);
+                videoPlaying = false;
+                videoCompleteCV.notify_all();
+            }
+        }
+    }
+
+    void playVideo(const std::string& path)
+    {
+        std::cout << "Playing video: " << path << std::endl;
+
+        SDL_ShowCursor(SDL_DISABLE);
+
+        std::string pathWithUri = std::string("fafile://") + path;
+
+        const char *cmd[] = {"loadfile", pathWithUri.c_str(), NULL};
+        check_error(mpv_command(mpv, cmd));
+
+        videoPlaying = true;
+
+        update();
+    }
+
+    void stopVideo() {
+        const char *cmd[] = {"stop", NULL};
+        check_error(mpv_command(mpv, cmd));
+    }
+
+    bool waitForVideoComplete(int ms)
+    {
+        auto tWait = std::chrono::milliseconds(ms);
+        std::unique_lock<std::mutex> lk(cvMutex);
+        if (videoCompleteCV.wait_for(lk, tWait, [] { return !videoPlaying; }))
+            return true;
+        return false;
+    }
+
+    static void check_error(int status)
+    {
+        if (status < 0)
+            std::cerr << "MPV API error: " << mpv_error_string(status) << std::endl;
+    }
+
+    static void *get_proc_address_mpv(void *fn_ctx, const char *name)
+    {
+        (void)fn_ctx;
+        return SDL_GL_GetProcAddress(name);
+    }
+
+    static void on_mpv_redraw(void *ctx)
+    {
+        // Do the rendering in the main loop for thread safety.
+        (void)ctx;
+        redraw = true;
+    }
+
+    static int media_open_fn(void *user_data, char *uri, mpv_stream_cb_info *info)
+    {
+        (void)user_data;
+        std::string prefix = "fafile://";
+        std::string path = std::string(&uri[prefix.length()]);
+        FAIO::FAFileObject* fp = new FAIO::FAFileObject(path);
+        info->cookie = fp;
+        info->read_fn = media_read_fn;
+        info->seek_fn = media_seek_fn;
+        info->close_fn = media_close_fn;
+        return fp ? 0 : MPV_ERROR_LOADING_FAILED;
+    }
+
+    static int64_t media_read_fn(void *cookie, char *buf, uint64_t nbytes)
+    {
+        FAIO::FAFileObject* fp = (FAIO::FAFileObject*)cookie;
+        return fp->FAfread(buf, 1, nbytes);
+    }
+
+    static int64_t media_seek_fn(void *cookie, int64_t offset)
+    {
+        FAIO::FAFileObject* fp = (FAIO::FAFileObject*)cookie;
+        return fp->FAfseek(offset, SEEK_SET);
+    }
+
+    static void media_close_fn(void *cookie)
+    {
+        FAIO::FAFileObject* fp = (FAIO::FAFileObject*)cookie;
+        delete fp;
+    }
+}
diff --git a/components/video/stubbackend.cpp b/components/video/stubbackend.cpp
new file mode 100644
index 000000000..b4363b6bd
--- /dev/null
+++ b/components/video/stubbackend.cpp
@@ -0,0 +1,22 @@
+#include "video.h"
+
+#include <iostream>
+
+namespace Video
+{
+    void init() { std::cout << "No video backend supplied, video disabled" << std::endl; }
+
+    void quit() {}
+
+    void update() {}
+
+    void playVideo(const std::string& path) { (void)path; }
+
+    bool waitForVideoComplete(int ms)
+    {
+        (void)ms;
+        return true;
+    }
+
+    void stopVideo() {}
+}
diff --git a/components/video/video.h b/components/video/video.h
new file mode 100644
index 000000000..361e32625
--- /dev/null
+++ b/components/video/video.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <stdint.h>
+#include <string>
+
+namespace Video
+{
+    void init();
+    void quit();
+
+    // No event system, so update() must be called periodically.
+    // Frames may be rendered here so call quickly while video is playing.
+    void update();
+
+    void playVideo(const std::string& path);
+    void stopVideo();
+
+    bool waitForVideoComplete(int ms); // Thread safe.
+
+    inline bool isVideoPlaying() { return !waitForVideoComplete(0); }
+}
diff --git a/components/video/videotest.cpp b/components/video/videotest.cpp
new file mode 100644
index 000000000..fe707004d
--- /dev/null
+++ b/components/video/videotest.cpp
@@ -0,0 +1,64 @@
+#include "video.h"
+#include <SDL.h>
+#include <iostream>
+
+int main(int argc, char* argv[])
+{
+    if (argc != 2)
+    {
+        std::cerr << "Usage: " << argv[0] << " <filename>" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
+    {
+        return EXIT_FAILURE;
+    }
+
+     SDL_Window *window = SDL_CreateWindow(
+            "VideoTest",
+            SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+            1280, 960,
+            SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN /*|SDL_WINDOW_FULLSCREEN*/);
+    if (!window) {
+        return EXIT_FAILURE;
+    }
+    SDL_GLContext glContext = SDL_GL_CreateContext(window);
+
+    Video::init();
+
+    Video::playVideo(argv[1]);
+
+    while (Video::isVideoPlaying())
+    {
+        SDL_Event event;
+        if (SDL_PollEvent(&event))
+        {
+            switch (event.type)
+            {
+                case SDL_QUIT:
+                    Video::stopVideo();
+                    break;
+                case SDL_KEYDOWN:
+                    switch (event.key.keysym.sym)
+                    {
+                        case SDLK_ESCAPE:
+                        case SDLK_q:
+                            Video::stopVideo();
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        }
+        Video::update();
+    }
+
+    Video::quit();
+    SDL_GL_DeleteContext(glContext);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return EXIT_SUCCESS;
+}

From f31c342625e5aafbc6a91e63ccb0bdb3b49dd02d Mon Sep 17 00:00:00 2001
From: Unknown <grant.ramsay@hotmail.com>
Date: Fri, 14 Dec 2018 17:36:20 +1300
Subject: [PATCH 2/4] Auto-format

---
 components/video/mpv_sdl_backend.cpp | 51 ++++++++++++++--------------
 components/video/videotest.cpp       | 10 +++---
 2 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/components/video/mpv_sdl_backend.cpp b/components/video/mpv_sdl_backend.cpp
index 8347a4da0..38f32d443 100644
--- a/components/video/mpv_sdl_backend.cpp
+++ b/components/video/mpv_sdl_backend.cpp
@@ -3,6 +3,7 @@
 //  https://github.com/mpv-player/mpv-examples/blob/master/libmpv/streamcb/simple-streamcb.c
 #include "video.h"
 
+#include <SDL.h>
 #include <condition_variable>
 #include <faio/fafileobject.h>
 #include <iostream>
@@ -10,24 +11,23 @@
 #include <mpv/render_gl.h>
 #include <mpv/stream_cb.h>
 #include <mutex>
-#include <SDL.h>
 
 namespace Video
 {
-    static mpv_handle *mpv;
-    static mpv_render_context *mpv_gl;
+    static mpv_handle* mpv;
+    static mpv_render_context* mpv_gl;
     static bool redraw;
     static std::mutex cvMutex;
     static bool videoPlaying;
     static std::condition_variable videoCompleteCV;
 
     static void check_error(int status);
-    static void *get_proc_address_mpv(void *fn_ctx, const char *name);
-    static void on_mpv_redraw(void *ctx);
-    static int media_open_fn(void *user_data, char *uri, mpv_stream_cb_info *info);
-    static int64_t media_read_fn(void *cookie, char *buf, uint64_t nbytes);
-    static int64_t media_seek_fn(void *cookie, int64_t offset);
-    static void media_close_fn(void *cookie);
+    static void* get_proc_address_mpv(void* fn_ctx, const char* name);
+    static void on_mpv_redraw(void* ctx);
+    static int media_open_fn(void* user_data, char* uri, mpv_stream_cb_info* info);
+    static int64_t media_read_fn(void* cookie, char* buf, uint64_t nbytes);
+    static int64_t media_seek_fn(void* cookie, int64_t offset);
+    static void media_close_fn(void* cookie);
 
     void init()
     {
@@ -42,10 +42,10 @@ namespace Video
         mpv_opengl_init_params mpvOpenglInitParams = {};
         mpvOpenglInitParams.get_proc_address = get_proc_address_mpv;
         mpv_render_param params[] = {
-                {MPV_RENDER_PARAM_API_TYPE, (void *)MPV_RENDER_API_TYPE_OPENGL},
-                {MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, &mpvOpenglInitParams},
-                {MPV_RENDER_PARAM_INVALID, NULL} // Terminate parameters.
-            };
+            {MPV_RENDER_PARAM_API_TYPE, (void*)MPV_RENDER_API_TYPE_OPENGL},
+            {MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, &mpvOpenglInitParams},
+            {MPV_RENDER_PARAM_INVALID, NULL} // Terminate parameters.
+        };
 
         // This makes mpv use the currently set GL context. It will use the callback
         // (passed via params) to resolve GL builtin functions, as well as extensions.
@@ -87,9 +87,7 @@ namespace Video
             // Flip rendering (needed due to flipped GL coordinate system).
             int flipY = 1;
             mpv_render_param params[] = {
-                {MPV_RENDER_PARAM_OPENGL_FBO, &openGlFbo},
-                {MPV_RENDER_PARAM_FLIP_Y, &flipY},
-                {MPV_RENDER_PARAM_INVALID, NULL} // Terminate parameters.
+                {MPV_RENDER_PARAM_OPENGL_FBO, &openGlFbo}, {MPV_RENDER_PARAM_FLIP_Y, &flipY}, {MPV_RENDER_PARAM_INVALID, NULL} // Terminate parameters.
             };
             // See render_gl.h on what OpenGL environment mpv expects, and
             // other API details.
@@ -100,7 +98,7 @@ namespace Video
         // Handle mpv events.
         while (1)
         {
-            mpv_event *mp_event = mpv_wait_event(mpv, 0);
+            mpv_event* mp_event = mpv_wait_event(mpv, 0);
             if (mp_event->event_id == MPV_EVENT_NONE)
                 break;
             if (mp_event->event_id == MPV_EVENT_END_FILE)
@@ -122,7 +120,7 @@ namespace Video
 
         std::string pathWithUri = std::string("fafile://") + path;
 
-        const char *cmd[] = {"loadfile", pathWithUri.c_str(), NULL};
+        const char* cmd[] = {"loadfile", pathWithUri.c_str(), NULL};
         check_error(mpv_command(mpv, cmd));
 
         videoPlaying = true;
@@ -130,8 +128,9 @@ namespace Video
         update();
     }
 
-    void stopVideo() {
-        const char *cmd[] = {"stop", NULL};
+    void stopVideo()
+    {
+        const char* cmd[] = {"stop", NULL};
         check_error(mpv_command(mpv, cmd));
     }
 
@@ -150,20 +149,20 @@ namespace Video
             std::cerr << "MPV API error: " << mpv_error_string(status) << std::endl;
     }
 
-    static void *get_proc_address_mpv(void *fn_ctx, const char *name)
+    static void* get_proc_address_mpv(void* fn_ctx, const char* name)
     {
         (void)fn_ctx;
         return SDL_GL_GetProcAddress(name);
     }
 
-    static void on_mpv_redraw(void *ctx)
+    static void on_mpv_redraw(void* ctx)
     {
         // Do the rendering in the main loop for thread safety.
         (void)ctx;
         redraw = true;
     }
 
-    static int media_open_fn(void *user_data, char *uri, mpv_stream_cb_info *info)
+    static int media_open_fn(void* user_data, char* uri, mpv_stream_cb_info* info)
     {
         (void)user_data;
         std::string prefix = "fafile://";
@@ -176,19 +175,19 @@ namespace Video
         return fp ? 0 : MPV_ERROR_LOADING_FAILED;
     }
 
-    static int64_t media_read_fn(void *cookie, char *buf, uint64_t nbytes)
+    static int64_t media_read_fn(void* cookie, char* buf, uint64_t nbytes)
     {
         FAIO::FAFileObject* fp = (FAIO::FAFileObject*)cookie;
         return fp->FAfread(buf, 1, nbytes);
     }
 
-    static int64_t media_seek_fn(void *cookie, int64_t offset)
+    static int64_t media_seek_fn(void* cookie, int64_t offset)
     {
         FAIO::FAFileObject* fp = (FAIO::FAFileObject*)cookie;
         return fp->FAfseek(offset, SEEK_SET);
     }
 
-    static void media_close_fn(void *cookie)
+    static void media_close_fn(void* cookie)
     {
         FAIO::FAFileObject* fp = (FAIO::FAFileObject*)cookie;
         delete fp;
diff --git a/components/video/videotest.cpp b/components/video/videotest.cpp
index fe707004d..7af393e21 100644
--- a/components/video/videotest.cpp
+++ b/components/video/videotest.cpp
@@ -15,12 +15,10 @@ int main(int argc, char* argv[])
         return EXIT_FAILURE;
     }
 
-     SDL_Window *window = SDL_CreateWindow(
-            "VideoTest",
-            SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-            1280, 960,
-            SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN /*|SDL_WINDOW_FULLSCREEN*/);
-    if (!window) {
+    SDL_Window* window = SDL_CreateWindow(
+        "VideoTest", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1280, 960, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN /*|SDL_WINDOW_FULLSCREEN*/);
+    if (!window)
+    {
         return EXIT_FAILURE;
     }
     SDL_GLContext glContext = SDL_GL_CreateContext(window);

From ac5f33c822d3b9f93aa0055af51f461833205e77 Mon Sep 17 00:00:00 2001
From: grantramsay <grant.ramsay@hotmail.com>
Date: Mon, 7 Jan 2019 20:30:54 -0800
Subject: [PATCH 3/4] Fix MSVC build

Stop SDL from messing with MSVC main()
---
 components/video/videotest.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/components/video/videotest.cpp b/components/video/videotest.cpp
index 7af393e21..477eb478d 100644
--- a/components/video/videotest.cpp
+++ b/components/video/videotest.cpp
@@ -1,4 +1,7 @@
 #include "video.h"
+// Stop SDL from messing with MSVC main()
+// https://wiki.libsdl.org/SDL_SetMainReady
+#define SDL_MAIN_HANDLED
 #include <SDL.h>
 #include <iostream>
 

From 2105caf6ed6eef516753565ed1173c4a9cc7e899 Mon Sep 17 00:00:00 2001
From: grantramsay <grant.ramsay@hotmail.com>
Date: Mon, 7 Jan 2019 20:42:54 -0800
Subject: [PATCH 4/4] Download and link prebuilt mpv MSYS2 libraries for MSVC
 build

---
 CMakeLists.txt            |  3 +++
 components/CMakeLists.txt | 54 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0a725d151..a4f6c74c6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -131,6 +131,9 @@ endif()
 add_subdirectory (extern)
 add_subdirectory (components)
 
+ # This is currently only for the MSVC libmpv, might be a better place to put library or to link/find it
+link_directories(${CMAKE_CURRENT_BINARY_DIR}/components)
+
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
 add_subdirectory(apps/freeablo)
diff --git a/components/CMakeLists.txt b/components/CMakeLists.txt
index 77d598847..89ecd5a12 100644
--- a/components/CMakeLists.txt
+++ b/components/CMakeLists.txt
@@ -110,12 +110,66 @@ add_library(Audio
 target_link_libraries(Audio FAIO SDL_mixer::SDL_mixer)
 set_target_properties(Audio PROPERTIES COMPILE_FLAGS "${FA_COMPILER_FLAGS}")
 
+if (MSVC)
+    # Download and prepare MSYS2 libmpv for MSVC conversion.
+	# https://github.com/mpv-player/mpv/blob/master/DOCS/compile-windows.md#linking-libmpv-with-msvc-programs
+	set(MPV_MSYS2_VERSION "mpv-dev-20181002")
+	set(MPV_MSYS2_URL "https://mpv.srsfckn.biz/${MPV_MSYS2_VERSION}.7z")
+	set(MPV_MSYS2_BASE_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MPV_MSYS2_VERSION}")
+	set(MPV_MSYS2_7Z_FILE "${MPV_MSYS2_BASE_DIR}.7z")
+	
+	if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+		# 64 bit
+		set(MPV_MSYS2_LIB_DIR "${MPV_MSYS2_BASE_DIR}/x86_64")
+		set(MSVC_LIB_MACHINE x64)
+	elseif (CMAKE_SIZEOF_VOID_P EQUAL 4)
+		# 32 bit
+		set(MPV_MSYS2_LIB_DIR "${MPV_MSYS2_BASE_DIR}/i686")
+		set(MSVC_LIB_MACHINE x86)
+	endif()
+
+	if (NOT EXISTS ${MPV_MSYS2_BASE_DIR})
+		message("Downloading MSYS2 mpv libraries ${MPV_MSYS2_URL}")
+		file(DOWNLOAD ${MPV_MSYS2_URL} ${MPV_MSYS2_7Z_FILE} SHOW_PROGRESS)
+		message("Extracting MSYS2 mpv libraries...")
+		file(MAKE_DIRECTORY ${MPV_MSYS2_BASE_DIR})
+		execute_process(
+			COMMAND ${CMAKE_COMMAND} -E tar xf ${MPV_MSYS2_7Z_FILE} --format=7zip
+			WORKING_DIRECTORY ${MPV_MSYS2_BASE_DIR}
+			RESULT_VARIABLE res)
+		if (res)
+			message(FATAL_ERROR "libmpv extraction failed: ${res}")
+		endif()
+
+		# Need to add "LIBRARY MPV-1\nEXPORTS\n" to the start of the def file
+		# https://github.com/mpv-player/mpv/issues/5007#issuecomment-337431977
+		file(READ ${MPV_MSYS2_LIB_DIR}/libmpv.def inital_libmpv_def_file)
+		file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/libmpv.def "LIBRARY MPV-1\nEXPORTS\n${inital_libmpv_def_file}" )
+
+		# Copy mpv-1.dll to build dir, this means exe's must be run from this location (otherwise could copy next to exe's or add to path).
+		file(COPY ${MPV_MSYS2_LIB_DIR}/mpv-1.dll DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/..)
+	endif()
+
+	set(MPV_FOUND TRUE)
+	set(MPV_LIBRARIES libmpv)
+	set(MPV_INCLUDE_DIRS "${MPV_MSYS2_BASE_DIR}/include")
+	set(MPV_DEFINITIONS "")
+else (MSVC)
 include(FindMPV)
+endif(MSVC)
+
 IF (MPV_FOUND)
     add_library(Video
         video/video.h
         video/mpv_sdl_backend.cpp
     )
+	if (MSVC)
+		# Convert MSYS2 lib to MSVC format, possibly could use built in cmake module GNUtoMS_lib.cmake instead.
+		add_custom_command(
+			TARGET Video
+			PRE_BUILD
+			COMMAND lib ARGS /def:${CMAKE_CURRENT_BINARY_DIR}/libmpv.def /name:mpv-1.dll /out:${CMAKE_CURRENT_BINARY_DIR}/libmpv.lib /machine:${MSVC_LIB_MACHINE})
+	endif(MSVC)
     target_link_libraries(Video FAIO "${MPV_LIBRARIES}" SDL2::SDL2)
     target_include_directories(Video PRIVATE "${MPV_INCLUDE_DIRS}")
     set_target_properties(Video PROPERTIES COMPILE_FLAGS "${FA_COMPILER_FLAGS} ${MPV_DEFINITIONS}")