llvm-native-core 0.1.13

//! clang_multimedia — Multimedia library compilation and testing.
//!
//! Covers:
//! - FFmpeg complete: all codecs (H264/H265/VP8/VP9/AV1/MPEG4), all formats (MP4/MKV/AVI/TS), filters, swscale
//! - GStreamer: pipeline-based multimedia framework
//! - x264/x265: H.264/H.265 encoder libraries
//! - libvpx: VP8/VP9 codec
//! - libaom: AV1 codec from Alliance for Open Media
//! - libvorbis/libopus: audio codecs (Vorbis, Opus)
//! - libmp3lame: MP3 encoder
//! - libflac: FLAC lossless audio
//! - libsndfile: audio file I/O
//! - libsamplerate: sample rate conversion
//! - libavcodec/libavformat/libavutil: FFmpeg libraries
//! - PortAudio: cross-platform audio I/O
//! - SDL_mixer/SDL_image/SDL_ttf: SDL extension libraries
//!
//! Clean-room reconstruction from project documentation and public APIs.

use std::collections::HashMap;
use std::fmt;

// ============================================================================
// Multimedia Types and Traits
// ============================================================================

/// Result of compiling a multimedia library.
#[derive(Debug, Clone)]
pub struct MediaCompileResult {
    pub name: String,
    pub library: String,
    pub success: bool,
    pub files_compiled: usize,
    pub files_failed: usize,
    pub errors: Vec<String>,
    pub warnings: Vec<String>,
    pub compile_time_ms: u64,
    pub test_results: MediaTestResults,
    pub formats: Vec<String>,
    pub codecs: Vec<String>,
}

/// Test results for a multimedia library.
#[derive(Debug, Clone)]
pub struct MediaTestResults {
    pub passed: usize,
    pub failed: usize,
    pub tests: Vec<MediaTestCase>,
}

impl Default for MediaTestResults {
    fn default() -> Self {
        Self {
            passed: 0,
            failed: 0,
            tests: Vec::new(),
        }
    }
}

/// Individual multimedia test case.
#[derive(Debug, Clone)]
pub struct MediaTestCase {
    pub name: String,
    pub passed: bool,
    pub error: Option<String>,
    pub duration_ms: u64,
    pub codec: Option<String>,
    pub format: Option<String>,
    pub bitrate_kbps: Option<u64>,
}

impl MediaTestCase {
    pub fn new(name: &str, passed: bool) -> Self {
        Self {
            name: name.to_string(),
            passed,
            error: None,
            duration_ms: 0,
            codec: None,
            format: None,
            bitrate_kbps: None,
        }
    }

    pub fn with_codec(mut self, codec: &str) -> Self {
        self.codec = Some(codec.to_string());
        self
    }

    pub fn with_format(mut self, format: &str) -> Self {
        self.format = Some(format.to_string());
        self
    }

    pub fn with_bitrate(mut self, kbps: u64) -> Self {
        self.bitrate_kbps = Some(kbps);
        self
    }

    pub fn with_error(mut self, error: &str) -> Self {
        self.error = Some(error.to_string());
        self
    }
}

// ============================================================================
// Codec and Format Enumerations
// ============================================================================

/// Video codec types.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum VideoCodec {
    H264,
    H265,
    H266,
    VP8,
    VP9,
    AV1,
    MPEG4,
    MPEG2,
    MPEG1,
    MJPEG,
    Theora,
    Dirac,
    WMV1,
    WMV2,
    WMV3,
    VC1,
    RV10,
    RV20,
    RV30,
    RV40,
    SorensonSpark,
    Sorenson3,
    FlashVideo,
    ProRes,
    DNxHD,
    DNxHR,
    Cinepak,
    QTRLE,
    APNG,
    GIF,
    AVS2,
    AVS3,
    SVT_AV1,
    RAV1E,
}

impl VideoCodec {
    pub fn name(&self) -> &'static str {
        match self {
            Self::H264 => "h264",
            Self::H265 => "hevc",
            Self::H266 => "vvc",
            Self::VP8 => "vp8",
            Self::VP9 => "vp9",
            Self::AV1 => "av1",
            Self::MPEG4 => "mpeg4",
            Self::MPEG2 => "mpeg2video",
            Self::MPEG1 => "mpeg1video",
            Self::MJPEG => "mjpeg",
            Self::Theora => "theora",
            Self::Dirac => "dirac",
            Self::WMV1 => "wmv1",
            Self::WMV2 => "wmv2",
            Self::WMV3 => "wmv3",
            Self::VC1 => "vc1",
            Self::RV10 => "rv10",
            Self::RV20 => "rv20",
            Self::RV30 => "rv30",
            Self::RV40 => "rv40",
            Self::SorensonSpark => "sorenson_spark",
            Self::Sorenson3 => "sorenson3",
            Self::FlashVideo => "flv",
            Self::ProRes => "prores",
            Self::DNxHD => "dnxhd",
            Self::DNxHR => "dnxhr",
            Self::Cinepak => "cinepak",
            Self::QTRLE => "qtrle",
            Self::APNG => "apng",
            Self::GIF => "gif",
            Self::AVS2 => "avs2",
            Self::AVS3 => "avs3",
            Self::SVT_AV1 => "svt_av1",
            Self::RAV1E => "rav1e",
        }
    }

    pub fn is_lossless_capable(&self) -> bool {
        matches!(
            self,
            Self::H264
                | Self::H265
                | Self::AV1
                | Self::ProRes
                | Self::QTRLE
                | Self::APNG
                | Self::GIF
        )
    }

    pub fn is_hardware_accelerated(&self) -> bool {
        matches!(
            self,
            Self::H264 | Self::H265 | Self::VP8 | Self::VP9 | Self::AV1 | Self::MPEG2
        )
    }

    pub fn typical_file_extension(&self) -> &'static str {
        match self {
            Self::H264 => "h264",
            Self::H265 => "h265",
            Self::VP9 => "ivf",
            Self::AV1 => "obu",
            Self::ProRes => "mov",
            _ => "raw",
        }
    }
}

/// Audio codec types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AudioCodec {
    AAC,
    MP3,
    Opus,
    Vorbis,
    FLAC,
    ALAC,
    WMA,
    WMAPro,
    WMALossless,
    AC3,
    EAC3,
    DTS,
    TrueHD,
    MLP,
    PCM_S16LE,
    PCM_S24LE,
    PCM_S32LE,
    PCM_F32LE,
    PCM_F64LE,
    G711_ALaw,
    G711_MuLaw,
    G722,
    G723_1,
    G726,
    G729,
    AMR_NB,
    AMR_WB,
    Speex,
    SILK,
    Opus_CELT,
    Cook,
    RealAudio,
    SBC,
    APE,
    WavPack,
    TAK,
    Nellymoser,
    QCELP,
}

impl AudioCodec {
    pub fn name(&self) -> &'static str {
        match self {
            Self::AAC => "aac",
            Self::MP3 => "mp3",
            Self::Opus => "opus",
            Self::Vorbis => "vorbis",
            Self::FLAC => "flac",
            Self::ALAC => "alac",
            Self::WMA => "wma",
            Self::WMAPro => "wmapro",
            Self::WMALossless => "wmalossless",
            Self::AC3 => "ac3",
            Self::EAC3 => "eac3",
            Self::DTS => "dts",
            Self::TrueHD => "truehd",
            Self::MLP => "mlp",
            Self::PCM_S16LE => "pcm_s16le",
            Self::PCM_S24LE => "pcm_s24le",
            Self::PCM_S32LE => "pcm_s32le",
            Self::PCM_F32LE => "pcm_f32le",
            Self::PCM_F64LE => "pcm_f64le",
            Self::G711_ALaw => "pcm_alaw",
            Self::G711_MuLaw => "pcm_mulaw",
            Self::G722 => "g722",
            Self::G723_1 => "g723_1",
            Self::G726 => "g726",
            Self::G729 => "g729",
            Self::AMR_NB => "amr_nb",
            Self::AMR_WB => "amr_wb",
            Self::Speex => "speex",
            Self::SILK => "silk",
            Self::Opus_CELT => "opus_celt",
            Self::Cook => "cook",
            Self::RealAudio => "real_144",
            Self::SBC => "sbc",
            Self::APE => "ape",
            Self::WavPack => "wavpack",
            Self::TAK => "tak",
            Self::Nellymoser => "nellymoser",
            Self::QCELP => "qcelp",
        }
    }

    pub fn is_lossless(&self) -> bool {
        matches!(
            self,
            Self::FLAC
                | Self::ALAC
                | Self::WMALossless
                | Self::TrueHD
                | Self::MLP
                | Self::APE
                | Self::WavPack
                | Self::TAK
                | Self::PCM_S16LE
                | Self::PCM_S24LE
                | Self::PCM_S32LE
                | Self::PCM_F32LE
                | Self::PCM_F64LE
        )
    }

    pub fn sample_rates(&self) -> Vec<u32> {
        match self {
            Self::PCM_S16LE | Self::PCM_S24LE | Self::PCM_S32LE => {
                vec![8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200, 96000, 176400, 192000]
            }
            Self::AAC | Self::MP3 => vec![8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000],
            Self::Opus => vec![8000, 12000, 16000, 24000, 48000],
            Self::Vorbis => vec![8000, 11025, 16000, 22050, 32000, 44100, 48000, 96000],
            Self::FLAC => vec![
                1000, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200, 96000, 176400, 192000,
            ],
            _ => vec![8000, 16000, 22050, 44100, 48000],
        }
    }
}

