gstreamer_pbutils/

functions.rs

// Take a look at the license at the top of the repository in the LICENSE file.

use std::{mem, ptr};

pub use crate::auto::functions::*;
use crate::ffi;
use glib::translate::*;

pub unsafe trait CodecTag<'a>: gst::Tag<'a, TagType = &'a str> {}

unsafe impl CodecTag<'_> for gst::tags::ContainerFormat {}
unsafe impl CodecTag<'_> for gst::tags::AudioCodec {}
unsafe impl CodecTag<'_> for gst::tags::VideoCodec {}
unsafe impl CodecTag<'_> for gst::tags::SubtitleCodec {}
unsafe impl CodecTag<'_> for gst::tags::Codec {}

pub fn pb_utils_add_codec_description_to_tag_list_for_tag<'a, T: CodecTag<'a>>(
    taglist: &mut gst::TagListRef,
    caps: &gst::CapsRef,
) -> Result<(), glib::BoolError> {
    assert_initialized_main_thread!();
    T::ensure();
    let codec_tag = T::TAG_NAME;
    unsafe {
        glib::result_from_gboolean!(
            ffi::gst_pb_utils_add_codec_description_to_tag_list(
                taglist.as_mut_ptr(),
                codec_tag.as_ptr(),
                caps.as_ptr(),
            ),
            "Failed to find codec description",
        )
    }
}

#[doc(alias = "gst_pb_utils_add_codec_description_to_tag_list")]
pub fn pb_utils_add_codec_description_to_tag_list(
    taglist: &mut gst::TagListRef,
    caps: &gst::CapsRef,
) -> Result<(), glib::BoolError> {
    assert_initialized_main_thread!();
    unsafe {
        glib::result_from_gboolean!(
            ffi::gst_pb_utils_add_codec_description_to_tag_list(
                taglist.as_mut_ptr(),
                ptr::null_mut(),
                caps.as_ptr(),
            ),
            "Failed to find codec description",
        )
    }
}

#[doc(alias = "gst_pb_utils_get_encoder_description")]
pub fn pb_utils_get_encoder_description(caps: &gst::CapsRef) -> glib::GString {
    assert_initialized_main_thread!();
    unsafe { from_glib_full(ffi::gst_pb_utils_get_encoder_description(caps.as_ptr())) }
}

#[doc(alias = "gst_pb_utils_get_decoder_description")]
pub fn pb_utils_get_decoder_description(caps: &gst::CapsRef) -> glib::GString {
    assert_initialized_main_thread!();
    unsafe { from_glib_full(ffi::gst_pb_utils_get_decoder_description(caps.as_ptr())) }
}

#[doc(alias = "gst_pb_utils_get_codec_description")]
pub fn pb_utils_get_codec_description(caps: &gst::CapsRef) -> glib::GString {
    assert_initialized_main_thread!();
    unsafe { from_glib_full(ffi::gst_pb_utils_get_codec_description(caps.as_ptr())) }
}

/// Sets the level and profile on `caps` if it can be determined from
/// `audio_config`. See [`codec_utils_aac_get_level()`][crate::codec_utils_aac_get_level()] and
/// [`codec_utils_aac_get_profile()`][crate::codec_utils_aac_get_profile()] for more details on the parameters.
/// `caps` must be audio/mpeg caps with an "mpegversion" field of either 2 or 4.
/// If mpegversion is 4, the "base-profile" field is also set in `caps`.
/// ## `caps`
/// the [`gst::Caps`][crate::gst::Caps] to which level and profile fields are to be added
/// ## `audio_config`
/// a pointer to the AudioSpecificConfig
///  as specified in the Elementary Stream Descriptor (esds)
///  in ISO/IEC 14496-1. (See below for more details)
///
/// # Returns
///
/// [`true`] if the level and profile could be set, [`false`] otherwise.
#[doc(alias = "gst_codec_utils_aac_caps_set_level_and_profile")]
pub fn codec_utils_aac_caps_set_level_and_profile(
    caps: &mut gst::CapsRef,
    audio_config: &[u8],
) -> Result<(), glib::BoolError> {
    assert_initialized_main_thread!();

    assert_eq!(caps.size(), 1);

    let s = caps.structure(0).unwrap();
    assert_eq!(s.name(), "audio/mpeg");
    assert!(s.get::<i32>("mpegversion").is_ok_and(|v| v == 2 || v == 4));

    let len = audio_config.len() as u32;
    unsafe {
        let res: bool = from_glib(ffi::gst_codec_utils_aac_caps_set_level_and_profile(
            caps.as_mut_ptr(),
            audio_config.to_glib_none().0,
            len,
        ));

        if res {
            Ok(())
        } else {
            Err(glib::bool_error!("Failed to set AAC level/profile to caps"))
        }
    }
}

