diff --git a/CMakeLists.txt b/CMakeLists.txt
index def78e09b..8368a3990 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/apps/freeablo/CMakeLists.txt b/apps/freeablo/CMakeLists.txt
index 21f9d0af5..636930dfd 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)
 target_include_directories(freeablo_lib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 
 add_executable(freeablo main.cpp)
diff --git a/apps/freeablo/engine/enginemain.cpp b/apps/freeablo/engine/enginemain.cpp
index 2fadcea82..19096a483 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 b3f40fba2..df6e0e904 100644
--- a/components/CMakeLists.txt
+++ b/components/CMakeLists.txt
@@ -110,6 +110,84 @@ 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}")    
+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..38f32d443
--- /dev/null
+++ b/components/video/mpv_sdl_backend.cpp
@@ -0,0 +1,195 @@
+// 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 <SDL.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>
+
+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..477eb478d
--- /dev/null
+++ b/components/video/videotest.cpp
@@ -0,0 +1,65 @@
+#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>
+
+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;
+}