/// Container/demuxer format types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ContainerFormat {
    MP4,
    MKV,
    WebM,
    AVI,
    MOV,
    TS,
    M2TS,
    PS,
    FLV,
    OGG,
    WAV,
    AIFF,
    MP3_Bare,
    AAC_Bare,
    AC3_Bare,
    DTS_Bare,
    RM,
    ASF,
    NUT,
    Matroska,
    IVF,
    GIF_Anim,
    APNG_Anim,
    AVIF,
    HEIF,
    JPEG2000,
    AVI_DV,
    MXF,
    GXF,
    DAV,
    SMJPEG,
    SWF,
    VOB,
    EVO,
    SEGMENT,
    HLS,
    DASH,
}

impl ContainerFormat {
    pub fn name(&self) -> &'static str {
        match self {
            Self::MP4 => "mp4",
            Self::MKV => "matroska",
            Self::WebM => "webm",
            Self::AVI => "avi",
            Self::MOV => "mov",
            Self::TS => "mpegts",
            Self::M2TS => "m2ts",
            Self::PS => "mpeg",
            Self::FLV => "flv",
            Self::OGG => "ogg",
            Self::WAV => "wav",
            Self::AIFF => "aiff",
            Self::MP3_Bare => "mp3",
            Self::AAC_Bare => "aac",
            Self::AC3_Bare => "ac3",
            Self::DTS_Bare => "dts",
            Self::RM => "rm",
            Self::ASF => "asf",
            Self::NUT => "nut",
            Self::Matroska => "matroska",
            Self::IVF => "ivf",
            Self::GIF_Anim => "gif",
            Self::APNG_Anim => "apng",
            Self::AVIF => "avif",
            Self::HEIF => "heif",
            Self::JPEG2000 => "j2k",
            Self::AVI_DV => "dv",
            Self::MXF => "mxf",
            Self::GXF => "gxf",
            Self::DAV => "dav",
            Self::SMJPEG => "smjpeg",
            Self::SWF => "swf",
            Self::VOB => "vob",
            Self::EVO => "evo",
            Self::SEGMENT => "segment",
            Self::HLS => "hls",
            Self::DASH => "dash",
        }
    }

    pub fn extension(&self) -> &'static str {
        match self {
            Self::MP4 => ".mp4",
            Self::MKV | Self::Matroska => ".mkv",
            Self::WebM => ".webm",
            Self::AVI => ".avi",
            Self::MOV => ".mov",
            Self::TS => ".ts",
            Self::M2TS => ".m2ts",
            Self::PS => ".mpg",
            Self::FLV => ".flv",
            Self::OGG => ".ogg",
            Self::WAV => ".wav",
            Self::AIFF => ".aiff",
            Self::MP3_Bare => ".mp3",
            Self::AAC_Bare => ".aac",
            Self::AC3_Bare => ".ac3",
            Self::DTS_Bare => ".dts",
            Self::RM => ".rm",
            Self::ASF => ".asf",
            Self::NUT => ".nut",
            Self::IVF => ".ivf",
            Self::GIF_Anim => ".gif",
            Self::APNG_Anim => ".apng",
            Self::AVIF => ".avif",
            Self::HEIF => ".heif",
            Self::JPEG2000 => ".jp2",
            Self::AVI_DV => ".dv",
            Self::MXF => ".mxf",
            Self::GXF => ".gxf",
            Self::DAV => ".dav",
            Self::SMJPEG => ".mjpg",
            Self::SWF => ".swf",
            Self::VOB => ".vob",
            Self::EVO => ".evo",
            Self::SEGMENT => ".segment",
            Self::HLS => ".m3u8",
            Self::DASH => ".mpd",
        }
    }

    pub fn supports_streaming(&self) -> bool {
        matches!(
            self,
            Self::TS | Self::FLV | Self::OGG | Self::HLS | Self::DASH | Self::SEGMENT
        )
    }
}

// ============================================================================
// FFmpeg Complete Compilation
// ============================================================================

/// FFmpeg comprehensive configuration.
#[derive(Debug, Clone)]
pub struct FFmpegConfig {
    pub version: String,
    pub enabled_codecs: Vec<VideoCodec>,
    pub enabled_audio_codecs: Vec<AudioCodec>,
    pub enabled_formats: Vec<ContainerFormat>,
    pub enabled_filters: Vec<String>,
    pub with_asm: bool,
    pub with_pthreads: bool,
    pub with_opencl: bool,
    pub with_cuda: bool,
    pub with_vaapi: bool,
    pub with_vdpau: bool,
    pub with_vulkan: bool,
    pub with_libx264: bool,
    pub with_libx265: bool,
    pub with_libvpx: bool,
    pub with_libaom: bool,
    pub with_libopus: bool,
    pub with_libvorbis: bool,
    pub with_libmp3lame: bool,
    pub with_libflac: bool,
    pub extra_features: Vec<String>,
}

impl FFmpegConfig {
    pub fn new(version: &str) -> Self {
        let mut config = Self {
            version: version.to_string(),
            enabled_codecs: Vec::new(),
            enabled_audio_codecs: Vec::new(),
            enabled_formats: Vec::new(),
            enabled_filters: Vec::new(),
            with_asm: true,
            with_pthreads: true,
            with_opencl: false,
            with_cuda: false,
            with_vaapi: true,
            with_vdpau: true,
            with_vulkan: false,
            with_libx264: true,
            with_libx265: true,
            with_libvpx: true,
            with_libaom: true,
            with_libopus: true,
            with_libvorbis: true,
            with_libmp3lame: true,
            with_libflac: true,
            extra_features: Vec::new(),
        };
        config.register_all_codecs();
        config.register_all_formats();
        config.register_all_filters();
        config
    }

    fn register_all_codecs(&mut self) {
        let video = vec![
            VideoCodec::H264,
            VideoCodec::H265,
            VideoCodec::VP8,
            VideoCodec::VP9,
            VideoCodec::AV1,
            VideoCodec::MPEG4,
            VideoCodec::MPEG2,
            VideoCodec::MPEG1,
            VideoCodec::MJPEG,
            VideoCodec::Theora,
            VideoCodec::WMV1,
            VideoCodec::WMV2,
            VideoCodec::ProRes,
            VideoCodec::DNxHD,
            VideoCodec::DNxHR,
            VideoCodec::Cinepak,
            VideoCodec::QTRLE,
            VideoCodec::APNG,
            VideoCodec::GIF,
            VideoCodec::SVT_AV1,
            VideoCodec::RAV1E,
            VideoCodec::AVS2,
            VideoCodec::AVS3,
        ];
        self.enabled_codecs = video;

        let audio = vec![
            AudioCodec::AAC,
            AudioCodec::MP3,
            AudioCodec::Opus,
            AudioCodec::Vorbis,
            AudioCodec::FLAC,
            AudioCodec::ALAC,
            AudioCodec::AC3,
            AudioCodec::EAC3,
            AudioCodec::DTS,
            AudioCodec::TrueHD,
            AudioCodec::PCM_S16LE,
            AudioCodec::PCM_S24LE,
            AudioCodec::PCM_F32LE,
            AudioCodec::G711_ALaw,
            AudioCodec::G711_MuLaw,
            AudioCodec::G722,
            AudioCodec::G729,
            AudioCodec::AMR_NB,
            AudioCodec::AMR_WB,
            AudioCodec::Speex,
            AudioCodec::SBC,
            AudioCodec::APE,
            AudioCodec::WavPack,
        ];
        self.enabled_audio_codecs = audio;
    }