/// Sets the level and profile in `caps` if it can be determined from `sps`. See
/// [`codec_utils_h264_get_level()`][crate::codec_utils_h264_get_level()] and [`codec_utils_h264_get_profile()`][crate::codec_utils_h264_get_profile()]
/// for more details on the parameters.
/// ## `caps`
/// the [`gst::Caps`][crate::gst::Caps] to which the level and profile are to be added
/// ## `sps`
/// Pointer to the sequence parameter set for the stream.
///
/// # Returns
///
/// [`true`] if the level and profile could be set, [`false`] otherwise.
#[doc(alias = "gst_codec_utils_h264_caps_set_level_and_profile")]
pub fn codec_utils_h264_caps_set_level_and_profile(
    caps: &mut gst::CapsRef,
    sps: &[u8],
) -> Result<(), glib::BoolError> {
    assert_initialized_main_thread!();

    assert_eq!(caps.size(), 1);

    let s = caps.structure(0).unwrap();
    assert_eq!(s.name(), "video/x-h264");

    let len = sps.len() as u32;
    unsafe {
        let res: bool = from_glib(ffi::gst_codec_utils_h264_caps_set_level_and_profile(
            caps.as_mut_ptr(),
            sps.to_glib_none().0,
            len,
        ));

        if res {
            Ok(())
        } else {
            Err(glib::bool_error!(
                "Failed to set H264 level/profile to caps"
            ))
        }
    }
}

/// Parses profile, flags, and level from a H264 AVCC extradata/sequence_header.
/// These are most commonly retrieved from a video/x-h264 caps with a codec_data
/// buffer.
///
/// The format of H264 AVCC extradata/sequence_header is documented in the
/// ITU-T H.264 specification section 7.3.2.1.1 as well as in ISO/IEC 14496-15
/// section 5.3.3.1.2.
/// ## `codec_data`
/// H264 AVCC extradata
///
/// # Returns
///
/// [`true`] on success, [`false`] on failure
///
/// ## `profile`
/// return location for h264 profile_idc or [`None`]
///
/// ## `flags`
/// return location for h264 constraint set flags or [`None`]
///
/// ## `level`
/// return location h264 level_idc or [`None`]
#[cfg(feature = "v1_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
#[doc(alias = "gst_codec_utils_h264_get_profile_flags_level")]
pub fn codec_utils_h264_get_profile_flags_level(
    codec_data: &[u8],
) -> Result<(u8, u8, u8), glib::BoolError> {
    assert_initialized_main_thread!();
    let len = codec_data.len() as u32;
    unsafe {
        let mut profile = mem::MaybeUninit::uninit();
        let mut flags = mem::MaybeUninit::uninit();
        let mut level = mem::MaybeUninit::uninit();
        glib::result_from_gboolean!(
            ffi::gst_codec_utils_h264_get_profile_flags_level(
                codec_data.to_glib_none().0,
                len,
                profile.as_mut_ptr(),
                flags.as_mut_ptr(),
                level.as_mut_ptr()
            ),
            "Failed to get H264 profile, flags and level"
        )?;
        let profile = profile.assume_init();
        let flags = flags.assume_init();
        let level = level.assume_init();
        Ok((profile, flags, level))
    }
}

#[cfg(feature = "v1_30")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
#[doc(alias = "GstH264LevelLimits")]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct H264LevelLimits {
    pub name: &'static glib::GStr,
    pub level_idc: u8,
    pub max_mbps: u32,
    pub max_fs: u32,
    pub max_dpb_mbs: u32,
    pub max_br: u32,
    pub max_cpb: u32,
    pub min_cr: u32,
}

