feat(video): add memory-based video loading and refactor stream handling

- Add createVideoTextureFromMemory() method to graphics device interface and D3D11 implementation for loading videos from memory buffers
- Add openFromMemory() method to VideoDecoder for opening video streams from memory with source name tracking
- Refactor video stream enumeration to use cached stream information instead of querying at runtime
- Improve stream info caching with proper initialization and cleanup in VideoDecoder
- Refactor openFile() to use new createStreamFromMemory() and openFromStream() helper methods
- Simplify Lua binding helpers by using range-based for loops and explicit index tracking instead of array indexing
- Add stack value cleanup (pop_value) in video and audio stream Lua binding loops to prevent stack leaks
- Improve code readability with better variable naming and consistent formatting in binding helpers

Author: BAKAOLC

LuaSTG/LuaSTG/LuaBinding/VideoBindingHelpers.hpp

@@ -50,14 +50,19 @@ namespace luastg::binding::video {
         decoder->getVideoStreams(callback, &list);
 
         auto array_idx = stack.create_array(list.size());
-        for (size_t i = 0; i < list.size(); ++i) {
+        int index = 1;
+        for (auto const& info : list) {
             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);
+            
+            stack.set_map_value(item_idx, "index", info.index);
+            stack.set_map_value(item_idx, "width", info.width);
+            stack.set_map_value(item_idx, "height", info.height);
+            stack.set_map_value(item_idx, "fps", info.fps);
+            stack.set_map_value(item_idx, "duration", info.duration_seconds);
+            
+            stack.set_array_value(array_idx, index, item_idx);
+            stack.pop_value();
+            ++index;
         }
     }
 
@@ -77,13 +82,18 @@ namespace luastg::binding::video {
         decoder->getAudioStreams(callback, &list);
 
         auto array_idx = stack.create_array(list.size());
-        for (size_t i = 0; i < list.size(); ++i) {
+        int index = 1;
+        for (auto const& info : list) {
             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);
+            
+            stack.set_map_value(item_idx, "index", info.index);
+            stack.set_map_value(item_idx, "channels", info.channels);
+            stack.set_map_value(item_idx, "sample_rate", info.sample_rate);
+            stack.set_map_value(item_idx, "duration", info.duration_seconds);
+            
+            stack.set_array_value(array_idx, index, item_idx);
+            stack.pop_value();
+            ++index;
         }
     }
 

engine/graphics/core/GraphicsDevice.hpp