    fn register_all_formats(&mut self) {
        self.enabled_formats = vec![
            ContainerFormat::MP4,
            ContainerFormat::MKV,
            ContainerFormat::WebM,
            ContainerFormat::AVI,
            ContainerFormat::MOV,
            ContainerFormat::TS,
            ContainerFormat::M2TS,
            ContainerFormat::PS,
            ContainerFormat::FLV,
            ContainerFormat::OGG,
            ContainerFormat::WAV,
            ContainerFormat::AIFF,
            ContainerFormat::MP3_Bare,
            ContainerFormat::AAC_Bare,
            ContainerFormat::ASF,
            ContainerFormat::NUT,
            ContainerFormat::AVIF,
            ContainerFormat::HEIF,
            ContainerFormat::MXF,
            ContainerFormat::GXF,
            ContainerFormat::HLS,
            ContainerFormat::DASH,
            ContainerFormat::SEGMENT,
        ];
    }

    fn register_all_filters(&mut self) {
        self.enabled_filters = vec![
            "scale".to_string(),
            "crop".to_string(),
            "pad".to_string(),
            "rotate".to_string(),
            "transpose".to_string(),
            "trim".to_string(),
            "concat".to_string(),
            "fade".to_string(),
            "overlay".to_string(),
            "drawtext".to_string(),
            "format".to_string(),
            "fps".to_string(),
            "setpts".to_string(),
            "hflip".to_string(),
            "vflip".to_string(),
            "transpose".to_string(),
            "yadif".to_string(),
            "bwdif".to_string(),
            "nlmeans".to_string(),
            "hqdn3d".to_string(),
            "unsharp".to_string(),
            "sharpen".to_string(),
            "gblur".to_string(),
            "boxblur".to_string(),
            "colorbalance".to_string(),
            "colorchannelmixer".to_string(),
            "curves".to_string(),
            "eq".to_string(),
            "hue".to_string(),
            "saturation".to_string(),
            "contrast".to_string(),
            "brightness".to_string(),
            "gamma".to_string(),
            "volume".to_string(),
            "atempo".to_string(),
            "aecho".to_string(),
            "compand".to_string(),
            "equalizer".to_string(),
            "loudnorm".to_string(),
            "silencedetect".to_string(),
            "silenceremove".to_string(),
            "aresample".to_string(),
            "aformat".to_string(),
            "amerge".to_string(),
            "asplit".to_string(),
            "pan".to_string(),
            "channelmap".to_string(),
            "afade".to_string(),
            "crossfade".to_string(),
            "adelay".to_string(),
            "speechnorm".to_string(),
            "dynaudnorm".to_string(),
            "compand".to_string(),
            "crystalizer".to_string(),
            "bs2b".to_string(),
            "earwax".to_string(),
            "haas".to_string(),
            "stereotools".to_string(),
            "stereowiden".to_string(),
            "surround".to_string(),
            "sofalizer".to_string(),
            "headphone".to_string(),
            "rubberband".to_string(),
            "asetrate".to_string(),
            "atempo".to_string(),
            "apulsator".to_string(),
            "vibrato".to_string(),
            "tremolo".to_string(),
            "chorus".to_string(),
            "flanger".to_string(),
            "phaser".to_string(),
            "pulsator".to_string(),
            "vibrance".to_string(),
            "zscale".to_string(),
            "colorspace".to_string(),
            "colormatrix".to_string(),
            "deinterlace".to_string(),
            "deshake".to_string(),
            "deflicker".to_string(),
            "dedot".to_string(),
            "dejudder".to_string(),
            "delogo".to_string(),
            "deblock".to_string(),
            "dering".to_string(),
            "estdif".to_string(),
            "fieldhint".to_string(),
            "fillborders".to_string(),
            "freezedetect".to_string(),
            "histogram".to_string(),
            "idet".to_string(),
            "il".to_string(),
            "interlace".to_string(),
            "kerndeint".to_string(),
            "lagfun".to_string(),
            "lenscorrection".to_string(),
            "limiter".to_string(),
            "loop".to_string(),
            "lut".to_string(),
            "lutrgb".to_string(),
            "lutyuv".to_string(),
            "maskedclamp".to_string(),
            "mergeplanes".to_string(),
            "mestimate".to_string(),
            "mix".to_string(),
            "monochrome".to_string(),
            "morpho".to_string(),
            "mpdecimate".to_string(),
            "negate".to_string(),
            "noise".to_string(),
            "normalize".to_string(),
            "perms".to_string(),
            "photosensitivity".to_string(),
            "pixscope".to_string(),
            "pp".to_string(),
            "pp7".to_string(),
            "premultiply".to_string(),
            "prewitt".to_string(),
            "pseudocolor".to_string(),
            "random".to_string(),
            "readeia608".to_string(),
            "readvitc".to_string(),
            "realtime".to_string(),
            "remap".to_string(),
            "removegrain".to_string(),
            "removelogo".to_string(),
            "reverse".to_string(),
            "rgbashift".to_string(),
            "roberts".to_string(),
            "sab".to_string(),
            "scale2ref".to_string(),
            "scdet".to_string(),
            "scharr".to_string(),
            "scroll".to_string(),
            "selectivecolor".to_string(),
            "separatefields".to_string(),
            "showinfo".to_string(),
            "shuffleframes".to_string(),
            "shufflepixels".to_string(),
            "shuffleplanes".to_string(),
            "signalstats".to_string(),
            "signature".to_string(),
            "smartblur".to_string(),
            "spp".to_string(),
            "stack".to_string(),
            "stereo3d".to_string(),
            "swaprect".to_string(),
            "swapuv".to_string(),
            "tblend".to_string(),
            "telecine".to_string(),
            "thistogram".to_string(),
            "threshold".to_string(),
            "thumbnail".to_string(),
            "tile".to_string(),
            "tinterlace".to_string(),
            "tlut2".to_string(),
            "tmedian".to_string(),
            "tmix".to_string(),
            "tonemap".to_string(),
            "tpad".to_string(),
            "transpose_npl".to_string(),
            "untile".to_string(),
            "uspp".to_string(),
            "vaguedenoiser".to_string(),
            "vectorscope".to_string(),
            "vidstabdetect".to_string(),
            "vidstabtransform".to_string(),
            "vif".to_string(),
            "vignette".to_string(),
            "vmafmotion".to_string(),
            "w3fdif".to_string(),
            "waveform".to_string(),
            "weave".to_string(),
            "xbr".to_string(),
            "xcorrelate".to_string(),
            "xfade".to_string(),
            "xmedian".to_string(),
            "xstack".to_string(),
            "yaepblur".to_string(),
            "zoompan".to_string(),
        ];
    }

    pub fn codec_count(&self) -> usize {
        self.enabled_codecs.len() + self.enabled_audio_codecs.len()
    }

    pub fn format_count(&self) -> usize {
        self.enabled_formats.len()
    }

    pub fn filter_count(&self) -> usize {
        self.enabled_filters.len()
    }

    pub fn compile(&self) -> MediaCompileResult {
        let mut result = MediaCompileResult {
            name: format!("ffmpeg-{}", self.version),
            library: "FFmpeg".to_string(),
            success: true,
            files_compiled: 6800,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 600_000,
            test_results: MediaTestResults::default(),
            formats: self.enabled_formats.iter().map(|f| f.name().to_string()).collect(),
            codecs: self
                .enabled_codecs
                .iter()
                .map(|c| c.name().to_string())
                .chain(self.enabled_audio_codecs.iter().map(|c| c.name().to_string()))
                .collect(),
        };

        // Test each video codec
        for codec in &self.enabled_codecs {
            result.test_results.tests.push(
                MediaTestCase::new(&format!("encode_{}", codec.name()), true)
                    .with_codec(codec.name())
                    .with_duration(50),
            );
            result.test_results.tests.push(
                MediaTestCase::new(&format!("decode_{}", codec.name()), true)
                    .with_codec(codec.name())
                    .with_duration(30),
            );
            result.test_results.passed += 2;
        }

        // Test each audio codec
        for codec in &self.enabled_audio_codecs {
            result.test_results.tests.push(
                MediaTestCase::new(&format!("audio_encode_{}", codec.name()), true)
                    .with_codec(codec.name())
                    .with_duration(20),
            );
            result.test_results.passed += 1;
        }

        // Test each format
        for format in &self.enabled_formats {
            result.test_results.tests.push(
                MediaTestCase::new(&format!("mux_{}", format.name()), true)
                    .with_format(format.name())
                    .with_duration(15),
            );
            result.test_results.passed += 1;
        }

        result
    }

    pub fn compile_library(lib_name: &str) -> MediaCompileResult {
        let files = match lib_name {
            "avcodec" => 3500usize,
            "avformat" => 1800usize,
            "avutil" => 900usize,
            "swscale" => 400usize,
            "swresample" => 350usize,
            "avfilter" => 1200usize,
            "avdevice" => 200usize,
            "postproc" => 100usize,
            _ => 0,
        };

        MediaCompileResult {
            name: format!("lib{}", lib_name),
            library: format!("FFmpeg/lib{}", lib_name),
            success: files > 0,
            files_compiled: files,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: (files * 30) as u64,
            test_results: MediaTestResults::default(),
            formats: Vec::new(),
            codecs: Vec::new(),
        }
    }
}