/// Finds the minimum H.264 level that can handle the given video parameters
/// based on the constraints defined in H.264 specification Annex A.
/// ## `width`
/// the video width in pixels
/// ## `height`
/// the video height in pixels
/// ## `fps_n`
/// the video frame rate numerator
/// ## `fps_d`
/// the video frame rate denominator
/// ## `bitrate`
/// the video bitrate in bits per second (0 if unknown)
/// ## `max_dec_frame_buffering`
/// the max size of DPB (0 if unknown)
/// ## `profile_idc`
/// the H.264 profile idc value (e.g., 66 for Baseline, 77 for Main, 100 for High)
///
/// # Returns
///
/// the `GstH264LevelLimits` for the
///  minimum level matching the parameters, or [`None`] if no suitable
///  level is found.
#[cfg(feature = "v1_30")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
#[doc(alias = "gst_codec_utils_h264_get_level_limits")]
pub fn codec_utils_h264_get_level_limits(
    width: i32,
    height: i32,
    fps_n: i32,
    fps_d: i32,
    bitrate: u32,
    max_dec_frame_buffering: u32,
    profile_idc: u8,
) -> Option<H264LevelLimits> {
    assert_initialized_main_thread!();
    unsafe {
        let limits = ffi::gst_codec_utils_h264_get_level_limits(
            width,
            height,
            fps_n,
            fps_d,
            bitrate,
            max_dec_frame_buffering,
            profile_idc,
        )
        .as_ref()?;

        Some(H264LevelLimits {
            name: glib::GStr::from_ptr(limits.name),
            level_idc: limits.level_idc,
            max_mbps: limits.max_mbps,
            max_fs: limits.max_fs,
            max_dpb_mbs: limits.max_dpb_mbs,
            max_br: limits.max_br,
            max_cpb: limits.max_cpb,
            min_cr: limits.min_cr,
        })
    }
}

/// Sets the level, tier and profile in `caps` if it can be determined from
/// `profile_tier_level`. See [`codec_utils_h265_get_level()`][crate::codec_utils_h265_get_level()],
/// [`codec_utils_h265_get_tier()`][crate::codec_utils_h265_get_tier()] and [`codec_utils_h265_get_profile()`][crate::codec_utils_h265_get_profile()]
/// for more details on the parameters.
/// ## `caps`
/// the [`gst::Caps`][crate::gst::Caps] to which the level, tier and profile are to be added
/// ## `profile_tier_level`
/// Pointer to the profile_tier_level
///  struct
///
/// # Returns
///
/// [`true`] if the level, tier, profile could be set, [`false`] otherwise.
#[doc(alias = "gst_codec_utils_h265_caps_set_level_tier_and_profile")]
pub fn codec_utils_h265_caps_set_level_tier_and_profile(
    caps: &mut gst::CapsRef,
    profile_tier_level: &[u8],
) -> Result<(), glib::BoolError> {
    assert_initialized_main_thread!();

    assert_eq!(caps.size(), 1);

    let s = caps.structure(0).unwrap();
    assert_eq!(s.name(), "video/x-h265");

    let len = profile_tier_level.len() as u32;
    unsafe {
        let res: bool = from_glib(ffi::gst_codec_utils_h265_caps_set_level_tier_and_profile(
            caps.as_mut_ptr(),
            profile_tier_level.to_glib_none().0,
            len,
        ));

        if res {
            Ok(())
        } else {
            Err(glib::bool_error!(
                "Failed to set H265 level/tier/profile to caps"
            ))
        }
    }
}

