libmirage 0.1.0

use crate::DebugMaskInfo;
use crate::{CdTextCoder, FilterStreamInfo, ParserInfo, WriterInfo};
use glib::prelude::*;
use glib::translate::*;
use std::slice;

#[doc(alias = "mirage_get_filter_streams_info")]
#[doc(alias = "get_filter_streams_info")]
pub fn filter_streams_info() -> Result<Vec<FilterStreamInfo>, glib::Error> {
    assert_initialized_main_thread!();
    unsafe {
        let mut info = std::ptr::null();
        let mut num_filter_streams = std::mem::MaybeUninit::uninit();
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::mirage_get_filter_streams_info(
            &mut info,
            num_filter_streams.as_mut_ptr(),
            &mut error,
        );
        debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(FromGlibContainer::from_glib_none_num(
                info,
                num_filter_streams.assume_init() as _,
            ))
        } else {
            Err(from_glib_full(error))
        }
    }
}

#[doc(alias = "mirage_get_parsers_info")]
#[doc(alias = "get_parsers_info")]
pub fn parsers_info() -> Result<Vec<ParserInfo>, glib::Error> {
    assert_initialized_main_thread!();
    unsafe {
        let mut info = std::ptr::null();
        let mut num_parsers = std::mem::MaybeUninit::uninit();
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::mirage_get_parsers_info(&mut info, num_parsers.as_mut_ptr(), &mut error);
        debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(FromGlibContainer::from_glib_none_num(
                info,
                num_parsers.assume_init() as _,
            ))
        } else {
            Err(from_glib_full(error))
        }
    }
}

#[doc(alias = "mirage_get_writers_info")]
#[doc(alias = "get_writers_info")]
pub fn writers_info() -> Result<Vec<WriterInfo>, glib::Error> {
    assert_initialized_main_thread!();
    unsafe {
        let mut info = std::ptr::null();
        let mut num_writers = std::mem::MaybeUninit::uninit();
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::mirage_get_writers_info(&mut info, num_writers.as_mut_ptr(), &mut error);
        debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(FromGlibContainer::from_glib_none_num(
                info,
                num_writers.assume_init() as _,
            ))
        } else {
            Err(from_glib_full(error))
        }
    }
}

#[doc(alias = "mirage_cdtext_decoder_get_data")]
pub fn cdtext_decoder_get_data<P: FnMut(i32, i32, i32, &[u8]) -> bool>(
    self_: &impl IsA<CdTextCoder>,
    block: i32,
    callback_func: P,
) -> bool {
    skip_assert_initialized!();
    let mut callback_func_data: P = callback_func;
    unsafe extern "C" fn callback_func_func<P: FnMut(i32, i32, i32, &[u8]) -> bool>(
        code: std::ffi::c_int,
        type_: std::ffi::c_int,
        track: std::ffi::c_int,
        data: *const u8,
        data_len: std::ffi::c_int,
        user_data: glib::ffi::gpointer,
    ) -> glib::ffi::gboolean {
        unsafe {
            let data = slice::from_raw_parts(data, data_len as usize);
            let callback = user_data as *mut P;
            (*callback)(code, type_, track, data).into_glib()
        }
    }
    let callback_func = Some(callback_func_func::<P> as _);
    let super_callback0: &mut P = &mut callback_func_data;
    unsafe {
        from_glib(ffi::mirage_cdtext_decoder_get_data(
            self_.as_ref().to_glib_none().0,
            block,
            callback_func,
            super_callback0 as *mut _ as *mut _,
        ))
    }
}

#[doc(alias = "mirage_get_filter_streams_type")]
#[doc(alias = "get_filter_streams_type")]
pub fn filter_streams_type() -> Result<Vec<glib::Type>, glib::Error> {
    assert_initialized_main_thread!();
    unsafe {
        let mut info = std::ptr::null();
        let mut num_filter_streams = std::mem::MaybeUninit::uninit();
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::mirage_get_filter_streams_type(
            &mut info,
            num_filter_streams.as_mut_ptr(),
            &mut error,
        );
        debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(FromGlibContainer::from_glib_none_num(
                info,
                num_filter_streams.assume_init() as _,
            ))
        } else {
            Err(from_glib_full(error))
        }
    }
}

#[doc(alias = "mirage_get_parsers_type")]
#[doc(alias = "get_parsers_type")]
pub fn parsers_type() -> Result<Vec<glib::Type>, glib::Error> {
    assert_initialized_main_thread!();
    unsafe {
        let mut info = std::ptr::null();
        let mut num_parsers = std::mem::MaybeUninit::uninit();
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::mirage_get_parsers_type(&mut info, num_parsers.as_mut_ptr(), &mut error);
        debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(FromGlibContainer::from_glib_none_num(
                info,
                num_parsers.assume_init() as _,
            ))
        } else {
            Err(from_glib_full(error))
        }
    }
}

#[doc(alias = "mirage_get_writers_type")]
#[doc(alias = "get_writers_type")]
pub fn writers_type() -> Result<Vec<glib::Type>, glib::Error> {
    assert_initialized_main_thread!();
    unsafe {
        let mut info = std::ptr::null();
        let mut num_writers = std::mem::MaybeUninit::uninit();
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::mirage_get_writers_type(&mut info, num_writers.as_mut_ptr(), &mut error);
        debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(FromGlibContainer::from_glib_none_num(
                info,
                num_writers.assume_init() as _,
            ))
        } else {
            Err(from_glib_full(error))
        }
    }
}

#[doc(alias = "mirage_get_supported_debug_masks")]
#[doc(alias = "get_supported_debug_masks")]
pub fn supported_debug_masks() -> Result<Vec<DebugMaskInfo>, glib::Error> {
    assert_initialized_main_thread!();
    unsafe {
        let mut masks = std::ptr::null();
        let mut num_masks = std::mem::MaybeUninit::uninit();
        let mut error = std::ptr::null_mut();
        let is_ok =
            ffi::mirage_get_supported_debug_masks(&mut masks, num_masks.as_mut_ptr(), &mut error);
        debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            let infos = slice::from_raw_parts(masks, num_masks.assume_init() as _);
            Ok(infos
                .iter()
                .map(|info| DebugMaskInfo {
                    name: from_glib_none(info.name),
                    value: from_glib(info.value),
                })
                .collect())
        } else {
            Err(from_glib_full(error))
        }
    }
}