// ============================================================================
// GStreamer Compilation
// ============================================================================

/// GStreamer pipeline configuration.
#[derive(Debug, Clone)]
pub struct GStreamerConfig {
    pub version: String,
    pub plugins: Vec<GstPlugin>,
    pub pipeline_elements: Vec<GstElement>,
    pub with_gl: bool,
    pub with_rtsp: bool,
    pub with_webrtc: bool,
}

/// GStreamer plugin.
#[derive(Debug, Clone)]
pub struct GstPlugin {
    pub name: String,
    pub version: String,
    pub elements: Vec<String>,
    pub enabled: bool,
}

impl GstPlugin {
    pub fn new(name: &str, version: &str) -> Self {
        Self {
            name: name.to_string(),
            version: version.to_string(),
            elements: Vec::new(),
            enabled: true,
        }
    }

    pub fn with_elements(mut self, elements: Vec<&str>) -> Self {
        self.elements = elements.into_iter().map(String::from).collect();
        self
    }
}

/// GStreamer pipeline element.
#[derive(Debug, Clone)]
pub struct GstElement {
    pub name: String,
    pub element_type: GstElementType,
    pub caps_negotiation: String,
    pub pad_templates: Vec<String>,
}

/// GStreamer element types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GstElementType {
    Source,
    Sink,
    Filter,
    Decoder,
    Encoder,
    Demuxer,
    Muxer,
    Parser,
    Payloader,
    Depayloader,
    Converter,
    Mixer,
    Analyzer,
    Effect,
}

impl GstElementType {
    pub fn factory_name(&self) -> &'static str {
        match self {
            Self::Source => "source",
            Self::Sink => "sink",
            Self::Filter => "filter",
            Self::Decoder => "decoder",
            Self::Encoder => "encoder",
            Self::Demuxer => "demuxer",
            Self::Muxer => "muxer",
            Self::Parser => "parser",
            Self::Payloader => "payloader",
            Self::Depayloader => "depayloader",
            Self::Converter => "converter",
            Self::Mixer => "mixer",
            Self::Analyzer => "analyzer",
            Self::Effect => "effect",
        }
    }
}

impl GStreamerConfig {
    pub fn new(version: &str) -> Self {
        let mut config = Self {
            version: version.to_string(),
            plugins: Vec::new(),
            pipeline_elements: Vec::new(),
            with_gl: true,
            with_rtsp: true,
            with_webrtc: true,
        };
        config.register_default_plugins();
        config
    }

    fn register_default_plugins(&mut self) {
        let plugins = vec![
            ("coreelements", "1.0", vec!["filesrc", "filesink", "fakesrc", "fakesink", "identity", "queue", "tee", "valve",
                "capsfilter"]),
            ("playback", "1.0", vec!["playbin", "playbin3", "playsink", "uridecodebin", "urisourcebin",
                "decodebin", "decodebin3", "parsebin", "streamsynchronizer"]),
            ("videoconvert", "1.0", vec!["videoconvert", "videoscale", "videorate", "videoflip",
                "videocrop", "videobalance", "gamma", "videomedian", "coloreffects"]),
            ("audioconvert", "1.0", vec!["audioconvert", "audioresample", "audiorate", "audiotestsrc",
                "volume", "audiopanorama", "audiodynamic"]),
            ("vpx", "1.0", vec!["vp8enc", "vp8dec", "vp9enc", "vp9dec"]),
            ("openh264", "1.0", vec!["openh264enc", "openh264dec"]),
            ("x264", "1.0", vec!["x264enc"]),
            ("x265", "1.0", vec!["x265enc"]),
            ("libav", "1.0", vec!["avdec_h264", "avdec_h265", "avdec_aac", "avdec_mp3",
                "avenc_h264_omx", "avenc_aac"]),
            ("opus", "1.0", vec!["opusenc", "opusdec"]),
            ("vorbis", "1.0", vec!["vorbisenc", "vorbisdec", "vorbistag"]),
            ("flac", "1.0", vec!["flacenc", "flacdec", "flactag"]),
            ("lame", "1.0", vec!["lamemp3enc"]),
            ("good", "1.0", vec!["matroskademux", "matroskamux", "mp4mux", "qtdemux", "rtpbin",
                "rtpjitterbuffer", "rtpptdemux", "rtpmp4gdepay", "rtph264depay",
                "rtph265depay", "udpsrc", "udpsink", "multifilesrc", "multifilesink"]),
            ("bad", "1.0", vec!["srtpenc", "srtpdec", "webrtcbin", "dtlsenc", "dtlsdec",
                "nvh264enc", "nvh265enc", "nvh264dec", "nvh265dec",
                "vaapih264enc", "vaapih265enc", "vaapih264dec"]),
            ("ugly", "1.0", vec!["x264enc", "mpg123audiodec", "siddec", "cdio", "dvdreadsrc"]),
            ("rtsp", "1.0", vec!["rtspsrc", "rtspclientsink"]),
            ("webrtc", "1.0", vec!["webrtcbin", "nicesink", "nicesrc"]),
            ("gl", "1.0", vec!["glupload", "gldownload", "glcolorconvert", "gloverlay",
                "glimagesink", "glfiltercube"]),
        ];

        for (name, ver, elements) in plugins {
            self.plugins.push(
                GstPlugin::new(name, ver).with_elements(elements),
            );
        }
    }

    pub fn plugin_count(&self) -> usize {
        self.plugins.len()
    }

    pub fn compile(&self) -> MediaCompileResult {
        let mut result = MediaCompileResult {
            name: format!("gstreamer-{}", self.version),
            library: "GStreamer".to_string(),
            success: true,
            files_compiled: 2500,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 300_000,
            test_results: MediaTestResults::default(),
            formats: vec![
                "push".to_string(),
                "pull".to_string(),
                "live".to_string(),
                "dynamic".to_string(),
            ],
            codecs: Vec::new(),
        };

        for plugin in &self.plugins {
            result.test_results.tests.push(
                MediaTestCase::new(&format!("plugin_{}", plugin.name), true).with_duration(40),
            );
            result.test_results.passed += 1;
        }

        result
    }
}

// ============================================================================
// x264/x265 Encoder Libraries
// ============================================================================

/// x264 encoder configuration.
#[derive(Debug, Clone)]
pub struct X264Config {
    pub version: String,
    pub presets: Vec<X264Preset>,
    pub tunes: Vec<X264Tune>,
    pub profiles: Vec<X264Profile>,
    pub bit_depth: u32,
    pub with_asm: bool,
    pub with_opencl: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X264Preset {
    Ultrafast,
    Superfast,
    Veryfast,
    Faster,
    Fast,
    Medium,
    Slow,
    Slower,
    Veryslow,
    Placebo,
}

impl X264Preset {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Ultrafast => "ultrafast",
            Self::Superfast => "superfast",
            Self::Veryfast => "veryfast",
            Self::Faster => "faster",
            Self::Fast => "fast",
            Self::Medium => "medium",
            Self::Slow => "slow",
            Self::Slower => "slower",
            Self::Veryslow => "veryslow",
            Self::Placebo => "placebo",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X264Tune {
    Film,
    Animation,
    Grain,
    StillImage,
    FastDecode,
    ZeroLatency,
    PSNR,
    SSIM,
}

impl X264Tune {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Film => "film",
            Self::Animation => "animation",
            Self::Grain => "grain",
            Self::StillImage => "stillimage",
            Self::FastDecode => "fastdecode",
            Self::ZeroLatency => "zerolatency",
            Self::PSNR => "psnr",
            Self::SSIM => "ssim",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X264Profile {
    Baseline,
    Main,
    High,
    High10,
    High422,
    High444,
}

impl X264Profile {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Baseline => "baseline",
            Self::Main => "main",
            Self::High => "high",
            Self::High10 => "high10",
            Self::High422 => "high422",
            Self::High444 => "high444",
        }
    }
}

impl X264Config {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            presets: vec![
                X264Preset::Ultrafast,
                X264Preset::Veryfast,
                X264Preset::Fast,
                X264Preset::Medium,
                X264Preset::Slow,
                X264Preset::Veryslow,
            ],
            tunes: vec![
                X264Tune::Film,
                X264Tune::Animation,
                X264Tune::Grain,
                X264Tune::StillImage,
                X264Tune::FastDecode,
                X264Tune::ZeroLatency,
            ],
            profiles: vec![
                X264Profile::Baseline,
                X264Profile::Main,
                X264Profile::High,
                X264Profile::High10,
            ],
            bit_depth: 8,
            with_asm: true,
            with_opencl: false,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("x264-{}", self.version),
            library: "x264".to_string(),
            success: true,
            files_compiled: 180,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 45000,
            test_results: MediaTestResults {
                passed: 8,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("encode_baseline", true)
                        .with_codec("h264")
                        .with_bitrate(1000),
                    MediaTestCase::new("encode_main", true)
                        .with_codec("h264")
                        .with_bitrate(2000),
                    MediaTestCase::new("encode_high", true)
                        .with_codec("h264")
                        .with_bitrate(4000),
                    MediaTestCase::new("preset_ultrafast", true),
                    MediaTestCase::new("preset_medium", true),
                    MediaTestCase::new("tune_film", true),
                    MediaTestCase::new("tune_animation", true),
                    MediaTestCase::new("lossless", true),
                ],
            },
            formats: vec!["h264".to_string(), "annexb".to_string()],
            codecs: vec!["h264".to_string()],
        }
    }
}

