diff --git a/LuaSTG/CMakeLists.txt b/LuaSTG/CMakeLists.txt
index 9cf83316d..8e90c261f 100644
--- a/LuaSTG/CMakeLists.txt
+++ b/LuaSTG/CMakeLists.txt
@@ -144,6 +144,10 @@ set(LUASTG_ENGINE_SOURCES
     LuaSTG/LuaBinding/modern/SwapChain.cpp
     LuaSTG/LuaBinding/modern/Texture2D.hpp
     LuaSTG/LuaBinding/modern/Texture2D.cpp
+    LuaSTG/LuaBinding/modern/Video.hpp
+    LuaSTG/LuaBinding/modern/Video.cpp
+    LuaSTG/LuaBinding/VideoBindingHelpers.hpp
+    LuaSTG/LuaBinding/VideoBindingHelpers.cpp
     LuaSTG/LuaBinding/modern/RenderTarget.hpp
     LuaSTG/LuaBinding/modern/RenderTarget.cpp
     LuaSTG/LuaBinding/modern/DepthStencilBuffer.hpp
diff --git a/LuaSTG/LuaSTG/GameResource/Implement/ResourceTextureImpl.hpp b/LuaSTG/LuaSTG/GameResource/Implement/ResourceTextureImpl.hpp
index bc7c5357d..66ddc7864 100644
--- a/LuaSTG/LuaSTG/GameResource/Implement/ResourceTextureImpl.hpp
+++ b/LuaSTG/LuaSTG/GameResource/Implement/ResourceTextureImpl.hpp
@@ -21,6 +21,7 @@ namespace luastg
 		core::IRenderTarget* GetRenderTarget() { return m_rt.get(); }
 		core::IDepthStencilBuffer* GetDepthStencilBuffer() { return m_ds.get(); }
 		bool IsRenderTarget() { return m_is_rendertarget; }
+		bool IsVideoTexture() { return m_texture && m_texture->isVideoTexture(); }
 		bool HasDepthStencilBuffer() { return m_enable_depthbuffer; }
 	public:
 		// 纹理容器
@@ -47,6 +48,7 @@ namespace luastg
 		core::IRenderTarget* GetRenderTarget() override { return m_rt.get(); }
 		core::IDepthStencilBuffer* GetDepthStencilBuffer() override { return m_ds.get(); }
 		bool IsRenderTarget() override { return true; }
+		bool IsVideoTexture() override { return false; }
 		bool HasDepthStencilBuffer() override { return !!m_ds; }
 
 		// RenderTargetStackResourceTextureImpl
diff --git a/LuaSTG/LuaSTG/GameResource/ResourceDebug.cpp b/LuaSTG/LuaSTG/GameResource/ResourceDebug.cpp
index ecda732f2..0ab5cf8c0 100644
--- a/LuaSTG/LuaSTG/GameResource/ResourceDebug.cpp
+++ b/LuaSTG/LuaSTG/GameResource/ResourceDebug.cpp
@@ -81,18 +81,21 @@ namespace luastg
 			};
 			auto draw_texture = [](IResourceTexture* p_res, bool show_info, float scale) -> void
 			{
-				auto const size = p_res->GetTexture()->getSize();
+				auto* p_tex = p_res->GetTexture();
+				auto const size = p_tex->getSize();
 				if (show_info)
 				{
 					ImGui::Text("Size: %u x %u", size.x, size.y);
-					ImGui::Text("RenderTarget: %s", p_res->IsRenderTarget() ? "Yes" : "Not");
-					ImGui::Text("Dynamic: %s", p_res->IsRenderTarget() ? "Yes" : "Not");
-					unsigned long long mem_usage = size.x * size.y * 4;
+					char const* type_str = p_tex->isVideoTexture() ? "Video" : (p_res->IsRenderTarget() ? "RenderTarget" : "Texture");
+					ImGui::Text("Type: %s", type_str);
+					ImGui::Text("Dynamic: %s", p_tex->isDynamic() ? "Yes" : "Not");
+					unsigned long long display_mem = (unsigned long long)size.x * size.y * 4;
+					unsigned long long mem_usage = display_mem;
 					ImGui::Text("Adapter Memory Usage (Approximate): %s", bytes_count_to_string(mem_usage).c_str());
 				}
 				ImGui::PushStyleVar(ImGuiStyleVar_ImageBorderSize, 1.0);
 				ImGui::Image(
-					reinterpret_cast<size_t>(p_res->GetTexture()->getNativeView()),
+					reinterpret_cast<size_t>(p_tex->getNativeView()),
 					ImVec2(scale * (float)size.x, scale * (float)size.y),
 					ImVec2(0.0f, 0.0f),
 					ImVec2(1.0f, 1.0f));
diff --git a/LuaSTG/LuaSTG/GameResource/ResourceManager.h b/LuaSTG/LuaSTG/GameResource/ResourceManager.h
index 3f6de2e48..ca82b9762 100644
--- a/LuaSTG/LuaSTG/GameResource/ResourceManager.h
+++ b/LuaSTG/LuaSTG/GameResource/ResourceManager.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "core/SmartReference.hpp"
+#include "core/VideoDecoder.hpp"
 #include "GameResource/ResourceTexture.hpp"
 #include "GameResource/ResourceSprite.hpp"
 #include "GameResource/ResourceAnimation.hpp"
@@ -98,6 +99,8 @@ namespace luastg
         // 纹理
         bool LoadTexture(const char* name, const char* path, bool mipmaps = true) noexcept;
         bool CreateTexture(const char* name, int width, int height) noexcept;
+        // 视频纹理（options 为 nullptr 时使用默认选项）
+        bool LoadVideo(const char* name, const char* path, core::VideoOpenOptions const* options = nullptr) noexcept;
         // 渲染目标
         bool CreateRenderTarget(const char* name, int width = 0, int height = 0, bool depth_buffer = false) noexcept;
         // 图片精灵
diff --git a/LuaSTG/LuaSTG/GameResource/ResourcePool.cpp b/LuaSTG/LuaSTG/GameResource/ResourcePool.cpp
index 90ccb910e..24ef04411 100644
--- a/LuaSTG/LuaSTG/GameResource/ResourcePool.cpp
+++ b/LuaSTG/LuaSTG/GameResource/ResourcePool.cpp
@@ -9,6 +9,7 @@
 #include "GameResource/Implement/ResourcePostEffectShaderImpl.hpp"
 #include "GameResource/Implement/ResourceModelImpl.hpp"
 #include "core/FileSystem.hpp"
+#include "core/AudioEngine.hpp"
 #include "AppFrame.h"
 #include "lua/plus.hpp"
 
@@ -227,6 +228,47 @@ namespace luastg
         return true;
     }
 
+    bool ResourcePool::LoadVideo(const char* name, const char* path, core::VideoOpenOptions const* options) noexcept
+    {
+        if (m_TexturePool.find(std::string_view(name)) != m_TexturePool.end())
+        {
+            if (ResourceMgr::GetResourceLoadingLog())
+            {
+                spdlog::warn("[luastg] LoadVideo: 纹理 '{}' 已存在，加载操作已取消", name);
+            }
+            return true;
+        }
+    
+        core::SmartReference<core::ITexture2D> p_texture;
+        bool ok = options
+            ? LAPP.getGraphicsDevice()->createVideoTexture(path, *options, p_texture.put())
+            : LAPP.getGraphicsDevice()->createVideoTexture(path, p_texture.put());
+        if (!ok)
+        {
+            spdlog::error("[luastg] 从 '{}' 创建视频纹理 '{}' 失败", path, name);
+            return false;
+        }
+
+        try
+        {
+            core::SmartReference<IResourceTexture> tRes;
+            tRes.attach(new ResourceTextureImpl(name, p_texture.get()));
+            m_TexturePool.emplace(name, tRes);
+        }
+        catch (std::exception const& e)
+        {
+            spdlog::error("[luastg] LoadVideo: 创建视频纹理 '{}' 失败 ({})", name, e.what());
+            return false;
+        }
+    
+        if (ResourceMgr::GetResourceLoadingLog())
+        {
+            spdlog::info("[luastg] LoadVideo: 已从 '{}' 加载视频 '{}' ({})", path, name, getResourcePoolTypeName());
+        }
+    
+        return true;
+    }
+
     bool ResourcePool::CreateTexture(const char* name, int width, int height) noexcept
     {
         if (m_TexturePool.find(std::string_view(name)) != m_TexturePool.end())
diff --git a/LuaSTG/LuaSTG/GameResource/ResourceTexture.hpp b/LuaSTG/LuaSTG/GameResource/ResourceTexture.hpp
index b692ef27e..ac6c54690 100644
--- a/LuaSTG/LuaSTG/GameResource/ResourceTexture.hpp
+++ b/LuaSTG/LuaSTG/GameResource/ResourceTexture.hpp
@@ -12,6 +12,7 @@ namespace luastg
 		virtual core::IRenderTarget* GetRenderTarget() = 0;
 		virtual core::IDepthStencilBuffer* GetDepthStencilBuffer() = 0;
 		virtual bool IsRenderTarget() = 0;
+		virtual bool IsVideoTexture() = 0;
 		virtual bool HasDepthStencilBuffer() = 0;
 	};
 };
diff --git a/LuaSTG/LuaSTG/LuaBinding/LW_ResourceMgr.cpp b/LuaSTG/LuaSTG/LuaBinding/LW_ResourceMgr.cpp
index 8fbc43612..7647108f2 100644
--- a/LuaSTG/LuaSTG/LuaBinding/LW_ResourceMgr.cpp
+++ b/LuaSTG/LuaSTG/LuaBinding/LW_ResourceMgr.cpp
@@ -1,6 +1,9 @@
 #include "LuaBinding/LuaWrapper.hpp"
+#include "LuaBinding/VideoBindingHelpers.hpp"
 #include "lua/plus.hpp"
 #include "AppFrame.h"
+#include "d3d11/VideoTexture.hpp"
+#include "core/VideoDecoder.hpp"
 
 void luastg::binding::ResourceManager::Register(lua_State* L) noexcept
 {
@@ -52,6 +55,25 @@ void luastg::binding::ResourceManager::Register(lua_State* L) noexcept
 				return luaL_error(L, "can't load texture from file '%s'.", path);
 			return 0;
 		}
+		static int LoadVideo(lua_State* L) noexcept
+		{
+			lua::stack_t const ctx(L);
+			const char* name = luaL_checkstring(L, 1);
+			const char* path = luaL_checkstring(L, 2);
+
+			ResourcePool* pActivedPool = LRES.GetActivedPool();
+			if (!pActivedPool)
+				return luaL_error(L, "can't load resource at this time.");
+			
+			core::VideoOpenOptions opt;
+			bool const has_options = ctx.index_of_top() >= 3 && ctx.is_table(3);
+			if (has_options)
+				video::parseVideoOptions(L, 3, opt);
+			
+			if (!pActivedPool->LoadVideo(name, path, has_options ? &opt : nullptr))
+				return luaL_error(L, "can't load video from file '%s'.", path);
+			return 0;
+		}
 		static int LoadSprite(lua_State* L) noexcept
 		{
 			const char* name = luaL_checkstring(L, 1);
@@ -414,6 +436,14 @@ void luastg::binding::ResourceManager::Register(lua_State* L) noexcept
 			lua_pushboolean(L, p->IsRenderTarget());
 			return 1;
 		}
+		static int IsVideoTexture(lua_State* L) noexcept
+		{
+			core::SmartReference<IResourceTexture> p = LRES.FindTexture(luaL_checkstring(L, 1));
+			if (!p)
+				return luaL_error(L, "texture '%s' not found.", luaL_checkstring(L, 1));
+			lua_pushboolean(L, p->IsVideoTexture());
+			return 1;
+		}
 		static int SetTexturePreMulAlphaState(lua_State* L) noexcept
 		{
 			core::SmartReference<IResourceTexture> p = LRES.FindTexture(luaL_checkstring(L, 1));
@@ -696,6 +726,98 @@ void luastg::binding::ResourceManager::Register(lua_State* L) noexcept
 			LRES.CacheTTFFontString(luaL_checkstring(L, 1), str, len);
 			return 0;
 		}
+
+		// Video control functions
+
+		static int VideoSeek(lua_State* L) noexcept {
+			lua::stack_t const ctx(L);
+			const char* name = luaL_checkstring(L, 1);
+			double time = luaL_checknumber(L, 2);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found or is not a video texture.", name);
+			bool ok = decoder->seek(time);
+			ctx.push_value(ok);
+			return 1;
+		}
+
+		static int VideoSetLooping(lua_State* L) noexcept {
+			lua::stack_t const ctx(L);
+			const char* name = luaL_checkstring(L, 1);
+			bool loop = ctx.get_value<bool>(2);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found.", name);
+			decoder->setLooping(loop);
+			return 0;
+		}
+		
+		static int VideoSetLoopRange(lua_State* L) noexcept {
+			const char* name = luaL_checkstring(L, 1);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found.", name);
+			double loop_end = luaL_checknumber(L, 2);
+			double loop_duration = luaL_checknumber(L, 3);
+			decoder->setLoopRange(loop_end, loop_duration);
+			return 0;
+		}
+		
+		static int VideoUpdate(lua_State* L) noexcept {
+			lua::stack_t const ctx(L);
+			const char* name = luaL_checkstring(L, 1);
+			double time = luaL_checknumber(L, 2);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found or is not a video texture.", name);
+			bool ok = decoder->updateToTime(time);
+			ctx.push_value(ok);
+			return 1;
+		}
+		
+		static int VideoGetInfo(lua_State* L) noexcept {
+			const char* name = luaL_checkstring(L, 1);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found.", name);
+			video::pushVideoInfoToLua(L, decoder);
+			return 1;
+		}
+		
+		static int VideoGetVideoStreams(lua_State* L) noexcept {
+			const char* name = luaL_checkstring(L, 1);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found.", name);
+			video::pushVideoStreamsToLua(L, decoder);
+			return 1;
+		}
+		
+		static int VideoGetAudioStreams(lua_State* L) noexcept {
+			const char* name = luaL_checkstring(L, 1);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found.", name);
+			video::pushAudioStreamsToLua(L, decoder);
+			return 1;
+		}
+		
+		static int VideoReopen(lua_State* L) noexcept {
+			lua::stack_t const ctx(L);
+			const char* name = luaL_checkstring(L, 1);
+			auto decoder = video::getDecoderFromResourceName(name);
+			if (!decoder)
+				return luaL_error(L, "video texture '%s' not found or is not a video texture.", name);
+			core::VideoOpenOptions opt = decoder->getLastOpenOptions();
+			if (ctx.index_of_top() >= 2 && ctx.is_table(2))
+				video::parseVideoOptions(L, 2, opt);
+			if (!decoder->reopen(opt)) {
+				ctx.push_value(false);
+				return 1;
+			}
+			ctx.push_value(true);
+			return 1;
+		}
 	};
 
 	luaL_Reg const lib[] = {
@@ -703,6 +825,7 @@ void luastg::binding::ResourceManager::Register(lua_State* L) noexcept
 		{ "SetResourceStatus", &Wrapper::SetResourceStatus },
 		{ "GetResourceStatus", &Wrapper::GetResourceStatus },
 		{ "LoadTexture", &Wrapper::LoadTexture },
+		{ "LoadVideo", &Wrapper::LoadVideo },
 		{ "LoadImage", &Wrapper::LoadSprite },
 		{ "CopyImage", &Wrapper::CopySprite },
 		{ "LoadAnimation", &Wrapper::LoadAnimation },
@@ -716,6 +839,7 @@ void luastg::binding::ResourceManager::Register(lua_State* L) noexcept
 		{ "LoadModel", &Wrapper::LoadModel },
 		{ "CreateRenderTarget", &Wrapper::CreateRenderTarget },
 		{ "IsRenderTarget", &Wrapper::IsRenderTarget },
+		{ "IsVideoTexture", &Wrapper::IsVideoTexture },
 		{ "SetTexturePreMulAlphaState", &Wrapper::SetTexturePreMulAlphaState },
 		{ "SetTextureSamplerState", &Wrapper::SetTextureSamplerState },
 		{ "GetTextureSize", &Wrapper::GetTextureSize },
@@ -737,6 +861,17 @@ void luastg::binding::ResourceManager::Register(lua_State* L) noexcept
 		{ "SetFontState", &Wrapper::SetFontState },
 
 		{ "CacheTTFString", &Wrapper::CacheTTFString },
+
+		// Video control functions
+		{ "VideoSeek", &Wrapper::VideoSeek },
+		{ "VideoSetLooping", &Wrapper::VideoSetLooping },
+		{ "VideoSetLoopRange", &Wrapper::VideoSetLoopRange },
+		{ "VideoUpdate", &Wrapper::VideoUpdate },
+		{ "VideoGetInfo", &Wrapper::VideoGetInfo },
+		{ "VideoGetVideoStreams", &Wrapper::VideoGetVideoStreams },
+		{ "VideoGetAudioStreams", &Wrapper::VideoGetAudioStreams },
+		{ "VideoReopen", &Wrapper::VideoReopen },
+
 		{ NULL, NULL },
 	};
 
