Implement VavCore library

vav2/Vav2Player/VavCore/src/Decoder/AdaptiveNVDECDecoder.h

@@ -0,0 +1,143 @@
+#pragma once
+#include "NVDECAV1Decoder.h"
+#include <queue>
+#include <mutex>
+#include <atomic>
+
+namespace VavCore {
+
+// Performance monitoring data
+struct PerformanceMetrics {
+    double avg_decode_time_ms = 0.0;
+    double avg_render_time_ms = 0.0;
+    double cpu_usage_percent = 0.0;
+    double gpu_usage_percent = 0.0;
+    uint64_t dropped_frames = 0;
+    std::chrono::steady_clock::time_point last_update;
+};
+
+// Quality levels for adaptive adjustment
+enum class QualityLevel {
+    ULTRA = 0,      // Original resolution, full quality
+    HIGH = 1,       // 75% resolution, high quality
+    MEDIUM = 2,     // 50% resolution, medium quality
+    LOW = 3,        // 25% resolution, low quality
+    MINIMUM = 4     // 12.5% resolution, minimal quality
+};
+
+// Adaptive decoder configuration
+struct AdaptiveConfig {
+    // Performance thresholds (milliseconds)
+    double target_frame_time_ms = 33.33;  // 30 FPS target
+    double critical_frame_time_ms = 50.0; // 20 FPS critical
+
+    // Quality adjustment thresholds
+    double quality_up_threshold = 0.8;    // Scale up when < 80% of target time
+    double quality_down_threshold = 1.2;  // Scale down when > 120% of target time
+
+    // Hysteresis to prevent oscillation
+    uint32_t stable_frames_required = 30; // Frames to wait before adjustment
+
+    // Memory constraints
+    uint32_t max_decode_surfaces = 16;
+    uint32_t min_decode_surfaces = 4;
+
+    // Enable/disable features
+    bool enable_dynamic_resolution = true;
+    bool enable_dynamic_surfaces = true;
+    bool enable_skip_non_reference = true;
+};
+
+// Enhanced NVDEC decoder with adaptive quality adjustment
+class AdaptiveNVDECDecoder : public NVDECAV1Decoder {
+public:
+    AdaptiveNVDECDecoder();
+    ~AdaptiveNVDECDecoder() override;
+
+    // Enhanced initialization with adaptive features
+    bool Initialize(const VideoMetadata& metadata) override;
+    bool Initialize(const VideoMetadata& metadata, const AdaptiveConfig& config);
+
+    // Override decode with adaptive logic
+    bool DecodeFrame(const uint8_t* packet_data, size_t packet_size, VideoFrame& output_frame) override;
+
+    // Adaptive quality control
+    void SetQualityLevel(QualityLevel level);
+    QualityLevel GetCurrentQualityLevel() const { return m_currentQuality; }
+
+    // Performance monitoring
+    PerformanceMetrics GetPerformanceMetrics() const;
+    void UpdatePerformanceMetrics(double decode_time, double render_time);
+
+    // Manual override controls
+    void EnableAdaptiveMode(bool enable) { m_adaptiveEnabled = enable; }
+    void SetTargetFrameRate(double fps);
+    void ForceQualityAdjustment(); // Immediate adjustment trigger
+
+    // Configuration management
+    void UpdateConfig(const AdaptiveConfig& config) { m_config = config; }
+    AdaptiveConfig GetConfig() const { return m_config; }
+
+private:
+    // Adaptive control state
+    QualityLevel m_currentQuality = QualityLevel::ULTRA;
+    QualityLevel m_targetQuality = QualityLevel::ULTRA;
+    AdaptiveConfig m_config;
+
+    // Performance monitoring
+    mutable std::mutex m_metricsMutex;
+    PerformanceMetrics m_metrics;
+    std::queue<double> m_recentDecodeTimes;
+    std::queue<double> m_recentRenderTimes;
+
+    // Adaptive decision making
+    std::atomic<bool> m_adaptiveEnabled{true};
+    uint32_t m_stableFrameCount = 0;
+    bool m_needsReconfiguration = false;
+
+    // Original video properties for scaling calculations
+    uint32_t m_originalWidth = 0;
+    uint32_t m_originalHeight = 0;
+
+    // Current scaled properties
+    uint32_t m_currentScaledWidth = 0;
+    uint32_t m_currentScaledHeight = 0;
+
+    // Adaptive logic methods
+    void AnalyzePerformanceAndAdjust();
+    bool ShouldAdjustQuality(double avgDecodeTime, double avgRenderTime);
+    QualityLevel DetermineOptimalQuality(double totalFrameTime);
+
+    // NVDEC reconfiguration methods
+    bool ReconfigureDecoder(uint32_t newWidth, uint32_t newHeight);
+    bool UpdateDecodeSurfaces(uint32_t newCount);
+    void CalculateScaledDimensions(QualityLevel quality, uint32_t& width, uint32_t& height);
+
+    // Performance calculation helpers
+    void UpdateMovingAverage(std::queue<double>& queue, double newValue, size_t maxSize = 30);
+    double CalculateMovingAverage(const std::queue<double>& queue) const;
+
+    // Quality level utilities
+    static double GetQualityScaleFactor(QualityLevel level);
+    static std::string QualityLevelToString(QualityLevel level);
+};
+
+// Utility functions for adaptive decoding
+namespace AdaptiveUtils {
+    // Performance estimation
+    double EstimateOptimalFrameRate(const PerformanceMetrics& metrics);
+    QualityLevel RecommendQualityForTargetFPS(double targetFPS, double currentFPS);
+
+    // System resource monitoring
+    double GetCurrentCPUUsage();
+    double GetCurrentGPUUsage();
+    size_t GetAvailableGPUMemory();
+
+    // Configuration presets
+    AdaptiveConfig CreateConfigForTarget(double targetFPS);
+    AdaptiveConfig GetConservativeConfig();   // Aggressive quality reduction
+    AdaptiveConfig GetBalancedConfig();       // Balanced performance/quality
+    AdaptiveConfig GetQualityConfig();        // Prioritize quality over performance
+}
+
+} // namespace VavCore