gstreamer-rs/gstreamer-pbutils/src/missing_plugins.rs

515 lines
16 KiB
Rust

// Take a look at the license at the top of the repository in the LICENSE file.
use glib::{translate::*, value::ToSendValue};
use gst::{ffi as gst_ffi, prelude::*, Element, Message, Seqnum};
use crate::ffi;
macro_rules! message_builder_generic_impl {
($new_fn:expr) => {
#[allow(clippy::needless_update)]
pub fn src<O: IsA<Element> + Cast + Clone>(self, src: &O) -> Self {
Self {
builder: self.builder.src(src),
..self
}
}
#[allow(clippy::needless_update)]
pub fn src_if<O: IsA<Element> + Cast + Clone>(self, src: &O, predicate: bool) -> Self {
if predicate {
self.src(src)
} else {
self
}
}
#[allow(clippy::needless_update)]
pub fn src_if_some<O: IsA<Element> + Cast + Clone>(self, src: Option<&O>) -> Self {
if let Some(src) = src {
self.src(src)
} else {
self
}
}
#[doc(alias = "gst_message_set_seqnum")]
#[allow(clippy::needless_update)]
pub fn seqnum(self, seqnum: Seqnum) -> Self {
Self {
builder: self.builder.seqnum(seqnum),
..self
}
}
#[doc(alias = "gst_message_set_seqnum")]
#[allow(clippy::needless_update)]
pub fn seqnum_if(self, seqnum: Seqnum, predicate: bool) -> Self {
if predicate {
self.seqnum(seqnum)
} else {
self
}
}
#[doc(alias = "gst_message_set_seqnum")]
#[allow(clippy::needless_update)]
pub fn seqnum_if_some(self, seqnum: Option<Seqnum>) -> Self {
if let Some(seqnum) = seqnum {
self.seqnum(seqnum)
} else {
self
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_message_set_details")]
pub fn details(self, details: gst::Structure) -> Self {
Self {
builder: self.builder.details(details),
..self
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_message_set_details")]
pub fn details_if(self, details: gst::Structure, predicate: bool) -> Self {
if predicate {
self.details(details)
} else {
self
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_message_set_details")]
pub fn details_if_some(self, details: Option<gst::Structure>) -> Self {
if let Some(details) = details {
self.details(details)
} else {
self
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_missing_plugin_message_set_stream_id")]
pub fn stream_id(self, stream_id: &'a str) -> Self {
Self {
stream_id: Some(stream_id),
..self
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_missing_plugin_message_set_stream_id")]
pub fn stream_id_if(self, stream_id: &'a str, predicate: bool) -> Self {
if predicate {
self.stream_id(stream_id)
} else {
self
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_missing_plugin_message_set_stream_id")]
pub fn stream_id_if_some(self, stream_id: Option<&'a str>) -> Self {
if let Some(stream_id) = stream_id {
self.stream_id(stream_id)
} else {
self
}
}
// rustdoc-stripper-ignore-next
/// Sets field `name` to the given value `value`.
///
/// Overrides any default or previously defined value for `name`.
pub fn other_field(self, name: &'a str, value: impl ToSendValue) -> Self {
Self {
builder: self.builder.other_field(name, value),
..self
}
}
gst::impl_builder_gvalue_extra_setters!(other_field);
#[must_use = "Building the message without using it has no effect"]
#[allow(clippy::redundant_closure_call)]
pub fn build(mut self) -> Message {
skip_assert_initialized!();
unsafe {
let src = self.builder.src.to_glib_none().0;
let msg = $new_fn(&mut self, src);
if let Some(seqnum) = self.builder.seqnum {
gst_ffi::gst_message_set_seqnum(msg, seqnum.into_glib());
}
#[cfg(feature = "v1_26")]
if let Some(details) = self.builder.details {
gst_ffi::gst_message_set_details(msg, details.into_glib_ptr());
}
if !self.builder.other_fields.is_empty() {
let structure = gst_ffi::gst_message_writable_structure(msg);
if !structure.is_null() {
let structure =
gst::StructureRef::from_glib_borrow_mut(structure as *mut _);
for (k, v) in self.builder.other_fields {
structure.set_value(k, v);
}
}
}
from_glib_full(msg)
}
}
};
}
struct MessageBuilder<'a> {
src: Option<Element>,
seqnum: Option<Seqnum>,
#[cfg(feature = "v1_26")]
details: Option<gst::Structure>,
other_fields: Vec<(&'a str, glib::SendValue)>,
}
impl<'a> MessageBuilder<'a> {
fn new() -> Self {
skip_assert_initialized!();
Self {
src: None,
seqnum: None,
#[cfg(feature = "v1_26")]
details: None,
other_fields: Vec::new(),
}
}
fn src<O: IsA<Element> + Cast + Clone>(self, src: &O) -> Self {
Self {
src: Some(src.clone().upcast::<Element>()),
..self
}
}
fn seqnum(self, seqnum: Seqnum) -> Self {
Self {
seqnum: Some(seqnum),
..self
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_message_set_details")]
fn details(self, details: gst::Structure) -> Self {
Self {
details: Some(details),
..self
}
}
fn other_field(self, name: &'a str, value: impl ToSendValue) -> Self {
let mut other_fields = self.other_fields;
other_fields.push((name, value.to_send_value()));
Self {
other_fields,
..self
}
}
}
enum MessageBuilderDetail<'a> {
Decoder(&'a gst::Caps),
Encoder(&'a gst::Caps),
Element(&'a str),
Sink(&'a str),
Src(&'a str),
}
#[must_use = "The builder must be built to be used"]
pub struct MissingPluginMessageBuilder<'a> {
builder: MessageBuilder<'a>,
detail: MessageBuilderDetail<'a>,
#[cfg(feature = "v1_26")]
stream_id: Option<&'a str>,
}
impl<'a> MissingPluginMessageBuilder<'a> {
fn new(detail: MessageBuilderDetail<'a>) -> Self {
skip_assert_initialized!();
Self {
builder: MessageBuilder::new(),
detail,
#[cfg(feature = "v1_26")]
stream_id: None,
}
}
message_builder_generic_impl!(|s: &Self, src| {
let msg = match s.detail {
MessageBuilderDetail::Decoder(caps) => {
ffi::gst_missing_decoder_message_new(src, caps.to_glib_none().0)
}
MessageBuilderDetail::Encoder(caps) => {
ffi::gst_missing_encoder_message_new(src, caps.to_glib_none().0)
}
MessageBuilderDetail::Element(name) => {
ffi::gst_missing_element_message_new(src, name.to_glib_none().0)
}
MessageBuilderDetail::Sink(protocol) => {
ffi::gst_missing_uri_sink_message_new(src, protocol.to_glib_none().0)
}
MessageBuilderDetail::Src(protocol) => {
ffi::gst_missing_uri_source_message_new(src, protocol.to_glib_none().0)
}
};
#[cfg(feature = "v1_26")]
if let Some(stream_id) = s.stream_id {
ffi::gst_missing_plugin_message_set_stream_id(msg, stream_id.to_glib_none().0);
}
msg
});
}
#[derive(Clone, Debug)]
pub struct MissingPluginMessage<'a> {
pub msg: &'a gst::MessageRef,
}
impl<'a> MissingPluginMessage<'a> {
#[doc(alias = "gst_missing_decoder_message_new")]
#[allow(clippy::new_ret_no_self)]
pub fn for_decoder(caps: &'a gst::Caps) -> gst::Message {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Decoder(caps)).build()
}
#[doc(alias = "gst_missing_decoder_message_new")]
pub fn builder_for_decoder(caps: &'a gst::Caps) -> MissingPluginMessageBuilder<'a> {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Decoder(caps))
}
#[doc(alias = "gst_missing_encoder_message_new")]
#[allow(clippy::new_ret_no_self)]
pub fn for_encoder(caps: &'a gst::Caps) -> gst::Message {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Encoder(caps)).build()
}
#[doc(alias = "gst_missing_encoder_message_new")]
pub fn builder_for_encoder(caps: &'a gst::Caps) -> MissingPluginMessageBuilder<'a> {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Encoder(caps))
}
#[doc(alias = "gst_missing_element_message_new")]
#[allow(clippy::new_ret_no_self)]
pub fn for_element(name: &'a str) -> gst::Message {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Element(name)).build()
}
#[doc(alias = "gst_missing_element_message_new")]
pub fn builder_for_element(name: &'a str) -> MissingPluginMessageBuilder<'a> {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Element(name))
}
#[doc(alias = "gst_missing_uri_source_message_new")]
#[allow(clippy::new_ret_no_self)]
pub fn for_uri_source(protocol: &'a str) -> gst::Message {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Src(protocol)).build()
}
#[doc(alias = "gst_missing_uri_source_message_new")]
pub fn builder_for_uri_source(protocol: &'a str) -> MissingPluginMessageBuilder<'a> {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Src(protocol))
}
#[doc(alias = "gst_missing_uri_sink_message_new")]
#[allow(clippy::new_ret_no_self)]
pub fn for_uri_sink(protocol: &'a str) -> gst::Message {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Sink(protocol)).build()
}
#[doc(alias = "gst_missing_uri_sink_message_new")]
pub fn builder_for_uri_sink(protocol: &'a str) -> MissingPluginMessageBuilder<'a> {
skip_assert_initialized!();
MissingPluginMessageBuilder::new(MessageBuilderDetail::Sink(protocol))
}
#[doc(alias = "gst_is_missing_plugin_message")]
pub fn is(msg: &gst::MessageRef) -> bool {
skip_assert_initialized!();
unsafe {
from_glib(ffi::gst_is_missing_plugin_message(mut_override(
msg.as_ptr(),
)))
}
}
pub fn parse(msg: &'a gst::MessageRef) -> Result<Self, glib::error::BoolError> {
skip_assert_initialized!();
if Self::is(msg) {
Ok(MissingPluginMessage { msg })
} else {
Err(glib::bool_error!("Invalid missing plugin message"))
}
}
#[doc(alias = "gst_missing_plugin_message_get_description")]
pub fn description(&self) -> glib::GString {
unsafe {
from_glib_full(ffi::gst_missing_plugin_message_get_description(
mut_override(self.msg.as_ptr()),
))
}
}
#[doc(alias = "gst_missing_plugin_message_get_installer_detail")]
pub fn installer_detail(&self) -> glib::GString {
unsafe {
from_glib_full(ffi::gst_missing_plugin_message_get_installer_detail(
mut_override(self.msg.as_ptr()),
))
}
}
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
#[doc(alias = "gst_missing_plugin_message_get_stream_id")]
pub fn stream_id(&self) -> Option<&glib::GStr> {
unsafe {
let stream_id =
ffi::gst_missing_plugin_message_get_stream_id(mut_override(self.msg.as_ptr()));
if stream_id.is_null() {
None
} else {
Some(glib::GStr::from_ptr(stream_id))
}
}
}
}
#[doc(alias = "gst_missing_decoder_installer_detail_new")]
pub fn missing_decoder_installer_detail_new(caps: &gst::Caps) -> glib::GString {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_missing_decoder_installer_detail_new(mut_override(
caps.as_ptr(),
)))
}
}
#[doc(alias = "gst_missing_encoder_installer_detail_new")]
pub fn missing_encoder_installer_detail_new(caps: &gst::Caps) -> glib::GString {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_missing_encoder_installer_detail_new(mut_override(
caps.as_ptr(),
)))
}
}
#[doc(alias = "gst_missing_element_installer_detail_new")]
pub fn missing_element_installer_detail_new(name: &str) -> glib::GString {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_missing_element_installer_detail_new(mut_override(
name.to_glib_none().0,
)))
}
}
#[doc(alias = "gst_missing_uri_source_installer_detail_new")]
pub fn missing_uri_source_installer_detail_new(protocol: &str) -> glib::GString {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_missing_uri_source_installer_detail_new(
mut_override(protocol.to_glib_none().0),
))
}
}
#[doc(alias = "gst_missing_uri_sink_installer_detail_new")]
pub fn missing_uri_sink_installer_detail_new(protocol: &str) -> glib::GString {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gst_missing_uri_sink_installer_detail_new(
mut_override(protocol.to_glib_none().0),
))
}
}
#[doc(alias = "gst_install_plugins_supported")]
pub fn install_plugins_supported() -> bool {
skip_assert_initialized!();
unsafe { from_glib(ffi::gst_install_plugins_supported()) }
}
#[doc(alias = "gst_install_plugins_installation_in_progress")]
pub fn install_plugins_installation_in_progress() -> bool {
skip_assert_initialized!();
unsafe { from_glib(ffi::gst_install_plugins_installation_in_progress()) }
}
#[doc(alias = "gst_install_plugins_sync")]
pub fn install_plugins_sync(
details: &[&str],
ctx: Option<&crate::InstallPluginsContext>,
) -> crate::InstallPluginsReturn {
skip_assert_initialized!();
unsafe {
from_glib(ffi::gst_install_plugins_sync(
ToGlibPtr::<*const *mut _>::to_glib_none(&glib::StrV::from(details)).0
as *const *const _,
ctx.to_glib_none().0,
))
}
}
#[doc(alias = "gst_install_plugins_async")]
pub fn install_plugins_async<F: FnOnce(crate::InstallPluginsReturn) + Send + 'static>(
details: &[&str],
ctx: Option<&crate::InstallPluginsContext>,
func: F,
) -> crate::InstallPluginsReturn {
skip_assert_initialized!();
let user_data: Box<Option<F>> = Box::new(Some(func));
unsafe extern "C" fn trampoline<F: FnOnce(crate::InstallPluginsReturn) + Send + 'static>(
ret: ffi::GstInstallPluginsReturn,
user_data: glib::ffi::gpointer,
) {
let callback = Box::from_raw(user_data as *mut F);
callback(from_glib(ret));
}
unsafe {
from_glib(ffi::gst_install_plugins_async(
ToGlibPtr::<*const *mut _>::to_glib_none(&glib::StrV::from(details)).0
as *const *const _,
ctx.to_glib_none().0,
Some(trampoline::<F>),
Box::into_raw(user_data) as *mut _,
))
}
}