/// Sets the level and profile in `caps` if it can be determined from
/// `vis_obj_seq`. See [`codec_utils_mpeg4video_get_level()`][crate::codec_utils_mpeg4video_get_level()] and
/// [`codec_utils_mpeg4video_get_profile()`][crate::codec_utils_mpeg4video_get_profile()] for more details on the
/// parameters.
/// ## `caps`
/// the [`gst::Caps`][crate::gst::Caps] to which the level and profile are to be added
/// ## `vis_obj_seq`
/// Pointer to the visual object
///  sequence for the stream.
///
/// # Returns
///
/// [`true`] if the level and profile could be set, [`false`] otherwise.
#[doc(alias = "gst_codec_utils_mpeg4video_caps_set_level_and_profile")]
pub fn codec_utils_mpeg4video_caps_set_level_and_profile(
    caps: &mut gst::CapsRef,
    vis_obj_seq: &[u8],
) -> Result<(), glib::BoolError> {
    assert_initialized_main_thread!();

    assert_eq!(caps.size(), 1);

    let s = caps.structure(0).unwrap();
    assert_eq!(s.name(), "video/mpeg");
    assert!(s.get::<i32>("mpegversion").is_ok_and(|v| v == 4));

    let len = vis_obj_seq.len() as u32;
    unsafe {
        let res: bool = from_glib(ffi::gst_codec_utils_mpeg4video_caps_set_level_and_profile(
            caps.as_mut_ptr(),
            vis_obj_seq.to_glib_none().0,
            len,
        ));

        if res {
            Ok(())
        } else {
            Err(glib::bool_error!(
                "Failed to set MPEG4 video level/profile to caps"
            ))
        }
    }
}

/// Creates Opus caps from the given parameters.
/// ## `rate`
/// the sample rate
/// ## `channels`
/// the number of channels
/// ## `channel_mapping_family`
/// the channel mapping family
/// ## `stream_count`
/// the number of independent streams
/// ## `coupled_count`
/// the number of stereo streams
/// ## `channel_mapping`
/// the mapping between the streams
///
/// # Returns
///
/// The [`gst::Caps`][crate::gst::Caps], or [`None`] if the parameters would lead to
/// invalid Opus caps.
#[doc(alias = "gst_codec_utils_opus_create_caps")]
pub fn codec_utils_opus_create_caps(
    rate: u32,
    channels: u8,
    channel_mapping_family: u8,
    stream_count: u8,
    coupled_count: u8,
    channel_mapping: &[u8],
) -> Result<gst::Caps, glib::BoolError> {
    assert_initialized_main_thread!();

    assert!(channel_mapping.is_empty() || channel_mapping.len() == channels as usize);

    unsafe {
        let caps = ffi::gst_codec_utils_opus_create_caps(
            rate,
            channels,
            channel_mapping_family,
            stream_count,
            coupled_count,
            if channel_mapping.is_empty() {
                ptr::null()
            } else {
                channel_mapping.to_glib_none().0
            },
        );

        if caps.is_null() {
            Err(glib::bool_error!(
                "Failed to create caps from Opus configuration"
            ))
        } else {
            Ok(from_glib_full(caps))
        }
    }
}

/// Creates Opus caps from the given OpusHead `header` and comment header
/// `comments`.
/// ## `header`
/// OpusHead header
/// ## `comments`
/// Comment header or NULL
///
/// # Returns
///
/// The [`gst::Caps`][crate::gst::Caps].
#[doc(alias = "gst_codec_utils_opus_create_caps_from_header")]
pub fn codec_utils_opus_create_caps_from_header(
    header: &gst::BufferRef,
    comments: Option<&gst::BufferRef>,
) -> Result<gst::Caps, glib::BoolError> {
    assert_initialized_main_thread!();
    unsafe {
        Option::<_>::from_glib_full(ffi::gst_codec_utils_opus_create_caps_from_header(
            mut_override(header.as_ptr()),
            comments
                .map(|b| mut_override(b.as_ptr()))
                .unwrap_or(ptr::null_mut()),
        ))
        .ok_or_else(|| glib::bool_error!("Failed to create caps from Opus headers"))
    }
}

