refactor: 重构 ffmpeg 编码器探测模块

src/video/encoder/h264.rs

@@ -17,6 +17,8 @@ use hwcodec::ffmpeg::AVPixelFormat;
 use hwcodec::ffmpeg_ram::encode::{EncodeContext, Encoder as HwEncoder};
 use hwcodec::ffmpeg_ram::CodecInfo;
 
+use super::detect_best_codec_for_format;
+use super::registry::EncoderBackend;
 use super::traits::{EncodedFormat, EncodedFrame, Encoder, EncoderConfig};
 use crate::error::{AppError, Result};
 use crate::video::format::{PixelFormat, Resolution};
@@ -69,21 +71,17 @@ impl std::fmt::Display for H264EncoderType {
 }
 
 /// Map codec name to encoder type
-fn codec_name_to_type(name: &str) -> H264EncoderType {
-    if name.contains("nvenc") {
-        H264EncoderType::Nvenc
-    } else if name.contains("qsv") {
-        H264EncoderType::Qsv
-    } else if name.contains("amf") {
-        H264EncoderType::Amf
-    } else if name.contains("vaapi") {
-        H264EncoderType::Vaapi
-    } else if name.contains("rkmpp") {
-        H264EncoderType::Rkmpp
-    } else if name.contains("v4l2m2m") {
-        H264EncoderType::V4l2M2m
-    } else {
-        H264EncoderType::Software
+impl From<EncoderBackend> for H264EncoderType {
+    fn from(backend: EncoderBackend) -> Self {
+        match backend {
+            EncoderBackend::Nvenc => H264EncoderType::Nvenc,
+            EncoderBackend::Qsv => H264EncoderType::Qsv,
+            EncoderBackend::Amf => H264EncoderType::Amf,
+            EncoderBackend::Vaapi => H264EncoderType::Vaapi,
+            EncoderBackend::Rkmpp => H264EncoderType::Rkmpp,
+            EncoderBackend::V4l2m2m => H264EncoderType::V4l2M2m,
+            EncoderBackend::Software => H264EncoderType::Software,
+        }
     }
 }
 
@@ -215,21 +213,15 @@ pub fn get_available_encoders(width: u32, height: u32) -> Vec<CodecInfo> {
 pub fn detect_best_encoder(width: u32, height: u32) -> (H264EncoderType, Option<String>) {
     let encoders = get_available_encoders(width, height);
 
-    if encoders.is_empty() {
+    if let Some((encoder_type, codec_name)) =
+        detect_best_codec_for_format(&encoders, hwcodec::common::DataFormat::H264, |_| true)
+    {
+        info!("Best H.264 encoder: {} ({})", codec_name, encoder_type);
+        (encoder_type, Some(codec_name))
+    } else {
         warn!("No H.264 encoders available from hwcodec");
-        return (H264EncoderType::None, None);
+        (H264EncoderType::None, None)
     }
-
-    // Find H264 encoder (not H265)
-    for codec in &encoders {
-        if codec.format == hwcodec::common::DataFormat::H264 {
-            let encoder_type = codec_name_to_type(&codec.name);
-            info!("Best H.264 encoder: {} ({})", codec.name, encoder_type);
-            return (encoder_type, Some(codec.name.clone()));
-        }
-    }
-
-    (H264EncoderType::None, None)
 }
 
 /// Encoded frame from hwcodec (cloned for ownership)
@@ -321,7 +313,7 @@ impl H264Encoder {
         })?;
 
         let yuv_length = inner.length;
-        let encoder_type = codec_name_to_type(codec_name);
+        let encoder_type = H264EncoderType::from(EncoderBackend::from_codec_name(codec_name));
 
         info!(
             "H.264 encoder created: {} (type: {}, buffer_length: {}, input_format: {:?})",

src/video/encoder/h265.rs

@@ -15,6 +15,7 @@ use hwcodec::ffmpeg::AVPixelFormat;
 use hwcodec::ffmpeg_ram::encode::{EncodeContext, Encoder as HwEncoder};
 use hwcodec::ffmpeg_ram::CodecInfo;
 
+use super::detect_best_codec_for_format;
 use super::registry::{EncoderBackend, EncoderRegistry, VideoEncoderType};
 use super::traits::{EncodedFormat, EncodedFrame, Encoder, EncoderConfig};
 use crate::error::{AppError, Result};
@@ -221,43 +222,25 @@ pub fn get_available_h265_encoders(width: u32, height: u32) -> Vec<CodecInfo> {
 pub fn detect_best_h265_encoder(width: u32, height: u32) -> (H265EncoderType, Option<String>) {
     let encoders = get_available_h265_encoders(width, height);
 
-    if encoders.is_empty() {
-        warn!("No H.265 encoders available");
-        return (H265EncoderType::None, None);
-    }
-
     // Prefer hardware encoders over software (libx265)
     // Hardware priority: NVENC > QSV > AMF > VAAPI > RKMPP > V4L2 M2M > Software
-    let codec = encoders
-        .iter()
-        .find(|e| !e.name.contains("libx265"))
-        .or_else(|| encoders.first())
-        .unwrap();
-
-    let encoder_type = if codec.name.contains("nvenc") {
-        H265EncoderType::Nvenc
-    } else if codec.name.contains("qsv") {
-        H265EncoderType::Qsv
-    } else if codec.name.contains("amf") {
-        H265EncoderType::Amf
-    } else if codec.name.contains("vaapi") {
-        H265EncoderType::Vaapi
-    } else if codec.name.contains("rkmpp") {
-        H265EncoderType::Rkmpp
-    } else if codec.name.contains("v4l2m2m") {
-        H265EncoderType::V4l2M2m
+    if let Some((encoder_type, codec_name)) =
+        detect_best_codec_for_format(&encoders, DataFormat::H265, |codec| {
+            !codec.name.contains("libx265")
+        })
+    {
+        info!("Selected H.265 encoder: {} ({})", codec_name, encoder_type);
+        (encoder_type, Some(codec_name))
     } else {
-        H265EncoderType::Software // Default to software for unknown
-    };
-
-    info!("Selected H.265 encoder: {} ({})", codec.name, encoder_type);
-    (encoder_type, Some(codec.name.clone()))
+        warn!("No H.265 encoders available");
+        (H265EncoderType::None, None)
+    }
 }
 
 /// Check if H265 hardware encoding is available
 pub fn is_h265_available() -> bool {
     let registry = EncoderRegistry::global();
-    registry.is_format_available(VideoEncoderType::H265, true)
+    registry.is_codec_available(VideoEncoderType::H265)
 }
 
 /// Encoded frame from hwcodec (cloned for ownership)
@@ -268,7 +251,7 @@ pub struct HwEncodeFrame {
     pub key: i32,
 }
 
-/// H.265 encoder using hwcodec (hardware only)
+/// H.265 encoder using hwcodec
 pub struct H265Encoder {
     /// hwcodec encoder instance
     inner: HwEncoder,

src/video/encoder/mod.rs

@@ -3,12 +3,15 @@
 //! This module provides video encoding capabilities including:
 //! - JPEG encoding for raw frames (YUYV, NV12, etc.)
 //! - H264 encoding (hardware + software)
-//! - H265 encoding (hardware only)
-//! - VP8 encoding (hardware only - VAAPI)
-//! - VP9 encoding (hardware only - VAAPI)
+//! - H265 encoding (hardware + software)
+//! - VP8 encoding (hardware + software)
+//! - VP9 encoding (hardware + software)
 //! - WebRTC video codec abstraction
 //! - Encoder registry for automatic detection
 
+use hwcodec::common::DataFormat;
+use hwcodec::ffmpeg_ram::CodecInfo;
+
 pub mod codec;
 pub mod h264;
 pub mod h265;
@@ -32,14 +35,45 @@ pub use registry::{AvailableEncoder, EncoderBackend, EncoderRegistry, VideoEncod
 // H264 encoder
 pub use h264::{H264Config, H264Encoder, H264EncoderType, H264InputFormat};
 
-// H265 encoder (hardware only)
+// H265 encoder
 pub use h265::{H265Config, H265Encoder, H265EncoderType, H265InputFormat};
 
-// VP8 encoder (hardware only)
+// VP8 encoder
 pub use vp8::{VP8Config, VP8Encoder, VP8EncoderType, VP8InputFormat};
 
-// VP9 encoder (hardware only)
+// VP9 encoder
 pub use vp9::{VP9Config, VP9Encoder, VP9EncoderType, VP9InputFormat};
 
 // JPEG encoder
 pub use jpeg::JpegEncoder;
+
+pub(crate) fn select_codec_for_format<F>(
+    encoders: &[CodecInfo],
+    format: DataFormat,
+    preferred: F,
+) -> Option<&CodecInfo>
+where
+    F: Fn(&CodecInfo) -> bool,
+{
+    encoders
+        .iter()
+        .find(|codec| codec.format == format && preferred(codec))
+        .or_else(|| encoders.iter().find(|codec| codec.format == format))
+}
+
+pub(crate) fn detect_best_codec_for_format<T, F>(
+    encoders: &[CodecInfo],
+    format: DataFormat,
+    preferred: F,
+) -> Option<(T, String)>
+where
+    T: From<EncoderBackend>,
+    F: Fn(&CodecInfo) -> bool,
+{
+    select_codec_for_format(encoders, format, preferred).map(|codec| {
+        (
+            T::from(EncoderBackend::from_codec_name(&codec.name)),
+            codec.name.clone(),
+        )
+    })
+}

src/video/encoder/registry.rs

@@ -7,6 +7,7 @@
 
 use std::collections::HashMap;
 use std::sync::OnceLock;
+use std::time::Duration;
 use tracing::{debug, info, warn};
 
 use hwcodec::common::{DataFormat, Quality, RateControl};
@@ -28,6 +29,10 @@ pub enum VideoEncoderType {
 }
 
 impl VideoEncoderType {
+    pub const fn ordered() -> [Self; 4] {
+        [Self::H264, Self::H265, Self::VP8, Self::VP9]
+    }
+
     /// Convert to hwcodec DataFormat
     pub fn to_data_format(&self) -> DataFormat {
         match self {
@@ -68,17 +73,6 @@ impl VideoEncoderType {
             VideoEncoderType::VP9 => "VP9",
         }
     }
-
-    /// Check if this format requires hardware-only encoding
-    /// H264 supports software fallback, others require hardware
-    pub fn hardware_only(&self) -> bool {
-        match self {
-            VideoEncoderType::H264 => false,
-            VideoEncoderType::H265 => true,
-            VideoEncoderType::VP8 => true,
-            VideoEncoderType::VP9 => true,
-        }
-    }
 }
 
 impl std::fmt::Display for VideoEncoderType {
@@ -210,6 +204,76 @@ pub struct EncoderRegistry {
 }
 
 impl EncoderRegistry {
+    fn detect_encoders_with_timeout(ctx: EncodeContext, timeout: Duration) -> Vec<CodecInfo> {
+        use std::sync::mpsc;
+
+        let (tx, rx) = mpsc::channel();
+        let handle = std::thread::Builder::new()
+            .name("ffmpeg-encoder-detect".to_string())
+            .spawn(move || {
+                let result = HwEncoder::available_encoders(ctx, None);
+                let _ = tx.send(result);
+            });
+
+        let Ok(handle) = handle else {
+            warn!("Failed to spawn encoder detection thread");
+            return Vec::new();
+        };
+
+        match rx.recv_timeout(timeout) {
+            Ok(encoders) => {
+                let _ = handle.join();
+                encoders
+            }
+            Err(mpsc::RecvTimeoutError::Timeout) => {
+                warn!(
+                    "Encoder detection timed out after {}ms, skipping hardware detection",
+                    timeout.as_millis()
+                );
+                std::thread::spawn(move || {
+                    let _ = handle.join();
+                });
+                Vec::new()
+            }
+            Err(mpsc::RecvTimeoutError::Disconnected) => {
+                let _ = handle.join();
+                warn!("Encoder detection thread exited unexpectedly");
+                Vec::new()
+            }
+        }
+    }
+
+    fn register_software_fallbacks(&mut self) {
+        info!("Registering software encoders...");
+
+        for format in VideoEncoderType::ordered() {
+            let encoders = self.encoders.entry(format).or_default();
+            if encoders.iter().any(|encoder| !encoder.is_hardware) {
+                continue;
+            }
+
+            let codec_name = match format {
+                VideoEncoderType::H264 => "libx264",
+                VideoEncoderType::H265 => "libx265",
+                VideoEncoderType::VP8 => "libvpx",
+                VideoEncoderType::VP9 => "libvpx-vp9",
+            };
+
+            encoders.push(AvailableEncoder {
+                format,
+                codec_name: codec_name.to_string(),
+                backend: EncoderBackend::Software,
+                priority: 100,
+                is_hardware: false,
+            });
+
+            debug!(
+                "Registered software encoder: {} for {} (priority: {})",
+                codec_name, format, 100
+            );
+        }
+    }
+
     /// Get the global registry instance
     ///
     /// The registry is initialized lazily on first access with 1920x1080 detection.
@@ -257,32 +321,11 @@ impl EncoderRegistry {
         };
 
         const DETECT_TIMEOUT_MS: u64 = 5000;
-
-        // Get all available encoders from hwcodec with a hard timeout
-        let all_encoders = {
-            use std::sync::mpsc;
-            use std::time::Duration;
-
-            info!("Encoder detection timeout: {}ms", DETECT_TIMEOUT_MS);
-
-            let (tx, rx) = mpsc::channel();
-            let ctx_clone = ctx.clone();
-            std::thread::spawn(move || {
-                let result = HwEncoder::available_encoders(ctx_clone, None);
-                let _ = tx.send(result);
-            });
-
-            match rx.recv_timeout(Duration::from_millis(DETECT_TIMEOUT_MS)) {
-                Ok(encoders) => encoders,
-                Err(_) => {
-                    warn!(
-                        "Encoder detection timed out after {}ms, skipping hardware detection",
-                        DETECT_TIMEOUT_MS
-                    );
-                    Vec::new()
-                }
-            }
-        };
+        info!("Encoder detection timeout: {}ms", DETECT_TIMEOUT_MS);
+        let all_encoders = Self::detect_encoders_with_timeout(
+            ctx.clone(),
+            Duration::from_millis(DETECT_TIMEOUT_MS),
+        );
 
         info!("Found {} encoders from hwcodec", all_encoders.len());
 
@@ -305,32 +348,7 @@ impl EncoderRegistry {
             encoders.sort_by_key(|e| e.priority);
         }
 
-        // Register software encoders as fallback
-        info!("Registering software encoders...");
-        let software_encoders = [
-            (VideoEncoderType::H264, "libx264", 100),
-            (VideoEncoderType::H265, "libx265", 100),
-            (VideoEncoderType::VP8, "libvpx", 100),
-            (VideoEncoderType::VP9, "libvpx-vp9", 100),
-        ];
-
-        for (format, codec_name, priority) in software_encoders {
-            self.encoders
-                .entry(format)
-                .or_default()
-                .push(AvailableEncoder {
-                    format,
-                    codec_name: codec_name.to_string(),
-                    backend: EncoderBackend::Software,
-                    priority,
-                    is_hardware: false,
-                });
-
-            debug!(
-                "Registered software encoder: {} for {} (priority: {})",
-                codec_name, format, priority
-            );
-        }
+        self.register_software_fallbacks();
 
         // Log summary
         for (format, encoders) in &self.encoders {
@@ -370,6 +388,10 @@ impl EncoderRegistry {
         )
     }
 
+    pub fn best_available_encoder(&self, format: VideoEncoderType) -> Option<&AvailableEncoder> {
+        self.best_encoder(format, false)
+    }
+
     /// Get all encoders for a format
     pub fn encoders_for_format(&self, format: VideoEncoderType) -> &[AvailableEncoder] {
         self.encoders
@@ -405,31 +427,17 @@ impl EncoderRegistry {
         self.best_encoder(format, hardware_only).is_some()
     }
 
+    pub fn is_codec_available(&self, format: VideoEncoderType) -> bool {
+        self.best_available_encoder(format).is_some()
+    }
+
     /// Get available formats for user selection
     ///
-    /// Returns formats that are actually usable based on their requirements:
-    /// - H264: Available if any encoder exists (hardware or software)
-    /// - H265/VP8/VP9: Available only if hardware encoder exists
     pub fn selectable_formats(&self) -> Vec<VideoEncoderType> {
-        let mut formats = Vec::new();
-
-        // H264 - supports software fallback
-        if self.is_format_available(VideoEncoderType::H264, false) {
-            formats.push(VideoEncoderType::H264);
-        }
-
-        // H265/VP8/VP9 - hardware only
-        for format in [
-            VideoEncoderType::H265,
-            VideoEncoderType::VP8,
-            VideoEncoderType::VP9,
-        ] {
-            if self.is_format_available(format, true) {
-                formats.push(format);
-            }
-        }
-
-        formats
+        VideoEncoderType::ordered()
+            .into_iter()
+            .filter(|format| self.is_codec_available(*format))
+            .collect()
     }
 
     /// Get detection resolution
@@ -534,11 +542,16 @@ mod tests {
     }
 
     #[test]
-    fn test_hardware_only_requirement() {
-        assert!(!VideoEncoderType::H264.hardware_only());
-        assert!(VideoEncoderType::H265.hardware_only());
-        assert!(VideoEncoderType::VP8.hardware_only());
-        assert!(VideoEncoderType::VP9.hardware_only());
+    fn test_codec_ordering() {
+        assert_eq!(
+            VideoEncoderType::ordered(),
+            [
+                VideoEncoderType::H264,
+                VideoEncoderType::H265,
+                VideoEncoderType::VP8,
+                VideoEncoderType::VP9,
+            ]
+        );
     }
 
     #[test]

src/video/encoder/vp8.rs

@@ -15,6 +15,7 @@ use hwcodec::ffmpeg::AVPixelFormat;
 use hwcodec::ffmpeg_ram::encode::{EncodeContext, Encoder as HwEncoder};
 use hwcodec::ffmpeg_ram::CodecInfo;
 
+use super::detect_best_codec_for_format;
 use super::registry::{EncoderBackend, EncoderRegistry, VideoEncoderType};
 use super::traits::{EncodedFormat, EncodedFrame, Encoder, EncoderConfig};
 use crate::error::{AppError, Result};
@@ -156,32 +157,24 @@ pub fn get_available_vp8_encoders(width: u32, height: u32) -> Vec<CodecInfo> {
 pub fn detect_best_vp8_encoder(width: u32, height: u32) -> (VP8EncoderType, Option<String>) {
     let encoders = get_available_vp8_encoders(width, height);
 
-    if encoders.is_empty() {
-        warn!("No VP8 encoders available");
-        return (VP8EncoderType::None, None);
-    }
-
     // Prefer hardware encoders (VAAPI) over software (libvpx)
-    let codec = encoders
-        .iter()
-        .find(|e| e.name.contains("vaapi"))
-        .or_else(|| encoders.first())
-        .unwrap();
-
-    let encoder_type = if codec.name.contains("vaapi") {
-        VP8EncoderType::Vaapi
+    if let Some((encoder_type, codec_name)) =
+        detect_best_codec_for_format(&encoders, DataFormat::VP8, |codec| {
+            codec.name.contains("vaapi")
+        })
+    {
+        info!("Selected VP8 encoder: {} ({})", codec_name, encoder_type);
+        (encoder_type, Some(codec_name))
     } else {
-        VP8EncoderType::Software // Default to software for unknown
-    };
-
-    info!("Selected VP8 encoder: {} ({})", codec.name, encoder_type);
-    (encoder_type, Some(codec.name.clone()))
+        warn!("No VP8 encoders available");
+        (VP8EncoderType::None, None)
+    }
 }
 
 /// Check if VP8 hardware encoding is available
 pub fn is_vp8_available() -> bool {
     let registry = EncoderRegistry::global();
-    registry.is_format_available(VideoEncoderType::VP8, true)
+    registry.is_codec_available(VideoEncoderType::VP8)
 }
 
 /// Encoded frame from hwcodec (cloned for ownership)
@@ -192,7 +185,7 @@ pub struct HwEncodeFrame {
     pub key: i32,
 }
 
-/// VP8 encoder using hwcodec (hardware only - VAAPI)
+/// VP8 encoder using hwcodec
 pub struct VP8Encoder {
     /// hwcodec encoder instance
     inner: HwEncoder,

src/video/encoder/vp9.rs

@@ -15,6 +15,7 @@ use hwcodec::ffmpeg::AVPixelFormat;
 use hwcodec::ffmpeg_ram::encode::{EncodeContext, Encoder as HwEncoder};
 use hwcodec::ffmpeg_ram::CodecInfo;
 
+use super::detect_best_codec_for_format;
 use super::registry::{EncoderBackend, EncoderRegistry, VideoEncoderType};
 use super::traits::{EncodedFormat, EncodedFrame, Encoder, EncoderConfig};
 use crate::error::{AppError, Result};
@@ -156,32 +157,24 @@ pub fn get_available_vp9_encoders(width: u32, height: u32) -> Vec<CodecInfo> {
 pub fn detect_best_vp9_encoder(width: u32, height: u32) -> (VP9EncoderType, Option<String>) {
     let encoders = get_available_vp9_encoders(width, height);
 
-    if encoders.is_empty() {
-        warn!("No VP9 encoders available");
-        return (VP9EncoderType::None, None);
-    }
-
     // Prefer hardware encoders (VAAPI) over software (libvpx-vp9)
-    let codec = encoders
-        .iter()
-        .find(|e| e.name.contains("vaapi"))
-        .or_else(|| encoders.first())
-        .unwrap();
-
-    let encoder_type = if codec.name.contains("vaapi") {
-        VP9EncoderType::Vaapi
+    if let Some((encoder_type, codec_name)) =
+        detect_best_codec_for_format(&encoders, DataFormat::VP9, |codec| {
+            codec.name.contains("vaapi")
+        })
+    {
+        info!("Selected VP9 encoder: {} ({})", codec_name, encoder_type);
+        (encoder_type, Some(codec_name))
     } else {
-        VP9EncoderType::Software // Default to software for unknown
-    };
-
-    info!("Selected VP9 encoder: {} ({})", codec.name, encoder_type);
-    (encoder_type, Some(codec.name.clone()))
+        warn!("No VP9 encoders available");
+        (VP9EncoderType::None, None)
+    }
 }
 
 /// Check if VP9 hardware encoding is available
 pub fn is_vp9_available() -> bool {
     let registry = EncoderRegistry::global();
-    registry.is_format_available(VideoEncoderType::VP9, true)
+    registry.is_codec_available(VideoEncoderType::VP9)
 }
 
 /// Encoded frame from hwcodec (cloned for ownership)
@@ -192,7 +185,7 @@ pub struct HwEncodeFrame {
     pub key: i32,
 }
 
-/// VP9 encoder using hwcodec (hardware only - VAAPI)
+/// VP9 encoder using hwcodec
 pub struct VP9Encoder {
     /// hwcodec encoder instance
     inner: HwEncoder,

src/video/shared_video_pipeline.rs

@@ -38,14 +38,12 @@ use crate::error::{AppError, Result};
 use crate::utils::LogThrottler;
 use crate::video::convert::{Nv12Converter, PixelConverter};
 use crate::video::decoder::MjpegTurboDecoder;
-use crate::video::encoder::h264::{detect_best_encoder, H264Config, H264Encoder, H264InputFormat};
-use crate::video::encoder::h265::{
-    detect_best_h265_encoder, H265Config, H265Encoder, H265InputFormat,
-};
+use crate::video::encoder::h264::{H264Config, H264Encoder, H264InputFormat};
+use crate::video::encoder::h265::{H265Config, H265Encoder, H265InputFormat};
 use crate::video::encoder::registry::{EncoderBackend, EncoderRegistry, VideoEncoderType};
 use crate::video::encoder::traits::EncoderConfig;
-use crate::video::encoder::vp8::{detect_best_vp8_encoder, VP8Config, VP8Encoder};
-use crate::video::encoder::vp9::{detect_best_vp9_encoder, VP9Config, VP9Encoder};
+use crate::video::encoder::vp8::{VP8Config, VP8Encoder};
+use crate::video::encoder::vp9::{VP9Config, VP9Encoder};
 use crate::video::format::{PixelFormat, Resolution};
 use crate::video::frame::{FrameBuffer, FrameBufferPool, VideoFrame};
 use crate::video::v4l2r_capture::V4l2rCaptureStream;
@@ -389,7 +387,7 @@ impl SharedVideoPipeline {
                         .encoder_with_backend(format, b)
                         .map(|e| e.codec_name.clone()),
                     None => registry
-                        .best_encoder(format, false)
+                        .best_available_encoder(format)
                         .map(|e| e.codec_name.clone()),
                 }
             };
@@ -447,10 +445,7 @@ impl SharedVideoPipeline {
                         ))
                     })?
                 } else {
-                    // Auto select best available encoder
-                    let (_encoder_type, detected) =
-                        detect_best_encoder(config.resolution.width, config.resolution.height);
-                    detected.ok_or_else(|| {
+                    get_codec_name(VideoEncoderType::H264, None).ok_or_else(|| {
                         AppError::VideoError("No H.264 encoder available".to_string())
                     })?
                 }
@@ -472,9 +467,7 @@ impl SharedVideoPipeline {
                         ))
                     })?
                 } else {
-                    let (_encoder_type, detected) =
-                        detect_best_h265_encoder(config.resolution.width, config.resolution.height);
-                    detected.ok_or_else(|| {
+                    get_codec_name(VideoEncoderType::H265, None).ok_or_else(|| {
                         AppError::VideoError("No H.265 encoder available".to_string())
                     })?
                 }
@@ -485,9 +478,7 @@ impl SharedVideoPipeline {
                         AppError::VideoError(format!("Backend {:?} does not support VP8", backend))
                     })?
                 } else {
-                    let (_encoder_type, detected) =
-                        detect_best_vp8_encoder(config.resolution.width, config.resolution.height);
-                    detected.ok_or_else(|| {
+                    get_codec_name(VideoEncoderType::VP8, None).ok_or_else(|| {
                         AppError::VideoError("No VP8 encoder available".to_string())
                     })?
                 }
@@ -498,9 +489,7 @@ impl SharedVideoPipeline {
                         AppError::VideoError(format!("Backend {:?} does not support VP9", backend))
                     })?
                 } else {
-                    let (_encoder_type, detected) =
-                        detect_best_vp9_encoder(config.resolution.width, config.resolution.height);
-                    detected.ok_or_else(|| {
+                    get_codec_name(VideoEncoderType::VP9, None).ok_or_else(|| {
                         AppError::VideoError("No VP9 encoder available".to_string())
                     })?
                 }

src/video/video_session.rs

@@ -191,15 +191,14 @@ impl VideoSessionManager {
         *self.frame_source.write().await = Some(rx);
     }
 
-    /// Get available codecs based on hardware capabilities
+    /// Get available codecs based on encoder availability
     pub fn available_codecs(&self) -> Vec<VideoEncoderType> {
         EncoderRegistry::global().selectable_formats()
     }
 
     /// Check if a codec is available
     pub fn is_codec_available(&self, codec: VideoEncoderType) -> bool {
-        let hardware_only = codec.hardware_only();
-        EncoderRegistry::global().is_format_available(codec, hardware_only)
+        EncoderRegistry::global().is_codec_available(codec)
     }
 
     /// Create a new video session
@@ -520,7 +519,7 @@ impl VideoSessionManager {
     /// Get codec info
     pub fn get_codec_info(&self, codec: VideoEncoderType) -> Option<CodecInfo> {
         let registry = EncoderRegistry::global();
-        let encoder = registry.best_encoder(codec, codec.hardware_only())?;
+        let encoder = registry.best_available_encoder(codec)?;
 
         Some(CodecInfo {
             codec_type: codec,