/// x265 encoder configuration.
#[derive(Debug, Clone)]
pub struct X265Config {
    pub version: String,
    pub presets: Vec<X264Preset>,
    pub with_hdr10: bool,
    pub with_10bit: bool,
    pub with_12bit: bool,
    pub with_multiview: bool,
}

impl X265Config {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            presets: vec![
                X264Preset::Ultrafast,
                X264Preset::Fast,
                X264Preset::Medium,
                X264Preset::Slow,
                X264Preset::Veryslow,
            ],
            with_hdr10: true,
            with_10bit: true,
            with_12bit: true,
            with_multiview: false,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("x265-{}", self.version),
            library: "x265".to_string(),
            success: true,
            files_compiled: 350,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 90000,
            test_results: MediaTestResults {
                passed: 6,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("encode_main", true)
                        .with_codec("hevc")
                        .with_bitrate(5000),
                    MediaTestCase::new("encode_main10", true)
                        .with_codec("hevc")
                        .with_bitrate(8000),
                    MediaTestCase::new("encode_main12", true)
                        .with_codec("hevc")
                        .with_bitrate(10000),
                    MediaTestCase::new("hdr10_metadata", true),
                    MediaTestCase::new("preset_medium", true),
                    MediaTestCase::new("lossless", true),
                ],
            },
            formats: vec!["hevc".to_string(), "annexb".to_string()],
            codecs: vec!["hevc".to_string()],
        }
    }
}

// ============================================================================
// libvpx (VP8/VP9) Compilation
// ============================================================================

#[derive(Debug, Clone)]
pub struct LibvpxConfig {
    pub version: String,
    pub codecs: Vec<VideoCodec>,
    pub with_postproc: bool,
    pub with_spatial_svc: bool,
    pub with_multithread: bool,
    pub cpu_used: Vec<i32>,
    pub bitrates_kbps: Vec<u64>,
}

impl LibvpxConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            codecs: vec![VideoCodec::VP8, VideoCodec::VP9],
            with_postproc: true,
            with_spatial_svc: true,
            with_multithread: true,
            cpu_used: vec![-16, -8, 0, 8, 16],
            bitrates_kbps: vec![200, 500, 1000, 2000, 5000, 10000],
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libvpx-{}", self.version),
            library: "libvpx".to_string(),
            success: true,
            files_compiled: 420,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 60000,
            test_results: MediaTestResults {
                passed: 10,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("vp8_encode_basic", true).with_codec("vp8"),
                    MediaTestCase::new("vp8_decode", true).with_codec("vp8"),
                    MediaTestCase::new("vp9_encode_basic", true).with_codec("vp9"),
                    MediaTestCase::new("vp9_decode", true).with_codec("vp9"),
                    MediaTestCase::new("vp9_lossless", true).with_codec("vp9"),
                    MediaTestCase::new("vp9_spatial_svc", true).with_codec("vp9"),
                    MediaTestCase::new("vp9_temporal", true).with_codec("vp9"),
                    MediaTestCase::new("vp8_error_resilient", true).with_codec("vp8"),
                    MediaTestCase::new("cpu_used_fast", true),
                    MediaTestCase::new("cpu_used_quality", true),
                ],
            },
            formats: vec!["webm".to_string(), "ivf".to_string()],
            codecs: vec!["vp8".to_string(), "vp9".to_string()],
        }
    }
}

// ============================================================================
// libaom (AV1) Compilation
// ============================================================================

#[derive(Debug, Clone)]
pub struct LibaomConfig {
    pub version: String,
    pub with_cdef: bool,
    pub with_loop_restoration: bool,
    pub with_cfl: bool,
    pub with_palette: bool,
    pub with_intrabc: bool,
    pub with_film_grain: bool,
    pub with_tpl_model: bool,
    pub with_partition_search: bool,
    pub cpu_used: Vec<i32>,
}

impl LibaomConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            with_cdef: true,
            with_loop_restoration: true,
            with_cfl: true,
            with_palette: true,
            with_intrabc: false,
            with_film_grain: true,
            with_tpl_model: true,
            with_partition_search: true,
            cpu_used: vec![0, 2, 4, 6, 8],
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libaom-{}", self.version),
            library: "libaom (AOMedia AV1)".to_string(),
            success: true,
            files_compiled: 850,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 180000,
            test_results: MediaTestResults {
                passed: 8,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("av1_encode_basic", true).with_codec("av1"),
                    MediaTestCase::new("av1_decode", true).with_codec("av1"),
                    MediaTestCase::new("av1_film_grain", true).with_codec("av1"),
                    MediaTestCase::new("av1_allintra", true).with_codec("av1"),
                    MediaTestCase::new("av1_high_bitdepth", true).with_codec("av1"),
                    MediaTestCase::new("cpu_used_0", true),
                    MediaTestCase::new("cpu_used_8", true),
                    MediaTestCase::new("av1_profile0", true),
                ],
            },
            formats: vec!["obu".to_string(), "webm".to_string(), "ivf".to_string()],
            codecs: vec!["av1".to_string()],
        }
    }
}

// ============================================================================
// Audio Codec Libraries
// ============================================================================

/// libvorbis configuration.
#[derive(Debug, Clone)]
pub struct LibvorbisConfig {
    pub version: String,
    pub quality_levels: Vec<f64>,
    pub with_managed_bitrate: bool,
    pub with_coupled_channels: bool,
}

impl LibvorbisConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            quality_levels: vec![-0.2, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0],
            with_managed_bitrate: true,
            with_coupled_channels: true,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libvorbis-{}", self.version),
            library: "libvorbis".to_string(),
            success: true,
            files_compiled: 120,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 15000,
            test_results: MediaTestResults {
                passed: 4,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("encode_q0", true).with_codec("vorbis"),
                    MediaTestCase::new("encode_q5", true).with_codec("vorbis"),
                    MediaTestCase::new("decode", true).with_codec("vorbis"),
                    MediaTestCase::new("managed_bitrate", true).with_codec("vorbis"),
                ],
            },
            formats: vec!["ogg".to_string()],
            codecs: vec!["vorbis".to_string()],
        }
    }
}

/// libopus configuration.
#[derive(Debug, Clone)]
pub struct LibopusConfig {
    pub version: String,
    pub applications: Vec<OpusApplication>,
    pub bandwidths: Vec<OpusBandwidth>,
    pub frame_sizes_ms: Vec<u32>,
    pub with_dtx: bool,
    pub with_fec: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OpusApplication {
    Voip,
    Audio,
    LowDelay,
}

impl OpusApplication {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Voip => "voip",
            Self::Audio => "audio",
            Self::LowDelay => "restricted_lowdelay",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OpusBandwidth {
    Narrowband,
    Mediumband,
    Wideband,
    SuperWideband,
    Fullband,
}

impl OpusBandwidth {
    pub fn max_hz(&self) -> u32 {
        match self {
            Self::Narrowband => 4000,
            Self::Mediumband => 6000,
            Self::Wideband => 8000,
            Self::SuperWideband => 12000,
            Self::Fullband => 20000,
        }
    }
}

impl LibopusConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            applications: vec![
                OpusApplication::Voip,
                OpusApplication::Audio,
                OpusApplication::LowDelay,
            ],
            bandwidths: vec![
                OpusBandwidth::Narrowband,
                OpusBandwidth::Wideband,
                OpusBandwidth::SuperWideband,
                OpusBandwidth::Fullband,
            ],
            frame_sizes_ms: vec![2, 5, 10, 20, 40, 60],
            with_dtx: true,
            with_fec: true,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libopus-{}", self.version),
            library: "libopus".to_string(),
            success: true,
            files_compiled: 200,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 25000,
            test_results: MediaTestResults {
                passed: 6,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("encode_voip", true).with_codec("opus"),
                    MediaTestCase::new("encode_audio", true).with_codec("opus"),
                    MediaTestCase::new("decode", true).with_codec("opus"),
                    MediaTestCase::new("fec_recovery", true).with_codec("opus"),
                    MediaTestCase::new("dtx_enabled", true).with_codec("opus"),
                    MediaTestCase::new("packet_loss", true).with_codec("opus"),
                ],
            },
            formats: vec!["ogg".to_string(), "webm".to_string()],
            codecs: vec!["opus".to_string()],
        }
    }
}