/// Creates OpusHead header from the given parameters.
/// ## `rate`
/// the sample rate
/// ## `channels`
/// the number of channels
/// ## `channel_mapping_family`
/// the channel mapping family
/// ## `stream_count`
/// the number of independent streams
/// ## `coupled_count`
/// the number of stereo streams
/// ## `channel_mapping`
/// the mapping between the streams
/// ## `pre_skip`
/// Pre-skip in 48kHz samples or 0
/// ## `output_gain`
/// Output gain or 0
///
/// # Returns
///
/// The [`gst::Buffer`][crate::gst::Buffer] containing the OpusHead.
#[doc(alias = "gst_codec_utils_opus_create_header")]
#[allow(clippy::too_many_arguments)]
pub fn codec_utils_opus_create_header(
    rate: u32,
    channels: u8,
    channel_mapping_family: u8,
    stream_count: u8,
    coupled_count: u8,
    channel_mapping: &[u8],
    pre_skip: u16,
    output_gain: i16,
) -> Result<gst::Buffer, glib::BoolError> {
    assert_initialized_main_thread!();

    assert!(channel_mapping.is_empty() || channel_mapping.len() == channels as usize);

    unsafe {
        let header = ffi::gst_codec_utils_opus_create_header(
            rate,
            channels,
            channel_mapping_family,
            stream_count,
            coupled_count,
            if channel_mapping.is_empty() {
                ptr::null()
            } else {
                channel_mapping.to_glib_none().0
            },
            pre_skip,
            output_gain,
        );

        if header.is_null() {
            Err(glib::bool_error!(
                "Failed to create header from Opus configuration"
            ))
        } else {
            Ok(from_glib_full(header))
        }
    }
}

/// Parses Opus caps and fills the different fields with defaults if possible.
/// ## `caps`
/// the [`gst::Caps`][crate::gst::Caps] to parse the data from
///
/// # Returns
///
/// [`true`] if parsing was successful, [`false`] otherwise.
///
/// ## `rate`
/// the sample rate
///
/// ## `channels`
/// the number of channels
///
/// ## `channel_mapping_family`
/// the channel mapping family
///
/// ## `stream_count`
/// the number of independent streams
///
/// ## `coupled_count`
/// the number of stereo streams
///
/// ## `channel_mapping`
/// the mapping between the streams
#[doc(alias = "gst_codec_utils_opus_parse_caps")]
pub fn codec_utils_opus_parse_caps(
    caps: &gst::CapsRef,
    channel_mapping: Option<&mut [u8; 256]>,
) -> Result<(u32, u8, u8, u8, u8), glib::BoolError> {
    assert_initialized_main_thread!();

    unsafe {
        let mut rate = mem::MaybeUninit::uninit();
        let mut channels = mem::MaybeUninit::uninit();
        let mut channel_mapping_family = mem::MaybeUninit::uninit();
        let mut stream_count = mem::MaybeUninit::uninit();
        let mut coupled_count = mem::MaybeUninit::uninit();

        let res: bool = from_glib(ffi::gst_codec_utils_opus_parse_caps(
            mut_override(caps.as_ptr()),
            rate.as_mut_ptr(),
            channels.as_mut_ptr(),
            channel_mapping_family.as_mut_ptr(),
            stream_count.as_mut_ptr(),
            coupled_count.as_mut_ptr(),
            if let Some(channel_mapping) = channel_mapping {
                channel_mapping.as_mut_ptr() as *mut [u8; 256]
            } else {
                ptr::null_mut()
            },
        ));

        if res {
            Ok((
                rate.assume_init(),
                channels.assume_init(),
                channel_mapping_family.assume_init(),
                stream_count.assume_init(),
                coupled_count.assume_init(),
            ))
        } else {
            Err(glib::bool_error!("Failed to parse Opus caps"))
        }
    }
}

