// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT

use crate::{ffi, EncodingTarget};
use glib::translate::*;

/// Returns the channels of the given AAC stream.
/// ## `audio_config`
/// a pointer to the AudioSpecificConfig
///  as specified in the Elementary Stream Descriptor (esds)
///  in ISO/IEC 14496-1.
///
/// # Returns
///
/// The channels or 0 if the channel could not be determined.
#[doc(alias = "gst_codec_utils_aac_get_channels")]
pub fn codec_utils_aac_get_channels(audio_config: &[u8]) -> u32 {
    assert_initialized_main_thread!();
    let len = audio_config.len() as _;
    unsafe { ffi::gst_codec_utils_aac_get_channels(audio_config.to_glib_none().0, len) }
}

/// Translates the sample rate to the index corresponding to it in AAC spec.
/// ## `rate`
/// Sample rate
///
/// # Returns
///
/// The AAC index for this sample rate, -1 if the rate is not a
/// valid AAC sample rate.
#[doc(alias = "gst_codec_utils_aac_get_index_from_sample_rate")]
pub fn codec_utils_aac_get_index_from_sample_rate(rate: u32) -> i32 {
    assert_initialized_main_thread!();
    unsafe { ffi::gst_codec_utils_aac_get_index_from_sample_rate(rate) }
}

/// Determines the level of a stream as defined in ISO/IEC 14496-3. For AAC LC
/// streams, the constraints from the AAC audio profile are applied. For AAC
/// Main, LTP, SSR and others, the Main profile is used.
///
/// The `audio_config` parameter follows the following format, starting from the
/// most significant bit of the first byte:
///
///  * Bit 0:4 contains the AudioObjectType (if this is 0x5, then the
///  real AudioObjectType is carried after the rate and channel data)
///  * Bit 5:8 contains the sample frequency index (if this is 0xf, then the
///  next 24 bits define the actual sample frequency, and subsequent
///  fields are appropriately shifted).
///  * Bit 9:12 contains the channel configuration
/// ## `audio_config`
/// a pointer to the AudioSpecificConfig
///  as specified in the Elementary Stream Descriptor (esds)
///  in ISO/IEC 14496-1.
///
/// # Returns
///
/// The level as a const string and [`None`] if the level could not be
/// determined.
#[doc(alias = "gst_codec_utils_aac_get_level")]
pub fn codec_utils_aac_get_level(audio_config: &[u8]) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = audio_config.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_aac_get_level(
            audio_config.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get AAC level"))
    }
}

/// Returns the profile of the given AAC stream as a string. The profile is
/// normally determined using the AudioObjectType field which is in the first
/// 5 bits of `audio_config`
/// ## `audio_config`
/// a pointer to the AudioSpecificConfig
///  as specified in the Elementary Stream Descriptor (esds)
///  in ISO/IEC 14496-1.
///
/// # Returns
///
/// The profile as a const string and [`None`] if the profile could not be
/// determined.
#[doc(alias = "gst_codec_utils_aac_get_profile")]
pub fn codec_utils_aac_get_profile(audio_config: &[u8]) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = audio_config.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_aac_get_profile(
            audio_config.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get AAC profile"))
    }
}

/// Translates the sample rate index found in AAC headers to the actual sample
/// rate.
/// ## `audio_config`
/// a pointer to the AudioSpecificConfig
///  as specified in the Elementary Stream Descriptor (esds)
///  in ISO/IEC 14496-1.
///
/// # Returns
///
/// The sample rate if sr_idx is valid, 0 otherwise.
#[doc(alias = "gst_codec_utils_aac_get_sample_rate")]
pub fn codec_utils_aac_get_sample_rate(audio_config: &[u8]) -> u32 {
    assert_initialized_main_thread!();
    let len = audio_config.len() as _;
    unsafe { ffi::gst_codec_utils_aac_get_sample_rate(audio_config.to_glib_none().0, len) }
}

/// Translates the sample rate index found in AAC headers to the actual sample
/// rate.
/// ## `sr_idx`
/// Sample rate index as from the AudioSpecificConfig (MPEG-4
///  container) or ADTS frame header
///
/// # Returns
///
/// The sample rate if `sr_idx` is valid, 0 otherwise.
#[doc(alias = "gst_codec_utils_aac_get_sample_rate_from_index")]
pub fn codec_utils_aac_get_sample_rate_from_index(sr_idx: u32) -> u32 {
    assert_initialized_main_thread!();
    unsafe { ffi::gst_codec_utils_aac_get_sample_rate_from_index(sr_idx) }
}