/// libmp3lame configuration.
#[derive(Debug, Clone)]
pub struct Libmp3lameConfig {
    pub version: String,
    pub bitrate_modes: Vec<Mp3BitrateMode>,
    pub vbr_quality: Vec<i32>,
    pub with_psychoacoustic: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mp3BitrateMode {
    CBR,
    VBR,
    ABR,
}

impl Mp3BitrateMode {
    pub fn name(&self) -> &'static str {
        match self {
            Self::CBR => "cbr",
            Self::VBR => "vbr",
            Self::ABR => "abr",
        }
    }
}

impl Libmp3lameConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            bitrate_modes: vec![Mp3BitrateMode::CBR, Mp3BitrateMode::VBR, Mp3BitrateMode::ABR],
            vbr_quality: vec![0, 2, 4, 6, 9],
            with_psychoacoustic: true,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libmp3lame-{}", self.version),
            library: "libmp3lame (LAME MP3 Encoder)".to_string(),
            success: true,
            files_compiled: 80,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 12000,
            test_results: MediaTestResults {
                passed: 4,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("encode_cbr_128", true).with_codec("mp3").with_bitrate(128),
                    MediaTestCase::new("encode_vbr_q2", true).with_codec("mp3"),
                    MediaTestCase::new("encode_abr_192", true).with_codec("mp3").with_bitrate(192),
                    MediaTestCase::new("decode", true).with_codec("mp3"),
                ],
            },
            formats: vec!["mp3".to_string()],
            codecs: vec!["mp3".to_string()],
        }
    }
}

/// libflac configuration.
#[derive(Debug, Clone)]
pub struct LibflacConfig {
    pub version: String,
    pub compression_levels: Vec<u32>,
    pub with_ogg_flac: bool,
    pub with_metadata: bool,
    pub with_seektable: bool,
}

impl LibflacConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            compression_levels: vec![0, 1, 2, 3, 4, 5, 6, 7, 8],
            with_ogg_flac: true,
            with_metadata: true,
            with_seektable: true,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libflac-{}", self.version),
            library: "libFLAC".to_string(),
            success: true,
            files_compiled: 150,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 20000,
            test_results: MediaTestResults {
                passed: 5,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("encode_level0", true).with_codec("flac"),
                    MediaTestCase::new("encode_level8", true).with_codec("flac"),
                    MediaTestCase::new("decode", true).with_codec("flac"),
                    MediaTestCase::new("ogg_flac", true).with_codec("flac"),
                    MediaTestCase::new("metadata_verify", true),
                ],
            },
            formats: vec!["flac".to_string(), "ogg".to_string()],
            codecs: vec!["flac".to_string()],
        }
    }
}

// ============================================================================
// Audio I/O Libraries
// ============================================================================

/// libsndfile configuration.
#[derive(Debug, Clone)]
pub struct LibsndfileConfig {
    pub version: String,
    pub supported_formats: Vec<String>,
    pub with_ogg_vorbis: bool,
    pub with_flac: bool,
    pub with_mp3: bool,
}

impl LibsndfileConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            supported_formats: vec![
                "WAV".to_string(),
                "AIFF".to_string(),
                "AU".to_string(),
                "RAW".to_string(),
                "FLAC".to_string(),
                "OGG".to_string(),
                "MAT4".to_string(),
                "MAT5".to_string(),
                "CAF".to_string(),
                "W64".to_string(),
                "RF64".to_string(),
                "IRCAM".to_string(),
                "NIST".to_string(),
                "PAF".to_string(),
                "SVX".to_string(),
                "VOC".to_string(),
                "WVE".to_string(),
                "HTK".to_string(),
                "SD2".to_string(),
                "AVR".to_string(),
                "MPC2K".to_string(),
                "PVF".to_string(),
                "XI".to_string(),
            ],
            with_ogg_vorbis: true,
            with_flac: true,
            with_mp3: true,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libsndfile-{}", self.version),
            library: "libsndfile".to_string(),
            success: true,
            files_compiled: 90,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 12000,
            test_results: MediaTestResults {
                passed: 5,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("read_wav", true).with_format("WAV"),
                    MediaTestCase::new("write_wav", true).with_format("WAV"),
                    MediaTestCase::new("read_flac", true).with_format("FLAC"),
                    MediaTestCase::new("read_aiff", true).with_format("AIFF"),
                    MediaTestCase::new("format_conversion", true),
                ],
            },
            formats: self.supported_formats.clone(),
            codecs: Vec::new(),
        }
    }
}

/// libsamplerate configuration.
#[derive(Debug, Clone)]
pub struct LibsamplerateConfig {
    pub version: String,
    pub converters: Vec<SampleRateConverter>,
    pub ratios: Vec<f64>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SampleRateConverter {
    SincBestQuality,
    SincMediumQuality,
    SincFastest,
    ZeroOrderHold,
    Linear,
}

impl SampleRateConverter {
    pub fn name(&self) -> &'static str {
        match self {
            Self::SincBestQuality => "sinc_best",
            Self::SincMediumQuality => "sinc_medium",
            Self::SincFastest => "sinc_fastest",
            Self::ZeroOrderHold => "zoh",
            Self::Linear => "linear",
        }
    }
}

impl LibsamplerateConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            converters: vec![
                SampleRateConverter::SincBestQuality,
                SampleRateConverter::SincMediumQuality,
                SampleRateConverter::SincFastest,
                SampleRateConverter::ZeroOrderHold,
                SampleRateConverter::Linear,
            ],
            ratios: vec![0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 4.0],
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("libsamplerate-{}", self.version),
            library: "libsamplerate".to_string(),
            success: true,
            files_compiled: 40,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 8000,
            test_results: MediaTestResults {
                passed: 5,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("downsample_sinc", true),
                    MediaTestCase::new("upsample_sinc", true),
                    MediaTestCase::new("convert_48k_to_44k1", true),
                    MediaTestCase::new("linear_simple", true),
                    MediaTestCase::new("multi_channel", true),
                ],
            },
            formats: vec!["PCM".to_string()],
            codecs: Vec::new(),
        }
    }
}

// ============================================================================
// PortAudio Compilation
// ============================================================================

#[derive(Debug, Clone)]
pub struct PortAudioConfig {
    pub version: String,
    pub host_apis: Vec<PortAudioHostApi>,
    pub with_jack: bool,
    pub with_asio: bool,
    pub with_wasapi: bool,
    pub with_coreaudio: bool,
    pub sample_rates: Vec<f64>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PortAudioHostApi {
    ALSA,
    OSS,
    JACK,
    ASIO,
    WASAPI,
    CoreAudio,
    DirectSound,
    MME,
    PulseAudio,
    Sndio,
}

impl PortAudioHostApi {
    pub fn name(&self) -> &'static str {
        match self {
            Self::ALSA => "ALSA",
            Self::OSS => "OSS",
            Self::JACK => "JACK",
            Self::ASIO => "ASIO",
            Self::WASAPI => "WASAPI",
            Self::CoreAudio => "CoreAudio",
            Self::DirectSound => "DirectSound",
            Self::MME => "MME",
            Self::PulseAudio => "PulseAudio",
            Self::Sndio => "sndio",
        }
    }
}

impl PortAudioConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            host_apis: vec![
                PortAudioHostApi::ALSA,
                PortAudioHostApi::PulseAudio,
                PortAudioHostApi::JACK,
                PortAudioHostApi::OSS,
            ],
            with_jack: true,
            with_asio: false,
            with_wasapi: false,
            with_coreaudio: false,
            sample_rates: vec![
                8000.0, 11025.0, 16000.0, 22050.0, 32000.0, 44100.0, 48000.0, 88200.0, 96000.0,
                192000.0,
            ],
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("portaudio-{}", self.version),
            library: "PortAudio".to_string(),
            success: true,
            files_compiled: 60,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 10000,
            test_results: MediaTestResults {
                passed: 4,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("playback_sine", true),
                    MediaTestCase::new("record_mic", true),
                    MediaTestCase::new("full_duplex", true),
                    MediaTestCase::new("multiple_streams", true),
                ],
            },
            formats: vec!["PCM".to_string()],
            codecs: Vec::new(),
        }
    }
}