@@ -111,6 +111,7 @@ namespace core {
         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 createVideoTextureFromMemory(void const* data, size_t size, VideoOpenOptions const& options, ITexture2D** out_texture, StringView source_name = "<memory>") = 0;
         virtual bool createVideoDecoder(IVideoDecoder** out_decoder) = 0;
 
         virtual bool createSampler(const GraphicsSamplerInfo& info, IGraphicsSampler** out_sampler) = 0;

engine/graphics/d3d11/GraphicsDevice.hpp

@@ -24,6 +24,7 @@ namespace core {
         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 createVideoTextureFromMemory(void const* data, size_t size, VideoOpenOptions const& options, ITexture2D** out_texture, StringView source_name = "<memory>") override;
         bool createVideoDecoder(IVideoDecoder** out_decoder) override;
 
         bool createSampler(const GraphicsSamplerInfo& info, IGraphicsSampler** out_sampler) override;

engine/graphics/d3d11/VideoDecoder.cpp

@@ -84,13 +84,14 @@ namespace core {
 
         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;
+        SmartReference<IData> file_data;
+        if (!FileSystemManager::readFile(path, file_data.put())) {
+            Logger::error("[core] [VideoDecoder] Failed to read video file: {}", path);
+            return false;
+        }
+        
+        if (!createStreamFromMemory(file_data->data(), file_data->size())) return false;
+        if (!openFromStream(options)) return false;
 
         m_last_open_path.assign(path.data(), path.size());
         m_last_open_options = options;
@@ -105,74 +106,105 @@ namespace core {
 
         return true;
     }
+    
+    bool VideoDecoder::openFromMemory(void const* data, size_t size, VideoOpenOptions const& options, StringView source_name) {
+        if (!m_initialized) {
+            Logger::error("[core] [VideoDecoder] Not initialized");
+            return false;
+        }
+        
+        close();
+        
+        if (!createStreamFromMemory(data, size)) return false;
+        if (!openFromStream(options)) return false;
+
+        m_last_open_path.assign(source_name.data(), source_name.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 from memory: {}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;
+        if (!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);
-            }
-            
+        for (auto const& info : m_cached_video_streams) {
             callback(info, userdata);
         }
     }
 
     void VideoDecoder::getAudioStreams(void (*callback)(AudioStreamInfo const&, void*), void* userdata) const {
-        if (!m_source_reader || !callback) return;
+        if (!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);
-            
+        for (auto const& info : m_cached_audio_streams) {
             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)");
+        if (!m_byte_stream) {
+            Logger::error("[core] [VideoDecoder] reopen: no byte stream available");
+            return false;
+        }
+        
+        auto saved_stream = m_byte_stream;
+        
+        m_source_reader.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;
+        m_cached_video_streams.clear();
+        m_cached_audio_streams.clear();
+        
+        m_byte_stream = saved_stream;
+        
+        if (FAILED(m_byte_stream->SetCurrentPosition(0))) {
+            Logger::error("[core] [VideoDecoder] reopen: failed to reset stream position");
             return false;
         }
-        return open(StringView(m_last_open_path), options);
+        
+        if (!openFromStream(options)) {
+            Logger::error("[core] [VideoDecoder] reopen: failed to reopen");
+            return false;
+        }
+        
+        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] Reopened video: {}x{}", 
+                    m_target_size.x, m_target_size.y);
+        
+        return true;
     }
 
     void VideoDecoder::close() {
@@ -200,6 +232,9 @@ namespace core {
         m_video_stream_index = 0;
         m_loop_state = LoopState{};
         m_first_texture_update_logged = false;
+        
+        m_cached_video_streams.clear();
+        m_cached_audio_streams.clear();
     }
 
     void VideoDecoder::setLoopRange(double end_sec, double duration_sec) {

engine/graphics/d3d11/VideoDecoder.hpp

@@ -10,6 +10,7 @@
 #include <mfreadwrite.h>
 #include <mutex>
 #include <string>
+#include <vector>
 
 namespace core {
     class VideoDecoder final :
@@ -33,6 +34,7 @@ namespace core {
 
         bool open(StringView path) override;
         bool open(StringView path, VideoOpenOptions const& options) override;
+        bool openFromMemory(void const* data, size_t size, VideoOpenOptions const& options, StringView source_name = "<memory>");
         void close() override;
 
         bool hasVideo() const noexcept override { return m_source_reader.get() != nullptr; }
@@ -78,8 +80,11 @@ namespace core {
         bool initialize(IGraphicsDevice* device);
 
     private:
-        // File loading
-        bool loadVideoFile(StringView path);
+        // Stream creation
+        bool createStreamFromMemory(void const* data, size_t size);
+        
+        // Video opening (requires stream to be set)
+        bool openFromStream(VideoOpenOptions const& options);
 
         // Hardware acceleration setup
         bool configureHardwareAcceleration();
@@ -99,6 +104,7 @@ namespace core {
 
         // Property extraction
         bool extractVideoProperties();
+        void cacheStreamInformation();
 
         // Resource creation
         bool createResources();
@@ -146,5 +152,9 @@ namespace core {
         VideoOpenOptions m_last_open_options;
         bool m_initialized{ false };
         bool m_first_texture_update_logged{ false };
+        
+        // Cached stream information
+        std::vector<VideoStreamInfo> m_cached_video_streams;
+        std::vector<AudioStreamInfo> m_cached_audio_streams;
     };
 }