libmirage 0.2.0

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::ffi;
use glib::translate::*;

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageDebugMask")]
pub enum DebugMask {
    #[doc(alias = "MIRAGE_DEBUG_ERROR")]
    Error,
    #[doc(alias = "MIRAGE_DEBUG_WARNING")]
    Warning,
    #[doc(alias = "MIRAGE_DEBUG_PARSER")]
    Parser,
    #[doc(alias = "MIRAGE_DEBUG_DISC")]
    Disc,
    #[doc(alias = "MIRAGE_DEBUG_SESSION")]
    Session,
    #[doc(alias = "MIRAGE_DEBUG_TRACK")]
    Track,
    #[doc(alias = "MIRAGE_DEBUG_SECTOR")]
    Sector,
    #[doc(alias = "MIRAGE_DEBUG_FRAGMENT")]
    Fragment,
    #[doc(alias = "MIRAGE_DEBUG_CDTEXT")]
    Cdtext,
    #[doc(alias = "MIRAGE_DEBUG_STREAM")]
    Stream,
    #[doc(alias = "MIRAGE_DEBUG_IMAGE_ID")]
    ImageId,
    #[doc(alias = "MIRAGE_DEBUG_WRITER")]
    Writer,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DebugMask {
    type GlibType = ffi::MirageDebugMask;

    #[inline]
    fn into_glib(self) -> ffi::MirageDebugMask {
        match self {
            Self::Error => ffi::MIRAGE_DEBUG_ERROR,
            Self::Warning => ffi::MIRAGE_DEBUG_WARNING,
            Self::Parser => ffi::MIRAGE_DEBUG_PARSER,
            Self::Disc => ffi::MIRAGE_DEBUG_DISC,
            Self::Session => ffi::MIRAGE_DEBUG_SESSION,
            Self::Track => ffi::MIRAGE_DEBUG_TRACK,
            Self::Sector => ffi::MIRAGE_DEBUG_SECTOR,
            Self::Fragment => ffi::MIRAGE_DEBUG_FRAGMENT,
            Self::Cdtext => ffi::MIRAGE_DEBUG_CDTEXT,
            Self::Stream => ffi::MIRAGE_DEBUG_STREAM,
            Self::ImageId => ffi::MIRAGE_DEBUG_IMAGE_ID,
            Self::Writer => ffi::MIRAGE_DEBUG_WRITER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageDebugMask> for DebugMask {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageDebugMask) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_DEBUG_ERROR => Self::Error,
            ffi::MIRAGE_DEBUG_WARNING => Self::Warning,
            ffi::MIRAGE_DEBUG_PARSER => Self::Parser,
            ffi::MIRAGE_DEBUG_DISC => Self::Disc,
            ffi::MIRAGE_DEBUG_SESSION => Self::Session,
            ffi::MIRAGE_DEBUG_TRACK => Self::Track,
            ffi::MIRAGE_DEBUG_SECTOR => Self::Sector,
            ffi::MIRAGE_DEBUG_FRAGMENT => Self::Fragment,
            ffi::MIRAGE_DEBUG_CDTEXT => Self::Cdtext,
            ffi::MIRAGE_DEBUG_STREAM => Self::Stream,
            ffi::MIRAGE_DEBUG_IMAGE_ID => Self::ImageId,
            ffi::MIRAGE_DEBUG_WRITER => Self::Writer,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageFragmentRole")]
pub enum FragmentRole {
    #[doc(alias = "MIRAGE_FRAGMENT_PREGAP")]
    Pregap,
    #[doc(alias = "MIRAGE_FRAGMENT_DATA")]
    Data,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FragmentRole {
    type GlibType = ffi::MirageFragmentRole;

    #[inline]
    fn into_glib(self) -> ffi::MirageFragmentRole {
        match self {
            Self::Pregap => ffi::MIRAGE_FRAGMENT_PREGAP,
            Self::Data => ffi::MIRAGE_FRAGMENT_DATA,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageFragmentRole> for FragmentRole {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageFragmentRole) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_FRAGMENT_PREGAP => Self::Pregap,
            ffi::MIRAGE_FRAGMENT_DATA => Self::Data,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageLanguagePackType")]
pub enum LanguagePackType {
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_TITLE")]
    Title,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_PERFORMER")]
    Performer,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_SONGWRITER")]
    Songwriter,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_COMPOSER")]
    Composer,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_ARRANGER")]
    Arranger,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_MESSAGE")]
    Message,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_DISC_ID")]
    DiscId,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_GENRE")]
    Genre,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_TOC")]
    Toc,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_TOC2")]
    Toc2,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_RES_8A")]
    Res8a,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_RES_8B")]
    Res8b,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_RES_8C")]
    Res8c,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_CLOSED_INFO")]
    ClosedInfo,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_UPC_ISRC")]
    UpcIsrc,
    #[doc(alias = "MIRAGE_LANGUAGE_PACK_SIZE")]
    Size,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for LanguagePackType {
    type GlibType = ffi::MirageLanguagePackType;

    fn into_glib(self) -> ffi::MirageLanguagePackType {
        match self {
            Self::Title => ffi::MIRAGE_LANGUAGE_PACK_TITLE,
            Self::Performer => ffi::MIRAGE_LANGUAGE_PACK_PERFORMER,
            Self::Songwriter => ffi::MIRAGE_LANGUAGE_PACK_SONGWRITER,
            Self::Composer => ffi::MIRAGE_LANGUAGE_PACK_COMPOSER,
            Self::Arranger => ffi::MIRAGE_LANGUAGE_PACK_ARRANGER,
            Self::Message => ffi::MIRAGE_LANGUAGE_PACK_MESSAGE,
            Self::DiscId => ffi::MIRAGE_LANGUAGE_PACK_DISC_ID,
            Self::Genre => ffi::MIRAGE_LANGUAGE_PACK_GENRE,
            Self::Toc => ffi::MIRAGE_LANGUAGE_PACK_TOC,
            Self::Toc2 => ffi::MIRAGE_LANGUAGE_PACK_TOC2,
            Self::Res8a => ffi::MIRAGE_LANGUAGE_PACK_RES_8A,
            Self::Res8b => ffi::MIRAGE_LANGUAGE_PACK_RES_8B,
            Self::Res8c => ffi::MIRAGE_LANGUAGE_PACK_RES_8C,
            Self::ClosedInfo => ffi::MIRAGE_LANGUAGE_PACK_CLOSED_INFO,
            Self::UpcIsrc => ffi::MIRAGE_LANGUAGE_PACK_UPC_ISRC,
            Self::Size => ffi::MIRAGE_LANGUAGE_PACK_SIZE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageLanguagePackType> for LanguagePackType {
    unsafe fn from_glib(value: ffi::MirageLanguagePackType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_LANGUAGE_PACK_TITLE => Self::Title,
            ffi::MIRAGE_LANGUAGE_PACK_PERFORMER => Self::Performer,
            ffi::MIRAGE_LANGUAGE_PACK_SONGWRITER => Self::Songwriter,
            ffi::MIRAGE_LANGUAGE_PACK_COMPOSER => Self::Composer,
            ffi::MIRAGE_LANGUAGE_PACK_ARRANGER => Self::Arranger,
            ffi::MIRAGE_LANGUAGE_PACK_MESSAGE => Self::Message,
            ffi::MIRAGE_LANGUAGE_PACK_DISC_ID => Self::DiscId,
            ffi::MIRAGE_LANGUAGE_PACK_GENRE => Self::Genre,
            ffi::MIRAGE_LANGUAGE_PACK_TOC => Self::Toc,
            ffi::MIRAGE_LANGUAGE_PACK_TOC2 => Self::Toc2,
            ffi::MIRAGE_LANGUAGE_PACK_RES_8A => Self::Res8a,
            ffi::MIRAGE_LANGUAGE_PACK_RES_8B => Self::Res8b,
            ffi::MIRAGE_LANGUAGE_PACK_RES_8C => Self::Res8c,
            ffi::MIRAGE_LANGUAGE_PACK_CLOSED_INFO => Self::ClosedInfo,
            ffi::MIRAGE_LANGUAGE_PACK_UPC_ISRC => Self::UpcIsrc,
            ffi::MIRAGE_LANGUAGE_PACK_SIZE => Self::Size,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageMainDataFormat")]
pub enum MainDataFormat {
    #[doc(alias = "MIRAGE_MAIN_DATA_FORMAT_DATA")]
    Data,
    #[doc(alias = "MIRAGE_MAIN_DATA_FORMAT_AUDIO")]
    Audio,
    #[doc(alias = "MIRAGE_MAIN_DATA_FORMAT_AUDIO_SWAP")]
    AudioSwap,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for MainDataFormat {
    type GlibType = ffi::MirageMainDataFormat;

    #[inline]
    fn into_glib(self) -> ffi::MirageMainDataFormat {
        match self {
            Self::Data => ffi::MIRAGE_MAIN_DATA_FORMAT_DATA,
            Self::Audio => ffi::MIRAGE_MAIN_DATA_FORMAT_AUDIO,
            Self::AudioSwap => ffi::MIRAGE_MAIN_DATA_FORMAT_AUDIO_SWAP,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageMainDataFormat> for MainDataFormat {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageMainDataFormat) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_MAIN_DATA_FORMAT_DATA => Self::Data,
            ffi::MIRAGE_MAIN_DATA_FORMAT_AUDIO => Self::Audio,
            ffi::MIRAGE_MAIN_DATA_FORMAT_AUDIO_SWAP => Self::AudioSwap,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageMediumType")]
pub enum MediumType {
    #[doc(alias = "MIRAGE_MEDIUM_CD")]
    Cd,
    #[doc(alias = "MIRAGE_MEDIUM_DVD")]
    Dvd,
    #[doc(alias = "MIRAGE_MEDIUM_BD")]
    Bd,
    #[doc(alias = "MIRAGE_MEDIUM_HD")]
    Hd,
    #[doc(alias = "MIRAGE_MEDIUM_HDD")]
    Hdd,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for MediumType {
    type GlibType = ffi::MirageMediumType;

    #[inline]
    fn into_glib(self) -> ffi::MirageMediumType {
        match self {
            Self::Cd => ffi::MIRAGE_MEDIUM_CD,
            Self::Dvd => ffi::MIRAGE_MEDIUM_DVD,
            Self::Bd => ffi::MIRAGE_MEDIUM_BD,
            Self::Hd => ffi::MIRAGE_MEDIUM_HD,
            Self::Hdd => ffi::MIRAGE_MEDIUM_HDD,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageMediumType> for MediumType {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageMediumType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_MEDIUM_CD => Self::Cd,
            ffi::MIRAGE_MEDIUM_DVD => Self::Dvd,
            ffi::MIRAGE_MEDIUM_BD => Self::Bd,
            ffi::MIRAGE_MEDIUM_HD => Self::Hd,
            ffi::MIRAGE_MEDIUM_HDD => Self::Hdd,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageSectorSubchannelFormat")]
pub enum SectorSubchannelFormat {
    #[doc(alias = "MIRAGE_SUBCHANNEL_NONE")]
    None,
    #[doc(alias = "MIRAGE_SUBCHANNEL_PW")]
    Pw,
    #[doc(alias = "MIRAGE_SUBCHANNEL_Q")]
    Q,
    #[doc(alias = "MIRAGE_SUBCHANNEL_RW")]
    Rw,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SectorSubchannelFormat {
    type GlibType = ffi::MirageSectorSubchannelFormat;

    #[inline]
    fn into_glib(self) -> ffi::MirageSectorSubchannelFormat {
        match self {
            Self::None => ffi::MIRAGE_SUBCHANNEL_NONE,
            Self::Pw => ffi::MIRAGE_SUBCHANNEL_PW,
            Self::Q => ffi::MIRAGE_SUBCHANNEL_Q,
            Self::Rw => ffi::MIRAGE_SUBCHANNEL_RW,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageSectorSubchannelFormat> for SectorSubchannelFormat {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageSectorSubchannelFormat) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_SUBCHANNEL_NONE => Self::None,
            ffi::MIRAGE_SUBCHANNEL_PW => Self::Pw,
            ffi::MIRAGE_SUBCHANNEL_Q => Self::Q,
            ffi::MIRAGE_SUBCHANNEL_RW => Self::Rw,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageSectorType")]
pub enum SectorType {
    #[doc(alias = "MIRAGE_SECTOR_MODE0")]
    Mode0,
    #[doc(alias = "MIRAGE_SECTOR_AUDIO")]
    Audio,
    #[doc(alias = "MIRAGE_SECTOR_MODE1")]
    Mode1,
    #[doc(alias = "MIRAGE_SECTOR_MODE2")]
    Mode2,
    #[doc(alias = "MIRAGE_SECTOR_MODE2_FORM1")]
    Mode2Form1,
    #[doc(alias = "MIRAGE_SECTOR_MODE2_FORM2")]
    Mode2Form2,
    #[doc(alias = "MIRAGE_SECTOR_MODE2_MIXED")]
    Mode2Mixed,
    #[doc(alias = "MIRAGE_SECTOR_RAW")]
    Raw,
    #[doc(alias = "MIRAGE_SECTOR_RAW_SCRAMBLED")]
    RawScrambled,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SectorType {
    type GlibType = ffi::MirageSectorType;

    #[inline]
    fn into_glib(self) -> ffi::MirageSectorType {
        match self {
            Self::Mode0 => ffi::MIRAGE_SECTOR_MODE0,
            Self::Audio => ffi::MIRAGE_SECTOR_AUDIO,
            Self::Mode1 => ffi::MIRAGE_SECTOR_MODE1,
            Self::Mode2 => ffi::MIRAGE_SECTOR_MODE2,
            Self::Mode2Form1 => ffi::MIRAGE_SECTOR_MODE2_FORM1,
            Self::Mode2Form2 => ffi::MIRAGE_SECTOR_MODE2_FORM2,
            Self::Mode2Mixed => ffi::MIRAGE_SECTOR_MODE2_MIXED,
            Self::Raw => ffi::MIRAGE_SECTOR_RAW,
            Self::RawScrambled => ffi::MIRAGE_SECTOR_RAW_SCRAMBLED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageSectorType> for SectorType {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageSectorType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_SECTOR_MODE0 => Self::Mode0,
            ffi::MIRAGE_SECTOR_AUDIO => Self::Audio,
            ffi::MIRAGE_SECTOR_MODE1 => Self::Mode1,
            ffi::MIRAGE_SECTOR_MODE2 => Self::Mode2,
            ffi::MIRAGE_SECTOR_MODE2_FORM1 => Self::Mode2Form1,
            ffi::MIRAGE_SECTOR_MODE2_FORM2 => Self::Mode2Form2,
            ffi::MIRAGE_SECTOR_MODE2_MIXED => Self::Mode2Mixed,
            ffi::MIRAGE_SECTOR_RAW => Self::Raw,
            ffi::MIRAGE_SECTOR_RAW_SCRAMBLED => Self::RawScrambled,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageSectorValidData")]
pub enum SectorValidData {
    #[doc(alias = "MIRAGE_VALID_SYNC")]
    Sync,
    #[doc(alias = "MIRAGE_VALID_HEADER")]
    Header,
    #[doc(alias = "MIRAGE_VALID_SUBHEADER")]
    Subheader,
    #[doc(alias = "MIRAGE_VALID_DATA")]
    Data,
    #[doc(alias = "MIRAGE_VALID_EDC_ECC")]
    EdcEcc,
    #[doc(alias = "MIRAGE_VALID_SUBCHAN")]
    Subchan,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SectorValidData {
    type GlibType = ffi::MirageSectorValidData;

    #[inline]
    fn into_glib(self) -> ffi::MirageSectorValidData {
        match self {
            Self::Sync => ffi::MIRAGE_VALID_SYNC,
            Self::Header => ffi::MIRAGE_VALID_HEADER,
            Self::Subheader => ffi::MIRAGE_VALID_SUBHEADER,
            Self::Data => ffi::MIRAGE_VALID_DATA,
            Self::EdcEcc => ffi::MIRAGE_VALID_EDC_ECC,
            Self::Subchan => ffi::MIRAGE_VALID_SUBCHAN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageSectorValidData> for SectorValidData {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageSectorValidData) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_VALID_SYNC => Self::Sync,
            ffi::MIRAGE_VALID_HEADER => Self::Header,
            ffi::MIRAGE_VALID_SUBHEADER => Self::Subheader,
            ffi::MIRAGE_VALID_DATA => Self::Data,
            ffi::MIRAGE_VALID_EDC_ECC => Self::EdcEcc,
            ffi::MIRAGE_VALID_SUBCHAN => Self::Subchan,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageSessionType")]
pub enum SessionType {
    #[doc(alias = "MIRAGE_SESSION_CDDA")]
    Cdda,
    #[doc(alias = "MIRAGE_SESSION_CDROM")]
    Cdrom,
    #[doc(alias = "MIRAGE_SESSION_CDI")]
    Cdi,
    #[doc(alias = "MIRAGE_SESSION_CDROM_XA")]
    CdromXa,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SessionType {
    type GlibType = ffi::MirageSessionType;

    #[inline]
    fn into_glib(self) -> ffi::MirageSessionType {
        match self {
            Self::Cdda => ffi::MIRAGE_SESSION_CDDA,
            Self::Cdrom => ffi::MIRAGE_SESSION_CDROM,
            Self::Cdi => ffi::MIRAGE_SESSION_CDI,
            Self::CdromXa => ffi::MIRAGE_SESSION_CDROM_XA,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageSessionType> for SessionType {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageSessionType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_SESSION_CDDA => Self::Cdda,
            ffi::MIRAGE_SESSION_CDROM => Self::Cdrom,
            ffi::MIRAGE_SESSION_CDI => Self::Cdi,
            ffi::MIRAGE_SESSION_CDROM_XA => Self::CdromXa,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageSubChannel")]
pub enum SubChannel {
    #[doc(alias = "SUBCHANNEL_W")]
    W,
    #[doc(alias = "SUBCHANNEL_V")]
    V,
    #[doc(alias = "SUBCHANNEL_U")]
    U,
    #[doc(alias = "SUBCHANNEL_T")]
    T,
    #[doc(alias = "SUBCHANNEL_S")]
    S,
    #[doc(alias = "SUBCHANNEL_R")]
    R,
    #[doc(alias = "SUBCHANNEL_Q")]
    Q,
    #[doc(alias = "SUBCHANNEL_P")]
    P,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SubChannel {
    type GlibType = ffi::MirageSubChannel;

    #[inline]
    fn into_glib(self) -> ffi::MirageSubChannel {
        match self {
            Self::W => ffi::SUBCHANNEL_W,
            Self::V => ffi::SUBCHANNEL_V,
            Self::U => ffi::SUBCHANNEL_U,
            Self::T => ffi::SUBCHANNEL_T,
            Self::S => ffi::SUBCHANNEL_S,
            Self::R => ffi::SUBCHANNEL_R,
            Self::Q => ffi::SUBCHANNEL_Q,
            Self::P => ffi::SUBCHANNEL_P,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageSubChannel> for SubChannel {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageSubChannel) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::SUBCHANNEL_W => Self::W,
            ffi::SUBCHANNEL_V => Self::V,
            ffi::SUBCHANNEL_U => Self::U,
            ffi::SUBCHANNEL_T => Self::T,
            ffi::SUBCHANNEL_S => Self::S,
            ffi::SUBCHANNEL_R => Self::R,
            ffi::SUBCHANNEL_Q => Self::Q,
            ffi::SUBCHANNEL_P => Self::P,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageSubchannelDataFormat")]
pub enum SubchannelDataFormat {
    #[doc(alias = "MIRAGE_SUBCHANNEL_DATA_FORMAT_INTERNAL")]
    Internal,
    #[doc(alias = "MIRAGE_SUBCHANNEL_DATA_FORMAT_EXTERNAL")]
    External,
    #[doc(alias = "MIRAGE_SUBCHANNEL_DATA_FORMAT_PW96_INTERLEAVED")]
    Pw96Interleaved,
    #[doc(alias = "MIRAGE_SUBCHANNEL_DATA_FORMAT_PW96_LINEAR")]
    Pw96Linear,
    #[doc(alias = "MIRAGE_SUBCHANNEL_DATA_FORMAT_RW96")]
    Rw96,
    #[doc(alias = "MIRAGE_SUBCHANNEL_DATA_FORMAT_Q16")]
    Q16,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SubchannelDataFormat {
    type GlibType = ffi::MirageSubchannelDataFormat;

    #[inline]
    fn into_glib(self) -> ffi::MirageSubchannelDataFormat {
        match self {
            Self::Internal => ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_INTERNAL,
            Self::External => ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_EXTERNAL,
            Self::Pw96Interleaved => ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_PW96_INTERLEAVED,
            Self::Pw96Linear => ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_PW96_LINEAR,
            Self::Rw96 => ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_RW96,
            Self::Q16 => ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_Q16,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageSubchannelDataFormat> for SubchannelDataFormat {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageSubchannelDataFormat) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_INTERNAL => Self::Internal,
            ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_EXTERNAL => Self::External,
            ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_PW96_INTERLEAVED => Self::Pw96Interleaved,
            ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_PW96_LINEAR => Self::Pw96Linear,
            ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_RW96 => Self::Rw96,
            ffi::MIRAGE_SUBCHANNEL_DATA_FORMAT_Q16 => Self::Q16,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageTrackConstant")]
pub enum TrackConstant {
    #[doc(alias = "MIRAGE_TRACK_LEADIN")]
    Leadin,
    #[doc(alias = "MIRAGE_TRACK_LEADOUT")]
    Leadout,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TrackConstant {
    type GlibType = ffi::MirageTrackConstant;

    #[inline]
    fn into_glib(self) -> ffi::MirageTrackConstant {
        match self {
            Self::Leadin => ffi::MIRAGE_TRACK_LEADIN,
            Self::Leadout => ffi::MIRAGE_TRACK_LEADOUT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageTrackConstant> for TrackConstant {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageTrackConstant) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_TRACK_LEADIN => Self::Leadin,
            ffi::MIRAGE_TRACK_LEADOUT => Self::Leadout,
            value => Self::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "MirageTrackFlag")]
pub enum TrackFlag {
    #[doc(alias = "MIRAGE_TRACK_FLAG_FOURCHANNEL")]
    Fourchannel,
    #[doc(alias = "MIRAGE_TRACK_FLAG_COPYPERMITTED")]
    Copypermitted,
    #[doc(alias = "MIRAGE_TRACK_FLAG_PREEMPHASIS")]
    Preemphasis,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TrackFlag {
    type GlibType = ffi::MirageTrackFlag;

    #[inline]
    fn into_glib(self) -> ffi::MirageTrackFlag {
        match self {
            Self::Fourchannel => ffi::MIRAGE_TRACK_FLAG_FOURCHANNEL,
            Self::Copypermitted => ffi::MIRAGE_TRACK_FLAG_COPYPERMITTED,
            Self::Preemphasis => ffi::MIRAGE_TRACK_FLAG_PREEMPHASIS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::MirageTrackFlag> for TrackFlag {
    #[inline]
    unsafe fn from_glib(value: ffi::MirageTrackFlag) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::MIRAGE_TRACK_FLAG_FOURCHANNEL => Self::Fourchannel,
            ffi::MIRAGE_TRACK_FLAG_COPYPERMITTED => Self::Copypermitted,
            ffi::MIRAGE_TRACK_FLAG_PREEMPHASIS => Self::Preemphasis,
            value => Self::__Unknown(value),
        }
    }
}