/// Transform a seq_level_idx into the level string
/// ## `seq_level_idx`
/// A seq_level_idx
///
/// # Returns
///
/// the level string or [`None`] if the seq_level_idx is unknown
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_codec_utils_av1_get_level")]
pub fn codec_utils_av1_get_level(seq_level_idx: u8) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_av1_get_level(seq_level_idx))
            .ok_or_else(|| glib::bool_error!("Failed to get AV1 level"))
    }
}

/// Transform a level string from the caps into the seq_level_idx
/// ## `level`
/// A level string from caps
///
/// # Returns
///
/// the seq_level_idx or 31 (max-level) if the level is unknown
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_codec_utils_av1_get_seq_level_idx")]
pub fn codec_utils_av1_get_seq_level_idx(level: &str) -> u8 {
    assert_initialized_main_thread!();
    unsafe { ffi::gst_codec_utils_av1_get_seq_level_idx(level.to_glib_none().0) }
}

/// Converts a RFC 6381 compatible codec string to [`gst::Caps`][crate::gst::Caps]. More than one codec
/// string can be present (separated by `,`).
///
/// Registered codecs can be found at http://mp4ra.org/#/codecs
/// ## `codecs_field`
/// A mime codec string field
///
/// # Returns
///
/// The corresponding [`gst::Caps`][crate::gst::Caps] or [`None`]
#[cfg(feature = "v1_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
#[doc(alias = "gst_codec_utils_caps_from_mime_codec")]
pub fn codec_utils_caps_from_mime_codec(codecs_field: &str) -> Option<gst::Caps> {
    assert_initialized_main_thread!();
    unsafe {
        from_glib_full(ffi::gst_codec_utils_caps_from_mime_codec(
            codecs_field.to_glib_none().0,
        ))
    }
}

/// Converts the level indication (level_idc) in the stream's
/// sequence parameter set into a string. The SPS is expected to have the
/// same format as for [`codec_utils_h264_get_profile()`][crate::codec_utils_h264_get_profile()].
/// ## `sps`
/// Pointer to the sequence parameter set for the stream.
///
/// # Returns
///
/// The level as a const string, or [`None`] if there is an error.
#[doc(alias = "gst_codec_utils_h264_get_level")]
pub fn codec_utils_h264_get_level(sps: &[u8]) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = sps.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_h264_get_level(
            sps.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get H264 level"))
    }
}

/// Transform a level string from the caps into the level_idc
/// ## `level`
/// A level string from caps
///
/// # Returns
///
/// the level_idc or 0 if the level is unknown
#[doc(alias = "gst_codec_utils_h264_get_level_idc")]
pub fn codec_utils_h264_get_level_idc(level: &str) -> u8 {
    assert_initialized_main_thread!();
    unsafe { ffi::gst_codec_utils_h264_get_level_idc(level.to_glib_none().0) }
}

/// Converts the profile indication (profile_idc) in the stream's
/// sequence parameter set into a string. The SPS is expected to have the
/// following format, as defined in the H.264 specification. The SPS is viewed
/// as a bitstream here, with bit 0 being the most significant bit of the first
/// byte.
///
/// * Bit 0:7 - Profile indication
/// * Bit 8 - constraint_set0_flag
/// * Bit 9 - constraint_set1_flag
/// * Bit 10 - constraint_set2_flag
/// * Bit 11 - constraint_set3_flag
/// * Bit 12 - constraint_set3_flag
/// * Bit 13:15 - Reserved
/// * Bit 16:24 - Level indication
/// ## `sps`
/// Pointer to the sequence parameter set for the stream.
///
/// # Returns
///
/// The profile as a const string, or [`None`] if there is an error.
#[doc(alias = "gst_codec_utils_h264_get_profile")]
pub fn codec_utils_h264_get_profile(sps: &[u8]) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = sps.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_h264_get_profile(
            sps.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get H264 profile"))
    }
}

/// Converts the level indication (general_level_idc) in the stream's
/// profile_tier_level structure into a string. The profiel_tier_level is
/// expected to have the same format as for [`codec_utils_h264_get_profile()`][crate::codec_utils_h264_get_profile()].
/// ## `profile_tier_level`
/// Pointer to the profile_tier_level
///  for the stream
///
/// # Returns
///
/// The level as a const string, or [`None`] if there is an error.
#[doc(alias = "gst_codec_utils_h265_get_level")]
pub fn codec_utils_h265_get_level(
    profile_tier_level: &[u8],
) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = profile_tier_level.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_h265_get_level(
            profile_tier_level.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get H265 level"))
    }
}