/// Parses the OpusHead header.
/// ## `header`
/// the OpusHead [`gst::Buffer`][crate::gst::Buffer]
///
/// # Returns
///
/// [`true`] if parsing was successful, [`false`] otherwise.
///
/// ## `rate`
/// the sample rate
///
/// ## `channels`
/// the number of channels
///
/// ## `channel_mapping_family`
/// the channel mapping family
///
/// ## `stream_count`
/// the number of independent streams
///
/// ## `coupled_count`
/// the number of stereo streams
///
/// ## `channel_mapping`
/// the mapping between the streams
///
/// ## `pre_skip`
/// Pre-skip in 48kHz samples or 0
///
/// ## `output_gain`
/// Output gain or 0
#[doc(alias = "gst_codec_utils_opus_parse_header")]
#[allow(clippy::type_complexity)]
pub fn codec_utils_opus_parse_header(
    header: &gst::BufferRef,
    channel_mapping: Option<&mut [u8; 256]>,
) -> Result<(u32, u8, u8, u8, u8, u16, i16), glib::BoolError> {
    assert_initialized_main_thread!();

    unsafe {
        let mut rate = mem::MaybeUninit::uninit();
        let mut channels = mem::MaybeUninit::uninit();
        let mut channel_mapping_family = mem::MaybeUninit::uninit();
        let mut stream_count = mem::MaybeUninit::uninit();
        let mut coupled_count = mem::MaybeUninit::uninit();
        let mut pre_skip = mem::MaybeUninit::uninit();
        let mut output_gain = mem::MaybeUninit::uninit();

        let res: bool = from_glib(ffi::gst_codec_utils_opus_parse_header(
            mut_override(header.as_ptr()),
            rate.as_mut_ptr(),
            channels.as_mut_ptr(),
            channel_mapping_family.as_mut_ptr(),
            stream_count.as_mut_ptr(),
            coupled_count.as_mut_ptr(),
            if let Some(channel_mapping) = channel_mapping {
                channel_mapping.as_mut_ptr() as *mut [u8; 256]
            } else {
                ptr::null_mut()
            },
            pre_skip.as_mut_ptr(),
            output_gain.as_mut_ptr(),
        ));

        if res {
            Ok((
                rate.assume_init(),
                channels.assume_init(),
                channel_mapping_family.assume_init(),
                stream_count.assume_init(),
                coupled_count.assume_init(),
                pre_skip.assume_init(),
                output_gain.assume_init(),
            ))
        } else {
            Err(glib::bool_error!("Failed to parse Opus header"))
        }
    }
}

/// Converts `caps` to a RFC 6381 compatible codec string if possible.
///
/// Useful for providing the 'codecs' field inside the 'Content-Type' HTTP
/// header for containerized formats, such as mp4 or matroska.
///
/// Registered codecs can be found at http://mp4ra.org/#/codecs
/// ## `caps`
/// A [`gst::Caps`][crate::gst::Caps] to convert to mime codec
///
/// # Returns
///
/// a RFC 6381 compatible codec string or [`None`]
#[cfg(feature = "v1_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
#[doc(alias = "gst_codec_utils_caps_get_mime_codec")]
pub fn codec_utils_caps_get_mime_codec(
    caps: &gst::CapsRef,
) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    unsafe {
        Option::<_>::from_glib_full(ffi::gst_codec_utils_caps_get_mime_codec(mut_override(
            caps.as_ptr(),
        )))
        .ok_or_else(|| glib::bool_error!("Unsupported caps"))
    }
}

/// Returns flags that describe the format of the caps if known. No flags are
/// set for unknown caps.
/// ## `caps`
/// the (fixed) [`gst::Caps`][crate::gst::Caps] for which flags are requested
///
/// # Returns
///
/// [`PbUtilsCapsDescriptionFlags`][crate::PbUtilsCapsDescriptionFlags] that describe `caps`, or no flags
///  if the caps are unknown.
#[cfg(feature = "v1_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
#[doc(alias = "gst_pb_utils_get_caps_description_flags")]
pub fn pb_utils_get_caps_description_flags(
    caps: &gst::CapsRef,
) -> crate::PbUtilsCapsDescriptionFlags {
    assert_initialized_main_thread!();
    unsafe { from_glib(ffi::gst_pb_utils_get_caps_description_flags(caps.as_ptr())) }
}

/// Returns a possible file extension for the given caps, if known.
/// ## `caps`
/// the (fixed) [`gst::Caps`][crate::gst::Caps] for which a file extension is needed
///
/// # Returns
///
/// a newly-allocated file extension string, or NULL on error. Free
///  string with `g_free()` when not needed any longer.
#[cfg(feature = "v1_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
#[doc(alias = "gst_pb_utils_get_file_extension_from_caps")]
pub fn pb_utils_get_file_extension_from_caps(caps: &gst::CapsRef) -> Option<glib::GString> {
    assert_initialized_main_thread!();
    unsafe {
        from_glib_full(ffi::gst_pb_utils_get_file_extension_from_caps(
            caps.as_ptr(),
        ))
    }
}

