pub mod playbin3;
pub use playbin3::*;
pub mod playbin;
pub use playbin::*;

bitflags::bitflags! {
    /// Extra flags to configure the behaviour of the sinks.
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
    pub struct PlayFlags: u32 {
        /// Render the video stream
        const VIDEO = (1 << 0);
        /// Render the audio stream
        const AUDIO = (1 << 1);
        /// Render subtitles
        const TEXT = (1 << 2);
        /// Render visualisation when no video is present
        const VIS = (1 << 3);
        /// Use software volume
        const SOFT_VOLUME = (1 << 4);
        /// Only use native audio formats
        const NATIVE_AUDIO = (1 << 5);
        /// Only use native video formats
        const NATIVE_VIDEO = (1 << 6);
        /// Attempt progressive download buffering
        const DOWNLOAD = (1 << 7);
        /// Buffer demuxed/parsed data
        const BUFFERING = (1 << 8);
        /// Deinterlace video if necessary
        const DEINTERLACE = (1 << 9);
        /// Use software color balance
        const SOFT_COLORBALANCE = (1 << 10);
        /// Force audio/video filter(s) to be applied
        const FORCE_FILTERS = (1 << 11);
        /// Force only software-based decoders (no effect for playbin3)
        const FORCE_SW_DECODERS = (1 << 12);
    }
}

const _: () = {
    use glib::types::StaticType;
    impl glib::types::StaticType for PlayFlags {
        #[inline]
        #[doc(alias = "gst_play_flags_get_type")]
        fn static_type() -> glib::Type {
            glib::Type::from_name("GstPlayFlags").expect("GstPlayFlags type not found")
        }
    }

    impl glib::value::ToValue for PlayFlags {
        #[inline]
        fn to_value(&self) -> glib::Value {
            let value = self.bits().to_value();
            value
                .transform_with_type(Self::static_type())
                .expect("Failed to transform PlayFlags(u32) to GstPlayFlags")
        }

        #[inline]
        fn value_type(&self) -> glib::Type {
            Self::static_type()
        }
    }

    impl From<PlayFlags> for glib::Value {
        #[inline]
        fn from(v: PlayFlags) -> Self {
            // skip_assert_initialized!();
            glib::value::ToValue::to_value(&v)
        }
    }
};