diff --git a/LuaSTG/LuaSTG/LuaBinding/LuaWrapper.cpp b/LuaSTG/LuaSTG/LuaBinding/LuaWrapper.cpp
index 67c0e4b52..b668ca65f 100644
--- a/LuaSTG/LuaSTG/LuaBinding/LuaWrapper.cpp
+++ b/LuaSTG/LuaSTG/LuaBinding/LuaWrapper.cpp
@@ -7,6 +7,7 @@
 #include "LuaBinding/modern/Window.hpp"
 #include "LuaBinding/modern/SwapChain.hpp"
 #include "LuaBinding/modern/Texture2D.hpp"
+#include "LuaBinding/modern/Video.hpp"
 #include "LuaBinding/modern/RenderTarget.hpp"
 #include "LuaBinding/modern/DepthStencilBuffer.hpp"
 #include "LuaBinding/modern/Mesh.hpp"
@@ -82,6 +83,7 @@ namespace luastg::binding
 		Window_Windows11Extension::registerClass(L);
 		SwapChain::registerClass(L);
 		Texture2D::registerClass(L);
+		Video::registerClass(L);
 		RenderTarget::registerClass(L);
 		DepthStencilBuffer::registerClass(L);
 		Mesh::registerClass(L);
diff --git a/LuaSTG/LuaSTG/LuaBinding/VideoBindingHelpers.cpp b/LuaSTG/LuaSTG/LuaBinding/VideoBindingHelpers.cpp
new file mode 100644
index 000000000..904bae9a6
--- /dev/null
+++ b/LuaSTG/LuaSTG/LuaBinding/VideoBindingHelpers.cpp
@@ -0,0 +1,18 @@
+#include "VideoBindingHelpers.hpp"
+#include "AppFrame.h"
+
+namespace luastg::binding::video {
+    core::IVideoDecoder* getDecoderFromResourceName(const char* name) noexcept {
+        auto texture = LRES.FindTexture(name);
+        if (!texture) {
+            return nullptr;
+        }
+        
+        auto texture2d = texture->GetTexture();
+        if (!texture2d) {
+            return nullptr;
+        }
+        
+        return getDecoderFromTexture(texture2d);
+    }
+}
diff --git a/LuaSTG/LuaSTG/LuaBinding/VideoBindingHelpers.hpp b/LuaSTG/LuaSTG/LuaBinding/VideoBindingHelpers.hpp
new file mode 100644
index 000000000..7fb9d95a2
--- /dev/null
+++ b/LuaSTG/LuaSTG/LuaBinding/VideoBindingHelpers.hpp
@@ -0,0 +1,123 @@
+#pragma once
+#include "core/VideoDecoder.hpp"
+#include "core/Texture2D.hpp"
+#include "lua/plus.hpp"
+#include <vector>
+
+namespace luastg::binding::video {
+    // Parse VideoOpenOptions from Lua table
+    inline void parseVideoOptions(lua_State* L, int index, core::VideoOpenOptions& opt) noexcept {
+        lua::stack_t stack(L);
+        lua::stack_index_t table_idx(index);
+        
+        if (!stack.is_table(table_idx)) {
+            return;
+        }
+        
+        opt.video_stream_index = stack.get_map_value<uint32_t>(table_idx, "video_stream", opt.video_stream_index);
+        opt.output_width = stack.get_map_value<uint32_t>(table_idx, "width", opt.output_width);
+        opt.output_height = stack.get_map_value<uint32_t>(table_idx, "height", opt.output_height);
+        opt.premultiplied_alpha = stack.get_map_value<bool>(table_idx, "premultiplied_alpha", opt.premultiplied_alpha);
+        opt.looping = stack.get_map_value<bool>(table_idx, "looping", opt.looping);
+        opt.loop_end = stack.get_map_value<double>(table_idx, "loop_end", opt.loop_end);
+        opt.loop_duration = stack.get_map_value<double>(table_idx, "loop_duration", opt.loop_duration);
+    }
+
+    // Get video decoder from texture object
+    inline core::IVideoDecoder* getDecoderFromTexture(core::ITexture2D* texture) noexcept {
+        if (!texture || !texture->isVideoTexture()) {
+            return nullptr;
+        }
+        return texture->getVideoDecoder();
+    }
+
+    // Get video decoder from resource name (via resource manager)
+    core::IVideoDecoder* getDecoderFromResourceName(const char* name) noexcept;
+
+    // Push video stream info array to Lua stack
+    inline void pushVideoStreamsToLua(lua_State* L, core::IVideoDecoder* decoder) {
+        lua::stack_t stack(L);
+        
+        if (!decoder) {
+            stack.create_array(0);
+            return;
+        }
+
+        std::vector<core::VideoStreamInfo> list;
+        auto callback = [](core::VideoStreamInfo const& info, void* userdata) {
+            static_cast<std::vector<core::VideoStreamInfo>*>(userdata)->push_back(info);
+        };
+        decoder->getVideoStreams(callback, &list);
+
+        auto array_idx = stack.create_array(list.size());
+        for (size_t i = 0; i < list.size(); ++i) {
+            auto item_idx = stack.create_map(5);
+            stack.set_map_value(item_idx, "index", list[i].index);
+            stack.set_map_value(item_idx, "width", list[i].width);
+            stack.set_map_value(item_idx, "height", list[i].height);
+            stack.set_map_value(item_idx, "fps", list[i].fps);
+            stack.set_map_value(item_idx, "duration", list[i].duration_seconds);
+            stack.set_array_value(array_idx, i + 1, item_idx);
+        }
+    }
+
+    // Push audio stream info array to Lua stack
+    inline void pushAudioStreamsToLua(lua_State* L, core::IVideoDecoder* decoder) {
+        lua::stack_t stack(L);
+        
+        if (!decoder) {
+            stack.create_array(0);
+            return;
+        }
+
+        std::vector<core::AudioStreamInfo> list;
+        auto callback = [](core::AudioStreamInfo const& info, void* userdata) {
+            static_cast<std::vector<core::AudioStreamInfo>*>(userdata)->push_back(info);
+        };
+        decoder->getAudioStreams(callback, &list);
+
+        auto array_idx = stack.create_array(list.size());
+        for (size_t i = 0; i < list.size(); ++i) {
+            auto item_idx = stack.create_map(4);
+            stack.set_map_value(item_idx, "index", list[i].index);
+            stack.set_map_value(item_idx, "channels", list[i].channels);
+            stack.set_map_value(item_idx, "sample_rate", list[i].sample_rate);
+            stack.set_map_value(item_idx, "duration", list[i].duration_seconds);
+            stack.set_array_value(array_idx, i + 1, item_idx);
+        }
+    }
+
+    // Push video info table to Lua stack
+    inline void pushVideoInfoToLua(lua_State* L, core::IVideoDecoder* decoder) {
+        lua::stack_t stack(L);
+        
+        if (!decoder) {
+            stack.create_map(0);
+            return;
+        }
+
+        auto map_idx = stack.create_map(10);
+        
+        stack.set_map_value(map_idx, "duration", decoder->getDuration());
+        stack.set_map_value(map_idx, "time", decoder->getCurrentTime());
+        stack.set_map_value(map_idx, "looping", decoder->isLooping());
+
+        double loop_end = 0.0, loop_duration = 0.0;
+        decoder->getLoopRange(&loop_end, &loop_duration);
+        stack.set_map_value(map_idx, "loop_end", loop_end);
+        stack.set_map_value(map_idx, "loop_duration", loop_duration);
+        
+        auto size = decoder->getVideoSize();
+        stack.set_map_value(map_idx, "width", size.x);
+        stack.set_map_value(map_idx, "height", size.y);
+        
+        stack.set_map_value(map_idx, "video_stream", decoder->getVideoStreamIndex());
+        
+        double frame_interval = decoder->getFrameInterval();
+        stack.set_map_value(map_idx, "frame_interval", frame_interval);
+        
+        if (frame_interval > 0.0) {
+            stack.set_map_value(map_idx, "fps", 1.0 / frame_interval);
+        }
+    }
+}
diff --git a/LuaSTG/LuaSTG/LuaBinding/modern/Video.cpp b/LuaSTG/LuaSTG/LuaBinding/modern/Video.cpp
new file mode 100644
index 000000000..852e0ed51
--- /dev/null
+++ b/LuaSTG/LuaSTG/LuaBinding/modern/Video.cpp
@@ -0,0 +1,289 @@
+#include "Video.hpp"
+#include "Texture2D.hpp"
+#include "VideoBindingHelpers.hpp"
+#include "lua/plus.hpp"
+#include "AppFrame.h"
+#include "core/VideoDecoder.hpp"
+
+namespace luastg::binding {
+	const std::string_view Video::class_name{ "lstg.Video" };
+
+	struct VideoBinding : Video {
+		// meta methods
+
+		// NOLINTBEGIN(*-reserved-identifier)
+
+		static int __gc(lua_State* vm) {
+			if (auto const self = as(vm, 1); self->data) {
+				self->data->release();
+				self->data = nullptr;
+			}
+			return 0;
+		}
+		static int __tostring(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			[[maybe_unused]] auto const self = as(vm, 1);
+			ctx.push_value(class_name);
+			return 1;
+		}
+		static int __eq(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			if (is(vm, 2)) {
+				auto const other = as(vm, 2);
+				ctx.push_value(self->data == other->data);
+			} else {
+				ctx.push_value(false);
+			}
+			return 1;
+		}
+
+		// NOLINTEND(*-reserved-identifier)
+
+		// method - video info
+
+		static int getWidth(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			ctx.push_value(self->data->getSize().x);
+			return 1;
+		}
+		static int getHeight(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			ctx.push_value(self->data->getSize().y);
+			return 1;
+		}
+		
+		template<typename Func>
+		static int withDecoder(lua_State* vm, Func&& func) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				return func(ctx, decoder);
+			}
+			ctx.push_value(0.0);
+			return 1;
+		}
+		
+		static int getDuration(lua_State* vm) {
+			return withDecoder(vm, [](auto& ctx, auto decoder) {
+				ctx.push_value(decoder->getDuration());
+				return 1;
+			});
+		}
+		static int getCurrentTime(lua_State* vm) {
+			return withDecoder(vm, [](auto& ctx, auto decoder) {
+				ctx.push_value(decoder->getCurrentTime());
+				return 1;
+			});
+		}
+		static int getFPS(lua_State* vm) {
+			return withDecoder(vm, [](auto& ctx, auto decoder) {
+				auto interval = decoder->getFrameInterval();
+				ctx.push_value(interval > 0.0 ? 1.0 / interval : 0.0);
+				return 1;
+			});
+		}
+		static int isLooping(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				ctx.push_value(decoder->isLooping());
+			} else {
+				ctx.push_value(false);
+			}
+			return 1;
+		}
+		static int getTexture(lua_State* vm) {
+			auto const self = as(vm, 1);
+			auto const texture = Texture2D::create(vm);
+			texture->data = self->data;
+			if (texture->data) {
+				texture->data->retain();
+			}
+			return 1;
+		}
+
+		// method - playback control
+
+		static int seek(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			auto const time = ctx.get_value<double>(2);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				ctx.push_value(decoder->seek(time));
+			} else {
+				ctx.push_value(false);
+			}
+			return 1;
+		}
+		static int update(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			auto const time = ctx.get_value<double>(2);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				ctx.push_value(decoder->updateToTime(time));
+			} else {
+				ctx.push_value(false);
+			}
+			return 1;
+		}
+		static int setLooping(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			auto const loop = ctx.get_value<bool>(2);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				decoder->setLooping(loop);
+			}
+			return 0;
+		}
+		static int setLoopRange(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			auto const loop_end = ctx.get_value<double>(2);
+			auto const loop_duration = ctx.get_value<double>(3);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				decoder->setLoopRange(loop_end, loop_duration);
+			}
+			return 0;
+		}
+		static int getLoopRange(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				double loop_end = 0.0, loop_duration = 0.0;
+				decoder->getLoopRange(&loop_end, &loop_duration);
+				ctx.push_value(loop_end);
+				ctx.push_value(loop_duration);
+				return 2;
+			}
+			ctx.push_value(0.0);
+			ctx.push_value(0.0);
+			return 2;
+		}
+
+		// method - stream info
+
+		static int getVideoStreams(lua_State* vm) {
+			auto const self = as(vm, 1);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				video::pushVideoStreamsToLua(vm, decoder);
+			} else {
+				lua::stack_t const ctx(vm);
+				ctx.create_array(0);
+			}
+			return 1;
+		}
+		static int getAudioStreams(lua_State* vm) {
+			auto const self = as(vm, 1);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				video::pushAudioStreamsToLua(vm, decoder);
+			} else {
+				lua::stack_t const ctx(vm);
+				ctx.create_array(0);
+			}
+			return 1;
+		}
+		static int getVideoStreamIndex(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				ctx.push_value(decoder->getVideoStreamIndex());
+			} else {
+				ctx.push_value(0);
+			}
+			return 1;
+		}
+		static int reopen(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const self = as(vm, 1);
+			if (auto decoder = video::getDecoderFromTexture(self->data)) {
+				core::VideoOpenOptions opt = decoder->getLastOpenOptions();
+				if (ctx.index_of_top() >= 2) {
+					video::parseVideoOptions(vm, 2, opt);
+				}
+				ctx.push_value(decoder->reopen(opt));
+			} else {
+				ctx.push_value(false);
+			}
+			return 1;
+		}
+
+		// static method
+
+		static int create(lua_State* vm) {
+			lua::stack_t const ctx(vm);
+			auto const path = ctx.get_value<std::string_view>(1);
+			
+			core::VideoOpenOptions opt{};
+			if (ctx.index_of_top() >= 2) {
+				video::parseVideoOptions(vm, 2, opt);
+			}
+
+			core::SmartReference<core::ITexture2D> texture;
+			if (!LAPP.getGraphicsDevice()->createVideoTexture(path, opt, texture.put())) {
+				auto const error_message = std::format(
+					"create Video from file '{}' failed", path);
+				return luaL_error(vm, error_message.c_str());
+			}
+			auto const self = Video::create(vm);
+			self->data = texture.detach();
+			return 1;
+		}
+	};
+
+	bool Video::is(lua_State* vm, int const index) {
+		lua::stack_t const ctx(vm);
+		return ctx.is_metatable(index, class_name);
+	}
+	Video* Video::as(lua_State* vm, int const index) {
+		lua::stack_t const ctx(vm);
+		return ctx.as_userdata<Video>(index);
+	}
+	Video* Video::create(lua_State* vm) {
+		lua::stack_t const ctx(vm);
+		auto const self = ctx.create_userdata<Video>();
+		auto const self_index = ctx.index_of_top();
+		ctx.set_metatable(self_index, class_name);
+		self->data = nullptr;
+		return self;
+	}
+	void Video::registerClass(lua_State* vm) {
+		[[maybe_unused]] lua::stack_balancer_t stack_balancer(vm);
+		lua::stack_t const ctx(vm);
+
+		// method
+
+		auto const method_table = ctx.create_module(class_name);
+		// video info
+		ctx.set_map_value(method_table, "getWidth", &VideoBinding::getWidth);
+		ctx.set_map_value(method_table, "getHeight", &VideoBinding::getHeight);
+		ctx.set_map_value(method_table, "getDuration", &VideoBinding::getDuration);
+		ctx.set_map_value(method_table, "getCurrentTime", &VideoBinding::getCurrentTime);
+		ctx.set_map_value(method_table, "getFPS", &VideoBinding::getFPS);
+		ctx.set_map_value(method_table, "isLooping", &VideoBinding::isLooping);
+		ctx.set_map_value(method_table, "getTexture", &VideoBinding::getTexture);
+		// playback control
+		ctx.set_map_value(method_table, "seek", &VideoBinding::seek);
+		ctx.set_map_value(method_table, "update", &VideoBinding::update);
+		ctx.set_map_value(method_table, "setLooping", &VideoBinding::setLooping);
+		ctx.set_map_value(method_table, "setLoopRange", &VideoBinding::setLoopRange);
+		ctx.set_map_value(method_table, "getLoopRange", &VideoBinding::getLoopRange);
+		// stream info
+		ctx.set_map_value(method_table, "getVideoStreams", &VideoBinding::getVideoStreams);
+		ctx.set_map_value(method_table, "getAudioStreams", &VideoBinding::getAudioStreams);
+		ctx.set_map_value(method_table, "getVideoStreamIndex", &VideoBinding::getVideoStreamIndex);
+		ctx.set_map_value(method_table, "reopen", &VideoBinding::reopen);
+		// static method
+		ctx.set_map_value(method_table, "create", &VideoBinding::create);
+
+		// metatable
+
+		auto const metatable = ctx.create_metatable(class_name);
+		ctx.set_map_value(metatable, "__gc", &VideoBinding::__gc);
+		ctx.set_map_value(metatable, "__tostring", &VideoBinding::__tostring);
+		ctx.set_map_value(metatable, "__eq", &VideoBinding::__eq);
+		ctx.set_map_value(metatable, "__index", method_table);
+	}
+}
diff --git a/LuaSTG/LuaSTG/LuaBinding/modern/Video.hpp b/LuaSTG/LuaSTG/LuaBinding/modern/Video.hpp
new file mode 100644
index 000000000..5602c623b
--- /dev/null
+++ b/LuaSTG/LuaSTG/LuaBinding/modern/Video.hpp
@@ -0,0 +1,17 @@
+#pragma once
+#include "core/Texture2D.hpp"
+#include "lua.hpp"
+#include <string_view>
+
+namespace luastg::binding {
+	struct Video {
+		static const std::string_view class_name;
+
+		core::ITexture2D* data{ nullptr };
+
+		static bool is(lua_State* vm, int index);
+		static Video* as(lua_State* vm, int index);
+		static Video* create(lua_State* vm);
+		static void registerClass(lua_State* vm);
+	};
+}
diff --git a/LuaSTG/doc/luastg/legacy/ResourceManager.lua b/LuaSTG/doc/luastg/legacy/ResourceManager.lua
index 49996b82d..efa182b62 100644
--- a/LuaSTG/doc/luastg/legacy/ResourceManager.lua
+++ b/LuaSTG/doc/luastg/legacy/ResourceManager.lua
@@ -107,6 +107,15 @@ end
 function M.IsRenderTarget(name)
 end
 