/// Parses the provided `av1c` and returns the corresponding caps
/// ## `av1c`
/// a [`gst::Buffer`][crate::gst::Buffer] containing a AV1CodecConfigurationRecord
///
/// # Returns
///
/// The parsed AV1 caps, or [`None`] if there
/// is an error
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_codec_utils_av1_create_caps_from_av1c")]
pub fn codec_utils_av1_create_caps_from_av1c(
    av1c: &gst::BufferRef,
) -> Result<gst::Caps, glib::BoolError> {
    assert_initialized_main_thread!();
    unsafe {
        Option::<_>::from_glib_full(ffi::gst_codec_utils_av1_create_caps_from_av1c(
            mut_override(av1c.as_ptr()),
        ))
        .ok_or_else(|| glib::bool_error!("Failed to create caps from AV1C header"))
    }
}

/// Creates the corresponding AV1 Codec Configuration Record
/// ## `caps`
/// a video/x-av1 [`gst::Caps`][crate::gst::Caps]
///
/// # Returns
///
/// The AV1 Codec Configuration Record, or
/// [`None`] if there was an error.
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_codec_utils_av1_create_av1c_from_caps")]
pub fn codec_utils_av1_create_av1c_from_caps(
    caps: &gst::CapsRef,
) -> Result<gst::Buffer, glib::BoolError> {
    assert_initialized_main_thread!();
    unsafe {
        Option::<_>::from_glib_full(ffi::gst_codec_utils_av1_create_av1c_from_caps(
            mut_override(caps.as_ptr()),
        ))
        .ok_or_else(|| glib::bool_error!("Failed to create AV1C header from caps"))
    }
}

/// Sets the level, tier and profile in `caps` if it can be determined from
/// `decoder_configuration`. See [`codec_utils_h266_get_level()`][crate::codec_utils_h266_get_level()],
/// [`codec_utils_h266_get_tier()`][crate::codec_utils_h266_get_tier()] and [`codec_utils_h266_get_profile()`][crate::codec_utils_h266_get_profile()]
/// for more details on the parameters.
/// ## `caps`
/// the [`gst::Caps`][crate::gst::Caps] to which the level, tier and profile are to be added
/// ## `decoder_configuration`
/// Pointer to the VvcDecoderConfigurationRecord struct as defined in ISO/IEC 14496-15
///
/// # Returns
///
/// [`true`] if the level, tier, profile could be set, [`false`] otherwise.
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_codec_utils_h266_caps_set_level_tier_and_profile")]
pub fn codec_utils_h266_caps_set_level_tier_and_profile(
    caps: &mut gst::CapsRef,
    decoder_configuration: &[u8],
) -> Result<(), glib::BoolError> {
    assert_initialized_main_thread!();
    let len = decoder_configuration.len() as _;
    unsafe {
        let res: bool = from_glib(ffi::gst_codec_utils_h266_caps_set_level_tier_and_profile(
            mut_override(caps.as_ptr()),
            decoder_configuration.to_glib_none().0,
            len,
        ));

        if res {
            Ok(())
        } else {
            Err(glib::bool_error!(
                "Failed to set H266 level/tier/profile to caps"
            ))
        }
    }
}

#[cfg(feature = "v1_30")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
pub type CodecUtilsVpxConfig = (i32, u8, u8, u8, u8, Option<bool>, u8, u8, u8);