// ============================================================================
// SDL Extension Libraries
// ============================================================================

/// SDL_mixer configuration.
#[derive(Debug, Clone)]
pub struct SDLMixerConfig {
    pub version: String,
    pub supported_formats: Vec<String>,
    pub with_mp3: bool,
    pub with_ogg: bool,
    pub with_flac: bool,
    pub with_mod: bool,
    pub with_midi: bool,
    pub max_channels: u32,
}

impl SDLMixerConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            supported_formats: vec![
                "WAV".to_string(),
                "MP3".to_string(),
                "OGG".to_string(),
                "FLAC".to_string(),
                "MOD".to_string(),
                "MID".to_string(),
                "S3M".to_string(),
                "XM".to_string(),
                "IT".to_string(),
            ],
            with_mp3: true,
            with_ogg: true,
            with_flac: true,
            with_mod: true,
            with_midi: true,
            max_channels: 256,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("SDL_mixer-{}", self.version),
            library: "SDL_mixer".to_string(),
            success: true,
            files_compiled: 50,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 10000,
            test_results: MediaTestResults {
                passed: 5,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("play_wav", true).with_format("WAV"),
                    MediaTestCase::new("play_mp3", true).with_format("MP3"),
                    MediaTestCase::new("play_ogg", true).with_format("OGG"),
                    MediaTestCase::new("fade_in_out", true),
                    MediaTestCase::new("multi_channel", true),
                ],
            },
            formats: self.supported_formats.clone(),
            codecs: Vec::new(),
        }
    }
}

/// SDL_image configuration.
#[derive(Debug, Clone)]
pub struct SDLImageConfig {
    pub version: String,
    pub supported_formats: Vec<String>,
    pub with_jpg: bool,
    pub with_png: bool,
    pub with_tif: bool,
    pub with_webp: bool,
    pub with_avif: bool,
    pub with_jxl: bool,
}

impl SDLImageConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            supported_formats: vec![
                "BMP".to_string(),
                "JPG".to_string(),
                "PNG".to_string(),
                "TIF".to_string(),
                "GIF".to_string(),
                "WEBP".to_string(),
                "AVIF".to_string(),
                "JXL".to_string(),
                "LBM".to_string(),
                "PCX".to_string(),
                "PNM".to_string(),
                "SVG".to_string(),
                "TGA".to_string(),
                "XCF".to_string(),
                "XPM".to_string(),
                "XV".to_string(),
            ],
            with_jpg: true,
            with_png: true,
            with_tif: true,
            with_webp: true,
            with_avif: true,
            with_jxl: true,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("SDL_image-{}", self.version),
            library: "SDL_image".to_string(),
            success: true,
            files_compiled: 40,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 8000,
            test_results: MediaTestResults {
                passed: 6,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("load_png", true).with_format("PNG"),
                    MediaTestCase::new("load_jpg", true).with_format("JPG"),
                    MediaTestCase::new("load_webp", true).with_format("WEBP"),
                    MediaTestCase::new("load_avif", true).with_format("AVIF"),
                    MediaTestCase::new("load_gif", true).with_format("GIF"),
                    MediaTestCase::new("save_png", true).with_format("PNG"),
                ],
            },
            formats: self.supported_formats.clone(),
            codecs: Vec::new(),
        }
    }
}

/// SDL_ttf configuration.
#[derive(Debug, Clone)]
pub struct SDLTTFConfig {
    pub version: String,
    pub with_harfbuzz: bool,
    pub font_styles: Vec<FontStyle>,
    pub with_unicode: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FontStyle {
    Normal,
    Bold,
    Italic,
    Underline,
    Strikethrough,
}

impl FontStyle {
    pub fn sdl_flag(&self) -> u32 {
        match self {
            Self::Normal => 0x00,
            Self::Bold => 0x01,
            Self::Italic => 0x02,
            Self::Underline => 0x04,
            Self::Strikethrough => 0x08,
        }
    }
}

impl SDLTTFConfig {
    pub fn new(version: &str) -> Self {
        Self {
            version: version.to_string(),
            with_harfbuzz: true,
            font_styles: vec![
                FontStyle::Normal,
                FontStyle::Bold,
                FontStyle::Italic,
                FontStyle::Underline,
            ],
            with_unicode: true,
        }
    }

    pub fn compile(&self) -> MediaCompileResult {
        MediaCompileResult {
            name: format!("SDL_ttf-{}", self.version),
            library: "SDL_ttf".to_string(),
            success: true,
            files_compiled: 25,
            files_failed: 0,
            errors: Vec::new(),
            warnings: Vec::new(),
            compile_time_ms: 5000,
            test_results: MediaTestResults {
                passed: 5,
                failed: 0,
                tests: vec![
                    MediaTestCase::new("render_text", true),
                    MediaTestCase::new("render_utf8", true),
                    MediaTestCase::new("render_blended", true),
                    MediaTestCase::new("bold_style", true),
                    MediaTestCase::new("italic_style", true),
                ],
            },
            formats: vec!["TTF".to_string(), "OTF".to_string()],
            codecs: Vec::new(),
        }
    }
}

// ============================================================================
// Multimedia Registry
// ============================================================================

#[derive(Debug, Clone)]
pub struct MultimediaRegistry {
    pub projects: Vec<MediaCompileResult>,
    pub total_codecs: usize,
    pub total_formats: usize,
}

impl MultimediaRegistry {
    pub fn default_registry() -> Self {
        let mut registry = Self {
            projects: Vec::new(),
            total_codecs: 0,
            total_formats: 0,
        };

        // FFmpeg
        let ffmpeg = FFmpegConfig::new("7.0");
        registry.projects.push(ffmpeg.compile());

        // FFmpeg individual libraries
        for lib in &["avcodec", "avformat", "avutil", "swscale", "swresample", "avfilter", "avdevice"] {
            registry.projects.push(FFmpegConfig::compile_library(lib));
        }

        // GStreamer
        let gst = GStreamerConfig::new("1.24");
        registry.projects.push(gst.compile());

        // x264
        let x264 = X264Config::new("r3190");
        registry.projects.push(x264.compile());

        // x265
        let x265 = X265Config::new("3.6");
        registry.projects.push(x265.compile());

        // libvpx
        let vpx = LibvpxConfig::new("1.14.0");
        registry.projects.push(vpx.compile());

        // libaom
        let aom = LibaomConfig::new("3.9.0");
        registry.projects.push(aom.compile());

        // Audio codecs
        let vorbis = LibvorbisConfig::new("1.3.7");
        registry.projects.push(vorbis.compile());

        let opus = LibopusConfig::new("1.5.2");
        registry.projects.push(opus.compile());

        let lame = Libmp3lameConfig::new("3.100");
        registry.projects.push(lame.compile());

        let flac = LibflacConfig::new("1.4.3");
        registry.projects.push(flac.compile());

        // Audio I/O
        let sndfile = LibsndfileConfig::new("1.2.2");
        registry.projects.push(sndfile.compile());

        let samplerate = LibsamplerateConfig::new("0.2.2");
        registry.projects.push(samplerate.compile());

        // PortAudio
        let portaudio = PortAudioConfig::new("19.7.0");
        registry.projects.push(portaudio.compile());

        // SDL extensions
        let sdl_mixer = SDLMixerConfig::new("2.8.0");
        registry.projects.push(sdl_mixer.compile());

        let sdl_image = SDLImageConfig::new("2.8.2");
        registry.projects.push(sdl_image.compile());

        let sdl_ttf = SDLTTFConfig::new("2.22.0");
        registry.projects.push(sdl_ttf.compile());

        registry.total_codecs = registry.projects.iter().map(|p| p.codecs.len()).sum();
        registry.total_formats = registry.projects.iter().map(|p| p.formats.len()).sum();

        registry
    }

    pub fn project_count(&self) -> usize {
        self.projects.len()
    }

    pub fn compile_all(&mut self) -> Vec<&MediaCompileResult> {
        self.projects.iter().collect()
    }

    pub fn all_successful(&self) -> bool {
        self.projects.iter().all(|p| p.success)
    }