+--- [LuaSTG Sub 新增]  
+--- 判断纹理是否为视频纹理  
+--- [LuaSTG Sub Add]  
+--- Check if a texture is a video texture  
+---@param name string 纹理名称 / Texture name
+---@return boolean is_video 是否为视频纹理 / Whether it is a video texture
+function M.IsVideoTexture(name)
+end
+
 --- 返回纹理或渲染目标的宽度和高度
 ---@param texname string
 ---@return number, number
@@ -404,6 +413,133 @@ end
 function M.LoadModel(modname, gltfpath)
 end
 
+--------------------------------------------------------------------------------
+--- 视频
+--- Video
+
+--- [LuaSTG Sub 新增]  
+--- 从文件加载视频纹理  
+--- 支持常见的视频格式（如 mp4, avi, mkv 等）  
+--- 加载后的视频可以像普通纹理一样使用，通过 LoadImage 创建精灵  
+--- [LuaSTG Sub Add]  
+--- Load video texture from file  
+--- Supports common video formats (such as mp4, avi, mkv, etc.)  
+--- The loaded video can be used like a normal texture, create sprite via LoadImage  
+---
+---# 示例 / Example
+---```lua
+---lstg.LoadVideo('video1', 'test_video.mp4')
+---lstg.LoadVideo('video2', 'test_video.mp4', {
+---    video_stream = 0,
+---    width = 1280,
+---    height = 720,
+---    looping = true,
+---    loop_end = 10.0,
+---    loop_duration = 5.0
+---})
+---lstg.LoadImage('video_sprite', 'video1', 0, 0, 640, 480)
+---```
+---@param videoname string 视频资源名称 / Video resource name
+---@param filepath string 视频文件路径 / Video file path
+---@param options? lstg.VideoOpenOptions 视频打开选项 / Video open options
+function M.LoadVideo(videoname, filepath, options)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 跳转到视频的指定时间  
+--- [LuaSTG Sub Add]  
+--- Seek video to specified time  
+---@param videoname string 视频资源名称 / Video resource name
+---@param time number 目标时间（秒）/ Target time in seconds
+---@return boolean success 是否成功 / Success status
+function M.VideoSeek(videoname, time)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 设置视频是否循环播放  
+--- [LuaSTG Sub Add]  
+--- Set whether the video loops  
+---@param videoname string 视频资源名称 / Video resource name
+---@param loop boolean 是否循环 / Whether to loop
+function M.VideoSetLooping(videoname, loop)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 设置视频循环区间  
+--- 循环区间为 [loop_end - loop_duration, loop_end)  
+--- 当播放时间超过 loop_end 时，会跳转到 loop_end - loop_duration  
+--- [LuaSTG Sub Add]  
+--- Set video loop range  
+--- Loop range is [loop_end - loop_duration, loop_end)  
+--- When playback time exceeds loop_end, it jumps to loop_end - loop_duration  
+---@param videoname string 视频资源名称 / Video resource name
+---@param loop_end number 循环结束时间（秒）/ Loop end time in seconds
+---@param loop_duration number 循环时长（秒）/ Loop duration in seconds
+function M.VideoSetLoopRange(videoname, loop_end, loop_duration)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 更新视频到指定的绝对时间  
+--- 通常配合 StopWatch 使用来同步视频播放  
+--- [LuaSTG Sub Add]  
+--- Update video to specified absolute time  
+--- Typically used with StopWatch to synchronize video playback  
+---
+---# 示例 / Example
+---```lua
+---local video_clock = lstg.StopWatch()
+---function RenderFunc()
+---    lstg.VideoUpdate('video1', video_clock:GetElapsed())
+---    lstg.Render('video_sprite', 100, 100)
+---end
+---```
+---@param videoname string 视频资源名称 / Video resource name
+---@param time number 目标时间（秒）/ Target time in seconds
+---@return boolean success 是否成功 / Success status
+function M.VideoUpdate(videoname, time)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 获取视频信息  
+--- [LuaSTG Sub Add]  
+--- Get video information  
+---@param videoname string 视频资源名称 / Video resource name
+---@return lstg.VideoInfo info 视频信息表 / Video information table
+function M.VideoGetInfo(videoname)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 获取视频文件中的所有视频流信息  
+--- 用于多轨视频的流选择  
+--- [LuaSTG Sub Add]  
+--- Get all video streams in the video file  
+--- Used for multi-track video stream selection  
+---@param videoname string 视频资源名称 / Video resource name
+---@return lstg.VideoStreamInfo[] streams 视频流信息数组 / Array of video stream info
+function M.VideoGetVideoStreams(videoname)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 获取视频文件中的所有音频流信息  
+--- [LuaSTG Sub Add]  
+--- Get all audio streams in the video file  
+---@param videoname string 视频资源名称 / Video resource name
+---@return lstg.AudioStreamInfo[] streams 音频流信息数组 / Array of audio stream info
+function M.VideoGetAudioStreams(videoname)
+end
+
+--- [LuaSTG Sub 新增]  
+--- 使用新的选项重新打开视频  
+--- 可用于切换视频流或修改输出尺寸  
+--- [LuaSTG Sub Add]  
+--- Reopen video with new options  
+--- Can be used to switch video streams or change output size  
+---@param videoname string 视频资源名称 / Video resource name
+---@param options? lstg.VideoOpenOptions 新的打开选项 / New open options
+---@return boolean success 是否成功 / Success status
+function M.VideoReopen(videoname, options)
+end
+
 --------------------------------------------------------------------------------
 --- 实验性 API
 
diff --git a/LuaSTG/doc/luastg/lstg.lua b/LuaSTG/doc/luastg/lstg.lua
index a9a13cd36..4d1d0edc3 100644
--- a/LuaSTG/doc/luastg/lstg.lua
+++ b/LuaSTG/doc/luastg/lstg.lua
@@ -190,8 +190,10 @@ M.CheckRes = ResourceManager.CheckRes
 M.EnumRes = ResourceManager.EnumRes
 
 M.LoadTexture = ResourceManager.LoadTexture
+M.LoadVideo = ResourceManager.LoadVideo
 M.CreateRenderTarget = ResourceManager.CreateRenderTarget
 M.IsRenderTarget = ResourceManager.IsRenderTarget
+M.IsVideoTexture = ResourceManager.IsVideoTexture
 M.GetTextureSize = ResourceManager.GetTextureSize
 M.SaveTexture = ResourceManager.SaveTexture
 M.Snapshot = ResourceManager.Snapshot
@@ -227,6 +229,15 @@ M.LoadFX = ResourceManager.LoadFX
 
 M.LoadModel = ResourceManager.LoadModel
 
+M.VideoSeek = ResourceManager.VideoSeek
+M.VideoSetLooping = ResourceManager.VideoSetLooping
+M.VideoSetLoopRange = ResourceManager.VideoSetLoopRange
+M.VideoUpdate = ResourceManager.VideoUpdate
+M.VideoGetInfo = ResourceManager.VideoGetInfo
+M.VideoGetVideoStreams = ResourceManager.VideoGetVideoStreams
+M.VideoGetAudioStreams = ResourceManager.VideoGetAudioStreams
+M.VideoReopen = ResourceManager.VideoReopen
+
 M.ResourceManager = ResourceManager.ResourceManager
 
 --------------------------------------------------------------------------------
diff --git a/LuaSTG/doc/luastg/lstg/Video.lua b/LuaSTG/doc/luastg/lstg/Video.lua
new file mode 100644
index 000000000..b8819c9a8
--- /dev/null
+++ b/LuaSTG/doc/luastg/lstg/Video.lua
@@ -0,0 +1,264 @@
+---@meta lstg.Video
+
+---@class lstg.Video
+---视频对象，用于播放视频文件
+---Video object for playing video files
+local Video = {}
+
+--------------------------------------------------------------------------------
+--- 静态方法 / Static Methods
+--------------------------------------------------------------------------------
+
+---创建视频对象
+---Create a video object from file
+---
+---# 示例 / Example
+---```lua
+---local video = lstg.Video.create('test_video.mp4')
+---local video_with_options = lstg.Video.create('test_video.mp4', {
+---    video_stream = 0,
+---    width = 1280,
+---    height = 720,
+---    premultiplied_alpha = false,
+---    looping = true,
+---    loop_end = 10.0,
+---    loop_duration = 5.0
+---})
+---```
+---@param path string 视频文件路径 / Video file path
+---@param options? lstg.VideoOpenOptions 视频打开选项 / Video open options
+---@return lstg.Video video 视频对象 / Video object
+function Video.create(path, options) end
+
+--------------------------------------------------------------------------------
+--- 视频信息 / Video Information
+--------------------------------------------------------------------------------
+
+---获取视频宽度（像素）
+---Get video width in pixels
+---@return number width 视频宽度 / Video width
+function Video:getWidth() end
+
+---获取视频高度（像素）
+---Get video height in pixels
+---@return number height 视频高度 / Video height
+function Video:getHeight() end
+
+---获取视频总时长（秒）
+---Get video duration in seconds
+---@return number duration 视频时长 / Video duration
+function Video:getDuration() end
+
+---获取当前播放时间（秒）
+---Get current playback time in seconds
+---@return number time 当前时间 / Current time
+function Video:getCurrentTime() end
+
+---获取视频帧率（FPS）
+---Get video frame rate (frames per second)
+---@return number fps 帧率 / Frame rate
+function Video:getFPS() end
+
+---获取是否循环播放
+---Get whether the video is looping
+---@return boolean looping 是否循环 / Is looping
+function Video:isLooping() end
+
+---获取视频纹理对象
+---Get the texture object of the video
+---
+---# 说明 / Description
+---返回的纹理对象可以用于创建精灵或直接渲染
+---The returned texture can be used to create sprites or render directly
+---
+---# 示例 / Example
+---```lua
+---local video = lstg.Video.create('test_video.mp4')
+---local texture = video:getTexture()
+---local sprite = lstg.Sprite.create(texture, 0, 0, video:getWidth(), video:getHeight())
+---```
+---@return lstg.Texture2D texture 纹理对象 / Texture object
+function Video:getTexture() end
+
+--------------------------------------------------------------------------------
+--- 播放控制 / Playback Control
+--------------------------------------------------------------------------------
+
+---跳转到指定时间
+---Seek to specified time
+---
+---# 说明 / Description
+---跳转到视频的指定时间点，会解码到该时间点的帧
+---Seeks to the specified time in the video and decodes to that frame
+---@param time number 目标时间（秒）/ Target time in seconds
+---@return boolean success 是否成功 / Success status
+function Video:seek(time) end
+
+---更新视频到指定时间
+---Update video to specified time
+---
+---# 说明 / Description
+---将视频更新到指定的绝对时间，通常配合 StopWatch 使用
+---Updates the video to the specified absolute time, typically used with StopWatch
+---
+---# 示例 / Example
+---```lua
+---local video = lstg.Video.create('test_video.mp4')
+---local clock = lstg.StopWatch()
+---
+---function RenderFunc()
+---    video:update(clock:GetElapsed())
+---    -- 渲染视频 / Render video
+---end
+---```
+---@param time number 目标时间（秒）/ Target time in seconds
+---@return boolean success 是否成功 / Success status
+function Video:update(time) end
+
+---设置是否循环播放
+---Set whether to loop playback
+---
+---# 示例 / Example
+---```lua
+---video:setLooping(true)  -- 启用循环 / Enable looping
+---video:setLooping(false) -- 禁用循环 / Disable looping
+---```
+---@param loop boolean 是否循环 / Whether to loop
+function Video:setLooping(loop) end
+
+---设置循环区间
+---Set loop range
+---
+---# 说明 / Description
+---设置循环区间为 [loop_end - loop_duration, loop_end)
+---当播放时间超过 loop_end 时，会跳转到 loop_end - loop_duration
+---Sets the loop range to [loop_end - loop_duration, loop_end)
+---When playback time exceeds loop_end, it jumps to loop_end - loop_duration
+---
+---# 示例 / Example
+---```lua
+---video:setLoopRange(10.0, 5.0)  -- 循环区间 [5.0, 10.0) / Loop range [5.0, 10.0)
+---```
+---@param loop_end number 循环结束时间（秒）/ Loop end time in seconds
+---@param loop_duration number 循环时长（秒）/ Loop duration in seconds
+function Video:setLoopRange(loop_end, loop_duration) end
+
+---获取循环区间
+---Get loop range
+---
+---# 示例 / Example
+---```lua
+---local loop_end, loop_duration = video:getLoopRange()
+---print(string.format("Loop range: [%.2f, %.2f)", loop_end - loop_duration, loop_end))
+---```
+---@return number loop_end 循环结束时间（秒）/ Loop end time in seconds
+---@return number loop_duration 循环时长（秒）/ Loop duration in seconds
+function Video:getLoopRange() end
+
+--------------------------------------------------------------------------------
+--- 流信息 / Stream Information
+--------------------------------------------------------------------------------
+
+---获取视频流列表
+---Get list of video streams
+---
+---# 说明 / Description
+---返回视频文件中所有视频流的信息，用于多轨视频的流选择
+---Returns information about all video streams in the file, used for multi-track video stream selection
+---
+---# 示例 / Example
+---```lua
+---local streams = video:getVideoStreams()
+---for i, stream in ipairs(streams) do
+---    print(string.format("Stream %d: %dx%d, %.2f fps, %.2f sec",
+---        stream.index, stream.width, stream.height, stream.fps, stream.duration))
+---end
+---```
+---@return lstg.VideoStreamInfo[] streams 视频流信息数组 / Array of video stream info
+function Video:getVideoStreams() end
+
+---获取音频流列表
+---Get list of audio streams
+---
+---# 说明 / Description
+---返回视频文件中所有音频流的信息
+---Returns information about all audio streams in the file
+---
+---# 示例 / Example
+---```lua
+---local streams = video:getAudioStreams()
+---for i, stream in ipairs(streams) do
+---    print(string.format("Stream %d: %d channels, %d Hz, %.2f sec",
+---        stream.index, stream.channels, stream.sample_rate, stream.duration))
+---end
+---```
+---@return lstg.AudioStreamInfo[] streams 音频流信息数组 / Array of audio stream info
+function Video:getAudioStreams() end
+
+---获取当前视频流索引
+---Get current video stream index
+---@return number index 视频流索引 / Video stream index
+function Video:getVideoStreamIndex() end
+
+---重新打开视频
+---Reopen the video with new options
+---
+---# 说明 / Description
+---使用新的选项重新打开视频，可用于切换视频流或修改输出尺寸
+---Reopens the video with new options, can be used to switch video streams or change output size
+---
+---# 示例 / Example
+---```lua
+---video:reopen({ video_stream = 1, width = 1920, height = 1080 })
+---```
+---@param options? lstg.VideoOpenOptions 新的打开选项 / New open options
+---@return boolean success 是否成功 / Success status
+function Video:reopen(options) end
+
+--------------------------------------------------------------------------------
+--- 类型定义 / Type Definitions
+--------------------------------------------------------------------------------
+
+---@class lstg.VideoOpenOptions
+---视频打开选项
+---Video open options
+---@field video_stream? number 视频流索引，默认自动选择 / Video stream index, auto-select by default
+---@field width? number 输出宽度（像素），0 表示使用原始尺寸 / Output width in pixels, 0 for original size
+---@field height? number 输出高度（像素），0 表示使用原始尺寸 / Output height in pixels, 0 for original size
+---@field premultiplied_alpha? boolean 是否使用预乘 Alpha，默认 false / Use premultiplied alpha, default false
+---@field looping? boolean 是否循环播放，默认 false / Enable looping, default false
+---@field loop_end? number 循环结束时间（秒），默认 0 / Loop end time in seconds, default 0
+---@field loop_duration? number 循环时长（秒），默认 0 / Loop duration in seconds, default 0
+
+---@class lstg.VideoInfo
+---视频信息
+---Video information
+---@field duration number 视频总时长（秒）/ Total duration in seconds
+---@field time number 当前播放时间（秒）/ Current playback time in seconds
+---@field looping boolean 是否循环播放 / Whether looping
+---@field loop_end number 循环结束时间（秒）/ Loop end time in seconds
+---@field loop_duration number 循环时长（秒）/ Loop duration in seconds
+---@field width number 视频宽度（像素）/ Video width in pixels
+---@field height number 视频高度（像素）/ Video height in pixels
+---@field video_stream number 当前视频流索引 / Current video stream index
+---@field frame_interval number 帧间隔（秒）/ Frame interval in seconds
+---@field fps number 帧率 / Frame rate
+
+---@class lstg.VideoStreamInfo
+---视频流信息
+---Video stream information
+---@field index number 流索引 / Stream index
+---@field width number 视频宽度（像素）/ Video width in pixels
+---@field height number 视频高度（像素）/ Video height in pixels
+---@field fps number 帧率 / Frame rate
+---@field duration number 时长（秒）/ Duration in seconds
+
+---@class lstg.AudioStreamInfo
+---音频流信息
+---Audio stream information
+---@field index number 流索引 / Stream index
+---@field channels number 声道数 / Number of channels
+---@field sample_rate number 采样率（Hz）/ Sample rate in Hz
+---@field duration number 时长（秒）/ Duration in seconds
+
+return Video
diff --git a/engine/configuration/core/Configuration.cpp b/engine/configuration/core/Configuration.cpp
index 6b0b77eab..f87e97481 100644
--- a/engine/configuration/core/Configuration.cpp
+++ b/engine/configuration/core/Configuration.cpp
@@ -467,6 +467,16 @@ namespace core {
 					assert_type_is_boolean(allow_direct_composition, "/graphics_system/allow_direct_composition"sv);
 					loader.graphics_system.setAllowDirectComposition(allow_direct_composition.get<bool>());
 				}