/// Transform a level string from the caps into the level_idc
/// ## `level`
/// A level string from caps
///
/// # Returns
///
/// the level_idc or 0 if the level is unknown
#[doc(alias = "gst_codec_utils_h265_get_level_idc")]
pub fn codec_utils_h265_get_level_idc(level: &str) -> u8 {
    assert_initialized_main_thread!();
    unsafe { ffi::gst_codec_utils_h265_get_level_idc(level.to_glib_none().0) }
}

/// Converts the profile indication (general_profile_idc) in the stream's
/// profile_level_tier structure into a string. The profile_tier_level is
/// expected to have the following format, as defined in the H.265
/// specification. The profile_tier_level is viewed as a bitstream here,
/// with bit 0 being the most significant bit of the first byte.
///
/// * Bit 0:1 - general_profile_space
/// * Bit 2 - general_tier_flag
/// * Bit 3:7 - general_profile_idc
/// * Bit 8:39 - gernal_profile_compatibility_flags
/// * Bit 40 - general_progressive_source_flag
/// * Bit 41 - general_interlaced_source_flag
/// * Bit 42 - general_non_packed_constraint_flag
/// * Bit 43 - general_frame_only_constraint_flag
/// * Bit 44:87 - See below
/// * Bit 88:95 - general_level_idc
/// ## `profile_tier_level`
/// Pointer to the profile_tier_level
///  structure for the stream.
///
/// # Returns
///
/// The profile as a const string, or [`None`] if there is an error.
#[doc(alias = "gst_codec_utils_h265_get_profile")]
pub fn codec_utils_h265_get_profile(
    profile_tier_level: &[u8],
) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = profile_tier_level.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_h265_get_profile(
            profile_tier_level.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get H265 profile"))
    }
}

/// Converts the tier indication (general_tier_flag) in the stream's
/// profile_tier_level structure into a string. The profile_tier_level
/// is expected to have the same format as for [`codec_utils_h264_get_profile()`][crate::codec_utils_h264_get_profile()].
/// ## `profile_tier_level`
/// Pointer to the profile_tier_level
///  for the stream.
///
/// # Returns
///
/// The tier as a const string, or [`None`] if there is an error.
#[doc(alias = "gst_codec_utils_h265_get_tier")]
pub fn codec_utils_h265_get_tier(
    profile_tier_level: &[u8],
) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = profile_tier_level.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_h265_get_tier(
            profile_tier_level.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get H265 tier"))
    }
}

/// Converts the level indication in the stream's visual object sequence into
/// a string. `vis_obj_seq` is expected to be the data following the visual
/// object sequence start code. Only the first byte
/// (profile_and_level_indication) is used.
/// ## `vis_obj_seq`
/// Pointer to the visual object
///  sequence for the stream.
///
/// # Returns
///
/// The level as a const string, or NULL if there is an error.
#[doc(alias = "gst_codec_utils_mpeg4video_get_level")]
pub fn codec_utils_mpeg4video_get_level(
    vis_obj_seq: &[u8],
) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = vis_obj_seq.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_mpeg4video_get_level(
            vis_obj_seq.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get MPEG4 video level"))
    }
}

/// Converts the profile indication in the stream's visual object sequence into
/// a string. `vis_obj_seq` is expected to be the data following the visual
/// object sequence start code. Only the first byte
/// (profile_and_level_indication) is used.
/// ## `vis_obj_seq`
/// Pointer to the visual object
///  sequence for the stream.
///
/// # Returns
///
/// The profile as a const string, or NULL if there is an error.
#[doc(alias = "gst_codec_utils_mpeg4video_get_profile")]
pub fn codec_utils_mpeg4video_get_profile(
    vis_obj_seq: &[u8],
) -> Result<glib::GString, glib::BoolError> {
    assert_initialized_main_thread!();
    let len = vis_obj_seq.len() as _;
    unsafe {
        Option::<_>::from_glib_none(ffi::gst_codec_utils_mpeg4video_get_profile(
            vis_obj_seq.to_glib_none().0,
            len,
        ))
        .ok_or_else(|| glib::bool_error!("Failed to get MPEG4 video profile"))
    }
}

/// List all available [`EncodingTarget`][crate::EncodingTarget] for the specified category, or all categories
/// if `categoryname` is [`None`].
/// ## `categoryname`
/// The category, for ex: `GST_ENCODING_CATEGORY_DEVICE`.
/// Can be [`None`].
///
/// # Returns
///
/// The list of [`EncodingTarget`][crate::EncodingTarget]
#[doc(alias = "gst_encoding_list_all_targets")]
pub fn encoding_list_all_targets(categoryname: Option<&str>) -> Vec<EncodingTarget> {
    assert_initialized_main_thread!();
    unsafe {
        FromGlibPtrContainer::from_glib_full(ffi::gst_encoding_list_all_targets(
            categoryname.to_glib_none().0,
        ))
    }
}