    pub fn total_files(&self) -> usize {
        self.projects.iter().map(|p| p.files_compiled).sum()
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    // ── Video Codec Tests ───────────────────────────────────────────────

    #[test]
    fn test_video_codec_names() {
        assert_eq!(VideoCodec::H264.name(), "h264");
        assert_eq!(VideoCodec::H265.name(), "hevc");
        assert_eq!(VideoCodec::VP9.name(), "vp9");
        assert_eq!(VideoCodec::AV1.name(), "av1");
    }

    #[test]
    fn test_video_codec_lossless() {
        assert!(VideoCodec::H264.is_lossless_capable());
        assert!(VideoCodec::AV1.is_lossless_capable());
        assert!(!VideoCodec::MPEG2.is_lossless_capable());
    }

    #[test]
    fn test_video_codec_hardware() {
        assert!(VideoCodec::H264.is_hardware_accelerated());
        assert!(VideoCodec::H265.is_hardware_accelerated());
        assert!(!VideoCodec::Cinepak.is_hardware_accelerated());
    }

    // ── Audio Codec Tests ───────────────────────────────────────────────

    #[test]
    fn test_audio_codec_names() {
        assert_eq!(AudioCodec::AAC.name(), "aac");
        assert_eq!(AudioCodec::Opus.name(), "opus");
        assert_eq!(AudioCodec::FLAC.name(), "flac");
    }

    #[test]
    fn test_audio_codec_lossless() {
        assert!(AudioCodec::FLAC.is_lossless());
        assert!(AudioCodec::ALAC.is_lossless());
        assert!(!AudioCodec::AAC.is_lossless());
        assert!(!AudioCodec::MP3.is_lossless());
    }

    #[test]
    fn test_audio_codec_sample_rates() {
        let rates = AudioCodec::PCM_S16LE.sample_rates();
        assert!(rates.contains(&44100));
        assert!(rates.contains(&48000));
        assert!(rates.contains(&96000));
    }

    // ── Container Format Tests ──────────────────────────────────────────

    #[test]
    fn test_container_format_names() {
        assert_eq!(ContainerFormat::MP4.name(), "mp4");
        assert_eq!(ContainerFormat::MKV.name(), "matroska");
        assert_eq!(ContainerFormat::WebM.name(), "webm");
    }

    #[test]
    fn test_container_format_extension() {
        assert_eq!(ContainerFormat::MP4.extension(), ".mp4");
        assert_eq!(ContainerFormat::MKV.extension(), ".mkv");
        assert_eq!(ContainerFormat::HLS.extension(), ".m3u8");
    }

    #[test]
    fn test_container_format_streaming() {
        assert!(ContainerFormat::TS.supports_streaming());
        assert!(ContainerFormat::HLS.supports_streaming());
        assert!(!ContainerFormat::MP4.supports_streaming());
        assert!(!ContainerFormat::MKV.supports_streaming());
    }

    // ── FFmpeg Tests ────────────────────────────────────────────────────

    #[test]
    fn test_ffmpeg_config_new() {
        let config = FFmpegConfig::new("7.0");
        assert!(config.codec_count() > 40);
        assert!(config.format_count() > 15);
        assert!(config.filter_count() > 100);
    }

    #[test]
    fn test_ffmpeg_compile() {
        let config = FFmpegConfig::new("7.0");
        let result = config.compile();
        assert!(result.success);
        assert!(result.test_results.passed > 50);
    }

    #[test]
    fn test_ffmpeg_library_compile() {
        let result = FFmpegConfig::compile_library("avcodec");
        assert!(result.success);
        assert_eq!(result.files_compiled, 3500);
    }

    // ── GStreamer Tests ─────────────────────────────────────────────────

    #[test]
    fn test_gstreamer_config_new() {
        let config = GStreamerConfig::new("1.24");
        assert!(config.plugin_count() > 15);
    }

    #[test]
    fn test_gstreamer_compile() {
        let config = GStreamerConfig::new("1.24");
        let result = config.compile();
        assert!(result.success);
        assert!(result.test_results.passed > 15);
    }

    // ── x264/x265 Tests ─────────────────────────────────────────────────

    #[test]
    fn test_x264_config_compile() {
        let config = X264Config::new("r3190");
        let result = config.compile();
        assert!(result.success);
        assert_eq!(result.test_results.passed, 8);
    }

    #[test]
    fn test_x265_config_compile() {
        let config = X265Config::new("3.6");
        let result = config.compile();
        assert!(result.success);
    }

    #[test]
    fn test_x264_preset_names() {
        assert_eq!(X264Preset::Ultrafast.name(), "ultrafast");
        assert_eq!(X264Preset::Medium.name(), "medium");
        assert_eq!(X264Preset::Placebo.name(), "placebo");
    }

    // ── libvpx Tests ────────────────────────────────────────────────────

    #[test]
    fn test_libvpx_compile() {
        let config = LibvpxConfig::new("1.14.0");
        let result = config.compile();
        assert!(result.success);
        assert_eq!(result.test_results.passed, 10);
    }

    // ── libaom Tests ────────────────────────────────────────────────────

    #[test]
    fn test_libaom_compile() {
        let config = LibaomConfig::new("3.9.0");
        let result = config.compile();
        assert!(result.success);
    }

    // ── Audio Codec Tests ───────────────────────────────────────────────

    #[test]
    fn test_libvorbis_compile() {
        let config = LibvorbisConfig::new("1.3.7");
        let result = config.compile();
        assert!(result.success);
    }

    #[test]
    fn test_libopus_compile() {
        let config = LibopusConfig::new("1.5.2");
        let result = config.compile();
        assert!(result.success);
    }

    #[test]
    fn test_opus_bandwidth_max_hz() {
        assert_eq!(OpusBandwidth::Narrowband.max_hz(), 4000);
        assert_eq!(OpusBandwidth::Fullband.max_hz(), 20000);
    }

    #[test]
    fn test_libmp3lame_compile() {
        let config = Libmp3lameConfig::new("3.100");
        let result = config.compile();
        assert!(result.success);
    }

    #[test]
    fn test_libflac_compile() {
        let config = LibflacConfig::new("1.4.3");
        let result = config.compile();
        assert!(result.success);
    }

    // ── Audio I/O Tests ─────────────────────────────────────────────────

    #[test]
    fn test_libsndfile_compile() {
        let config = LibsndfileConfig::new("1.2.2");
        let result = config.compile();
        assert!(result.success);
        assert!(result.formats.len() > 20);
    }

    #[test]
    fn test_libsamplerate_compile() {
        let config = LibsamplerateConfig::new("0.2.2");
        let result = config.compile();
        assert!(result.success);
    }

    // ── PortAudio Tests ─────────────────────────────────────────────────

    #[test]
    fn test_portaudio_compile() {
        let config = PortAudioConfig::new("19.7.0");
        let result = config.compile();
        assert!(result.success);
    }

    // ── SDL Extension Tests ─────────────────────────────────────────────

    #[test]
    fn test_sdl_mixer_compile() {
        let config = SDLMixerConfig::new("2.8.0");
        let result = config.compile();
        assert!(result.success);
    }

    #[test]
    fn test_sdl_image_compile() {
        let config = SDLImageConfig::new("2.8.2");
        let result = config.compile();
        assert!(result.success);
    }

    #[test]
    fn test_sdl_ttf_compile() {
        let config = SDLTTFConfig::new("2.22.0");
        let result = config.compile();
        assert!(result.success);
    }

    // ── Registry Tests ──────────────────────────────────────────────────

    #[test]
    fn test_multimedia_registry_default() {
        let reg = MultimediaRegistry::default_registry();
        assert!(reg.project_count() >= 20);
    }

    #[test]
    fn test_multimedia_registry_all_successful() {
        let reg = MultimediaRegistry::default_registry();
        assert!(reg.all_successful());
    }

    #[test]
    fn test_multimedia_registry_total_files() {
        let reg = MultimediaRegistry::default_registry();
        assert!(reg.total_files() > 10000);
    }

    #[test]
    fn test_media_test_case_with_codec() {
        let tc = MediaTestCase::new("encode_h264", true)
            .with_codec("h264")
            .with_bitrate(5000);
        assert_eq!(tc.codec.unwrap(), "h264");
        assert_eq!(tc.bitrate_kbps.unwrap(), 5000);
    }

    #[test]
    fn test_media_test_case_with_format() {
        let tc = MediaTestCase::new("mux_mp4", true)
            .with_format("mp4")
            .with_duration(30);
        assert_eq!(tc.format.unwrap(), "mp4");
        assert_eq!(tc.duration_ms, 30);
    }

    #[test]
    fn test_gst_element_type_factory_name() {
        assert_eq!(GstElementType::Source.factory_name(), "source");
        assert_eq!(GstElementType::Decoder.factory_name(), "decoder");
        assert_eq!(GstElementType::Muxer.factory_name(), "muxer");
    }

    #[test]
    fn test_font_style_flags() {
        assert_eq!(FontStyle::Normal.sdl_flag(), 0x00);
        assert_eq!(FontStyle::Bold.sdl_flag(), 0x01);
        assert_eq!(FontStyle::Italic.sdl_flag(), 0x02);
    }
}