+				if (graphics_system.contains("allow_hardware_video_decode"sv)) {
+					auto const& v = graphics_system.at("allow_hardware_video_decode"sv);
+					assert_type_is_boolean(v, "/graphics_system/allow_hardware_video_decode"sv);
+					loader.graphics_system.setAllowHardwareVideoDecode(v.get<bool>());
+				}
+				else if (graphics_system.contains("disable_hardware_video_decode"sv)) {
+					auto const& v = graphics_system.at("disable_hardware_video_decode"sv);
+					assert_type_is_boolean(v, "/graphics_system/disable_hardware_video_decode"sv);
+					loader.graphics_system.setAllowHardwareVideoDecode(!v.get<bool>());
+				}
 				// TODO: display
 			}
 
@@ -738,6 +748,7 @@ namespace {
 		{ .type = OptionType::boolean, .prefix = "--graphics_system.allow_exclusive_fullscreen="sv, .path = "/graphics_system/allow_exclusive_fullscreen"_json_pointer },
 		{ .type = OptionType::boolean, .prefix = "--graphics_system.allow_modern_swap_chain="sv   , .path = "/graphics_system/allow_modern_swap_chain"_json_pointer },
 		{ .type = OptionType::boolean, .prefix = "--graphics_system.allow_direct_composition="sv  , .path = "/graphics_system/allow_direct_composition"_json_pointer },
+		{ .type = OptionType::boolean, .prefix = "--graphics_system.allow_hardware_video_decode="sv, .path = "/graphics_system/allow_hardware_video_decode"_json_pointer },
 		// audio_system
 		{ .type = OptionType::string , .prefix = "--audio_system.preferred_endpoint_name="sv, .path = "/audio_system/preferred_endpoint_name"_json_pointer },
 		{ .type = OptionType::number , .prefix = "--audio_system.sound_effect_volume="sv    , .path = "/audio_system/sound_effect_volume"_json_pointer },
diff --git a/engine/configuration/core/Configuration.hpp b/engine/configuration/core/Configuration.hpp
index b02bb8a58..524abbf34 100644
--- a/engine/configuration/core/Configuration.hpp
+++ b/engine/configuration/core/Configuration.hpp
@@ -153,6 +153,7 @@ namespace core {
 			GetterSetterBoolean(GraphicsSystem, allow_exclusive_fullscreen, AllowExclusiveFullscreen);
 			GetterSetterBoolean(GraphicsSystem, allow_modern_swap_chain, AllowModernSwapChain);
 			GetterSetterBoolean(GraphicsSystem, allow_direct_composition, AllowDirectComposition);
+			GetterSetterBoolean(GraphicsSystem, allow_hardware_video_decode, AllowHardwareVideoDecode);
 		private:
 			std::string preferred_device_name;
 			uint32_t width{ 640u };
@@ -163,6 +164,7 @@ namespace core {
 			bool allow_exclusive_fullscreen{ true };
 			bool allow_modern_swap_chain{ true };
 			bool allow_direct_composition{ true };
+			bool allow_hardware_video_decode{ true };
 		};
 		class AudioSystem {
 		public:
diff --git a/engine/graphics/CMakeLists.txt b/engine/graphics/CMakeLists.txt
index 19c29b5e6..08f320a44 100644
--- a/engine/graphics/CMakeLists.txt
+++ b/engine/graphics/CMakeLists.txt
@@ -46,6 +46,11 @@ target_link_libraries(${lib_name} PUBLIC
     dxgi.lib
     d3d11.lib
     d2d1.lib
+    # media foundation (for video)
+    mfplat.lib
+    mfreadwrite.lib
+    mfuuid.lib
+    shlwapi.lib
     Microsoft.Windows.ImplementationLibrary
     Microsoft::DirectXTexMini
     libqoi
diff --git a/engine/graphics/core/GraphicsDevice.hpp b/engine/graphics/core/GraphicsDevice.hpp
index f73c8dd07..34f15bf4c 100644
--- a/engine/graphics/core/GraphicsDevice.hpp
+++ b/engine/graphics/core/GraphicsDevice.hpp
@@ -3,6 +3,7 @@
 #include "core/ImmutableString.hpp"
 #include "core/GraphicsBuffer.hpp"
 #include "core/Texture2D.hpp"
+#include "core/VideoDecoder.hpp"
 #include "core/GraphicsSampler.hpp"
 #include "core/RenderTarget.hpp"
 #include "core/DepthStencilBuffer.hpp"
@@ -108,6 +109,9 @@ namespace core {
         virtual bool createTextureFromFile(StringView path, bool mipmap, ITexture2D** out_texture) = 0;
         virtual bool createTextureFromImage(IImage* image, bool mipmap, ITexture2D** out_texture) = 0;
         virtual bool createTexture(Vector2U size, ITexture2D** out_texture) = 0;
+        virtual bool createVideoTexture(StringView path, ITexture2D** out_texture) = 0;
+        virtual bool createVideoTexture(StringView path, VideoOpenOptions const& options, ITexture2D** out_texture) = 0;
+        virtual bool createVideoDecoder(IVideoDecoder** out_decoder) = 0;
 
         virtual bool createSampler(const GraphicsSamplerInfo& info, IGraphicsSampler** out_sampler) = 0;
 
diff --git a/engine/graphics/core/Texture2D.hpp b/engine/graphics/core/Texture2D.hpp
index 6daddee43..3c6a3af39 100644
--- a/engine/graphics/core/Texture2D.hpp
+++ b/engine/graphics/core/Texture2D.hpp
@@ -8,6 +8,8 @@
 #include "core/GraphicsSampler.hpp"
 
 namespace core {
+    // Forward declaration
+    CORE_INTERFACE IVideoDecoder;
     enum class TextureBindFlag {
         shader_resource = 0x8,
         render_target = 0x20,
@@ -27,6 +29,7 @@ namespace core {
         virtual void* getNativeView() const noexcept = 0;
 
         virtual bool isDynamic() const noexcept = 0;
+        virtual bool isVideoTexture() const noexcept = 0;
         virtual bool isPremultipliedAlpha() const noexcept = 0;
         virtual void setPremultipliedAlpha(bool v) = 0;
         virtual Vector2U getSize() const noexcept = 0;
@@ -39,6 +42,9 @@ namespace core {
 
         virtual void setSamplerState(IGraphicsSampler* sampler) = 0;
         virtual IGraphicsSampler* getSamplerState() const noexcept = 0;
+
+        // 获取视频解码器（仅当 isVideoTexture() 返回 true 时有效）
+        virtual IVideoDecoder* getVideoDecoder() const noexcept = 0;
     };
 
     CORE_INTERFACE_ID(ITexture2D, "5477054a-61c9-5071-9339-a9959e538a21")
diff --git a/engine/graphics/core/VideoDecoder.hpp b/engine/graphics/core/VideoDecoder.hpp
new file mode 100644
index 000000000..f99d0b074
--- /dev/null
+++ b/engine/graphics/core/VideoDecoder.hpp
@@ -0,0 +1,69 @@
+#pragma once
+#include "core/ReferenceCounted.hpp"
+#include "core/Vector2.hpp"
+#include "core/ImmutableString.hpp"
+#include <cstdint>
+#include <string_view>
+
+namespace core {
+    struct VideoOpenOptions {
+        uint32_t video_stream_index{ static_cast<uint32_t>(-1) };
+        uint32_t output_width{ 0 };
+        uint32_t output_height{ 0 };
+        bool premultiplied_alpha{ false };
+        bool looping{ false };
+        double loop_end{ 0.0 };
+        double loop_duration{ 0.0 };
+    };
+
+    struct VideoStreamInfo {
+        uint32_t index{ 0 };
+        uint32_t width{ 0 };
+        uint32_t height{ 0 };
+        double fps{ 0.0 };
+        double duration_seconds{ 0.0 };
+    };
+
+    struct AudioStreamInfo {
+        uint32_t index{ 0 };
+        uint32_t channels{ 0 };
+        uint32_t sample_rate{ 0 };
+        double duration_seconds{ 0.0 };
+    };
+
+    CORE_INTERFACE IVideoDecoder : IReferenceCounted {
+        virtual bool open(StringView path) = 0;
+        virtual bool open(StringView path, VideoOpenOptions const& options) = 0;
+
+        virtual void close() = 0;
+
+        virtual bool hasVideo() const noexcept = 0;
+
+        virtual Vector2U getVideoSize() const noexcept = 0;
+        virtual double getDuration() const noexcept = 0;
+        virtual double getCurrentTime() const noexcept = 0;
+        virtual double getFrameInterval() const noexcept = 0;
+
+        virtual bool seek(double time_in_seconds) = 0;
+
+        virtual void setLooping(bool loop) = 0;
+        virtual bool isLooping() const noexcept = 0;
+        virtual void setLoopRange(double end_sec, double duration_sec) = 0;
+        virtual void getLoopRange(double* end_sec, double* duration_sec) const noexcept = 0;
+
+        virtual bool updateToTime(double time_in_seconds) = 0;
+
+        virtual void* getNativeTexture() const noexcept = 0;
+        virtual void* getNativeShaderResourceView() const noexcept = 0;
+
+        virtual uint32_t getVideoStreamIndex() const noexcept = 0;
+        virtual void getVideoStreams(void (*callback)(VideoStreamInfo const&, void*), void* userdata) const = 0;
+        virtual void getAudioStreams(void (*callback)(AudioStreamInfo const&, void*), void* userdata) const = 0;
+
+        virtual bool reopen(VideoOpenOptions const& options) = 0;
+        virtual VideoOpenOptions getLastOpenOptions() const noexcept = 0;
+        virtual std::string_view getLastOpenPath() const noexcept = 0;
+    };
+
+    CORE_INTERFACE_ID(IVideoDecoder, "a4b5c6d7-e8f9-1234-5678-9abcdef01234")
+}
diff --git a/engine/graphics/d3d11/GraphicsDevice.hpp b/engine/graphics/d3d11/GraphicsDevice.hpp
index 665374707..e364aff69 100644
--- a/engine/graphics/d3d11/GraphicsDevice.hpp
+++ b/engine/graphics/d3d11/GraphicsDevice.hpp
@@ -22,6 +22,9 @@ namespace core {
         bool createTextureFromFile(StringView path, bool mipmap, ITexture2D** out_texture) override;
         bool createTexture(Vector2U size, ITexture2D** out_texture) override;
         bool createTextureFromImage(IImage* image, bool mipmap, ITexture2D** out_texture) override;
+        bool createVideoTexture(StringView path, ITexture2D** out_texture) override;
+        bool createVideoTexture(StringView path, VideoOpenOptions const& options, ITexture2D** out_texture) override;
+        bool createVideoDecoder(IVideoDecoder** out_decoder) override;
 
         bool createSampler(const GraphicsSamplerInfo& info, IGraphicsSampler** out_sampler) override;
 
diff --git a/engine/graphics/d3d11/Texture2D.hpp b/engine/graphics/d3d11/Texture2D.hpp
index 96accdfc3..4eca4c5fa 100644
--- a/engine/graphics/d3d11/Texture2D.hpp
+++ b/engine/graphics/d3d11/Texture2D.hpp
@@ -15,8 +15,11 @@ namespace core {
         void* getNativeView() const noexcept override { return m_view.get(); }
 
         bool isDynamic() const noexcept override { return m_dynamic; }
+        bool isVideoTexture() const noexcept override { return false; }
         bool isPremultipliedAlpha() const noexcept override { return m_pre_mul_alpha; }
         void setPremultipliedAlpha(bool const v) override { m_pre_mul_alpha = v; }
+        
+        IVideoDecoder* getVideoDecoder() const noexcept override { return nullptr; }
         Vector2U getSize() const noexcept override { return m_size; }
 
         bool setSize(Vector2U size) override;
diff --git a/engine/graphics/d3d11/VideoDecoder.cpp b/engine/graphics/d3d11/VideoDecoder.cpp
new file mode 100644
index 000000000..90fbd4a15
--- /dev/null
+++ b/engine/graphics/d3d11/VideoDecoder.cpp
@@ -0,0 +1,768 @@
+#include "d3d11/VideoDecoder.hpp"
+#include "d3d11/VideoDecoderConfig.hpp"
+#include "core/Configuration.hpp"
+#include "core/FileSystem.hpp"
+#include "core/Logger.hpp"
+#include "utf8.hpp"
+#include <wil/resource.h>
+#include <mferror.h>
+#include <mfapi.h>
+#include <mfobjects.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+#include <shlwapi.h>
+#include <algorithm>
+
+namespace {
+    using std::string_view_literals::operator ""sv;
+    using Config = core::VideoDecoderConfig;
+    
+    class MFInitializer {
+    public:
+        static MFInitializer& getInstance() {
+            static MFInitializer instance;
+            return instance;
+        }
+        
+        bool isInitialized() const { return m_initialized; }
+        
+    private:
+        MFInitializer() {
+            m_initialized = win32::check_hresult_as_boolean(
+                MFStartup(MF_VERSION, MFSTARTUP_FULL),
+                "MFStartup"sv
+            );
+        }
+        
+        ~MFInitializer() {
+            if (m_initialized) {
+                MFShutdown();
+            }
+        }
+        
+        bool m_initialized{ false };
+    };
+}
+
+namespace core {
+    VideoDecoder::VideoDecoder() = default;
+    
+    VideoDecoder::~VideoDecoder() {
+        if (m_initialized && m_device) {
+            m_device->removeEventListener(this);
+        }
+        close();
+    }
+    
+    bool VideoDecoder::initialize(IGraphicsDevice* device) {
+        if (!device) {
+            Logger::error("[core] [VideoDecoder] Invalid device");
+            return false;
+        }
+        
+        if (!MFInitializer::getInstance().isInitialized()) {
+            Logger::error("[core] [VideoDecoder] MediaFoundation not initialized");
+            return false;
+        }
+        
+        m_device = device;
+        m_initialized = true;
+        m_device->addEventListener(this);
+        
+        return true;
+    }
+    
+    bool VideoDecoder::open(StringView path) {
+        return open(path, VideoOpenOptions{});
+    }
+
+    bool VideoDecoder::open(StringView path, VideoOpenOptions const& options) {
+        if (!m_initialized) {
+            Logger::error("[core] [VideoDecoder] Not initialized");
+            return false;
+        }
+        
+        close();
+        
+        if (!loadVideoFile(path)) return false;
+        if (!configureHardwareAcceleration()) return false;
+        if (!selectVideoStream(options.video_stream_index)) return false;
+        if (!negotiateOutputFormat(options)) return false;
+        if (!extractVideoProperties()) return false;
+        if (!createResources()) return false;
+        if (!loadFirstFrame()) return false;
+
+        m_last_open_path.assign(path.data(), path.size());
+        m_last_open_options = options;
+
+        setLooping(options.looping);
+        if (options.loop_duration > 0.0) {
+            setLoopRange(options.loop_end, options.loop_duration);
+        }
+
+        Logger::info("[core] [VideoDecoder] Opened video: {}x{}, duration: {:.2f}s", 
+                    m_target_size.x, m_target_size.y, m_duration);
+
+        return true;
+    }
+
+    void VideoDecoder::getVideoStreams(void (*callback)(VideoStreamInfo const&, void*), void* userdata) const {
+        if (!m_source_reader || !callback) return;
+        
+        wil::unique_prop_variant var;
+        double duration_sec = 0.0;
+        if (SUCCEEDED(m_source_reader->GetPresentationAttribute((DWORD)MF_SOURCE_READER_MEDIASOURCE, MF_PD_DURATION, &var))) {
+            duration_sec = var.hVal.QuadPart / 10000000.0;
+        }
+        
+        for (DWORD si = 0; si < Config::kMaxStreams; ++si) {
+            win32::com_ptr<IMFMediaType> mt;
+            if (FAILED(m_source_reader->GetNativeMediaType(si, 0, mt.put()))) continue;
+            
+            GUID major = GUID_NULL;
+            if (FAILED(mt->GetGUID(MF_MT_MAJOR_TYPE, &major)) || major != MFMediaType_Video) continue;
+            
+            VideoStreamInfo info{};
+            info.index = si;
+            info.duration_seconds = duration_sec;
+            
+            UINT32 w = 0, h = 0;
+            if (SUCCEEDED(MFGetAttributeSize(mt.get(), MF_MT_FRAME_SIZE, &w, &h))) {
+                info.width = w;
+                info.height = h;
+            }
+            
+            UINT32 num = 0, den = 0;
+            if (SUCCEEDED(MFGetAttributeRatio(mt.get(), MF_MT_FRAME_RATE, &num, &den)) && den > 0) {
+                info.fps = static_cast<double>(num) / static_cast<double>(den);
+            }
+            
+            callback(info, userdata);
+        }
+    }
+
+    void VideoDecoder::getAudioStreams(void (*callback)(AudioStreamInfo const&, void*), void* userdata) const {
+        if (!m_source_reader || !callback) return;
+        
+        wil::unique_prop_variant var;
+        double duration_sec = 0.0;
+        if (SUCCEEDED(m_source_reader->GetPresentationAttribute((DWORD)MF_SOURCE_READER_MEDIASOURCE, MF_PD_DURATION, &var))) {
+            duration_sec = var.hVal.QuadPart / 10000000.0;
+        }
+        
+        for (DWORD si = 0; si < Config::kMaxStreams; ++si) {
+            win32::com_ptr<IMFMediaType> mt;
+            if (FAILED(m_source_reader->GetNativeMediaType(si, 0, mt.put()))) continue;
+            
+            GUID major = GUID_NULL;
+            if (FAILED(mt->GetGUID(MF_MT_MAJOR_TYPE, &major)) || major != MFMediaType_Audio) continue;
+            
+            AudioStreamInfo info{};
+            info.index = si;
+            info.duration_seconds = duration_sec;
+            info.channels = (UINT32)MFGetAttributeUINT32(mt.get(), MF_MT_AUDIO_NUM_CHANNELS, 0);
+            info.sample_rate = MFGetAttributeUINT32(mt.get(), MF_MT_AUDIO_SAMPLES_PER_SECOND, 0);
+            
+            callback(info, userdata);
+        }
+    }
+
+    bool VideoDecoder::reopen(VideoOpenOptions const& options) {
+        if (m_last_open_path.empty()) {
+            Logger::error("[core] [VideoDecoder] reopen: no previous path (open was never successful)");
+            return false;
+        }
+        return open(StringView(m_last_open_path), options);
+    }
+    
+    void VideoDecoder::close() {
+        m_source_reader.reset();
+        m_byte_stream.reset();
+        m_media_type.reset();
+        m_texture.reset();
+        m_shader_resource_view.reset();
+        m_device_context.reset();
+        m_video_processor.reset();
+        m_video_processor_enum.reset();
+        m_video_context.reset();
+        m_video_device.reset();
+        
+        m_output_format = OutputFormat::ARGB32;
+        m_video_size = Vector2U{};
+        m_target_size = Vector2U{};
+        m_duration = 0.0;
+        m_current_time = 0.0;
+        m_last_requested_time = -1.0;
+        m_frame_interval = 1.0 / Config::kDefaultFrameRateNum;
+        m_frame_rate_num = Config::kDefaultFrameRateNum;
+        m_frame_rate_den = Config::kDefaultFrameRateDen;
+        m_frame_pitch = 0;
+        m_video_stream_index = 0;
+        m_loop_state = LoopState{};
+        m_first_texture_update_logged = false;
+    }
+
+    void VideoDecoder::setLoopRange(double end_sec, double duration_sec) {
+        if (duration_sec > 0.0 && end_sec >= duration_sec) {
+            m_loop_state.start = end_sec - duration_sec;
+            double cap = m_duration > 0.0 ? m_duration : end_sec;
+            m_loop_state.end = (std::min)(end_sec, cap);
+            m_loop_state.has_range = (m_loop_state.end > m_loop_state.start);
+            if (!m_loop_state.has_range) { 
+                m_loop_state.start = 0.0; 
+                m_loop_state.end = m_duration; 
+            }
+        } else {
+            m_loop_state.has_range = false;
+            m_loop_state.start = 0.0;
+            m_loop_state.end = m_duration;
+        }
+    }
+
+    void VideoDecoder::getLoopRange(double* end_sec, double* duration_sec) const noexcept {
+        if (end_sec) *end_sec = m_loop_state.has_range ? m_loop_state.end : m_duration;
+        if (duration_sec) *duration_sec = m_loop_state.has_range ? (m_loop_state.end - m_loop_state.start) : m_duration;
+    }
+    
+    bool VideoDecoder::seek(double time_in_seconds) {
+        if (!hasVideo()) {
+            return false;
+        }
+        
+        time_in_seconds = std::clamp(time_in_seconds, 0.0, m_duration);
+        
+        wil::unique_prop_variant var;
+        var.vt = VT_I8;
+        var.hVal.QuadPart = static_cast<LONGLONG>(time_in_seconds * 10000000.0);
+        
+        HRESULT const hr = m_source_reader->SetCurrentPosition(GUID_NULL, var);
+        
+        if (!win32::check_hresult_as_boolean(hr, "IMFSourceReader::SetCurrentPosition"sv)) {
+            return false;
+        }
+        
+        m_current_time = time_in_seconds;
+        return true;
+    }
+    
+    bool VideoDecoder::updateToTime(double time_in_seconds) {
+        if (!hasVideo()) {
+            return false;
+        }
+
+        if (m_duration <= 0.0) {
+            m_current_time = 0.0;
+            return false;
+        }
+        
+        auto const loop_begin = m_loop_state.has_range ? m_loop_state.start : 0.0;
+        auto const loop_end = m_loop_state.has_range ? m_loop_state.end : m_duration;
+        auto const loop_len = loop_end - loop_begin;
+
+        if (time_in_seconds >= m_duration) {
+            if (m_looping) {
+                if (loop_end > m_duration && time_in_seconds < loop_end) {
+                    if (m_current_time < m_duration - Config::kEndEpsilon) {
+                        double const last_frame_time = std::max(0.0, m_duration - Config::kEndEpsilon);
+                        readFrameAtTime(last_frame_time);
+                        m_current_time = m_duration;
+                    }
+                    return true;
+                }
+                if (loop_len > 0.0)
+                    time_in_seconds = loop_begin + std::fmod(time_in_seconds - loop_begin, loop_len);
+                else
+                    time_in_seconds = std::fmod(time_in_seconds, m_duration);
+            } else {
+                if (m_current_time >= m_duration - Config::kEndEpsilon) {
+                    return true;
+                }
+                double const last_frame_time = std::max(0.0, m_duration - Config::kEndEpsilon);
+                bool const ok = readFrameAtTime(last_frame_time);
+                m_current_time = m_duration;
+                return ok;
+            }
+        } else if (time_in_seconds >= loop_end && m_looping && loop_len > 0.0) {
+            time_in_seconds = loop_begin + std::fmod(time_in_seconds - loop_begin, loop_len);
+        } else if (time_in_seconds < loop_begin) {
+            if (m_looping && loop_len > 0.0) {
+                double t = time_in_seconds - loop_begin;
+                t = loop_begin + std::fmod(t, loop_len);
+                if (t < loop_begin) t += loop_len;
+                time_in_seconds = t;
+            } else {
+                time_in_seconds = loop_begin;
+            }
+        } else if (time_in_seconds < 0.0) {
+            if (m_looping) {
+                if (loop_len > 0.0) {
+                    double t = std::fmod(time_in_seconds - loop_begin, loop_len);
+                    if (t < 0.0) t += loop_len;
+                    time_in_seconds = loop_begin + t;
+                } else {
+                    double t = std::fmod(time_in_seconds, m_duration);
+                    if (t < 0.0) t += m_duration;
+                    time_in_seconds = t;
+                }
+            } else {
+                time_in_seconds = 0.0;
+            }
+        }
+        
+        double const frame_tolerance = m_frame_interval * 0.5;
+        double const seek_threshold = (std::max)(0.1, 16.0 * m_frame_interval);
+        int const max_catch_up_frames = (std::min)(16, (std::max)(1, static_cast<int>(0.2 / m_frame_interval)));
+
+        bool const is_backward = (m_last_requested_time >= 0.0) && (time_in_seconds + Config::kBackwardTolerance < m_last_requested_time);
+        bool const large_jump = (m_current_time + seek_threshold < time_in_seconds);
+
+        m_last_requested_time = time_in_seconds;
+
+        if (is_backward || large_jump) {
+            return readFrameAtTime(time_in_seconds);
+        }
+
+        if (m_current_time + frame_tolerance >= time_in_seconds) {
+            return true;
+        }
+
+        for (int i = 0; i < max_catch_up_frames; ++i) {
+            if (!readNextFrame()) {
+                return false;
+            }
+            if (m_current_time + Config::kTimeEpsilon >= time_in_seconds) {
+                return true;
+            }
+        }
+
+        return readFrameAtTime(time_in_seconds);
+    }
+    
+    bool VideoDecoder::readNextFrame() {
+        if (!hasVideo()) {
+            return false;
+        }
+
+        HRESULT hr = S_OK;
+        win32::com_ptr<IMFSample> sample;
+        DWORD stream_flags = 0;
+        LONGLONG timestamp = 0;
+
+        hr = m_source_reader->ReadSample(
+            (DWORD)m_video_stream_index,
+            0,
+            nullptr,
+            &stream_flags,
+            &timestamp,
+            sample.put()
+        );
+
+        if (!win32::check_hresult_as_boolean(hr, "IMFSourceReader::ReadSample"sv)) {
+            return false;
+        }
+
+        if (stream_flags & MF_SOURCE_READERF_ENDOFSTREAM) {
+            m_current_time = m_duration;
+            return false;
+        }
+
+        if (!sample) {
+            return false;
+        }
+
+        m_current_time = timestamp / 10000000.0;
+        if (m_current_time > m_duration) {
+            m_current_time = m_duration;
+        }
+
+        return updateTextureFromSample(sample.get());
+    }
+    
+    bool VideoDecoder::readFrameAtTime(double time_in_seconds) {
+        if (!hasVideo()) {
+            return false;
+        }
+
+        if (!seek(time_in_seconds)) {
+            return false;
+        }
+
+        for (int i = 0; i < Config::kMaxDecodeFramesAfterSeek; ++i) {
+            if (!readNextFrame()) {
+                return false;
+            }
+            if (m_current_time + Config::kTimeEpsilon >= time_in_seconds) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    
+    void VideoDecoder::onGraphicsDeviceCreate() {
+        if (hasVideo()) {
+            createTexture();
+            if (m_output_format == OutputFormat::NV12) {
+                createVideoProcessor();
+            }
+        }
+    }
+    
+    void VideoDecoder::onGraphicsDeviceDestroy() {
+        close();
+    }
+
+    bool VideoDecoder::createTexture() {
+        if (!m_device || m_target_size.x == 0 || m_target_size.y == 0) {
+            return false;
+        }
+        
+        auto d3d_device = static_cast<ID3D11Device*>(m_device->getNativeDevice());
+        if (!d3d_device) {
+            return false;
+        }
+        
+        D3D11_TEXTURE2D_DESC desc = {};
+        desc.Width = m_target_size.x;
+        desc.Height = m_target_size.y;
+        desc.MipLevels = 1;
+        desc.ArraySize = 1;
+        desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+        desc.SampleDesc.Count = 1;
+        desc.SampleDesc.Quality = 0;
+        if (m_output_format == OutputFormat::NV12) {
+            desc.Usage = D3D11_USAGE_DEFAULT;
+            desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
+            desc.CPUAccessFlags = 0;
+        } else {
+            desc.Usage = D3D11_USAGE_DYNAMIC;
+            desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+            desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        }
+        desc.MiscFlags = 0;
+        
+        HRESULT hr = d3d_device->CreateTexture2D(&desc, nullptr, m_texture.put());
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11Device::CreateTexture2D"sv)) {
+            return false;
+        }
+        
+        D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
+        srv_desc.Format = desc.Format;
+        srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+        srv_desc.Texture2D.MipLevels = 1;
+        srv_desc.Texture2D.MostDetailedMip = 0;
+        
+        hr = d3d_device->CreateShaderResourceView(m_texture.get(), &srv_desc, m_shader_resource_view.put());
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11Device::CreateShaderResourceView"sv)) {
+            m_texture.reset();
+            return false;
+        }
+        
+        d3d_device->GetImmediateContext(m_device_context.put());
+        
+        win32::com_ptr<ID3D11Multithread> multithread;
+        if (SUCCEEDED(m_device_context->QueryInterface(IID_PPV_ARGS(multithread.put())))) {
+            multithread->SetMultithreadProtected(TRUE);
+        }
+        
+        return true;
+    }
+    
+    bool VideoDecoder::createVideoProcessor() {
+        if (!m_device || m_target_size.x == 0 || m_target_size.y == 0 || !m_texture) {
+            return false;
+        }
+        
+        auto d3d_device = static_cast<ID3D11Device*>(m_device->getNativeDevice());
+        if (!d3d_device) {
+            return false;
+        }
+        
+        HRESULT hr = d3d_device->QueryInterface(IID_PPV_ARGS(m_video_device.put()));
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11Device::QueryInterface(ID3D11VideoDevice)"sv)) {
+            return false;
+        }
+        
+        hr = m_device_context->QueryInterface(IID_PPV_ARGS(m_video_context.put()));
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11DeviceContext::QueryInterface(ID3D11VideoContext)"sv)) {
+            return false;
+        }
+        
+        D3D11_VIDEO_PROCESSOR_CONTENT_DESC content_desc = {};
+        content_desc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
+        UINT input_fps_num = m_frame_rate_num;
+        UINT input_fps_den = m_frame_rate_den;
+        if (input_fps_num == 0 || input_fps_den == 0) {
+            input_fps_num = 30;
+            input_fps_den = 1;
+        }
+        content_desc.InputFrameRate.Numerator = input_fps_num;
+        content_desc.InputFrameRate.Denominator = input_fps_den;
+        content_desc.InputWidth = m_video_size.x;
+        content_desc.InputHeight = m_video_size.y;
+        content_desc.OutputFrameRate.Numerator = input_fps_num;
+        content_desc.OutputFrameRate.Denominator = input_fps_den;
+        content_desc.OutputWidth = m_target_size.x;
+        content_desc.OutputHeight = m_target_size.y;
+        content_desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
+        
+        hr = m_video_device->CreateVideoProcessorEnumerator(&content_desc, m_video_processor_enum.put());
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11VideoDevice::CreateVideoProcessorEnumerator"sv)) {
+            return false;
+        }
+        
+        hr = m_video_device->CreateVideoProcessor(m_video_processor_enum.get(), 0, m_video_processor.put());
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11VideoDevice::CreateVideoProcessor"sv)) {
+            return false;
+        }
+        
+        Logger::info("[core] [VideoDecoder] Video Processor created for NV12->BGRA conversion");
+        return true;
+    }
+    
+    bool VideoDecoder::updateTextureFromNV12Sample(IMFSample* sample) {
+        if (!m_texture || !sample) return false;
+        return updateTextureFromNV12SampleTo(sample, m_texture.get());
+    }
+    
+    bool VideoDecoder::updateTextureFromNV12SampleTo(IMFSample* sample, ID3D11Texture2D* output_texture) {
+        if (!output_texture || !sample || !m_device_context || !m_video_device || !m_video_context
+            || !m_video_processor || !m_video_processor_enum) {
+            return false;
+        }
+        
+        DWORD buffer_count = 0;
+        HRESULT hr = sample->GetBufferCount(&buffer_count);
+        if (!win32::check_hresult_as_boolean(hr, "IMFSample::GetBufferCount"sv) || buffer_count == 0) {
+            return false;
+        }
+        
+        win32::com_ptr<IMFMediaBuffer> buffer;
+        if (!win32::check_hresult_as_boolean(
+            sample->GetBufferByIndex(0, buffer.put()),
+            "IMFSample::GetBufferByIndex"sv
+        )) {
+            return false;
+        }
+        
+        win32::com_ptr<IMFDXGIBuffer> dxgi_buffer;
+        if (!win32::check_hresult_as_boolean(
+            buffer->QueryInterface(IID_PPV_ARGS(dxgi_buffer.put())),
+            "IMFMediaBuffer::QueryInterface(IMFDXGIBuffer)"sv
+        )) {
+            Logger::error("[core] [VideoDecoder] NV12 sample does not have DXGI buffer");
+            return false;
+        }
+        
+        win32::com_ptr<ID3D11Texture2D> nv12_texture;
+        hr = dxgi_buffer->GetResource(IID_PPV_ARGS(nv12_texture.put()));
+        if (!win32::check_hresult_as_boolean(hr, "IMFDXGIBuffer::GetResource"sv) || !nv12_texture) {
+            return false;
+        }
+        
+        D3D11_TEXTURE2D_DESC nv12_desc{};
+        nv12_texture->GetDesc(&nv12_desc);
+        if (nv12_desc.Format != DXGI_FORMAT_NV12) {
+            Logger::error("[core] [VideoDecoder] Expected NV12 format, got {:x}", (uint32_t)nv12_desc.Format);
+            return false;
+        }
+        
+        UINT subresource_index = 0;
+        dxgi_buffer->GetSubresourceIndex(&subresource_index);
+        
+        D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC input_view_desc = {};
+        input_view_desc.FourCC = 0;
+        input_view_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
+        input_view_desc.Texture2D.ArraySlice = subresource_index / std::max(1u, nv12_desc.MipLevels);
+        input_view_desc.Texture2D.MipSlice = subresource_index % std::max(1u, nv12_desc.MipLevels);
+        
+        win32::com_ptr<ID3D11VideoProcessorInputView> input_view;
+        hr = m_video_device->CreateVideoProcessorInputView(
+            nv12_texture.get(), m_video_processor_enum.get(), &input_view_desc, input_view.put());
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11VideoDevice::CreateVideoProcessorInputView"sv)) {
+            input_view_desc.Texture2D.ArraySlice = 0;
+            input_view_desc.Texture2D.MipSlice = 0;
+            hr = m_video_device->CreateVideoProcessorInputView(
+                nv12_texture.get(), m_video_processor_enum.get(), &input_view_desc, input_view.put());
+        }
+        if (!win32::check_hresult_as_boolean(hr, "ID3D11VideoDevice::CreateVideoProcessorInputView (retry)"sv)) {
+            return false;
+        }
+        
+        D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC output_view_desc = {};
+        output_view_desc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D;
+        output_view_desc.Texture2D.MipSlice = 0;
+        
+        win32::com_ptr<ID3D11VideoProcessorOutputView> output_view;
+        if (!win32::check_hresult_as_boolean(
+            m_video_device->CreateVideoProcessorOutputView(
+                output_texture, m_video_processor_enum.get(), &output_view_desc, output_view.put()),
+            "ID3D11VideoDevice::CreateVideoProcessorOutputView"sv
+        )) {
+            return false;
+        }
+        
+        D3D11_VIDEO_PROCESSOR_STREAM stream = {};
+        stream.Enable = TRUE;
+        stream.OutputIndex = 0;
+        stream.InputFrameOrField = 0;
+        stream.PastFrames = 0;
+        stream.FutureFrames = 0;
+        stream.pInputSurface = input_view.get();
+        
+        if (!win32::check_hresult_as_boolean(
+            m_video_context->VideoProcessorBlt(m_video_processor.get(), output_view.get(), 0, 1, &stream),
+            "ID3D11VideoContext::VideoProcessorBlt"sv
+        )) {
+            return false;
+        }
+        
+        return true;
+    }
+    
+    bool VideoDecoder::updateTextureFromSample(IMFSample* sample) {
+        if (!m_texture || !sample || !m_device_context) {
+            return false;
+        }
+        std::lock_guard<std::mutex> lock(m_device_context_mutex);
+        if (m_output_format == OutputFormat::NV12 && m_video_processor) {
+            return updateTextureFromNV12SampleTo(sample, m_texture.get());
+        }
+        
+        DWORD buffer_count = 0;
+        HRESULT hr = sample->GetBufferCount(&buffer_count);
+        if (SUCCEEDED(hr) && buffer_count > 0) {
+            win32::com_ptr<IMFMediaBuffer> buffer;
+            hr = sample->GetBufferByIndex(0, buffer.put());
+            if (SUCCEEDED(hr)) {
+                win32::com_ptr<IMFDXGIBuffer> dxgi_buffer;
+                if (SUCCEEDED(buffer->QueryInterface(IID_PPV_ARGS(dxgi_buffer.put())))) {
+                    win32::com_ptr<ID3D11Texture2D> source_texture;
+                    hr = dxgi_buffer->GetResource(IID_PPV_ARGS(source_texture.put()));
+                    if (SUCCEEDED(hr) && source_texture) {
+                        D3D11_TEXTURE2D_DESC src_desc{};
+                        source_texture->GetDesc(&src_desc);
+                        D3D11_TEXTURE2D_DESC dst_desc{};
+                        m_texture->GetDesc(&dst_desc);
+                        if (src_desc.Width == dst_desc.Width && src_desc.Height == dst_desc.Height
+                            && src_desc.Format == dst_desc.Format) {
+                            m_device_context->CopyResource(m_texture.get(), source_texture.get());
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        
+        win32::com_ptr<IMFMediaBuffer> buffer;
+        if (!win32::check_hresult_as_boolean(
+            sample->ConvertToContiguousBuffer(buffer.put()),
+            "IMFSample::ConvertToContiguousBuffer"sv
+        )) {
+            return false;
+        }
+        
+        win32::com_ptr<IMF2DBuffer> buffer_2d;
+        LONG source_pitch = m_frame_pitch;
+        BYTE* src_data = nullptr;
+        bool using_2d_buffer = false;
+        
+        if (SUCCEEDED(buffer->QueryInterface(IID_PPV_ARGS(buffer_2d.put())))) {
+            if (SUCCEEDED(buffer_2d->Lock2D(&src_data, &source_pitch))) {
+                using_2d_buffer = true;
+            }
+        }
+        
+        if (!using_2d_buffer) {
+            DWORD max_length = 0, current_length = 0;
+            if (!win32::check_hresult_as_boolean(
+                buffer->Lock(&src_data, &max_length, &current_length),
+                "IMFMediaBuffer::Lock"sv
+            )) {
+                return false;
+            }
+        }
+        
+        D3D11_MAPPED_SUBRESOURCE mapped;
+        if (!win32::check_hresult_as_boolean(
+            m_device_context->Map(m_texture.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped),
+            "ID3D11DeviceContext::Map"sv
+        )) {
+            if (using_2d_buffer) {
+                buffer_2d->Unlock2D();
+            } else {
+                buffer->Unlock();
+            }
+            return false;
+        }
+        
+        uint8_t* dst = static_cast<uint8_t*>(mapped.pData);
+        const uint8_t* src = src_data;
+        const uint32_t src_w = m_video_size.x;
+        const uint32_t src_h = m_video_size.y;
+        const uint32_t dst_w = m_target_size.x;
+        const uint32_t dst_h = m_target_size.y;
+        const bool need_scale = (src_w != dst_w || src_h != dst_h);
+        
+        GUID format = GUID_NULL;
+        bool force_opaque_alpha = false;
+        if (m_media_type && SUCCEEDED(m_media_type->GetGUID(MF_MT_SUBTYPE, &format))) {
+            if (format == MFVideoFormat_RGB32) {
+                force_opaque_alpha = true;
+            }
+        }
+        
+        if (!m_first_texture_update_logged) [[unlikely]] {
+            Logger::info("[core] [VideoDecoder] Texture update: source={}x{} pitch={}, dest={}x{} pitch={}, force_alpha={}, scale={}",
+                        src_w, src_h, source_pitch, dst_w, dst_h, mapped.RowPitch, force_opaque_alpha, need_scale);
+            m_first_texture_update_logged = true;
+        }
+        
+        if (!need_scale) {
+            const size_t copy_size = m_frame_pitch;
+            if (!force_opaque_alpha) {
+                for (uint32_t y = 0; y < dst_h; ++y) {
+                    memcpy(dst, src, copy_size);
+                    dst += mapped.RowPitch;
+                    src += source_pitch;
+                }
+            } else {
+                for (uint32_t y = 0; y < dst_h; ++y) {
+                    memcpy(dst, src, copy_size);
+                    for (uint32_t x = 0; x < dst_w; ++x) {
+                        dst[x * 4 + 3] = 0xFF;
+                    }
+                    dst += mapped.RowPitch;
+                    src += source_pitch;
+                }
+            }
+        } else {
+            for (uint32_t y_dst = 0; y_dst < dst_h; ++y_dst) {
+                uint32_t y_src = (src_h > 1) ? (y_dst * src_h / dst_h) : 0;
+                if (y_src >= src_h) y_src = src_h - 1;
+                const uint8_t* row_src = src + static_cast<size_t>(y_src) * source_pitch;
+                for (uint32_t x_dst = 0; x_dst < dst_w; ++x_dst) {
+                    uint32_t x_src = (src_w > 1) ? (x_dst * src_w / dst_w) : 0;
+                    if (x_src >= src_w) x_src = src_w - 1;
+                    const uint8_t* px = row_src + static_cast<size_t>(x_src) * 4;
+                    dst[0] = px[0];
+                    dst[1] = px[1];
+                    dst[2] = px[2];
+                    dst[3] = force_opaque_alpha ? 0xFF : px[3];
+                    dst += 4;
+                }
+                dst += mapped.RowPitch - static_cast<size_t>(dst_w) * 4;
+            }
+        }
+        
+        m_device_context->Unmap(m_texture.get(), 0);
+        
+        if (using_2d_buffer) {
+            buffer_2d->Unlock2D();
+        } else {
+            buffer->Unlock();
+        }
+        
+        return true;
+    }
+}
diff --git a/engine/graphics/d3d11/VideoDecoder.hpp b/engine/graphics/d3d11/VideoDecoder.hpp
new file mode 100644
index 000000000..e32650a99
--- /dev/null
+++ b/engine/graphics/d3d11/VideoDecoder.hpp
@@ -0,0 +1,150 @@
+#pragma once
+#include "core/VideoDecoder.hpp"
+#include "core/GraphicsDevice.hpp"
+#include "core/SmartReference.hpp"
+#include "core/implement/ReferenceCounted.hpp"
+#include "d3d11/VideoDecoderConfig.hpp"
+#include "d3d11/pch.h"
+#include <mfapi.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+#include <mutex>
+#include <string>
+
+namespace core {
+    class VideoDecoder final :
+        public implement::ReferenceCounted<IVideoDecoder>,
+        public IGraphicsDeviceEventListener {
+    private:
+        enum class OutputFormat {
+            ARGB32,
+            RGB32,
+            NV12
+        };
+
+        struct LoopState {
+            bool has_range{ false };
+            double start{ 0.0 };
+            double end{ 0.0 };
+        };
+        
+    public:
+        // IVideoDecoder
+
+        bool open(StringView path) override;
+        bool open(StringView path, VideoOpenOptions const& options) override;
+        void close() override;
+
+        bool hasVideo() const noexcept override { return m_source_reader.get() != nullptr; }
+
+        Vector2U getVideoSize() const noexcept override { return m_target_size; }
+        double getDuration() const noexcept override { return m_duration; }
+        double getCurrentTime() const noexcept override { return m_current_time; }
+        double getFrameInterval() const noexcept override { return m_frame_interval; }
+
+        bool seek(double time_in_seconds) override;
+
+        void setLooping(bool loop) override { m_looping = loop; }
+        bool isLooping() const noexcept override { return m_looping; }
+        void setLoopRange(double end_sec, double duration_sec) override;
+        void getLoopRange(double* end_sec, double* duration_sec) const noexcept override;
+
+        bool updateToTime(double time_in_seconds) override;
+        void* getNativeTexture() const noexcept override { return m_texture.get(); }
+        void* getNativeShaderResourceView() const noexcept override { return m_shader_resource_view.get(); }
+
+        uint32_t getVideoStreamIndex() const noexcept override { return m_video_stream_index; }
+        void getVideoStreams(void (*callback)(VideoStreamInfo const&, void*), void* userdata) const override;
+        void getAudioStreams(void (*callback)(AudioStreamInfo const&, void*), void* userdata) const override;
+        bool reopen(VideoOpenOptions const& options) override;
+        VideoOpenOptions getLastOpenOptions() const noexcept override { return m_last_open_options; }
+        std::string_view getLastOpenPath() const noexcept override { return m_last_open_path; }
+
+        // IGraphicsDeviceEventListener
+
+        void onGraphicsDeviceCreate() override;
+        void onGraphicsDeviceDestroy() override;
+
+        // VideoDecoder
+
+        VideoDecoder();
+        VideoDecoder(VideoDecoder const&) = delete;
+        VideoDecoder(VideoDecoder&&) = delete;
+        ~VideoDecoder();
+
+        VideoDecoder& operator=(VideoDecoder const&) = delete;
+        VideoDecoder& operator=(VideoDecoder&&) = delete;
+
+        bool initialize(IGraphicsDevice* device);
+
+    private:
+        // File loading
+        bool loadVideoFile(StringView path);
+        
+        // Hardware acceleration setup
+        bool configureHardwareAcceleration();
+        
+        // Stream selection
+        bool selectVideoStream(uint32_t preferred_index);
+        
+        // Output format negotiation
+        bool negotiateOutputFormat(VideoOpenOptions const& options);
+        void logNativeFormat(IMFMediaType* partial_media_type);
+        void enumerateOutputFormats(IMFMediaType* partial_media_type);
+        bool configureOutputResolution(IMFMediaType* partial_media_type, IMFMediaType* media_type, VideoOpenOptions const& options);
+        bool trySetOutputFormat(IMFMediaType* partial_media_type, IMFMediaType* media_type);
+        bool tryNV12Format(IMFMediaType* partial_media_type, IMFMediaType* media_type);
+        bool retryWithOriginalResolution(IMFMediaType* partial_media_type, IMFMediaType* media_type, HRESULT& hr, bool& succeeded);
+        void logFinalFormat();
+        
+        // Property extraction
+        bool extractVideoProperties();
+        
+        // Resource creation
+        bool createResources();
+        bool createTexture();
+        bool createVideoProcessor();
+        
+        // Frame loading
+        bool loadFirstFrame();
+        
+        // Frame decoding
+        bool updateTextureFromSample(IMFSample* sample);
+        bool updateTextureFromNV12Sample(IMFSample* sample);
+        bool updateTextureFromNV12SampleTo(IMFSample* sample, ID3D11Texture2D* output_texture);
+        bool readNextFrame();
+        bool readFrameAtTime(double time_in_seconds);
+
+        std::mutex m_device_context_mutex;
+        SmartReference<IGraphicsDevice> m_device;
+        win32::com_ptr<ID3D11Texture2D> m_texture;
+        win32::com_ptr<ID3D11ShaderResourceView> m_shader_resource_view;
+        win32::com_ptr<ID3D11DeviceContext> m_device_context;
+        
+        win32::com_ptr<IMFSourceReader> m_source_reader;
+        win32::com_ptr<IMFByteStream> m_byte_stream;
+        win32::com_ptr<IMFMediaType> m_media_type;
+        
+        win32::com_ptr<ID3D11VideoDevice> m_video_device;
+        win32::com_ptr<ID3D11VideoContext> m_video_context;
+        win32::com_ptr<ID3D11VideoProcessor> m_video_processor;
+        win32::com_ptr<ID3D11VideoProcessorEnumerator> m_video_processor_enum;
+        OutputFormat m_output_format{ OutputFormat::ARGB32 };
+        Vector2U m_video_size{};
+        Vector2U m_target_size{};
+        double m_duration{ 0.0 };
+        double m_current_time{ 0.0 };
+        double m_last_requested_time{ -1.0 };
+        double m_frame_interval{ 1.0 / VideoDecoderConfig::kDefaultFrameRateNum };
+        uint32_t m_frame_rate_num{ VideoDecoderConfig::kDefaultFrameRateNum };
+        uint32_t m_frame_rate_den{ VideoDecoderConfig::kDefaultFrameRateDen };
+        uint32_t m_frame_pitch{ 0 };
+        uint32_t m_video_stream_index{ 0 };
+        bool m_looping{ false };
+        LoopState m_loop_state{};
+        std::string m_last_open_path;
+        VideoOpenOptions m_last_open_options;
+        bool m_initialized{ false };
+        bool m_first_texture_update_logged{ false };
+    };
+}
diff --git a/engine/graphics/d3d11/VideoDecoderConfig.hpp b/engine/graphics/d3d11/VideoDecoderConfig.hpp
new file mode 100644
index 000000000..73a197e4d
--- /dev/null
+++ b/engine/graphics/d3d11/VideoDecoderConfig.hpp
@@ -0,0 +1,29 @@
+#pragma once
+#include <cstdint>
+
+namespace core {
+    // Configuration constants for VideoDecoder
+    // Using struct with static constexpr for better encapsulation and clarity
+    struct VideoDecoderConfig {
+        VideoDecoderConfig() = delete;  // Prevent instantiation
+        
+        // Maximum number of streams to enumerate (video/audio)
+        static constexpr uint32_t kMaxStreams = 16;
+        
+        // Maximum number of frames to decode after seeking to reach the requested timestamp
+        static constexpr int kMaxDecodeFramesAfterSeek = 360;
+        
+        // Time comparison epsilon for frame timing
+        static constexpr double kTimeEpsilon = 1e-4;
+        
+        // Tolerance for detecting backward seeks
+        static constexpr double kBackwardTolerance = 1.0 / 120.0;
+        
+        // Epsilon for detecting end of video
+        static constexpr double kEndEpsilon = 1e-6;
+        
+        // Default frame rate if not available from media
+        static constexpr uint32_t kDefaultFrameRateNum = 30;
+        static constexpr uint32_t kDefaultFrameRateDen = 1;
+    };
+}
diff --git a/engine/graphics/d3d11/VideoDecoderImpl.cpp b/engine/graphics/d3d11/VideoDecoderImpl.cpp
new file mode 100644
index 000000000..549d93c73
--- /dev/null
+++ b/engine/graphics/d3d11/VideoDecoderImpl.cpp
@@ -0,0 +1,483 @@
+// VideoDecoder implementation - helper functions
+// This file contains the refactored open() function split into logical parts
+
+#include "d3d11/VideoDecoder.hpp"
+#include "d3d11/VideoDecoderConfig.hpp"
+#include "core/Configuration.hpp"
+#include "core/FileSystem.hpp"
+#include "core/Logger.hpp"
+#include "utf8.hpp"
+#include <wil/resource.h>
+#include <shlwapi.h>
+
+namespace core {
+    using std::string_view_literals::operator ""sv;
+    using Config = VideoDecoderConfig;
+
+    bool VideoDecoder::loadVideoFile(StringView path) {
+        SmartReference<IData> file_data;
+        if (!FileSystemManager::readFile(path, file_data.put())) {
+            Logger::error("[core] [VideoDecoder] Failed to read video file: {}", path);
+            return false;
+        }
+        
+        win32::com_ptr<IStream> mem_stream;
+        mem_stream.attach(static_cast<IStream*>(SHCreateMemStream(
+            static_cast<BYTE const*>(file_data->data()),
+            static_cast<UINT>(file_data->size()))));
+        if (!mem_stream) {
+            Logger::error("[core] [VideoDecoder] Failed to create memory stream");
+            return false;
+        }
+        
+        win32::com_ptr<IMFByteStream> byte_stream;
+        if (!win32::check_hresult_as_boolean(
+            MFCreateMFByteStreamOnStream(mem_stream.get(), byte_stream.put()),
+            "MFCreateMFByteStreamOnStream"sv
+        )) {
+            return false;
+        }
+        
+        m_byte_stream = std::move(byte_stream);
+        return true;
+    }
+
+    bool VideoDecoder::configureHardwareAcceleration() {
+        auto d3d_device = static_cast<ID3D11Device*>(m_device->getNativeDevice());
+        if (!d3d_device) {
+            Logger::error("[core] [VideoDecoder] Failed to get D3D11 device");
+            return false;
+        }
+        
+        win32::com_ptr<ID3D11DeviceContext> temp_context;
+        d3d_device->GetImmediateContext(temp_context.put());
+        if (temp_context) {
+            win32::com_ptr<ID3D11Multithread> multithread;
+            if (SUCCEEDED(temp_context->QueryInterface(IID_PPV_ARGS(multithread.put())))) {
+                multithread->SetMultithreadProtected(TRUE);
+                Logger::info("[core] [VideoDecoder] Enabled D3D11 multithread protection");
+            } else {
+                Logger::warn("[core] [VideoDecoder] Failed to enable D3D11 multithread protection");
+            }
+        }
+        
+        win32::com_ptr<ID3D11VideoDevice> video_device;
+        HRESULT hr = d3d_device->QueryInterface(IID_PPV_ARGS(video_device.put()));
+        if (win32::check_hresult_as_boolean(hr, "ID3D11Device::QueryInterface(ID3D11VideoDevice)"sv)) {
+            Logger::info("[core] [VideoDecoder] D3D11 device supports video decoding");
+        } else {
+            Logger::warn("[core] [VideoDecoder] D3D11 device does not support video decoding");
+        }
+        
+        win32::com_ptr<IMFAttributes> attributes;
+        if (!win32::check_hresult_as_boolean(
+            MFCreateAttributes(attributes.put(), 3),
+            "MFCreateAttributes"sv
+        )) {
+            return false;
+        }
+        
+        win32::com_ptr<IMFDXGIDeviceManager> dxgi_device_manager;
+        UINT dxgi_reset_token = 0;
+        bool use_hardware_accel = false;
+        
+        bool const allow_hw_decode = core::ConfigurationLoader::getInstance().getGraphicsSystem().isAllowHardwareVideoDecode();
+        hr = MFCreateDXGIDeviceManager(&dxgi_reset_token, dxgi_device_manager.put());
+        if (win32::check_hresult_as_boolean(hr, "MFCreateDXGIDeviceManager"sv)) {
+            hr = dxgi_device_manager->ResetDevice(d3d_device, dxgi_reset_token);
+            if (win32::check_hresult_as_boolean(hr, "IMFDXGIDeviceManager::ResetDevice"sv)) {
+                if (video_device && allow_hw_decode) {
+                    hr = attributes->SetUnknown(MF_SOURCE_READER_D3D_MANAGER, dxgi_device_manager.get());
+                    if (win32::check_hresult_as_boolean(hr, "IMFAttributes::SetUnknown(MF_SOURCE_READER_D3D_MANAGER)"sv)) {
+                        use_hardware_accel = true;
+                        Logger::info("[core] [VideoDecoder] Attempting D3D11 hardware acceleration (IMFDXGIDeviceManager)");
+                    }
+                } else if (!allow_hw_decode) {
+                    Logger::info("[core] [VideoDecoder] Hardware video decode disabled by config");
+                } else {
+                    Logger::warn("[core] [VideoDecoder] Skipping hardware acceleration - device does not support video");
+                }
+            }
+        }
+        
+        if (!use_hardware_accel) {
+            win32::check_hresult(
+                attributes->SetUINT32(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, TRUE),
+                "IMFAttributes::SetUINT32(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS)"sv
+            );
+            
+            win32::check_hresult(
+                attributes->SetUINT32(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, TRUE),
+                "IMFAttributes::SetUINT32(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING)"sv
+            );
+        }
+        
+        hr = MFCreateSourceReaderFromByteStream(m_byte_stream.get(), attributes.get(), m_source_reader.put());
+        if (!win32::check_hresult_as_boolean(hr, "MFCreateSourceReaderFromByteStream"sv)) {
+            if (use_hardware_accel && hr == E_INVALIDARG) {
+                Logger::warn("[core] [VideoDecoder] Hardware acceleration failed, retrying without D3D manager");
+                attributes->DeleteItem(MF_SOURCE_READER_D3D_MANAGER);
+                dxgi_device_manager.reset();
+                use_hardware_accel = false;
+                
+                hr = MFCreateSourceReaderFromByteStream(m_byte_stream.get(), attributes.get(), m_source_reader.put());
+            }
+            
+            if (!win32::check_hresult_as_boolean(hr, "MFCreateSourceReaderFromByteStream (retry)"sv)) {
+                return false;
+            } else {
+                Logger::info("[core] [VideoDecoder] Falling back to software decoding");
+            }
+        } else if (use_hardware_accel) {
+            Logger::info("[core] [VideoDecoder] Using D3D11 hardware acceleration (IMFDXGIDeviceManager)");
+        }
+        
+        return true;
+    }
+
+    bool VideoDecoder::selectVideoStream(uint32_t preferred_index) {
+        m_video_stream_index = preferred_index;
+        if (m_video_stream_index == static_cast<uint32_t>(-1)) {
+            for (DWORD i = 0; i < Config::kMaxStreams; ++i) {
+                win32::com_ptr<IMFMediaType> mt;
+                if (FAILED(m_source_reader->GetNativeMediaType(i, 0, mt.put()))) continue;
+                GUID major = GUID_NULL;
+                if (FAILED(mt->GetGUID(MF_MT_MAJOR_TYPE, &major)) || major != MFMediaType_Video) continue;
+                m_video_stream_index = i;
+                Logger::info("[core] [VideoDecoder] Auto-selected video stream index {}", (unsigned)i);
+                break;
+            }
+            if (m_video_stream_index == static_cast<uint32_t>(-1)) {
+                Logger::error("[core] [VideoDecoder] No video stream found in file");
+                return false;
+            }
+        }
+        
+        for (DWORD i = 0; i < Config::kMaxStreams; ++i) {
+            BOOL const select = (i == m_video_stream_index);
+            m_source_reader->SetStreamSelection(i, select);
+        }
+        
+        return true;
+    }
+
+    bool VideoDecoder::negotiateOutputFormat(VideoOpenOptions const& options) {
+        win32::com_ptr<IMFMediaType> partial_media_type;
+        HRESULT hr = m_source_reader->GetNativeMediaType((DWORD)m_video_stream_index, 0, partial_media_type.put());
+        if (!win32::check_hresult_as_boolean(hr, "IMFSourceReader::GetNativeMediaType"sv)) {
+            Logger::warn("[core] [VideoDecoder] Failed to get native media type, trying current type");
+            hr = m_source_reader->GetCurrentMediaType((DWORD)m_video_stream_index, partial_media_type.put());
+            win32::check_hresult(hr, "IMFSourceReader::GetCurrentMediaType"sv);
+        }
+        
+        logNativeFormat(partial_media_type.get());
+        
+        win32::com_ptr<IMFMediaType> media_type;
+        if (!win32::check_hresult_as_boolean(
+            MFCreateMediaType(media_type.put()),
+            "MFCreateMediaType"sv
+        )) {
+            return false;
+        }
+        
+        if (!win32::check_hresult_as_boolean(
+            media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
+            "IMFMediaType::SetGUID(MF_MT_MAJOR_TYPE)"sv
+        )) {
+            return false;
+        }
+        
+        enumerateOutputFormats(partial_media_type.get());
+        
+        if (!configureOutputResolution(partial_media_type.get(), media_type.get(), options)) {
+            return false;
+        }
+        
+        if (!trySetOutputFormat(partial_media_type.get(), media_type.get())) {
+            return false;
+        }
+        
+        if (!win32::check_hresult_as_boolean(
+            m_source_reader->GetCurrentMediaType((DWORD)m_video_stream_index, m_media_type.put()),
+            "IMFSourceReader::GetCurrentMediaType"sv
+        )) {
+            return false;
+        }
+        
+        logFinalFormat();
+        
+        return true;
+    }
+
+    void VideoDecoder::logNativeFormat(IMFMediaType* partial_media_type) {
+        if (!partial_media_type) return;
+        
+        GUID native_subtype = GUID_NULL;
+        if (SUCCEEDED(partial_media_type->GetGUID(MF_MT_SUBTYPE, &native_subtype))) {
+            const char* format_name = "Unknown";
+            if (native_subtype == MFVideoFormat_NV12) {
+                format_name = "NV12";
+            } else if (native_subtype == MFVideoFormat_ARGB32) {
+                format_name = "ARGB32";
+            } else if (native_subtype == MFVideoFormat_RGB32) {
+                format_name = "RGB32";
+            }
+            Logger::info("[core] [VideoDecoder] Native hardware decoder format: {} ({:08x}-{:04x}-{:04x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x})",
+                format_name,
+                native_subtype.Data1, native_subtype.Data2, native_subtype.Data3,
+                native_subtype.Data4[0], native_subtype.Data4[1],
+                native_subtype.Data4[2], native_subtype.Data4[3],
+                native_subtype.Data4[4], native_subtype.Data4[5],
+                native_subtype.Data4[6], native_subtype.Data4[7]);
+        }
+    }
+
+    void VideoDecoder::enumerateOutputFormats(IMFMediaType* partial_media_type) {
+        if (!partial_media_type) return;
+        
+        GUID native_subtype = GUID_NULL;
+        if (SUCCEEDED(partial_media_type->GetGUID(MF_MT_SUBTYPE, &native_subtype))) {
+            if (native_subtype == MFVideoFormat_H264) {
+                Logger::info("[core] [VideoDecoder] Hardware decoder outputs compressed format, enumerating supported output formats");
+                for (DWORD i = 0; ; ++i) {
+                    win32::com_ptr<IMFMediaType> output_type;
+                    if (!win32::check_hresult_as_boolean(
+                        m_source_reader->GetNativeMediaType((DWORD)m_video_stream_index, i, output_type.put()),
+                        "IMFSourceReader::GetNativeMediaType"sv
+                    )) {
+                        break;
+                    }
+                    GUID output_subtype = GUID_NULL;
+                    if (SUCCEEDED(output_type->GetGUID(MF_MT_SUBTYPE, &output_subtype))) {
+                        const char* format_name = "Unknown";
+                        if (output_subtype == MFVideoFormat_NV12) format_name = "NV12";
+                        else if (output_subtype == MFVideoFormat_ARGB32) format_name = "ARGB32";
+                        else if (output_subtype == MFVideoFormat_RGB32) format_name = "RGB32";
+                        Logger::info("[core] [VideoDecoder]   Output format {}: {}", i, format_name);
+                    }
+                }
+            }
+        }
+    }
+
+    bool VideoDecoder::configureOutputResolution(IMFMediaType* partial_media_type, IMFMediaType* media_type, VideoOpenOptions const& options) {
+        if (!partial_media_type) return true;
+        
+        UINT32 width = 0, height = 0;
+        if (SUCCEEDED(MFGetAttributeSize(partial_media_type, MF_MT_FRAME_SIZE, &width, &height))) {
+            UINT32 out_w = options.output_width > 0 ? options.output_width : width;
+            UINT32 out_h = options.output_height > 0 ? options.output_height : height;
+            if (out_w != width || out_h != height) {
+                Logger::info("[core] [VideoDecoder] Requesting output resolution: {}x{} (original: {}x{})", out_w, out_h, width, height);
+            }
+            HRESULT hr = MFSetAttributeSize(media_type, MF_MT_FRAME_SIZE, out_w, out_h);
+            if (!win32::check_hresult_as_boolean(hr, "MFSetAttributeSize"sv)) {
+                Logger::warn("[core] [VideoDecoder] Failed to set output resolution {}x{}, using original {}x{}", 
+                    out_w, out_h, width, height);
+                win32::check_hresult(
+                    MFSetAttributeSize(media_type, MF_MT_FRAME_SIZE, width, height),
+                    "MFSetAttributeSize (original)"sv
+                );
+            }
+        }
+        
+        MFVideoArea area = {};
+        if (SUCCEEDED(partial_media_type->GetBlob(MF_MT_GEOMETRIC_APERTURE, (UINT8*)&area, sizeof(area), nullptr))) {
+            media_type->SetBlob(MF_MT_GEOMETRIC_APERTURE, (UINT8*)&area, sizeof(area));
+        }
+        
+        return true;
+    }
+
+    bool VideoDecoder::trySetOutputFormat(IMFMediaType* partial_media_type, IMFMediaType* media_type) {
+        if (!win32::check_hresult_as_boolean(
+            media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_ARGB32),
+            "IMFMediaType::SetGUID(MFVideoFormat_ARGB32)"sv
+        )) {
+            return false;
+        }
+        
+        HRESULT hr = m_source_reader->SetCurrentMediaType((DWORD)m_video_stream_index, nullptr, media_type);
+        
+        if (!win32::check_hresult_as_boolean(hr, "IMFSourceReader::SetCurrentMediaType(ARGB32)"sv)) {
+            Logger::info("[core] [VideoDecoder] ARGB32 not supported, trying RGB32");
+            if (!win32::check_hresult_as_boolean(
+                media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32),
+                "IMFMediaType::SetGUID(MFVideoFormat_RGB32)"sv
+            )) {
+                return false;
+            }
+            hr = m_source_reader->SetCurrentMediaType((DWORD)m_video_stream_index, nullptr, media_type);
+            
+            if (!win32::check_hresult_as_boolean(hr, "IMFSourceReader::SetCurrentMediaType(RGB32)"sv)) {
+                return tryNV12Format(partial_media_type, media_type);
+            }
+        }
+        
+        return true;
+    }
+
+    bool VideoDecoder::tryNV12Format(IMFMediaType* partial_media_type, IMFMediaType* media_type) {
+        Logger::info("[core] [VideoDecoder] RGB32 not supported, trying NV12 (hardware native)");
+        if (!win32::check_hresult_as_boolean(
+            media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12),
+            "IMFMediaType::SetGUID(MFVideoFormat_NV12)"sv
+        )) {
+            return false;
+        }
+        
+        HRESULT hr = m_source_reader->SetCurrentMediaType((DWORD)m_video_stream_index, nullptr, media_type);
+        bool succeeded_via_retry = false;
+        
+        if (!win32::check_hresult_as_boolean(hr, "IMFSourceReader::SetCurrentMediaType(NV12)"sv)) {
+            if (!retryWithOriginalResolution(partial_media_type, media_type, hr, succeeded_via_retry)) {
+                return false;
+            }
+        } else if (!succeeded_via_retry) {
+            m_output_format = OutputFormat::NV12;
+            Logger::info("[core] [VideoDecoder] Using NV12 output, will convert to BGRA via Video Processor");
+        }
+        
+        return true;
+    }
+
+    bool VideoDecoder::retryWithOriginalResolution(IMFMediaType* partial_media_type, IMFMediaType* media_type, HRESULT& hr, bool& succeeded) {
+        UINT32 req_w = 0, req_h = 0;
+        MFGetAttributeSize(media_type, MF_MT_FRAME_SIZE, &req_w, &req_h);
+        UINT32 orig_w = 0, orig_h = 0;
+        bool can_retry_original = partial_media_type
+            && SUCCEEDED(MFGetAttributeSize(partial_media_type, MF_MT_FRAME_SIZE, &orig_w, &orig_h))
+            && (req_w != orig_w || req_h != orig_h);
+            
+        if (can_retry_original) {
+            Logger::info("[core] [VideoDecoder] Scaled resolution {}x{} not supported by decoder, retrying with original {}x{}",
+                req_w, req_h, orig_w, orig_h);
+            hr = MFSetAttributeSize(media_type, MF_MT_FRAME_SIZE, orig_w, orig_h);
+            if (SUCCEEDED(hr)) {
+                hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_ARGB32);
+                if (SUCCEEDED(hr)) {
+                    hr = m_source_reader->SetCurrentMediaType((DWORD)m_video_stream_index, nullptr, media_type);
+                }
+                if (!win32::check_hresult_as_boolean(hr, "SetCurrentMediaType(ARGB32, original)"sv)) {
+                    hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32);
+                    if (SUCCEEDED(hr)) {
+                        hr = m_source_reader->SetCurrentMediaType((DWORD)m_video_stream_index, nullptr, media_type);
+                    }
+                }
+                if (!win32::check_hresult_as_boolean(hr, "SetCurrentMediaType(RGB32, original)"sv)) {
+                    hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12);
+                    if (SUCCEEDED(hr)) {
+                        hr = m_source_reader->SetCurrentMediaType((DWORD)m_video_stream_index, nullptr, media_type);
+                    }
+                    if (win32::check_hresult_as_boolean(hr, "SetCurrentMediaType(NV12, original)"sv)) {
+                        m_output_format = OutputFormat::NV12;
+                        Logger::info("[core] [VideoDecoder] Using NV12 output (original resolution), will convert to BGRA via Video Processor");
+                    }
+                }
+                if (win32::check_hresult_as_boolean(hr, "SetCurrentMediaType (retry)"sv)) {
+                    succeeded = true;
+                }
+            }
+        }
+        
+        if (!win32::check_hresult_as_boolean(hr, "SetCurrentMediaType (final)"sv)) {
+            UINT32 err_w = 0, err_h = 0;
+            MFGetAttributeSize(media_type, MF_MT_FRAME_SIZE, &err_w, &err_h);
+            Logger::error("[core] [VideoDecoder] Failed to set media type (tried ARGB32, RGB32, NV12) at resolution {}x{}",
+                err_w, err_h);
+            Logger::error("[core] [VideoDecoder] This may be due to unsupported output resolution or codec format");
+            return false;
+        }
+        
+        return true;
+    }
+
+    void VideoDecoder::logFinalFormat() {
+        GUID subtype = GUID_NULL;
+        HRESULT hr = m_media_type->GetGUID(MF_MT_SUBTYPE, &subtype);
+        if (SUCCEEDED(hr)) {
+            if (subtype == MFVideoFormat_ARGB32) {
+                Logger::info("[core] [VideoDecoder] Using video format: ARGB32 (native BGRA)");
+            } else if (subtype == MFVideoFormat_RGB32) {
+                Logger::info("[core] [VideoDecoder] Using video format: RGB32");
+            } else if (subtype == MFVideoFormat_NV12) {
+                Logger::info("[core] [VideoDecoder] Using video format: NV12 (hardware native, GPU conversion to BGRA)");
+            } else {
+                Logger::warn("[core] [VideoDecoder] Using unknown video format, display may be incorrect");
+            }
+        }
+    }
+
+    bool VideoDecoder::extractVideoProperties() {
+        UINT32 width = 0, height = 0;
+        if (!win32::check_hresult_as_boolean(
+            MFGetAttributeSize(m_media_type.get(), MF_MT_FRAME_SIZE, &width, &height),
+            "MFGetAttributeSize(MF_MT_FRAME_SIZE)"sv
+        )) {
+            return false;
+        }
+        
+        m_video_size = Vector2U{ width, height };
+        m_target_size = m_video_size;
+        
+        wil::unique_prop_variant var;
+        if (SUCCEEDED(m_source_reader->GetPresentationAttribute((DWORD)MF_SOURCE_READER_MEDIASOURCE, MF_PD_DURATION, &var))) {
+            m_duration = var.hVal.QuadPart / 10000000.0;
+        }
+        
+        UINT32 rate_num = 0, rate_den = 0;
+        for (DWORD i = 0; ; ++i) {
+            win32::com_ptr<IMFMediaType> mt;
+            if (!win32::check_hresult_as_boolean(
+                m_source_reader->GetNativeMediaType((DWORD)m_video_stream_index, i, mt.put()),
+                "IMFSourceReader::GetNativeMediaType"sv
+            )) {
+                break;
+            }
+            if (SUCCEEDED(MFGetAttributeRatio(mt.get(), MF_MT_FRAME_RATE, &rate_num, &rate_den)) && rate_den > 0 && rate_num > 0)
+                break;
+        }
+        if (rate_den == 0 || rate_num == 0) {
+            HRESULT hr = MFGetAttributeRatio(m_media_type.get(), MF_MT_FRAME_RATE, &rate_num, &rate_den);
+        }
+        if (rate_den > 0 && rate_num > 0) {
+            m_frame_interval = static_cast<double>(rate_den) / static_cast<double>(rate_num);
+            m_frame_rate_num = rate_num;
+            m_frame_rate_den = rate_den;
+            Logger::info("[core] [VideoDecoder] Frame rate: {} / {} (= {:.2f} fps)", rate_num, rate_den, 1.0 / m_frame_interval);
+        } else {
+            m_frame_rate_num = Config::kDefaultFrameRateNum;
+            m_frame_rate_den = Config::kDefaultFrameRateDen;
+            m_frame_interval = 1.0 / Config::kDefaultFrameRateNum;
+            Logger::warn("[core] [VideoDecoder] MF_MT_FRAME_RATE not available, assuming 30 fps");
+        }
+        
+        return true;
+    }
+
+    bool VideoDecoder::createResources() {
+        if (!createTexture()) {
+            close();
+            return false;
+        }
+        
+        if (m_output_format == OutputFormat::NV12 && !createVideoProcessor()) {
+            Logger::error("[core] [VideoDecoder] Failed to create Video Processor for NV12 conversion");
+            close();
+            return false;
+        }
+        
+        m_frame_pitch = m_video_size.x * 4;
+        return true;
+    }
+
+    bool VideoDecoder::loadFirstFrame() {
+        m_current_time = 0.0;
+        m_last_requested_time = -1.0;
+        
+        bool first_frame_loaded = readFrameAtTime(0.0);
+        Logger::info("[core] [VideoDecoder] First frame loaded: {}", first_frame_loaded);
+        return true;
+    }
+
+} // namespace core
diff --git a/engine/graphics/d3d11/VideoTexture.cpp b/engine/graphics/d3d11/VideoTexture.cpp
new file mode 100644
index 000000000..079a4b17d
--- /dev/null
+++ b/engine/graphics/d3d11/VideoTexture.cpp
@@ -0,0 +1,127 @@
+#include "d3d11/VideoTexture.hpp"
+#include "d3d11/VideoDecoder.hpp"
+#include "d3d11/GraphicsDevice.hpp"
+#include "core/Logger.hpp"
+#include "core/SmartReference.hpp"
+
+namespace core {
+    VideoTexture::VideoTexture() = default;
+    
+    VideoTexture::~VideoTexture() {
+        if (m_initialized && static_cast<bool>(m_device)) {
+            m_device->removeEventListener(this);
+        }
+    }
+    
+    bool VideoTexture::initialize(IGraphicsDevice* device, StringView path) {
+        return initialize(device, path, VideoOpenOptions{});
+    }
+
+    bool VideoTexture::initialize(IGraphicsDevice* device, StringView path, VideoOpenOptions const& options) {
+        if (!device) {
+            Logger::error("[core] [VideoTexture] Invalid device");
+            return false;
+        }
+        
+        m_device = device;
+        
+        SmartReference<VideoDecoder> decoder;
+        decoder.attach(new VideoDecoder);
+        if (!decoder->initialize(device)) {
+            Logger::error("[core] [VideoTexture] Failed to initialize video decoder");
+            return false;
+        }
+        
+        if (!decoder->open(path, options)) {
+            Logger::error("[core] [VideoTexture] Failed to open video file: {}", path);
+            return false;
+        }
+        
+        m_decoder.attach(decoder.detach());
+        m_premultiplied_alpha = options.premultiplied_alpha;
+        m_initialized = true;
+        m_device->addEventListener(this);
+
+        Logger::info("[core] [VideoTexture] Created video texture from: {}", path);
+        return true;
+    }
+
+    
+    void* VideoTexture::getNativeResource() const noexcept {
+        if (m_decoder) {
+            return m_decoder->getNativeTexture(); // ID3D11Texture2D*
+        }
+        return nullptr;
+    }
+    
+    void* VideoTexture::getNativeView() const noexcept {
+        if (m_decoder) {
+            return m_decoder->getNativeShaderResourceView(); // ID3D11ShaderResourceView*
+        }
+        return nullptr;
+    }
+    
+    Vector2U VideoTexture::getSize() const noexcept {
+        if (m_decoder) {
+            return m_decoder->getVideoSize();
+        }
+        return Vector2U{};
+    }
+    
+    bool VideoTexture::setSize(Vector2U) {
+        Logger::warn("[core] [VideoTexture] setSize() is not supported on video textures");
+        return false;
+    }
+    
+    bool VideoTexture::update(RectU, void const*, uint32_t) {
+        Logger::warn("[core] [VideoTexture] update() is not supported on video textures");
+        return false;
+    }
+    
+    void VideoTexture::setImage(IImage*) {
+        Logger::warn("[core] [VideoTexture] setImage() is not supported on video textures");
+    }
+    
+    bool VideoTexture::saveToFile(StringView) {
+        Logger::warn("[core] [VideoTexture] saveToFile() is not supported on video textures");
+        return false;
+    }
+    
+    void VideoTexture::onGraphicsDeviceCreate() {
+    }
+    
+    void VideoTexture::onGraphicsDeviceDestroy() {
+    }
+    
+    bool GraphicsDevice::createVideoTexture(StringView path, ITexture2D** out_texture) {
+        return createVideoTexture(path, VideoOpenOptions{}, out_texture);
+    }
+
+    bool GraphicsDevice::createVideoTexture(StringView path, VideoOpenOptions const& options, ITexture2D** out_texture) {
+        if (out_texture == nullptr) {
+            assert(false);
+            return false;
+        }
+        SmartReference<VideoTexture> video_texture;
+        video_texture.attach(new VideoTexture);
+        if (!video_texture->initialize(this, path, options)) {
+            return false;
+        }
+        *out_texture = video_texture.detach();
+        return true;
+    }
+    
+    bool GraphicsDevice::createVideoDecoder(IVideoDecoder** out_decoder) {
+        if (out_decoder == nullptr) {
+            assert(false);
+            return false;
+        }
+        SmartReference<VideoDecoder> decoder;
+        decoder.attach(new VideoDecoder);
+        if (!decoder->initialize(this)) {
+            return false;
+        }
+        *out_decoder = decoder.detach();
+        return true;
+    }
+}
diff --git a/engine/graphics/d3d11/VideoTexture.hpp b/engine/graphics/d3d11/VideoTexture.hpp
new file mode 100644
index 000000000..1e64b1d5f
--- /dev/null
+++ b/engine/graphics/d3d11/VideoTexture.hpp
@@ -0,0 +1,61 @@
+#pragma once
+#include "core/Texture2D.hpp"
+#include "core/VideoDecoder.hpp"
+#include "core/GraphicsDevice.hpp"
+#include "core/SmartReference.hpp"
+#include "core/implement/ReferenceCounted.hpp"
+#include "d3d11/pch.h"
+
+namespace core {
+    class VideoTexture final :
+        public implement::ReferenceCounted<ITexture2D>,
+        public IGraphicsDeviceEventListener {
+    public:
+        // ITexture2D
+
+        void* getNativeResource() const noexcept override;
+        void* getNativeView() const noexcept override;
+
+        bool isDynamic() const noexcept override { return true; }
+        bool isVideoTexture() const noexcept override { return true; }
+        bool isPremultipliedAlpha() const noexcept override { return m_premultiplied_alpha; }
+        void setPremultipliedAlpha(bool v) override { m_premultiplied_alpha = v; }
+        Vector2U getSize() const noexcept override;
+
+        bool setSize(Vector2U) override;
+        bool update(RectU, void const*, uint32_t) override;
+        void setImage(IImage*) override;
+
+        bool saveToFile(StringView) override;
+
+        void setSamplerState(IGraphicsSampler* sampler) override { m_sampler = sampler; }
+        IGraphicsSampler* getSamplerState() const noexcept override { return m_sampler.get(); }
+
+        IVideoDecoder* getVideoDecoder() const noexcept override { return m_decoder.get(); }
+
+        // IGraphicsDeviceEventListener
+
+        void onGraphicsDeviceCreate() override;
+        void onGraphicsDeviceDestroy() override;
+
+        // VideoTexture
+
+        VideoTexture();
+        VideoTexture(VideoTexture const&) = delete;
+        VideoTexture(VideoTexture&&) = delete;
+        ~VideoTexture();
+
+        VideoTexture& operator=(VideoTexture const&) = delete;
+        VideoTexture& operator=(VideoTexture&&) = delete;
+
+        bool initialize(IGraphicsDevice* device, StringView path);
+        bool initialize(IGraphicsDevice* device, StringView path, VideoOpenOptions const& options);
+
+    private:
+        SmartReference<IGraphicsDevice> m_device;
+        SmartReference<IVideoDecoder> m_decoder;
+        SmartReference<IGraphicsSampler> m_sampler;
+        bool m_premultiplied_alpha{ false };
+        bool m_initialized{ false };
+    };
+}
diff --git a/engine/lua/lua/plus.hpp b/engine/lua/lua/plus.hpp
index 8897691a7..55626619f 100644
--- a/engine/lua/lua/plus.hpp
+++ b/engine/lua/lua/plus.hpp
@@ -11,6 +11,8 @@ namespace lua {
 
 		stack_index_t() = default;
 		constexpr stack_index_t(int32_t const index) : value(index) {}
+		constexpr stack_index_t(size_t const index) : value(static_cast<int32_t>(index)) {}
+		constexpr stack_index_t(uint32_t const index) : value(static_cast<int32_t>(index)) {}
 
 		bool operator>(int32_t const right) const {
 			return value > right;