/// Parses VP8/VP9 caps and extracts normalized VPX configuration fields.
/// Unlike [`codec_utils_vpx_caps_set_format_fields()`][crate::codec_utils_vpx_caps_set_format_fields()], this getter includes
/// the colorimetry-derived fields needed to build a full vpcC record.
/// ## `caps`
/// a video/x-vp8 or video/x-vp9 [`gst::Caps`][crate::gst::Caps]
///
/// # Returns
///
/// [`true`] if extraction succeeded, [`false`] otherwise.
///
/// ## `vpx_version`
/// VPX version described by `caps` (8 or 9)
///
/// ## `profile`
/// profile value
///
/// ## `level`
/// level value
///
/// ## `bit_depth`
/// bit depth value
///
/// ## `chroma_subsampling`
/// chroma subsampling value
///
/// ## `video_full_range`
/// whether full-range signaling is set
///
/// ## `colour_primaries`
/// ISO color primaries value
///
/// ## `transfer_characteristics`
/// ISO transfer characteristics value
///
/// ## `matrix_coefficients`
/// ISO matrix coefficients value
#[cfg(feature = "v1_30")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
#[doc(alias = "gst_codec_utils_vpx_caps_get_config")]
pub fn codec_utils_vpx_caps_get_config(caps: &gst::CapsRef) -> Option<CodecUtilsVpxConfig> {
    assert_initialized_main_thread!();
    unsafe {
        let mut vpx_version = std::mem::MaybeUninit::uninit();
        let mut profile = std::mem::MaybeUninit::uninit();
        let mut level = std::mem::MaybeUninit::uninit();
        let mut bit_depth = std::mem::MaybeUninit::uninit();
        let mut chroma_subsampling = std::mem::MaybeUninit::uninit();
        let mut video_full_range = std::mem::MaybeUninit::uninit();
        let mut colour_primaries = std::mem::MaybeUninit::uninit();
        let mut transfer_characteristics = std::mem::MaybeUninit::uninit();
        let mut matrix_coefficients = std::mem::MaybeUninit::uninit();

        let ret: bool = from_glib(ffi::gst_codec_utils_vpx_caps_get_config(
            mut_override(caps.as_ptr()),
            vpx_version.as_mut_ptr(),
            profile.as_mut_ptr(),
            level.as_mut_ptr(),
            bit_depth.as_mut_ptr(),
            chroma_subsampling.as_mut_ptr(),
            video_full_range.as_mut_ptr(),
            colour_primaries.as_mut_ptr(),
            transfer_characteristics.as_mut_ptr(),
            matrix_coefficients.as_mut_ptr(),
        ));

        if ret {
            let video_full_range = match video_full_range.assume_init() {
                -1 => None,
                0 => Some(false),
                _ => Some(true),
            };

            Some((
                vpx_version.assume_init(),
                profile.assume_init(),
                level.assume_init(),
                bit_depth.assume_init(),
                chroma_subsampling.assume_init(),
                video_full_range,
                colour_primaries.assume_init(),
                transfer_characteristics.assume_init(),
                matrix_coefficients.assume_init(),
            ))
        } else {
            None
        }
    }
}

/// Estimates the vp9 level as defined in
/// https://www.webmproject.org/vp9/mp4/`vp`-codec-configuration-box, using
/// the resolution and, if available, frame rate found in the structure passed
/// in.
/// ## `caps`
/// a video/x-vp9 [`gst::Caps`][crate::gst::Caps]
///
/// # Returns
///
/// The estimated vp9 level indicator, and 0 if it could not be
/// estimated.
#[cfg(feature = "v1_30")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
#[doc(alias = "gst_codec_utils_vp9_estimate_level_idc_from_caps")]
pub fn codec_utils_vp9_estimate_level_idc_from_caps(caps: &gst::CapsRef) -> u8 {
    assert_initialized_main_thread!();
    unsafe { ffi::gst_codec_utils_vp9_estimate_level_idc_from_caps(mut_override(caps.as_ptr())) }
}

/// Creates a vpcC record for VP8/VP9 as per the VP Codec ISO Media File Format
/// Binding definition found at
/// https://www.webmproject.org/vp9/mp4/`vp`-codec-configuration-box
/// ## `caps`
/// a video/x-vp8 or video/x-vp9 [`gst::Caps`][crate::gst::Caps]
///
/// # Returns
///
/// Buffer containing the vpcC record, or
/// [`None`] if the record could not be created.
#[cfg(feature = "v1_30")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
#[doc(alias = "gst_codec_utils_vpx_create_vpcc_from_caps")]
pub fn codec_utils_vpx_create_vpcc_from_caps(caps: &gst::CapsRef) -> Option<gst::Buffer> {
    assert_initialized_main_thread!();
    unsafe {
        from_glib_full(ffi::gst_codec_utils_vpx_create_vpcc_from_caps(
            mut_override(caps.as_ptr()),
        ))
    }
}