use crate::{CdTextCoder, FilterStreamInfo, ParserInfo, Writer, WriterInfo, ffi};
use glib::{prelude::*, translate::*};
#[doc(alias = "mirage_cdtext_decoder_get_block_info")]
pub fn cdtext_decoder_get_block_info(
self_: &impl IsA<CdTextCoder>,
block: i32,
) -> Result<(i32, i32, i32), glib::Error> {
skip_assert_initialized!();
unsafe {
let mut code = std::mem::MaybeUninit::uninit();
let mut charset = std::mem::MaybeUninit::uninit();
let mut copyright = std::mem::MaybeUninit::uninit();
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_cdtext_decoder_get_block_info(
self_.as_ref().to_glib_none().0,
block,
code.as_mut_ptr(),
charset.as_mut_ptr(),
copyright.as_mut_ptr(),
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok((
code.assume_init(),
charset.assume_init(),
copyright.assume_init(),
))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_cdtext_decoder_init")]
pub fn cdtext_decoder_init(self_: &impl IsA<CdTextCoder>, buffer: &[u8]) {
skip_assert_initialized!();
let buflen = buffer.len() as _;
unsafe {
ffi::mirage_cdtext_decoder_init(
self_.as_ref().to_glib_none().0,
buffer.to_glib_none().0,
buflen,
);
}
}
#[doc(alias = "mirage_cdtext_encoder_add_data")]
pub fn cdtext_encoder_add_data(
self_: &impl IsA<CdTextCoder>,
code: i32,
type_: i32,
track: i32,
data: &[u8],
) {
skip_assert_initialized!();
let data_len = data.len() as _;
unsafe {
ffi::mirage_cdtext_encoder_add_data(
self_.as_ref().to_glib_none().0,
code,
type_,
track,
data.to_glib_none().0,
data_len,
);
}
}
#[doc(alias = "mirage_cdtext_encoder_encode")]
pub fn cdtext_encoder_encode(self_: &impl IsA<CdTextCoder>) -> Vec<u8> {
skip_assert_initialized!();
unsafe {
let mut buffer = std::ptr::null_mut();
let mut buflen = std::mem::MaybeUninit::uninit();
ffi::mirage_cdtext_encoder_encode(
self_.as_ref().to_glib_none().0,
&mut buffer,
buflen.as_mut_ptr(),
);
FromGlibContainer::from_glib_full_num(buffer, buflen.assume_init() as _)
}
}
#[doc(alias = "mirage_cdtext_encoder_init")]
pub fn cdtext_encoder_init(self_: &impl IsA<CdTextCoder>, buffer: &[u8]) {
skip_assert_initialized!();
let buflen = buffer.len() as _;
unsafe {
ffi::mirage_cdtext_encoder_init(
self_.as_ref().to_glib_none().0,
buffer.to_glib_none().0,
buflen,
);
}
}
#[doc(alias = "mirage_cdtext_encoder_set_block_info")]
pub fn cdtext_encoder_set_block_info(
self_: &impl IsA<CdTextCoder>,
block: i32,
code: i32,
charset: i32,
copyright: i32,
) -> Result<(), glib::Error> {
skip_assert_initialized!();
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_cdtext_encoder_set_block_info(
self_.as_ref().to_glib_none().0,
block,
code,
charset,
copyright,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_create_writer")]
pub fn create_writer(writer_id: &str) -> Result<Writer, glib::Error> {
assert_initialized_main_thread!();
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_create_writer(writer_id.to_glib_none().0, &mut error);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_enumerate_filter_streams")]
pub fn enumerate_filter_streams<P: FnMut(&FilterStreamInfo) -> bool>(
func: P,
) -> Result<(), glib::Error> {
assert_initialized_main_thread!();
let mut func_data: P = func;
unsafe extern "C" fn func_func<P: FnMut(&FilterStreamInfo) -> bool>(
info: *const ffi::MirageFilterStreamInfo,
user_data: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
unsafe {
let info = from_glib_borrow(info);
let callback = user_data as *mut P;
(*callback)(&info).into_glib()
}
}
let func = Some(func_func::<P> as _);
let super_callback0: &mut P = &mut func_data;
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_enumerate_filter_streams(
func,
super_callback0 as *mut _ as *mut _,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_enumerate_parsers")]
pub fn enumerate_parsers<P: FnMut(&ParserInfo) -> bool>(func: P) -> Result<(), glib::Error> {
assert_initialized_main_thread!();
let mut func_data: P = func;
unsafe extern "C" fn func_func<P: FnMut(&ParserInfo) -> bool>(
info: *const ffi::MirageParserInfo,
user_data: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
unsafe {
let info = from_glib_borrow(info);
let callback = user_data as *mut P;
(*callback)(&info).into_glib()
}
}
let func = Some(func_func::<P> as _);
let super_callback0: &mut P = &mut func_data;
unsafe {
let mut error = std::ptr::null_mut();
let is_ok =
ffi::mirage_enumerate_parsers(func, super_callback0 as *mut _ as *mut _, &mut error);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_enumerate_writers")]
pub fn enumerate_writers<P: FnMut(&WriterInfo) -> bool>(func: P) -> Result<(), glib::Error> {
assert_initialized_main_thread!();
let mut func_data: P = func;
unsafe extern "C" fn func_func<P: FnMut(&WriterInfo) -> bool>(
info: *const ffi::MirageWriterInfo,
user_data: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
unsafe {
let info = from_glib_borrow(info);
let callback = user_data as *mut P;
(*callback)(&info).into_glib()
}
}
let func = Some(func_func::<P> as _);
let super_callback0: &mut P = &mut func_data;
unsafe {
let mut error = std::ptr::null_mut();
let is_ok =
ffi::mirage_enumerate_writers(func, super_callback0 as *mut _ as *mut _, &mut error);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}