/// Lists all [`EncodingTarget`][crate::EncodingTarget] categories present on disk.
///
/// # Returns
///
/// A list
/// of [`EncodingTarget`][crate::EncodingTarget] categories.
#[doc(alias = "gst_encoding_list_available_categories")]
pub fn encoding_list_available_categories() -> Vec<glib::GString> {
    assert_initialized_main_thread!();
    unsafe { FromGlibPtrContainer::from_glib_full(ffi::gst_encoding_list_available_categories()) }
}

/// Returns a localised string describing the given element, for use in
/// error dialogs or other messages to be seen by the user.
///
/// This function is mainly for internal use, applications would typically
/// use `gst_missing_plugin_message_get_description()` to get a description of
/// a missing feature from a missing-plugin message.
/// ## `factory_name`
/// the name of the element, e.g. "giosrc"
///
/// # Returns
///
/// a newly-allocated description string. Free
///  string with `g_free()` when not needed any longer.
#[doc(alias = "gst_pb_utils_get_element_description")]
pub fn pb_utils_get_element_description(factory_name: &str) -> glib::GString {
    assert_initialized_main_thread!();
    unsafe {
        from_glib_full(ffi::gst_pb_utils_get_element_description(
            factory_name.to_glib_none().0,
        ))
    }
}

/// Returns a localised string describing a sink element handling the protocol
/// specified in `protocol`, for use in error dialogs or other messages to be
/// seen by the user.
///
/// This function is mainly for internal use, applications would typically
/// use `gst_missing_plugin_message_get_description()` to get a description of
/// a missing feature from a missing-plugin message.
/// ## `protocol`
/// the protocol the sink element needs to handle, e.g. "http"
///
/// # Returns
///
/// a newly-allocated description string. Free
///  string with `g_free()` when not needed any longer.
#[doc(alias = "gst_pb_utils_get_sink_description")]
pub fn pb_utils_get_sink_description(protocol: &str) -> glib::GString {
    assert_initialized_main_thread!();
    unsafe {
        from_glib_full(ffi::gst_pb_utils_get_sink_description(
            protocol.to_glib_none().0,
        ))
    }
}

/// Returns a localised string describing a source element handling the protocol
/// specified in `protocol`, for use in error dialogs or other messages to be
/// seen by the user.
///
/// This function is mainly for internal use, applications would typically
/// use `gst_missing_plugin_message_get_description()` to get a description of
/// a missing feature from a missing-plugin message.
/// ## `protocol`
/// the protocol the source element needs to handle, e.g. "http"
///
/// # Returns
///
/// a newly-allocated description string. Free
///  string with `g_free()` when not needed any longer.
#[doc(alias = "gst_pb_utils_get_source_description")]
pub fn pb_utils_get_source_description(protocol: &str) -> glib::GString {
    assert_initialized_main_thread!();
    unsafe {
        from_glib_full(ffi::gst_pb_utils_get_source_description(
            protocol.to_glib_none().0,
        ))
    }
}

/// Gets the version number of the GStreamer Plugins Base libraries.
///
/// # Returns
///
///
/// ## `major`
/// pointer to a guint to store the major version number, or [`None`]
///
/// ## `minor`
/// pointer to a guint to store the minor version number, or [`None`]
///
/// ## `micro`
/// pointer to a guint to store the micro version number, or [`None`]
///
/// ## `nano`
/// pointer to a guint to store the nano version number, or [`None`]
#[doc(alias = "gst_plugins_base_version")]
pub fn plugins_base_version() -> (u32, u32, u32, u32) {
    skip_assert_initialized!();
    unsafe {
        let mut major = std::mem::MaybeUninit::uninit();
        let mut minor = std::mem::MaybeUninit::uninit();
        let mut micro = std::mem::MaybeUninit::uninit();
        let mut nano = std::mem::MaybeUninit::uninit();
        ffi::gst_plugins_base_version(
            major.as_mut_ptr(),
            minor.as_mut_ptr(),
            micro.as_mut_ptr(),
            nano.as_mut_ptr(),
        );
        (
            major.assume_init(),
            minor.assume_init(),
            micro.assume_init(),
            nano.assume_init(),
        )
    }
}

/// This function returns a string that is useful for describing this version
/// of GStreamer's gst-plugins-base libraries to the outside world: user agent
/// strings, logging, about dialogs ...
///
/// # Returns
///
/// a newly allocated string describing this version of gst-plugins-base
#[doc(alias = "gst_plugins_base_version_string")]
pub fn plugins_base_version_string() -> glib::GString {
    skip_assert_initialized!();
    unsafe { from_glib_full(ffi::gst_plugins_base_version_string()) }
}