mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2025-02-16 19:15:30 +00:00
Code Issues Projects Releases Wiki Activity

gstreamer-video: Update manual code to 2018 edition

Browse source
This commit is contained in:
Sebastian Dröge 2020-11-22 11:53:17 +02:00
parent 4bd7f7af1a
commit d31badf9ac
25 changed files with 1266 additions and 1447 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
gstreamer-video/Cargo.toml
View file

@ -11,19 +11,16 @@ homepage = "https://gstreamer.freedesktop.org"
documentation = "https://gstreamer.pages.freedesktop.org/gstreamer-rs/gstreamer_video/" documentation = "https://gstreamer.pages.freedesktop.org/gstreamer-rs/gstreamer_video/"
keywords = ["gstreamer", "multimedia", "audio", "video", "gnome"] keywords = ["gstreamer", "multimedia", "audio", "video", "gnome"]
build = "build.rs" build = "build.rs"
edition = "2018"
[dependencies] [dependencies]
bitflags = "1.0" bitflags = "1.0"
libc = "0.2" libc = "0.2"
cfg-if = "1.0" cfg-if = "1.0"
glib-sys = { git = "https://github.com/gtk-rs/gtk-rs" } ffi = { package = "gstreamer-video-sys", path = "../gstreamer-video/sys", features = ["v1_8"] }
gobject-sys = { git = "https://github.com/gtk-rs/gtk-rs" }
gstreamer-sys = { path = "../gstreamer/sys", features = ["v1_8"] }
gstreamer-base-sys = { path = "../gstreamer-base/sys", features = ["v1_8"] }
gstreamer-video-sys = { path = "../gstreamer-video/sys", features = ["v1_8"] }
glib = { git = "https://github.com/gtk-rs/gtk-rs" } glib = { git = "https://github.com/gtk-rs/gtk-rs" }
gstreamer = { path = "../gstreamer" } gst = { package = "gstreamer", path = "../gstreamer" }
gstreamer-base = { path = "../gstreamer-base" } gst-base = { package = "gstreamer-base", path = "../gstreamer-base" }
once_cell = "1.0" once_cell = "1.0"
futures-channel = "0.3" futures-channel = "0.3"
futures-util = "0.3" futures-util = "0.3"
@ -36,14 +33,14 @@ itertools = "0.9"
[features] [features]
default = [] default = []
v1_10 = ["gstreamer/v1_10", "gstreamer-base/v1_10", "gstreamer-video-sys/v1_10"] v1_10 = ["gst/v1_10", "gst-base/v1_10", "ffi/v1_10"]
v1_12 = ["gstreamer/v1_12", "gstreamer-base/v1_12", "gstreamer-video-sys/v1_12", "v1_10"] v1_12 = ["gst/v1_12", "gst-base/v1_12", "ffi/v1_12", "v1_10"]
v1_14 = ["gstreamer/v1_14", "gstreamer-base/v1_14", "gstreamer-video-sys/v1_14", "v1_12"] v1_14 = ["gst/v1_14", "gst-base/v1_14", "ffi/v1_14", "v1_12"]
v1_16 = ["gstreamer/v1_16", "gstreamer-base/v1_16", "gstreamer-video-sys/v1_16", "v1_14"] v1_16 = ["gst/v1_16", "gst-base/v1_16", "ffi/v1_16", "v1_14"]
v1_18 = ["gstreamer/v1_18", "gstreamer-base/v1_18", "gstreamer-video-sys/v1_18", "v1_16"] v1_18 = ["gst/v1_18", "gst-base/v1_18", "ffi/v1_18", "v1_16"]
embed-lgpl-docs = ["gstreamer-rs-lgpl-docs"] embed-lgpl-docs = ["gstreamer-rs-lgpl-docs"]
purge-lgpl-docs = ["gstreamer-rs-lgpl-docs"] purge-lgpl-docs = ["gstreamer-rs-lgpl-docs"]
dox = ["v1_18", "gstreamer-video-sys/dox", "glib/dox", "gstreamer/dox", "gstreamer-base/dox"] dox = ["v1_18", "ffi/dox", "glib/dox", "gst/dox", "gst-base/dox"]
[package.metadata.docs.rs] [package.metadata.docs.rs]
features = ["dox", "embed-lgpl-docs"] features = ["dox", "embed-lgpl-docs"]

11
gstreamer-video/src/caps_features.rs
View file

@ -7,7 +7,6 @@
// except according to those terms. // except according to those terms.
use gst::CapsFeatures; use gst::CapsFeatures;
use gst_video_sys;
use std::ffi::CStr; use std::ffi::CStr;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -15,7 +14,7 @@ use once_cell::sync::Lazy;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub static CAPS_FEATURE_FORMAT_INTERLACED: Lazy<&'static str> = Lazy::new(|| unsafe { pub static CAPS_FEATURE_FORMAT_INTERLACED: Lazy<&'static str> = Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_CAPS_FEATURE_FORMAT_INTERLACED) CStr::from_ptr(ffi::GST_CAPS_FEATURE_FORMAT_INTERLACED)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
@ -26,7 +25,7 @@ pub static CAPS_FEATURES_FORMAT_INTERLACED: Lazy<CapsFeatures> =
pub static CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META: Lazy<&'static str> = pub static CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META: Lazy<&'static str> =
Lazy::new(|| unsafe { Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META) CStr::from_ptr(ffi::GST_CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
@ -35,7 +34,7 @@ pub static CAPS_FEATURES_META_GST_VIDEO_AFFINE_TRANSFORMATION_META: Lazy<CapsFea
pub static CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META: Lazy<&'static str> = pub static CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META: Lazy<&'static str> =
Lazy::new(|| unsafe { Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META) CStr::from_ptr(ffi::GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
@ -43,7 +42,7 @@ pub static CAPS_FEATURES_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META: Lazy<CapsFeature
Lazy::new(|| CapsFeatures::new(&[*CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META])); Lazy::new(|| CapsFeatures::new(&[*CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META]));
pub static CAPS_FEATURE_META_GST_VIDEO_META: Lazy<&'static str> = Lazy::new(|| unsafe { pub static CAPS_FEATURE_META_GST_VIDEO_META: Lazy<&'static str> = Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_CAPS_FEATURE_META_GST_VIDEO_META) CStr::from_ptr(ffi::GST_CAPS_FEATURE_META_GST_VIDEO_META)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
@ -52,7 +51,7 @@ pub static CAPS_FEATURES_META_GST_VIDEO_META: Lazy<CapsFeatures> =
pub static CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION: Lazy<&'static str> = pub static CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION: Lazy<&'static str> =
Lazy::new(|| unsafe { Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION) CStr::from_ptr(ffi::GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION)
.to_str() .to_str()
.unwrap() .unwrap()
}); });

54
gstreamer-video/src/functions.rs
View file

@ -6,14 +6,8 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use glib_sys;
use gst_sys;
use gst_video_sys;
use glib;
use glib::translate::{from_glib, from_glib_full, ToGlib, ToGlibPtr}; use glib::translate::{from_glib, from_glib_full, ToGlib, ToGlibPtr};
use glib::ToSendValue; use glib::ToSendValue;
use gst;
use std::i32; use std::i32;
use std::mem; use std::mem;
@ -27,7 +21,7 @@ pub fn convert_sample(
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = gst_video_sys::gst_video_convert_sample( let ret = ffi::gst_video_convert_sample(
sample.to_glib_none().0, sample.to_glib_none().0,
caps.to_glib_none().0, caps.to_glib_none().0,
timeout.to_glib(), timeout.to_glib(),
@ -78,9 +72,9 @@ unsafe fn convert_sample_async_unsafe<F>(
F: FnOnce(Result<gst::Sample, glib::Error>) + 'static, F: FnOnce(Result<gst::Sample, glib::Error>) + 'static,
{ {
unsafe extern "C" fn convert_sample_async_trampoline<F>( unsafe extern "C" fn convert_sample_async_trampoline<F>(
sample: *mut gst_sys::GstSample, sample: *mut gst::ffi::GstSample,
error: *mut glib_sys::GError, error: *mut glib::ffi::GError,
user_data: glib_sys::gpointer, user_data: glib::ffi::gpointer,
) where ) where
F: FnOnce(Result<gst::Sample, glib::Error>) + 'static, F: FnOnce(Result<gst::Sample, glib::Error>) + 'static,
{ {
@ -93,7 +87,7 @@ unsafe fn convert_sample_async_unsafe<F>(
callback(Err(from_glib_full(error))) callback(Err(from_glib_full(error)))
} }
} }
unsafe extern "C" fn convert_sample_async_free<F>(user_data: glib_sys::gpointer) unsafe extern "C" fn convert_sample_async_free<F>(user_data: glib::ffi::gpointer)
where where
F: FnOnce(Result<gst::Sample, glib::Error>) + 'static, F: FnOnce(Result<gst::Sample, glib::Error>) + 'static,
{ {
@ -102,12 +96,12 @@ unsafe fn convert_sample_async_unsafe<F>(
let user_data: Box<Option<F>> = Box::new(Some(func)); let user_data: Box<Option<F>> = Box::new(Some(func));
gst_video_sys::gst_video_convert_sample_async( ffi::gst_video_convert_sample_async(
sample.to_glib_none().0, sample.to_glib_none().0,
caps.to_glib_none().0, caps.to_glib_none().0,
timeout.to_glib(), timeout.to_glib(),
Some(convert_sample_async_trampoline::<F>), Some(convert_sample_async_trampoline::<F>),
Box::into_raw(user_data) as glib_sys::gpointer, Box::into_raw(user_data) as glib::ffi::gpointer,
Some(convert_sample_async_free::<F>), Some(convert_sample_async_free::<F>),
); );
} }
@ -155,7 +149,7 @@ pub fn calculate_display_ratio(
let mut dar_n = mem::MaybeUninit::uninit(); let mut dar_n = mem::MaybeUninit::uninit();
let mut dar_d = mem::MaybeUninit::uninit(); let mut dar_d = mem::MaybeUninit::uninit();
let res: bool = from_glib(gst_video_sys::gst_video_calculate_display_ratio( let res: bool = from_glib(ffi::gst_video_calculate_display_ratio(
dar_n.as_mut_ptr(), dar_n.as_mut_ptr(),
dar_d.as_mut_ptr(), dar_d.as_mut_ptr(),
video_width, video_width,
@ -182,7 +176,7 @@ pub fn guess_framerate(duration: gst::ClockTime) -> Option<gst::Fraction> {
unsafe { unsafe {
let mut dest_n = mem::MaybeUninit::uninit(); let mut dest_n = mem::MaybeUninit::uninit();
let mut dest_d = mem::MaybeUninit::uninit(); let mut dest_d = mem::MaybeUninit::uninit();
let res: bool = from_glib(gst_video_sys::gst_video_guess_framerate( let res: bool = from_glib(ffi::gst_video_guess_framerate(
duration.to_glib(), duration.to_glib(),
dest_n.as_mut_ptr(), dest_n.as_mut_ptr(),
dest_d.as_mut_ptr(), dest_d.as_mut_ptr(),
@ -198,14 +192,16 @@ pub fn guess_framerate(duration: gst::ClockTime) -> Option<gst::Fraction> {
} }
} }
pub fn video_make_raw_caps(formats: &[::VideoFormat]) -> gst::caps::Builder<gst::caps::NoFeature> { pub fn video_make_raw_caps(
formats: &[crate::VideoFormat],
) -> gst::caps::Builder<gst::caps::NoFeature> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
let formats: Vec<glib::SendValue> = formats let formats: Vec<glib::SendValue> = formats
.iter() .iter()
.map(|f| match f { .map(|f| match f {
::VideoFormat::Encoded => panic!("Invalid encoded format"), crate::VideoFormat::Encoded => panic!("Invalid encoded format"),
::VideoFormat::Unknown => panic!("Invalid unknown format"), crate::VideoFormat::Unknown => panic!("Invalid unknown format"),
_ => f.to_string().to_send_value(), _ => f.to_string().to_send_value(),
}) })
.collect(); .collect();
@ -223,8 +219,6 @@ pub fn video_make_raw_caps(formats: &[::VideoFormat]) -> gst::caps::Builder<gst:
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use glib;
use gst;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
#[test] #[test]
@ -245,7 +239,7 @@ mod tests {
p[3] = 255; p[3] = 255;
} }
} }
let in_caps = ::VideoInfo::builder(::VideoFormat::Rgba, 320, 240) let in_caps = crate::VideoInfo::builder(crate::VideoFormat::Rgba, 320, 240)
.build() .build()
.unwrap() .unwrap()
.to_caps() .to_caps()
@ -255,7 +249,7 @@ mod tests {
.caps(&in_caps) .caps(&in_caps)
.build(); .build();
let out_caps = ::VideoInfo::builder(::VideoFormat::Abgr, 320, 240) let out_caps = crate::VideoInfo::builder(crate::VideoFormat::Abgr, 320, 240)
.build() .build()
.unwrap() .unwrap()
.to_caps() .to_caps()
@ -290,26 +284,26 @@ mod tests {
fn video_caps() { fn video_caps() {
gst::init().unwrap(); gst::init().unwrap();
let caps = video_make_raw_caps(&[::VideoFormat::Nv12, ::VideoFormat::Nv16]).build(); let caps =
video_make_raw_caps(&[crate::VideoFormat::Nv12, crate::VideoFormat::Nv16]).build();
assert_eq!(caps.to_string(), "video/x-raw, format=(string){ NV12, NV16 }, width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], framerate=(fraction)[ 0/1, 2147483647/1 ]"); assert_eq!(caps.to_string(), "video/x-raw, format=(string){ NV12, NV16 }, width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], framerate=(fraction)[ 0/1, 2147483647/1 ]");
#[cfg(feature = "v1_18")] #[cfg(feature = "v1_18")]
{ {
/* video_make_raw_caps() is a re-implementation so ensure it returns the same caps as the C API */ /* video_make_raw_caps() is a re-implementation so ensure it returns the same caps as the C API */
let c_caps = unsafe { let c_caps = unsafe {
let formats: Vec<gst_video_sys::GstVideoFormat> = let formats: Vec<ffi::GstVideoFormat> =
[::VideoFormat::Nv12, ::VideoFormat::Nv16] [crate::VideoFormat::Nv12, crate::VideoFormat::Nv16]
.iter() .iter()
.map(|f| f.to_glib()) .map(|f| f.to_glib())
.collect(); .collect();
let caps = let caps = ffi::gst_video_make_raw_caps(formats.as_ptr(), formats.len() as u32);
gst_video_sys::gst_video_make_raw_caps(formats.as_ptr(), formats.len() as u32);
from_glib_full(caps) from_glib_full(caps)
}; };
assert_eq!(caps, c_caps); assert_eq!(caps, c_caps);
} }
let caps = video_make_raw_caps(&[::VideoFormat::Nv12, ::VideoFormat::Nv16]) let caps = video_make_raw_caps(&[crate::VideoFormat::Nv12, crate::VideoFormat::Nv16])
.field("width", &800) .field("width", &800)
.field("height", &600) .field("height", &600)
.field("framerate", &gst::Fraction::new(30, 1)) .field("framerate", &gst::Fraction::new(30, 1))
@ -321,13 +315,13 @@ mod tests {
#[should_panic(expected = "Invalid encoded format")] #[should_panic(expected = "Invalid encoded format")]
fn video_caps_encoded() { fn video_caps_encoded() {
gst::init().unwrap(); gst::init().unwrap();
video_make_raw_caps(&[::VideoFormat::Encoded]); video_make_raw_caps(&[crate::VideoFormat::Encoded]);
} }
#[test] #[test]
#[should_panic(expected = "Invalid unknown format")] #[should_panic(expected = "Invalid unknown format")]
fn video_caps_unknown() { fn video_caps_unknown() {
gst::init().unwrap(); gst::init().unwrap();
video_make_raw_caps(&[::VideoFormat::Unknown]); video_make_raw_caps(&[crate::VideoFormat::Unknown]);
} }
} }

88
gstreamer-video/src/lib.rs
View file

@ -8,33 +8,11 @@
#![cfg_attr(feature = "dox", feature(doc_cfg))] #![cfg_attr(feature = "dox", feature(doc_cfg))]
#[macro_use] pub use ffi;
extern crate bitflags;
extern crate libc;
extern crate once_cell;
#[macro_use]
extern crate cfg_if;
#[macro_use]
extern crate glib;
extern crate glib_sys;
extern crate gobject_sys;
#[macro_use]
extern crate gstreamer as gst;
extern crate futures_channel;
extern crate futures_util;
extern crate gstreamer_base as gst_base;
extern crate gstreamer_base_sys as gst_base_sys;
extern crate gstreamer_sys as gst_sys;
extern crate gstreamer_video_sys as gst_video_sys;
#[cfg(test)]
extern crate itertools;
macro_rules! assert_initialized_main_thread { macro_rules! assert_initialized_main_thread {
() => { () => {
if unsafe { ::gst_sys::gst_is_initialized() } != ::glib_sys::GTRUE { if unsafe { gst::ffi::gst_is_initialized() } != glib::ffi::GTRUE {
panic!("GStreamer has not been initialized. Call `gst::init` first."); panic!("GStreamer has not been initialized. Call `gst::init` first.");
} }
}; };
@ -49,13 +27,13 @@ macro_rules! skip_assert_initialized {
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[allow(unused_imports)] #[allow(unused_imports)]
mod auto; mod auto;
pub use auto::*; pub use crate::auto::*;
mod caps_features; mod caps_features;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub use caps_features::{CAPS_FEATURES_FORMAT_INTERLACED, CAPS_FEATURE_FORMAT_INTERLACED}; pub use crate::caps_features::{CAPS_FEATURES_FORMAT_INTERLACED, CAPS_FEATURE_FORMAT_INTERLACED};
pub use caps_features::{ pub use crate::caps_features::{
CAPS_FEATURES_META_GST_VIDEO_AFFINE_TRANSFORMATION_META, CAPS_FEATURES_META_GST_VIDEO_AFFINE_TRANSFORMATION_META,
CAPS_FEATURES_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, CAPS_FEATURES_META_GST_VIDEO_META, CAPS_FEATURES_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, CAPS_FEATURES_META_GST_VIDEO_META,
CAPS_FEATURES_META_GST_VIDEO_OVERLAY_COMPOSITION, CAPS_FEATURES_META_GST_VIDEO_OVERLAY_COMPOSITION,
@ -64,33 +42,35 @@ pub use caps_features::{
CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
}; };
mod video_format; mod video_format;
pub use video_format::*; pub use crate::video_format::*;
mod video_format_info; mod video_format_info;
pub use video_format_info::*; pub use crate::video_format_info::*;
mod video_info; mod video_info;
pub use video_info::*; pub use crate::video_info::*;
pub mod video_frame; pub mod video_frame;
pub use video_frame::{VideoBufferExt, VideoFrame, VideoFrameRef}; pub use crate::video_frame::{VideoBufferExt, VideoFrame, VideoFrameRef};
mod video_overlay; mod video_overlay;
pub use video_overlay::{is_video_overlay_prepare_window_handle_message, VideoOverlayExtManual}; pub use crate::video_overlay::{
is_video_overlay_prepare_window_handle_message, VideoOverlayExtManual,
};
pub mod video_event; pub mod video_event;
pub use video_event::{ pub use crate::video_event::{
DownstreamForceKeyUnitEvent, ForceKeyUnitEvent, StillFrameEvent, UpstreamForceKeyUnitEvent, DownstreamForceKeyUnitEvent, ForceKeyUnitEvent, StillFrameEvent, UpstreamForceKeyUnitEvent,
}; };
mod functions; mod functions;
pub use functions::*; pub use crate::functions::*;
mod video_rectangle; mod video_rectangle;
pub use video_rectangle::*; pub use crate::video_rectangle::*;
mod video_overlay_composition; mod video_overlay_composition;
pub use video_overlay_composition::*; pub use crate::video_overlay_composition::*;
pub mod video_meta; pub mod video_meta;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub use video_meta::VideoCaptionMeta; pub use crate::video_meta::VideoCaptionMeta;
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub use video_meta::{VideoAFDMeta, VideoBarMeta}; pub use crate::video_meta::{VideoAFDMeta, VideoBarMeta};
pub use video_meta::{ pub use crate::video_meta::{
VideoAffineTransformationMeta, VideoCropMeta, VideoMeta, VideoOverlayCompositionMeta, VideoAffineTransformationMeta, VideoCropMeta, VideoMeta, VideoOverlayCompositionMeta,
VideoRegionOfInterestMeta, VideoRegionOfInterestMeta,
}; };
@ -99,30 +79,30 @@ pub use video_meta::{
mod video_time_code; mod video_time_code;
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
pub use video_time_code::{ValidVideoTimeCode, VideoTimeCode, VideoTimeCodeMeta}; pub use crate::video_time_code::{ValidVideoTimeCode, VideoTimeCode, VideoTimeCodeMeta};
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
mod video_time_code_interval; mod video_time_code_interval;
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
pub use video_time_code_interval::VideoTimeCodeInterval; pub use crate::video_time_code_interval::VideoTimeCodeInterval;
mod video_buffer_pool; mod video_buffer_pool;
pub use video_buffer_pool::{ pub use crate::video_buffer_pool::{
VideoAlignment, VideoBufferPoolConfig, BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META, VideoAlignment, VideoBufferPoolConfig, BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META,
BUFFER_POOL_OPTION_VIDEO_ALIGNMENT, BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META, BUFFER_POOL_OPTION_VIDEO_ALIGNMENT, BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META,
BUFFER_POOL_OPTION_VIDEO_META, BUFFER_POOL_OPTION_VIDEO_META,
}; };
pub mod video_converter; pub mod video_converter;
pub use video_converter::{VideoConverter, VideoConverterConfig}; pub use crate::video_converter::{VideoConverter, VideoConverterConfig};
mod video_codec_frame; mod video_codec_frame;
mod video_decoder; mod video_decoder;
pub use video_decoder::VideoDecoderExtManual; pub use crate::video_decoder::VideoDecoderExtManual;
mod video_encoder; mod video_encoder;
pub use video_codec_frame::VideoCodecFrame; pub use crate::video_codec_frame::VideoCodecFrame;
pub use video_encoder::VideoEncoderExtManual; pub use crate::video_encoder::VideoEncoderExtManual;
pub mod video_codec_state; pub mod video_codec_state;
pub use video_codec_state::{VideoCodecState, VideoCodecStateContext}; pub use crate::video_codec_state::{VideoCodecState, VideoCodecStateContext};
mod utils; mod utils;
pub const VIDEO_ENCODER_FLOW_NEED_DATA: gst::FlowSuccess = gst::FlowSuccess::CustomSuccess; pub const VIDEO_ENCODER_FLOW_NEED_DATA: gst::FlowSuccess = gst::FlowSuccess::CustomSuccess;
@ -134,13 +114,13 @@ pub mod prelude {
pub use glib::prelude::*; pub use glib::prelude::*;
pub use gst::prelude::*; pub use gst::prelude::*;
pub use auto::traits::*; pub use crate::auto::traits::*;
pub use video_buffer_pool::VideoBufferPoolConfig; pub use crate::video_buffer_pool::VideoBufferPoolConfig;
pub use video_decoder::VideoDecoderExtManual; pub use crate::video_decoder::VideoDecoderExtManual;
pub use video_encoder::VideoEncoderExtManual; pub use crate::video_encoder::VideoEncoderExtManual;
pub use video_format::VideoFormatIteratorExt; pub use crate::video_format::VideoFormatIteratorExt;
pub use video_frame::VideoBufferExt; pub use crate::video_frame::VideoBufferExt;
pub use video_overlay::VideoOverlayExtManual; pub use crate::video_overlay::VideoOverlayExtManual;
} }
pub mod subclass; pub mod subclass;

218
gstreamer-video/src/subclass/video_decoder.rs
View file

@ -7,22 +7,16 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use glib_sys;
use gst_sys;
use gst_video_sys;
use glib::prelude::*; use glib::prelude::*;
use glib::subclass::prelude::*; use glib::subclass::prelude::*;
use glib::translate::*; use glib::translate::*;
use gst;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst_base;
use crate::prelude::*; use crate::prelude::*;
use video_codec_state::{Readable, VideoCodecState}; use crate::video_codec_state::{Readable, VideoCodecState};
use VideoCodecFrame; use crate::VideoCodecFrame;
use VideoDecoder; use crate::VideoDecoder;
pub trait VideoDecoderImpl: VideoDecoderImplExt + ElementImpl { pub trait VideoDecoderImpl: VideoDecoderImplExt + ElementImpl {
fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
@ -184,8 +178,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.open .open
.map(|f| { .map(|f| {
@ -196,7 +189,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `open` failed"] ["Parent function `open` failed"]
)) ))
@ -209,8 +202,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.close .close
.map(|f| { .map(|f| {
@ -221,7 +213,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `close` failed"] ["Parent function `close` failed"]
)) ))
@ -234,8 +226,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.start .start
.map(|f| { .map(|f| {
@ -246,7 +237,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `start` failed"] ["Parent function `start` failed"]
)) ))
@ -259,8 +250,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.stop .stop
.map(|f| { .map(|f| {
@ -271,7 +261,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `stop` failed"] ["Parent function `stop` failed"]
)) ))
@ -284,8 +274,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { fn parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.finish .finish
.map(|f| { .map(|f| {
@ -302,8 +291,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_drain(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { fn parent_drain(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.drain .drain
.map(|f| { .map(|f| {
@ -324,12 +312,11 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.set_format .set_format
.map(|f| { .map(|f| {
gst_result_from_gboolean!( gst::gst_result_from_gboolean!(
f( f(
element.unsafe_cast_ref::<VideoDecoder>().to_glib_none().0, element.unsafe_cast_ref::<VideoDecoder>().to_glib_none().0,
state.as_mut_ptr() state.as_mut_ptr()
@ -351,8 +338,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.parse .parse
.map(|f| { .map(|f| {
@ -375,8 +361,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.handle_frame .handle_frame
.map(|f| { .map(|f| {
@ -393,8 +378,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_flush(&self, element: &Self::Type) -> bool { fn parent_flush(&self, element: &Self::Type) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.flush .flush
.map(|f| { .map(|f| {
@ -410,12 +394,11 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.negotiate .negotiate
.map(|f| { .map(|f| {
gst_result_from_gboolean!( gst::gst_result_from_gboolean!(
f(element.unsafe_cast_ref::<VideoDecoder>().to_glib_none().0), f(element.unsafe_cast_ref::<VideoDecoder>().to_glib_none().0),
gst::CAT_RUST, gst::CAT_RUST,
"Parent function `negotiate` failed" "Parent function `negotiate` failed"
@ -428,8 +411,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.getcaps .getcaps
.map(|f| { .map(|f| {
@ -449,8 +431,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
let f = (*parent_class) let f = (*parent_class)
.sink_event .sink_event
.expect("Missing parent function `sink_event`"); .expect("Missing parent function `sink_event`");
@ -464,8 +445,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
let f = (*parent_class) let f = (*parent_class)
.sink_query .sink_query
.expect("Missing parent function `sink_query`"); .expect("Missing parent function `sink_query`");
@ -479,8 +459,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
let f = (*parent_class) let f = (*parent_class)
.src_event .src_event
.expect("Missing parent function `src_event`"); .expect("Missing parent function `src_event`");
@ -494,8 +473,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
let f = (*parent_class) let f = (*parent_class)
.src_query .src_query
.expect("Missing parent function `src_query`"); .expect("Missing parent function `src_query`");
@ -513,8 +491,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
) -> Result<(), gst::ErrorMessage> { ) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.propose_allocation .propose_allocation
.map(|f| { .map(|f| {
@ -524,7 +501,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
)) { )) {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `propose_allocation` failed"] ["Parent function `propose_allocation` failed"]
)) ))
@ -541,8 +518,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
) -> Result<(), gst::ErrorMessage> { ) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoDecoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoDecoderClass;
(*parent_class) (*parent_class)
.decide_allocation .decide_allocation
.map(|f| { .map(|f| {
@ -552,7 +528,7 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
)) { )) {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `decide_allocation` failed"] ["Parent function `decide_allocation` failed"]
)) ))
@ -592,8 +568,8 @@ where
} }
unsafe extern "C" fn video_decoder_open<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_open<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -601,7 +577,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) { match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -614,8 +590,8 @@ where
} }
unsafe extern "C" fn video_decoder_close<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_close<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -623,7 +599,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) { match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -636,8 +612,8 @@ where
} }
unsafe extern "C" fn video_decoder_start<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_start<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -645,7 +621,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) { match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -658,8 +634,8 @@ where
} }
unsafe extern "C" fn video_decoder_stop<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_stop<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -667,7 +643,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) { match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -680,8 +656,8 @@ where
} }
unsafe extern "C" fn video_decoder_finish<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_finish<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> gst_sys::GstFlowReturn ) -> gst::ffi::GstFlowReturn
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -689,15 +665,15 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
imp.finish(wrap.unsafe_cast_ref()).into() imp.finish(wrap.unsafe_cast_ref()).into()
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_drain<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_drain<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> gst_sys::GstFlowReturn ) -> gst::ffi::GstFlowReturn
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -705,26 +681,26 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
imp.drain(wrap.unsafe_cast_ref()).into() imp.drain(wrap.unsafe_cast_ref()).into()
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_set_format<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_set_format<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
state: *mut gst_video_sys::GstVideoCodecState, state: *mut ffi::GstVideoCodecState,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_video_sys::gst_video_codec_state_ref(state); ffi::gst_video_codec_state_ref(state);
let wrap_state = VideoCodecState::<Readable>::new(state); let wrap_state = VideoCodecState::<Readable>::new(state);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) { match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -737,23 +713,23 @@ where
} }
unsafe extern "C" fn video_decoder_parse<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_parse<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
frame: *mut gst_video_sys::GstVideoCodecFrame, frame: *mut ffi::GstVideoCodecFrame,
adapter: *mut gst_base_sys::GstAdapter, adapter: *mut gst_base::ffi::GstAdapter,
at_eos: glib_sys::gboolean, at_eos: glib::ffi::gboolean,
) -> gst_sys::GstFlowReturn ) -> gst::ffi::GstFlowReturn
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_video_sys::gst_video_codec_frame_ref(frame); ffi::gst_video_codec_frame_ref(frame);
let wrap_frame = VideoCodecFrame::new(frame, &*wrap); let wrap_frame = VideoCodecFrame::new(frame, &*wrap);
let wrap_adapter: Borrowed<gst_base::Adapter> = from_glib_borrow(adapter); let wrap_adapter: Borrowed<gst_base::Adapter> = from_glib_borrow(adapter);
let at_eos: bool = from_glib(at_eos); let at_eos: bool = from_glib(at_eos);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
imp.parse(wrap.unsafe_cast_ref(), &wrap_frame, &wrap_adapter, at_eos) imp.parse(wrap.unsafe_cast_ref(), &wrap_frame, &wrap_adapter, at_eos)
.into() .into()
}) })
@ -761,9 +737,9 @@ where
} }
unsafe extern "C" fn video_decoder_handle_frame<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_handle_frame<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
frame: *mut gst_video_sys::GstVideoCodecFrame, frame: *mut ffi::GstVideoCodecFrame,
) -> gst_sys::GstFlowReturn ) -> gst::ffi::GstFlowReturn
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -772,15 +748,15 @@ where
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
let wrap_frame = VideoCodecFrame::new(frame, &*wrap); let wrap_frame = VideoCodecFrame::new(frame, &*wrap);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into() imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into()
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_flush<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_flush<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -788,15 +764,15 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
VideoDecoderImpl::flush(imp, wrap.unsafe_cast_ref()) VideoDecoderImpl::flush(imp, wrap.unsafe_cast_ref())
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_negotiate<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_negotiate<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -804,7 +780,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.negotiate(wrap.unsafe_cast_ref()) { match imp.negotiate(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -817,9 +793,9 @@ where
} }
unsafe extern "C" fn video_decoder_getcaps<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_getcaps<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
filter: *mut gst_sys::GstCaps, filter: *mut gst::ffi::GstCaps,
) -> *mut gst_sys::GstCaps ) -> *mut gst::ffi::GstCaps
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -827,7 +803,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::Caps::new_empty(), { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::Caps::new_empty(), {
VideoDecoderImpl::get_caps( VideoDecoderImpl::get_caps(
imp, imp,
wrap.unsafe_cast_ref(), wrap.unsafe_cast_ref(),
@ -840,9 +816,9 @@ where
} }
unsafe extern "C" fn video_decoder_sink_event<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_sink_event<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
event: *mut gst_sys::GstEvent, event: *mut gst::ffi::GstEvent,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -850,16 +826,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_sink_query<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_sink_query<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -867,16 +843,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_src_event<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_src_event<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
event: *mut gst_sys::GstEvent, event: *mut gst::ffi::GstEvent,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -884,16 +860,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_src_query<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_src_query<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -901,16 +877,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_decoder_propose_allocation<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_propose_allocation<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -919,7 +895,7 @@ where
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query); let query = gst::QueryRef::from_mut_ptr(query);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.propose_allocation(wrap.unsafe_cast_ref(), query) { match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -932,9 +908,9 @@ where
} }
unsafe extern "C" fn video_decoder_decide_allocation<T: VideoDecoderImpl>( unsafe extern "C" fn video_decoder_decide_allocation<T: VideoDecoderImpl>(
ptr: *mut gst_video_sys::GstVideoDecoder, ptr: *mut ffi::GstVideoDecoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -943,7 +919,7 @@ where
let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoDecoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query); let query = gst::QueryRef::from_mut_ptr(query);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {

191
gstreamer-video/src/subclass/video_encoder.rs
View file

@ -7,21 +7,16 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use glib_sys;
use gst_sys;
use gst_video_sys;
use glib::prelude::*; use glib::prelude::*;
use glib::subclass::prelude::*; use glib::subclass::prelude::*;
use glib::translate::*; use glib::translate::*;
use gst;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use crate::prelude::*; use crate::prelude::*;
use video_codec_state::{Readable, VideoCodecState}; use crate::video_codec_state::{Readable, VideoCodecState};
use VideoCodecFrame; use crate::VideoCodecFrame;
use VideoEncoder; use crate::VideoEncoder;
pub trait VideoEncoderImpl: VideoEncoderImplExt + ElementImpl { pub trait VideoEncoderImpl: VideoEncoderImplExt + ElementImpl {
fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
@ -159,8 +154,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_open(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.open .open
.map(|f| { .map(|f| {
@ -171,7 +165,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `open` failed"] ["Parent function `open` failed"]
)) ))
@ -184,8 +178,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_close(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.close .close
.map(|f| { .map(|f| {
@ -196,7 +189,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `close` failed"] ["Parent function `close` failed"]
)) ))
@ -209,8 +202,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.start .start
.map(|f| { .map(|f| {
@ -221,7 +213,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `start` failed"] ["Parent function `start` failed"]
)) ))
@ -234,8 +226,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> { fn parent_stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.stop .stop
.map(|f| { .map(|f| {
@ -246,7 +237,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
{ {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `stop` failed"] ["Parent function `stop` failed"]
)) ))
@ -259,8 +250,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> { fn parent_finish(&self, element: &Self::Type) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.finish .finish
.map(|f| { .map(|f| {
@ -281,12 +271,11 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
) -> Result<(), gst::LoggableError> { ) -> Result<(), gst::LoggableError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.set_format .set_format
.map(|f| { .map(|f| {
gst_result_from_gboolean!( gst::gst_result_from_gboolean!(
f( f(
element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0, element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0,
state.as_mut_ptr() state.as_mut_ptr()
@ -306,8 +295,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.handle_frame .handle_frame
.map(|f| { .map(|f| {
@ -324,8 +312,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_flush(&self, element: &Self::Type) -> bool { fn parent_flush(&self, element: &Self::Type) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.flush .flush
.map(|f| { .map(|f| {
@ -341,12 +328,11 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> { fn parent_negotiate(&self, element: &Self::Type) -> Result<(), gst::LoggableError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.negotiate .negotiate
.map(|f| { .map(|f| {
gst_result_from_gboolean!( gst::gst_result_from_gboolean!(
f(element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0), f(element.unsafe_cast_ref::<VideoEncoder>().to_glib_none().0),
gst::CAT_RUST, gst::CAT_RUST,
"Parent function `negotiate` failed" "Parent function `negotiate` failed"
@ -359,8 +345,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps { fn parent_get_caps(&self, element: &Self::Type, filter: Option<&gst::Caps>) -> gst::Caps {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.getcaps .getcaps
.map(|f| { .map(|f| {
@ -380,8 +365,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool { fn parent_sink_event(&self, element: &Self::Type, event: gst::Event) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
let f = (*parent_class) let f = (*parent_class)
.sink_event .sink_event
.expect("Missing parent function `sink_event`"); .expect("Missing parent function `sink_event`");
@ -395,8 +379,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { fn parent_sink_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
let f = (*parent_class) let f = (*parent_class)
.sink_query .sink_query
.expect("Missing parent function `sink_query`"); .expect("Missing parent function `sink_query`");
@ -410,8 +393,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool { fn parent_src_event(&self, element: &Self::Type, event: gst::Event) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
let f = (*parent_class) let f = (*parent_class)
.src_event .src_event
.expect("Missing parent function `src_event`"); .expect("Missing parent function `src_event`");
@ -425,8 +407,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool { fn parent_src_query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
let f = (*parent_class) let f = (*parent_class)
.src_query .src_query
.expect("Missing parent function `src_query`"); .expect("Missing parent function `src_query`");
@ -444,8 +425,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
) -> Result<(), gst::ErrorMessage> { ) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.propose_allocation .propose_allocation
.map(|f| { .map(|f| {
@ -455,7 +435,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
)) { )) {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `propose_allocation` failed"] ["Parent function `propose_allocation` failed"]
)) ))
@ -472,8 +452,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
) -> Result<(), gst::ErrorMessage> { ) -> Result<(), gst::ErrorMessage> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoEncoderClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoEncoderClass;
(*parent_class) (*parent_class)
.decide_allocation .decide_allocation
.map(|f| { .map(|f| {
@ -483,7 +462,7 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
)) { )) {
Ok(()) Ok(())
} else { } else {
Err(gst_error_msg!( Err(gst::gst_error_msg!(
gst::CoreError::StateChange, gst::CoreError::StateChange,
["Parent function `decide_allocation` failed"] ["Parent function `decide_allocation` failed"]
)) ))
@ -521,8 +500,8 @@ where
} }
unsafe extern "C" fn video_encoder_open<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_open<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -530,7 +509,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.open(wrap.unsafe_cast_ref()) { match imp.open(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -543,8 +522,8 @@ where
} }
unsafe extern "C" fn video_encoder_close<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_close<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -552,7 +531,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.close(wrap.unsafe_cast_ref()) { match imp.close(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -565,8 +544,8 @@ where
} }
unsafe extern "C" fn video_encoder_start<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_start<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -574,7 +553,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.start(wrap.unsafe_cast_ref()) { match imp.start(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -587,8 +566,8 @@ where
} }
unsafe extern "C" fn video_encoder_stop<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_stop<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -596,7 +575,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.stop(wrap.unsafe_cast_ref()) { match imp.stop(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -609,8 +588,8 @@ where
} }
unsafe extern "C" fn video_encoder_finish<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_finish<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
) -> gst_sys::GstFlowReturn ) -> gst::ffi::GstFlowReturn
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -618,26 +597,26 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
imp.finish(wrap.unsafe_cast_ref()).into() imp.finish(wrap.unsafe_cast_ref()).into()
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_encoder_set_format<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_set_format<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
state: *mut gst_video_sys::GstVideoCodecState, state: *mut ffi::GstVideoCodecState,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
let instance = &*(ptr as *mut T::Instance); let instance = &*(ptr as *mut T::Instance);
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_video_sys::gst_video_codec_state_ref(state); ffi::gst_video_codec_state_ref(state);
let wrap_state = VideoCodecState::<Readable>::new(state); let wrap_state = VideoCodecState::<Readable>::new(state);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) { match imp.set_format(wrap.unsafe_cast_ref(), &wrap_state) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -650,9 +629,9 @@ where
} }
unsafe extern "C" fn video_encoder_handle_frame<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_handle_frame<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
frame: *mut gst_video_sys::GstVideoCodecFrame, frame: *mut ffi::GstVideoCodecFrame,
) -> gst_sys::GstFlowReturn ) -> gst::ffi::GstFlowReturn
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -661,15 +640,15 @@ where
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
let wrap_frame = VideoCodecFrame::new(frame, &*wrap); let wrap_frame = VideoCodecFrame::new(frame, &*wrap);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into() imp.handle_frame(wrap.unsafe_cast_ref(), wrap_frame).into()
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_encoder_flush<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_flush<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -677,15 +656,15 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
VideoEncoderImpl::flush(imp, wrap.unsafe_cast_ref()) VideoEncoderImpl::flush(imp, wrap.unsafe_cast_ref())
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_encoder_negotiate<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_negotiate<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -693,7 +672,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.negotiate(wrap.unsafe_cast_ref()) { match imp.negotiate(wrap.unsafe_cast_ref()) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -706,9 +685,9 @@ where
} }
unsafe extern "C" fn video_encoder_getcaps<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_getcaps<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
filter: *mut gst_sys::GstCaps, filter: *mut gst::ffi::GstCaps,
) -> *mut gst_sys::GstCaps ) -> *mut gst::ffi::GstCaps
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -716,7 +695,7 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::Caps::new_empty(), { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::Caps::new_empty(), {
VideoEncoderImpl::get_caps( VideoEncoderImpl::get_caps(
imp, imp,
wrap.unsafe_cast_ref(), wrap.unsafe_cast_ref(),
@ -729,9 +708,9 @@ where
} }
unsafe extern "C" fn video_encoder_sink_event<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_sink_event<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
event: *mut gst_sys::GstEvent, event: *mut gst::ffi::GstEvent,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -739,16 +718,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event)) imp.sink_event(wrap.unsafe_cast_ref(), from_glib_full(event))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_encoder_sink_query<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_sink_query<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -756,16 +735,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) imp.sink_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_encoder_src_event<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_src_event<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
event: *mut gst_sys::GstEvent, event: *mut gst::ffi::GstEvent,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -773,16 +752,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event)) imp.src_event(wrap.unsafe_cast_ref(), from_glib_full(event))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_encoder_src_query<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_src_query<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -790,16 +769,16 @@ where
let imp = instance.get_impl(); let imp = instance.get_impl();
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query)) imp.src_query(wrap.unsafe_cast_ref(), gst::QueryRef::from_mut_ptr(query))
}) })
.to_glib() .to_glib()
} }
unsafe extern "C" fn video_encoder_propose_allocation<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_propose_allocation<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -808,7 +787,7 @@ where
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query); let query = gst::QueryRef::from_mut_ptr(query);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.propose_allocation(wrap.unsafe_cast_ref(), query) { match imp.propose_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {
@ -821,9 +800,9 @@ where
} }
unsafe extern "C" fn video_encoder_decide_allocation<T: VideoEncoderImpl>( unsafe extern "C" fn video_encoder_decide_allocation<T: VideoEncoderImpl>(
ptr: *mut gst_video_sys::GstVideoEncoder, ptr: *mut ffi::GstVideoEncoder,
query: *mut gst_sys::GstQuery, query: *mut gst::ffi::GstQuery,
) -> glib_sys::gboolean ) -> glib::ffi::gboolean
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -832,7 +811,7 @@ where
let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr); let wrap: Borrowed<VideoEncoder> = from_glib_borrow(ptr);
let query = gst::QueryRef::from_mut_ptr(query); let query = gst::QueryRef::from_mut_ptr(query);
gst_panic_to_error!(&wrap, &instance.panicked(), false, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), false, {
match imp.decide_allocation(wrap.unsafe_cast_ref(), query) { match imp.decide_allocation(wrap.unsafe_cast_ref(), query) {
Ok(()) => true, Ok(()) => true,
Err(err) => { Err(err) => {

17
gstreamer-video/src/subclass/video_sink.rs
View file

@ -6,18 +6,14 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use gst_sys;
use gst_video_sys;
use glib::prelude::*; use glib::prelude::*;
use glib::subclass::prelude::*; use glib::subclass::prelude::*;
use glib::translate::*; use glib::translate::*;
use gst;
use gst::subclass::prelude::*; use gst::subclass::prelude::*;
use gst_base::subclass::prelude::*; use gst_base::subclass::prelude::*;
use VideoSink; use crate::VideoSink;
pub trait VideoSinkImpl: VideoSinkImplExt + BaseSinkImpl + ElementImpl { pub trait VideoSinkImpl: VideoSinkImplExt + BaseSinkImpl + ElementImpl {
fn show_frame( fn show_frame(
@ -45,8 +41,7 @@ impl<T: VideoSinkImpl> VideoSinkImplExt for T {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
unsafe { unsafe {
let data = T::type_data(); let data = T::type_data();
let parent_class = let parent_class = data.as_ref().get_parent_class() as *mut ffi::GstVideoSinkClass;
data.as_ref().get_parent_class() as *mut gst_video_sys::GstVideoSinkClass;
(*parent_class) (*parent_class)
.show_frame .show_frame
.map(|f| { .map(|f| {
@ -73,9 +68,9 @@ where
} }
unsafe extern "C" fn video_sink_show_frame<T: VideoSinkImpl>( unsafe extern "C" fn video_sink_show_frame<T: VideoSinkImpl>(
ptr: *mut gst_video_sys::GstVideoSink, ptr: *mut ffi::GstVideoSink,
buffer: *mut gst_sys::GstBuffer, buffer: *mut gst::ffi::GstBuffer,
) -> gst_sys::GstFlowReturn ) -> gst::ffi::GstFlowReturn
where where
T::Instance: PanicPoison, T::Instance: PanicPoison,
{ {
@ -84,7 +79,7 @@ where
let wrap: Borrowed<VideoSink> = from_glib_borrow(ptr); let wrap: Borrowed<VideoSink> = from_glib_borrow(ptr);
let buffer = from_glib_borrow(buffer); let buffer = from_glib_borrow(buffer);
gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, { gst::gst_panic_to_error!(&wrap, &instance.panicked(), gst::FlowReturn::Error, {
imp.show_frame(wrap.unsafe_cast_ref(), &buffer).into() imp.show_frame(wrap.unsafe_cast_ref(), &buffer).into()
}) })
.to_glib() .to_glib()

4
gstreamer-video/src/utils.rs
View file

@ -7,6 +7,6 @@
// except according to those terms. // except according to those terms.
pub trait HasStreamLock { pub trait HasStreamLock {
fn get_stream_lock(&self) -> *mut glib_sys::GRecMutex; fn get_stream_lock(&self) -> *mut glib::ffi::GRecMutex;
fn get_element_as_ptr(&self) -> *const gst_sys::GstElement; fn get_element_as_ptr(&self) -> *const gst::ffi::GstElement;
} }

20
gstreamer-video/src/video_buffer_pool.rs
View file

@ -16,29 +16,29 @@ use once_cell::sync::Lazy;
pub static BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META: Lazy<&'static str> = pub static BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META: Lazy<&'static str> =
Lazy::new(|| unsafe { Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META) CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
pub static BUFFER_POOL_OPTION_VIDEO_ALIGNMENT: Lazy<&'static str> = Lazy::new(|| unsafe { pub static BUFFER_POOL_OPTION_VIDEO_ALIGNMENT: Lazy<&'static str> = Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT) CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
pub static BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META: Lazy<&'static str> = pub static BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META: Lazy<&'static str> =
Lazy::new(|| unsafe { Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META) CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
pub static BUFFER_POOL_OPTION_VIDEO_META: Lazy<&'static str> = Lazy::new(|| unsafe { pub static BUFFER_POOL_OPTION_VIDEO_META: Lazy<&'static str> = Lazy::new(|| unsafe {
CStr::from_ptr(gst_video_sys::GST_BUFFER_POOL_OPTION_VIDEO_META) CStr::from_ptr(ffi::GST_BUFFER_POOL_OPTION_VIDEO_META)
.to_str() .to_str()
.unwrap() .unwrap()
}); });
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct VideoAlignment(pub(crate) gst_video_sys::GstVideoAlignment); pub struct VideoAlignment(pub(crate) ffi::GstVideoAlignment);
impl VideoAlignment { impl VideoAlignment {
pub fn get_padding_top(&self) -> u32 { pub fn get_padding_top(&self) -> u32 {
@ -53,7 +53,7 @@ impl VideoAlignment {
pub fn get_padding_right(&self) -> u32 { pub fn get_padding_right(&self) -> u32 {
self.0.padding_right self.0.padding_right
} }
pub fn get_stride_align(&self) -> &[u32; gst_video_sys::GST_VIDEO_MAX_PLANES as usize] { pub fn get_stride_align(&self) -> &[u32; ffi::GST_VIDEO_MAX_PLANES as usize] {
&self.0.stride_align &self.0.stride_align
} }
@ -62,12 +62,12 @@ impl VideoAlignment {
padding_bottom: u32, padding_bottom: u32,
padding_left: u32, padding_left: u32,
padding_right: u32, padding_right: u32,
stride_align: &[u32; gst_video_sys::GST_VIDEO_MAX_PLANES as usize], stride_align: &[u32; ffi::GST_VIDEO_MAX_PLANES as usize],
) -> Self { ) -> Self {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
let videoalignment = unsafe { let videoalignment = unsafe {
let mut videoalignment: gst_video_sys::GstVideoAlignment = mem::zeroed(); let mut videoalignment: ffi::GstVideoAlignment = mem::zeroed();
videoalignment.padding_top = padding_top; videoalignment.padding_top = padding_top;
videoalignment.padding_bottom = padding_bottom; videoalignment.padding_bottom = padding_bottom;
@ -92,7 +92,7 @@ impl VideoBufferPoolConfig for gst::BufferPoolConfig {
fn get_video_alignment(&self) -> Option<VideoAlignment> { fn get_video_alignment(&self) -> Option<VideoAlignment> {
unsafe { unsafe {
let mut alignment = mem::MaybeUninit::zeroed(); let mut alignment = mem::MaybeUninit::zeroed();
let ret = from_glib(gst_video_sys::gst_buffer_pool_config_get_video_alignment( let ret = from_glib(ffi::gst_buffer_pool_config_get_video_alignment(
self.as_ref().as_mut_ptr(), self.as_ref().as_mut_ptr(),
alignment.as_mut_ptr(), alignment.as_mut_ptr(),
)); ));
@ -106,7 +106,7 @@ impl VideoBufferPoolConfig for gst::BufferPoolConfig {
fn set_video_alignment(&mut self, align: &VideoAlignment) { fn set_video_alignment(&mut self, align: &VideoAlignment) {
unsafe { unsafe {
gst_video_sys::gst_buffer_pool_config_set_video_alignment( ffi::gst_buffer_pool_config_set_video_alignment(
self.as_mut().as_mut_ptr(), self.as_mut().as_mut_ptr(),
&align.0 as *const _ as *mut _, &align.0 as *const _ as *mut _,
) )

40
gstreamer-video/src/video_codec_frame.rs
View file

@ -7,34 +7,28 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use crate::utils::HasStreamLock;
use crate::VideoCodecFrameFlags;
use glib::translate::*; use glib::translate::*;
use gst;
use gst_video_sys;
use std::fmt; use std::fmt;
use std::mem; use std::mem;
use utils::HasStreamLock;
use VideoCodecFrameFlags;
pub struct VideoCodecFrame<'a> { pub struct VideoCodecFrame<'a> {
frame: *mut gst_video_sys::GstVideoCodecFrame, frame: *mut ffi::GstVideoCodecFrame,
/* GstVideoCodecFrame API isn't safe so protect the frame using the /* GstVideoCodecFrame API isn't safe so protect the frame using the
* element (decoder or encoder) stream lock */ * element (decoder or encoder) stream lock */
element: &'a dyn HasStreamLock, element: &'a dyn HasStreamLock,
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> ::glib::translate::ToGlibPtr<'a, *mut gst_video_sys::GstVideoCodecFrame> impl<'a> ::glib::translate::ToGlibPtr<'a, *mut ffi::GstVideoCodecFrame> for VideoCodecFrame<'a> {
for VideoCodecFrame<'a>
{
type Storage = &'a Self; type Storage = &'a Self;
fn to_glib_none( fn to_glib_none(&'a self) -> ::glib::translate::Stash<'a, *mut ffi::GstVideoCodecFrame, Self> {
&'a self,
) -> ::glib::translate::Stash<'a, *mut gst_video_sys::GstVideoCodecFrame, Self> {
Stash(self.frame, self) Stash(self.frame, self)
} }
fn to_glib_full(&self) -> *mut gst_video_sys::GstVideoCodecFrame { fn to_glib_full(&self) -> *mut ffi::GstVideoCodecFrame {
unimplemented!() unimplemented!()
} }
} }
@ -65,12 +59,12 @@ impl<'a> fmt::Debug for VideoCodecFrame<'a> {
impl<'a> VideoCodecFrame<'a> { impl<'a> VideoCodecFrame<'a> {
// Take ownership of @frame // Take ownership of @frame
pub(crate) unsafe fn new<T: HasStreamLock>( pub(crate) unsafe fn new<T: HasStreamLock>(
frame: *mut gst_video_sys::GstVideoCodecFrame, frame: *mut ffi::GstVideoCodecFrame,
element: &'a T, element: &'a T,
) -> Self { ) -> Self {
skip_assert_initialized!(); skip_assert_initialized!();
let stream_lock = element.get_stream_lock(); let stream_lock = element.get_stream_lock();
glib_sys::g_rec_mutex_lock(stream_lock); glib::ffi::g_rec_mutex_lock(stream_lock);
Self { frame, element } Self { frame, element }
} }
@ -161,8 +155,8 @@ impl<'a> VideoCodecFrame<'a> {
if ptr.is_null() { if ptr.is_null() {
None None
} else { } else {
let writable: bool = from_glib(gst_sys::gst_mini_object_is_writable( let writable: bool = from_glib(gst::ffi::gst_mini_object_is_writable(
ptr as *const gst_sys::GstMiniObject, ptr as *const gst::ffi::GstMiniObject,
)); ));
assert!(writable); assert!(writable);
@ -176,12 +170,12 @@ impl<'a> VideoCodecFrame<'a> {
let prev = (*self.to_glib_none().0).output_buffer; let prev = (*self.to_glib_none().0).output_buffer;
if !prev.is_null() { if !prev.is_null() {
gst_sys::gst_mini_object_unref(prev as *mut gst_sys::GstMiniObject); gst::ffi::gst_mini_object_unref(prev as *mut gst::ffi::GstMiniObject);
} }
let ptr = output_buffer.into_ptr(); let ptr = output_buffer.into_ptr();
let writable: bool = from_glib(gst_sys::gst_mini_object_is_writable( let writable: bool = from_glib(gst::ffi::gst_mini_object_is_writable(
ptr as *const gst_sys::GstMiniObject, ptr as *const gst::ffi::GstMiniObject,
)); ));
assert!(writable); assert!(writable);
@ -194,9 +188,9 @@ impl<'a> VideoCodecFrame<'a> {
} }
#[doc(hidden)] #[doc(hidden)]
pub unsafe fn into_ptr(self) -> *mut gst_video_sys::GstVideoCodecFrame { pub unsafe fn into_ptr(self) -> *mut ffi::GstVideoCodecFrame {
let stream_lock = self.element.get_stream_lock(); let stream_lock = self.element.get_stream_lock();
glib_sys::g_rec_mutex_unlock(stream_lock); glib::ffi::g_rec_mutex_unlock(stream_lock);
let s = mem::ManuallyDrop::new(self); let s = mem::ManuallyDrop::new(self);
s.to_glib_none().0 s.to_glib_none().0
@ -207,9 +201,9 @@ impl<'a> Drop for VideoCodecFrame<'a> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
let stream_lock = self.element.get_stream_lock(); let stream_lock = self.element.get_stream_lock();
glib_sys::g_rec_mutex_unlock(stream_lock); glib::ffi::g_rec_mutex_unlock(stream_lock);
gst_video_sys::gst_video_codec_frame_unref(self.frame); ffi::gst_video_codec_frame_unref(self.frame);
} }
} }
} }

42
gstreamer-video/src/video_codec_state.rs
View file

@ -7,21 +7,17 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use crate::utils::HasStreamLock;
use glib::translate::*; use glib::translate::*;
use gst_sys;
use gst_video_sys;
use std::fmt; use std::fmt;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::ptr; use std::ptr;
use utils::HasStreamLock;
use gst; use crate::video_info::VideoInfo;
use video_info::VideoInfo;
pub trait VideoCodecStateContext<'a> { pub trait VideoCodecStateContext<'a> {
fn get_element(&self) -> Option<&'a dyn HasStreamLock>; fn get_element(&self) -> Option<&'a dyn HasStreamLock>;
fn get_element_as_ptr(&self) -> *const gst_sys::GstElement; fn get_element_as_ptr(&self) -> *const gst::ffi::GstElement;
} }
pub struct InNegotiation<'a> { pub struct InNegotiation<'a> {
@ -36,7 +32,7 @@ impl<'a> VideoCodecStateContext<'a> for InNegotiation<'a> {
Some(self.element) Some(self.element)
} }
fn get_element_as_ptr(&self) -> *const gst_sys::GstElement { fn get_element_as_ptr(&self) -> *const gst::ffi::GstElement {
self.element.get_element_as_ptr() self.element.get_element_as_ptr()
} }
} }
@ -46,13 +42,13 @@ impl<'a> VideoCodecStateContext<'a> for Readable {
None None
} }
fn get_element_as_ptr(&self) -> *const gst_sys::GstElement { fn get_element_as_ptr(&self) -> *const gst::ffi::GstElement {
ptr::null() ptr::null()
} }
} }
pub struct VideoCodecState<'a, T: VideoCodecStateContext<'a>> { pub struct VideoCodecState<'a, T: VideoCodecStateContext<'a>> {
state: *mut gst_video_sys::GstVideoCodecState, state: *mut ffi::GstVideoCodecState,
pub(crate) context: T, pub(crate) context: T,
phantom: PhantomData<&'a T>, phantom: PhantomData<&'a T>,
} }
@ -70,7 +66,7 @@ impl<'a, T: VideoCodecStateContext<'a>> fmt::Debug for VideoCodecState<'a, T> {
impl<'a> VideoCodecState<'a, Readable> { impl<'a> VideoCodecState<'a, Readable> {
// Take ownership of @state // Take ownership of @state
pub(crate) unsafe fn new(state: *mut gst_video_sys::GstVideoCodecState) -> Self { pub(crate) unsafe fn new(state: *mut ffi::GstVideoCodecState) -> Self {
skip_assert_initialized!(); skip_assert_initialized!();
Self { Self {
state, state,
@ -83,12 +79,12 @@ impl<'a> VideoCodecState<'a, Readable> {
impl<'a> VideoCodecState<'a, InNegotiation<'a>> { impl<'a> VideoCodecState<'a, InNegotiation<'a>> {
// Take ownership of @state // Take ownership of @state
pub(crate) unsafe fn new<T: HasStreamLock>( pub(crate) unsafe fn new<T: HasStreamLock>(
state: *mut gst_video_sys::GstVideoCodecState, state: *mut ffi::GstVideoCodecState,
element: &'a T, element: &'a T,
) -> Self { ) -> Self {
skip_assert_initialized!(); skip_assert_initialized!();
let stream_lock = element.get_stream_lock(); let stream_lock = element.get_stream_lock();
glib_sys::g_rec_mutex_lock(stream_lock); glib::ffi::g_rec_mutex_lock(stream_lock);
Self { Self {
state, state,
context: InNegotiation { element }, context: InNegotiation { element },
@ -141,7 +137,7 @@ impl<'a, T: VideoCodecStateContext<'a>> VideoCodecState<'a, T> {
} }
} }
#[doc(hidden)] #[doc(hidden)]
pub fn as_mut_ptr(&self) -> *mut gst_video_sys::GstVideoCodecState { pub fn as_mut_ptr(&self) -> *mut ffi::GstVideoCodecState {
self.state self.state
} }
} }
@ -151,9 +147,9 @@ impl<'a, T: VideoCodecStateContext<'a>> Drop for VideoCodecState<'a, T> {
unsafe { unsafe {
if let Some(element) = self.context.get_element() { if let Some(element) = self.context.get_element() {
let stream_lock = element.get_stream_lock(); let stream_lock = element.get_stream_lock();
glib_sys::g_rec_mutex_unlock(stream_lock); glib::ffi::g_rec_mutex_unlock(stream_lock);
} }
gst_video_sys::gst_video_codec_state_unref(self.state); ffi::gst_video_codec_state_unref(self.state);
} }
} }
} }
@ -170,12 +166,12 @@ impl<'a> VideoCodecState<'a, InNegotiation<'a>> {
let prev = (*self.as_mut_ptr()).caps; let prev = (*self.as_mut_ptr()).caps;
if !prev.is_null() { if !prev.is_null() {
gst_sys::gst_mini_object_unref(prev as *mut gst_sys::GstMiniObject) gst::ffi::gst_mini_object_unref(prev as *mut gst::ffi::GstMiniObject)
} }
ptr::write( ptr::write(
&mut (*self.as_mut_ptr()).caps, &mut (*self.as_mut_ptr()).caps,
gst_sys::gst_mini_object_ref(caps.as_mut_ptr() as *mut _) as *mut _, gst::ffi::gst_mini_object_ref(caps.as_mut_ptr() as *mut _) as *mut _,
); );
} }
} }
@ -185,12 +181,12 @@ impl<'a> VideoCodecState<'a, InNegotiation<'a>> {
let prev = (*self.as_mut_ptr()).codec_data; let prev = (*self.as_mut_ptr()).codec_data;
if !prev.is_null() { if !prev.is_null() {
gst_sys::gst_mini_object_unref(prev as *mut gst_sys::GstMiniObject) gst::ffi::gst_mini_object_unref(prev as *mut gst::ffi::GstMiniObject)
} }
ptr::write( ptr::write(
&mut (*self.as_mut_ptr()).codec_data, &mut (*self.as_mut_ptr()).codec_data,
gst_sys::gst_mini_object_ref(codec_data.as_mut_ptr() as *mut _) as *mut _, gst::ffi::gst_mini_object_ref(codec_data.as_mut_ptr() as *mut _) as *mut _,
); );
} }
} }
@ -200,12 +196,12 @@ impl<'a> VideoCodecState<'a, InNegotiation<'a>> {
let prev = (*self.as_mut_ptr()).allocation_caps; let prev = (*self.as_mut_ptr()).allocation_caps;
if !prev.is_null() { if !prev.is_null() {
gst_sys::gst_mini_object_unref(prev as *mut gst_sys::GstMiniObject) gst::ffi::gst_mini_object_unref(prev as *mut gst::ffi::GstMiniObject)
} }
ptr::write( ptr::write(
&mut (*self.as_mut_ptr()).allocation_caps, &mut (*self.as_mut_ptr()).allocation_caps,
gst_sys::gst_mini_object_ref(allocation_caps.as_mut_ptr() as *mut _) as *mut _, gst::ffi::gst_mini_object_ref(allocation_caps.as_mut_ptr() as *mut _) as *mut _,
); );
} }
} }
@ -214,7 +210,7 @@ impl<'a> VideoCodecState<'a, InNegotiation<'a>> {
impl<'a> Clone for VideoCodecState<'a, Readable> { impl<'a> Clone for VideoCodecState<'a, Readable> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
unsafe { unsafe {
let state = gst_video_sys::gst_video_codec_state_ref(self.state); let state = ffi::gst_video_codec_state_ref(self.state);
Self::new(state) Self::new(state)
} }
} }

96
gstreamer-video/src/video_converter.rs
View file

@ -6,23 +6,19 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use gst_video_sys;
use glib;
use glib::translate::ToGlibPtr; use glib::translate::ToGlibPtr;
use gst;
use std::convert; use std::convert;
use std::ops; use std::ops;
use std::ptr; use std::ptr;
#[derive(Debug)] #[derive(Debug)]
pub struct VideoConverter(ptr::NonNull<gst_video_sys::GstVideoConverter>); pub struct VideoConverter(ptr::NonNull<ffi::GstVideoConverter>);
impl Drop for VideoConverter { impl Drop for VideoConverter {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst_video_sys::gst_video_converter_free(self.0.as_ptr()); ffi::gst_video_converter_free(self.0.as_ptr());
} }
} }
} }
@ -32,27 +28,27 @@ unsafe impl Sync for VideoConverter {}
impl VideoConverter { impl VideoConverter {
pub fn new( pub fn new(
in_info: &::VideoInfo, in_info: &crate::VideoInfo,
out_info: &::VideoInfo, out_info: &crate::VideoInfo,
config: Option<VideoConverterConfig>, config: Option<VideoConverterConfig>,
) -> Result<Self, glib::BoolError> { ) -> Result<Self, glib::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
if in_info.fps() != out_info.fps() { if in_info.fps() != out_info.fps() {
return Err(glib_bool_error!("Can't do framerate conversion")); return Err(glib::glib_bool_error!("Can't do framerate conversion"));
} }
if in_info.interlace_mode() != out_info.interlace_mode() { if in_info.interlace_mode() != out_info.interlace_mode() {
return Err(glib_bool_error!("Can't do interlacing conversion")); return Err(glib::glib_bool_error!("Can't do interlacing conversion"));
} }
unsafe { unsafe {
let ptr = gst_video_sys::gst_video_converter_new( let ptr = ffi::gst_video_converter_new(
in_info.to_glib_none().0 as *mut _, in_info.to_glib_none().0 as *mut _,
out_info.to_glib_none().0 as *mut _, out_info.to_glib_none().0 as *mut _,
config.map(|s| s.0.into_ptr()).unwrap_or(ptr::null_mut()), config.map(|s| s.0.into_ptr()).unwrap_or(ptr::null_mut()),
); );
if ptr.is_null() { if ptr.is_null() {
Err(glib_bool_error!("Failed to create video converter")) Err(glib::glib_bool_error!("Failed to create video converter"))
} else { } else {
Ok(VideoConverter(ptr::NonNull::new_unchecked(ptr))) Ok(VideoConverter(ptr::NonNull::new_unchecked(ptr)))
} }
@ -62,7 +58,7 @@ impl VideoConverter {
pub fn get_config(&self) -> VideoConverterConfig { pub fn get_config(&self) -> VideoConverterConfig {
unsafe { unsafe {
VideoConverterConfig( VideoConverterConfig(
gst::StructureRef::from_glib_borrow(gst_video_sys::gst_video_converter_get_config( gst::StructureRef::from_glib_borrow(ffi::gst_video_converter_get_config(
self.0.as_ptr(), self.0.as_ptr(),
)) ))
.to_owned(), .to_owned(),
@ -72,35 +68,27 @@ impl VideoConverter {
pub fn set_config(&mut self, config: VideoConverterConfig) { pub fn set_config(&mut self, config: VideoConverterConfig) {
unsafe { unsafe {
gst_video_sys::gst_video_converter_set_config(self.0.as_ptr(), config.0.into_ptr()); ffi::gst_video_converter_set_config(self.0.as_ptr(), config.0.into_ptr());
} }
} }
pub fn frame<T>( pub fn frame<T>(
&self, &self,
src: &::VideoFrame<T>, src: &crate::VideoFrame<T>,
dest: &mut ::VideoFrame<::video_frame::Writable>, dest: &mut crate::VideoFrame<crate::video_frame::Writable>,
) { ) {
unsafe { unsafe {
gst_video_sys::gst_video_converter_frame( ffi::gst_video_converter_frame(self.0.as_ptr(), src.as_ptr(), dest.as_mut_ptr());
self.0.as_ptr(),
src.as_ptr(),
dest.as_mut_ptr(),
);
} }
} }
pub fn frame_ref<T>( pub fn frame_ref<T>(
&self, &self,
src: &::VideoFrameRef<T>, src: &crate::VideoFrameRef<T>,
dest: &mut ::VideoFrameRef<&mut gst::BufferRef>, dest: &mut crate::VideoFrameRef<&mut gst::BufferRef>,
) { ) {
unsafe { unsafe {
gst_video_sys::gst_video_converter_frame( ffi::gst_video_converter_frame(self.0.as_ptr(), src.as_ptr(), dest.as_mut_ptr());
self.0.as_ptr(),
src.as_ptr(),
dest.as_mut_ptr(),
);
} }
} }
} }
@ -148,7 +136,9 @@ impl convert::TryFrom<gst::Structure> for VideoConverterConfig {
if v.get_name() == "GstVideoConverter" { if v.get_name() == "GstVideoConverter" {
Ok(VideoConverterConfig(v)) Ok(VideoConverterConfig(v))
} else { } else {
Err(glib_bool_error!("Structure is no VideoConverterConfig")) Err(glib::glib_bool_error!(
"Structure is no VideoConverterConfig"
))
} }
} }
} }
@ -174,26 +164,26 @@ impl VideoConverterConfig {
VideoConverterConfig(gst::Structure::new_empty("GstVideoConverter")) VideoConverterConfig(gst::Structure::new_empty("GstVideoConverter"))
} }
pub fn set_resampler_method(&mut self, v: ::VideoResamplerMethod) { pub fn set_resampler_method(&mut self, v: crate::VideoResamplerMethod) {
self.0.set("GstVideoConverter.resampler-method", &v); self.0.set("GstVideoConverter.resampler-method", &v);
} }
pub fn get_resampler_method(&self) -> ::VideoResamplerMethod { pub fn get_resampler_method(&self) -> crate::VideoResamplerMethod {
self.0 self.0
.get_optional("GstVideoConverter.resampler-method") .get_optional("GstVideoConverter.resampler-method")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoResamplerMethod::Cubic) .unwrap_or(crate::VideoResamplerMethod::Cubic)
} }
pub fn set_chroma_resampler_method(&mut self, v: ::VideoResamplerMethod) { pub fn set_chroma_resampler_method(&mut self, v: crate::VideoResamplerMethod) {
self.0.set("GstVideoConverter.chroma-resampler-method", &v); self.0.set("GstVideoConverter.chroma-resampler-method", &v);
} }
pub fn get_chroma_resampler_method(&self) -> ::VideoResamplerMethod { pub fn get_chroma_resampler_method(&self) -> crate::VideoResamplerMethod {
self.0 self.0
.get_optional("GstVideoConverter.chroma-resampler-method") .get_optional("GstVideoConverter.chroma-resampler-method")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoResamplerMethod::Linear) .unwrap_or(crate::VideoResamplerMethod::Linear)
} }
pub fn set_resampler_taps(&mut self, v: u32) { pub fn set_resampler_taps(&mut self, v: u32) {
@ -207,15 +197,15 @@ impl VideoConverterConfig {
.unwrap_or(0) .unwrap_or(0)
} }
pub fn set_dither_method(&mut self, v: ::VideoDitherMethod) { pub fn set_dither_method(&mut self, v: crate::VideoDitherMethod) {
self.0.set("GstVideoConverter.dither-method", &v); self.0.set("GstVideoConverter.dither-method", &v);
} }
pub fn get_dither_method(&self) -> ::VideoDitherMethod { pub fn get_dither_method(&self) -> crate::VideoDitherMethod {
self.0 self.0
.get_optional("GstVideoConverter.dither-method") .get_optional("GstVideoConverter.dither-method")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoDitherMethod::Bayer) .unwrap_or(crate::VideoDitherMethod::Bayer)
} }
pub fn set_dither_quantization(&mut self, v: u32) { pub fn set_dither_quantization(&mut self, v: u32) {
@ -351,15 +341,15 @@ impl VideoConverterConfig {
.unwrap_or(1.0) .unwrap_or(1.0)
} }
pub fn set_alpha_mode(&mut self, v: ::VideoAlphaMode) { pub fn set_alpha_mode(&mut self, v: crate::VideoAlphaMode) {
self.0.set("GstVideoConverter.alpha-mode", &v); self.0.set("GstVideoConverter.alpha-mode", &v);
} }
pub fn get_alpha_mode(&self) -> ::VideoAlphaMode { pub fn get_alpha_mode(&self) -> crate::VideoAlphaMode {
self.0 self.0
.get_optional("GstVideoConverter.alpha-mode") .get_optional("GstVideoConverter.alpha-mode")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoAlphaMode::Copy) .unwrap_or(crate::VideoAlphaMode::Copy)
} }
pub fn set_border_argb(&mut self, v: u32) { pub fn set_border_argb(&mut self, v: u32) {
@ -373,48 +363,48 @@ impl VideoConverterConfig {
.unwrap_or(0xff_00_00_00) .unwrap_or(0xff_00_00_00)
} }
pub fn set_chroma_mode(&mut self, v: ::VideoChromaMode) { pub fn set_chroma_mode(&mut self, v: crate::VideoChromaMode) {
self.0.set("GstVideoConverter.chroma-mode", &v); self.0.set("GstVideoConverter.chroma-mode", &v);
} }
pub fn get_chroma_mode(&self) -> ::VideoChromaMode { pub fn get_chroma_mode(&self) -> crate::VideoChromaMode {
self.0 self.0
.get_optional("GstVideoConverter.chroma-mode") .get_optional("GstVideoConverter.chroma-mode")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoChromaMode::Full) .unwrap_or(crate::VideoChromaMode::Full)
} }
pub fn set_matrix_mode(&mut self, v: ::VideoMatrixMode) { pub fn set_matrix_mode(&mut self, v: crate::VideoMatrixMode) {
self.0.set("GstVideoConverter.matrix-mode", &v); self.0.set("GstVideoConverter.matrix-mode", &v);
} }
pub fn get_matrix_mode(&self) -> ::VideoMatrixMode { pub fn get_matrix_mode(&self) -> crate::VideoMatrixMode {
self.0 self.0
.get_optional("GstVideoConverter.matrix-mode") .get_optional("GstVideoConverter.matrix-mode")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoMatrixMode::Full) .unwrap_or(crate::VideoMatrixMode::Full)
} }
pub fn set_gamma_mode(&mut self, v: ::VideoGammaMode) { pub fn set_gamma_mode(&mut self, v: crate::VideoGammaMode) {
self.0.set("GstVideoConverter.gamma-mode", &v); self.0.set("GstVideoConverter.gamma-mode", &v);
} }
pub fn get_gamma_mode(&self) -> ::VideoGammaMode { pub fn get_gamma_mode(&self) -> crate::VideoGammaMode {
self.0 self.0
.get_optional("GstVideoConverter.gamma-mode") .get_optional("GstVideoConverter.gamma-mode")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoGammaMode::None) .unwrap_or(crate::VideoGammaMode::None)
} }
pub fn set_primaries_mode(&mut self, v: ::VideoPrimariesMode) { pub fn set_primaries_mode(&mut self, v: crate::VideoPrimariesMode) {
self.0.set("GstVideoConverter.primaries-mode", &v); self.0.set("GstVideoConverter.primaries-mode", &v);
} }
pub fn get_primaries_mode(&self) -> ::VideoPrimariesMode { pub fn get_primaries_mode(&self) -> crate::VideoPrimariesMode {
self.0 self.0
.get_optional("GstVideoConverter.primaries-mode") .get_optional("GstVideoConverter.primaries-mode")
.expect("Wrong type") .expect("Wrong type")
.unwrap_or(::VideoPrimariesMode::None) .unwrap_or(crate::VideoPrimariesMode::None)
} }
pub fn set_threads(&mut self, v: u32) { pub fn set_threads(&mut self, v: u32) {

98
gstreamer-video/src/video_decoder.rs
View file

@ -7,33 +7,31 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use glib::object::IsA; use crate::utils::HasStreamLock;
use glib::translate::*; use crate::video_codec_state::{InNegotiation, Readable, VideoCodecState, VideoCodecStateContext};
use gst; use crate::VideoCodecFrame;
use gst_video_sys; use crate::VideoDecoder;
use std::mem; use crate::VideoFormat;
use std::ptr;
use utils::HasStreamLock;
use video_codec_state::{InNegotiation, Readable, VideoCodecState, VideoCodecStateContext};
use VideoCodecFrame;
use VideoDecoder;
use VideoFormat;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
use VideoInterlaceMode; use crate::VideoInterlaceMode;
use glib::object::IsA;
use glib::translate::*;
use std::mem;
use std::ptr;
extern "C" { extern "C" {
fn _gst_video_decoder_error( fn _gst_video_decoder_error(
dec: *mut gst_video_sys::GstVideoDecoder, dec: *mut ffi::GstVideoDecoder,
weight: i32, weight: i32,
domain: glib_sys::GQuark, domain: glib::ffi::GQuark,
code: i32, code: i32,
txt: *mut libc::c_char, txt: *mut libc::c_char,
debug: *mut libc::c_char, debug: *mut libc::c_char,
file: *const libc::c_char, file: *const libc::c_char,
function: *const libc::c_char, function: *const libc::c_char,
line: i32, line: i32,
) -> gst_sys::GstFlowReturn; ) -> gst::ffi::GstFlowReturn;
} }
pub trait VideoDecoderExtManual: 'static { pub trait VideoDecoderExtManual: 'static {
@ -106,13 +104,11 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let ret: gst::FlowReturn = unsafe { let ret: gst::FlowReturn = unsafe {
let params_ptr = params.to_glib_none().0 as *mut _; let params_ptr = params.to_glib_none().0 as *mut _;
from_glib( from_glib(ffi::gst_video_decoder_allocate_output_frame_with_params(
gst_video_sys::gst_video_decoder_allocate_output_frame_with_params( self.as_ref().to_glib_none().0,
self.as_ref().to_glib_none().0, frame.to_glib_none().0,
frame.to_glib_none().0, params_ptr,
params_ptr, ))
),
)
}; };
ret.into_result() ret.into_result()
} }
@ -121,7 +117,7 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
unsafe { unsafe {
let mut allocator = ptr::null_mut(); let mut allocator = ptr::null_mut();
let mut params = mem::zeroed(); let mut params = mem::zeroed();
gst_video_sys::gst_video_decoder_get_allocator( ffi::gst_video_decoder_get_allocator(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
&mut allocator, &mut allocator,
&mut params, &mut params,
@ -132,7 +128,7 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
fn have_frame(&self) -> Result<gst::FlowSuccess, gst::FlowError> { fn have_frame(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
let ret: gst::FlowReturn = unsafe { let ret: gst::FlowReturn = unsafe {
from_glib(gst_video_sys::gst_video_decoder_have_frame( from_glib(ffi::gst_video_decoder_have_frame(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
)) ))
}; };
@ -141,7 +137,7 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
fn finish_frame(&self, frame: VideoCodecFrame) -> Result<gst::FlowSuccess, gst::FlowError> { fn finish_frame(&self, frame: VideoCodecFrame) -> Result<gst::FlowSuccess, gst::FlowError> {
let ret: gst::FlowReturn = unsafe { let ret: gst::FlowReturn = unsafe {
from_glib(gst_video_sys::gst_video_decoder_finish_frame( from_glib(ffi::gst_video_decoder_finish_frame(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
frame.into_ptr(), frame.into_ptr(),
)) ))
@ -151,16 +147,13 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
fn release_frame(&self, frame: VideoCodecFrame) { fn release_frame(&self, frame: VideoCodecFrame) {
unsafe { unsafe {
gst_video_sys::gst_video_decoder_release_frame( ffi::gst_video_decoder_release_frame(self.as_ref().to_glib_none().0, frame.into_ptr())
self.as_ref().to_glib_none().0,
frame.into_ptr(),
)
} }
} }
fn drop_frame(&self, frame: VideoCodecFrame) -> Result<gst::FlowSuccess, gst::FlowError> { fn drop_frame(&self, frame: VideoCodecFrame) -> Result<gst::FlowSuccess, gst::FlowError> {
let ret: gst::FlowReturn = unsafe { let ret: gst::FlowReturn = unsafe {
from_glib(gst_video_sys::gst_video_decoder_drop_frame( from_glib(ffi::gst_video_decoder_drop_frame(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
frame.into_ptr(), frame.into_ptr(),
)) ))
@ -169,11 +162,11 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
} }
fn get_latency(&self) -> (gst::ClockTime, gst::ClockTime) { fn get_latency(&self) -> (gst::ClockTime, gst::ClockTime) {
let mut min_latency = gst_sys::GST_CLOCK_TIME_NONE; let mut min_latency = gst::ffi::GST_CLOCK_TIME_NONE;
let mut max_latency = gst_sys::GST_CLOCK_TIME_NONE; let mut max_latency = gst::ffi::GST_CLOCK_TIME_NONE;
unsafe { unsafe {
gst_video_sys::gst_video_decoder_get_latency( ffi::gst_video_decoder_get_latency(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
&mut min_latency, &mut min_latency,
&mut max_latency, &mut max_latency,
@ -185,7 +178,7 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) { fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) {
unsafe { unsafe {
gst_video_sys::gst_video_decoder_set_latency( ffi::gst_video_decoder_set_latency(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
min_latency.to_glib(), min_latency.to_glib(),
max_latency.to_glib(), max_latency.to_glib(),
@ -195,7 +188,7 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
fn get_frame(&self, frame_number: i32) -> Option<VideoCodecFrame> { fn get_frame(&self, frame_number: i32) -> Option<VideoCodecFrame> {
let frame = unsafe { let frame = unsafe {
gst_video_sys::gst_video_decoder_get_frame(self.as_ref().to_glib_none().0, frame_number) ffi::gst_video_decoder_get_frame(self.as_ref().to_glib_none().0, frame_number)
}; };
if frame.is_null() { if frame.is_null() {
@ -207,9 +200,8 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
fn get_frames(&self) -> Vec<VideoCodecFrame> { fn get_frames(&self) -> Vec<VideoCodecFrame> {
unsafe { unsafe {
let frames = let frames = ffi::gst_video_decoder_get_frames(self.as_ref().to_glib_none().0);
gst_video_sys::gst_video_decoder_get_frames(self.as_ref().to_glib_none().0); let mut iter: *const glib::ffi::GList = frames;
let mut iter: *const glib_sys::GList = frames;
let mut vec = Vec::new(); let mut vec = Vec::new();
while !iter.is_null() { while !iter.is_null() {
@ -220,15 +212,14 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
iter = (*iter).next; iter = (*iter).next;
} }
glib_sys::g_list_free(frames); glib::ffi::g_list_free(frames);
vec vec
} }
} }
fn get_oldest_frame(&self) -> Option<VideoCodecFrame> { fn get_oldest_frame(&self) -> Option<VideoCodecFrame> {
let frame = unsafe { let frame =
gst_video_sys::gst_video_decoder_get_oldest_frame(self.as_ref().to_glib_none().0) unsafe { ffi::gst_video_decoder_get_oldest_frame(self.as_ref().to_glib_none().0) };
};
if frame.is_null() { if frame.is_null() {
None None
@ -238,9 +229,8 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
} }
fn get_output_state(&self) -> Option<VideoCodecState<'static, Readable>> { fn get_output_state(&self) -> Option<VideoCodecState<'static, Readable>> {
let state = unsafe { let state =
gst_video_sys::gst_video_decoder_get_output_state(self.as_ref().to_glib_none().0) unsafe { ffi::gst_video_decoder_get_output_state(self.as_ref().to_glib_none().0) };
};
if state.is_null() { if state.is_null() {
None None
@ -261,7 +251,7 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
Some(reference) => reference.as_mut_ptr(), Some(reference) => reference.as_mut_ptr(),
None => ptr::null_mut(), None => ptr::null_mut(),
}; };
gst_video_sys::gst_video_decoder_set_output_state( ffi::gst_video_decoder_set_output_state(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
fmt.to_glib(), fmt.to_glib(),
width, width,
@ -292,7 +282,7 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
Some(reference) => reference.as_mut_ptr(), Some(reference) => reference.as_mut_ptr(),
None => ptr::null_mut(), None => ptr::null_mut(),
}; };
gst_video_sys::gst_video_decoder_set_interlaced_output_state( ffi::gst_video_decoder_set_interlaced_output_state(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
fmt.to_glib(), fmt.to_glib(),
mode.to_glib(), mode.to_glib(),
@ -314,11 +304,11 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
output_state: VideoCodecState<'a, InNegotiation<'a>>, output_state: VideoCodecState<'a, InNegotiation<'a>>,
) -> Result<(), gst::FlowError> { ) -> Result<(), gst::FlowError> {
// Consume output_state so user won't be able to modify it anymore // Consume output_state so user won't be able to modify it anymore
let self_ptr = self.to_glib_none().0 as *const gst_sys::GstElement; let self_ptr = self.to_glib_none().0 as *const gst::ffi::GstElement;
assert_eq!(output_state.context.get_element_as_ptr(), self_ptr); assert_eq!(output_state.context.get_element_as_ptr(), self_ptr);
let ret = unsafe { let ret = unsafe {
from_glib(gst_video_sys::gst_video_decoder_negotiate( from_glib(ffi::gst_video_decoder_negotiate(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
)) ))
}; };
@ -356,14 +346,14 @@ impl<O: IsA<VideoDecoder>> VideoDecoderExtManual for O {
} }
impl HasStreamLock for VideoDecoder { impl HasStreamLock for VideoDecoder {
fn get_stream_lock(&self) -> *mut glib_sys::GRecMutex { fn get_stream_lock(&self) -> *mut glib::ffi::GRecMutex {
let decoder_sys: *const gstreamer_video_sys::GstVideoDecoder = self.to_glib_none().0; let decoder_sys: *const ffi::GstVideoDecoder = self.to_glib_none().0;
unsafe { &(*decoder_sys).stream_lock as *const _ as usize as *mut _ } unsafe { &(*decoder_sys).stream_lock as *const _ as usize as *mut _ }
} }
fn get_element_as_ptr(&self) -> *const gst_sys::GstElement { fn get_element_as_ptr(&self) -> *const gst::ffi::GstElement {
let decoder_sys: *const gstreamer_video_sys::GstVideoDecoder = self.to_glib_none().0; let decoder_sys: *const ffi::GstVideoDecoder = self.to_glib_none().0;
decoder_sys as *const gst_sys::GstElement decoder_sys as *const gst::ffi::GstElement
} }
} }

61
gstreamer-video/src/video_encoder.rs
View file

@ -8,16 +8,14 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use crate::utils::HasStreamLock;
use crate::video_codec_state::{InNegotiation, Readable, VideoCodecState, VideoCodecStateContext};
use crate::VideoCodecFrame;
use crate::VideoEncoder;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use gst;
use gst_video_sys;
use std::mem; use std::mem;
use std::ptr; use std::ptr;
use utils::HasStreamLock;
use video_codec_state::{InNegotiation, Readable, VideoCodecState, VideoCodecStateContext};
use VideoCodecFrame;
use VideoEncoder;
pub trait VideoEncoderExtManual: 'static { pub trait VideoEncoderExtManual: 'static {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
@ -68,7 +66,7 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
size: usize, size: usize,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let ret: gst::FlowReturn = unsafe { let ret: gst::FlowReturn = unsafe {
from_glib(gst_video_sys::gst_video_encoder_allocate_output_frame( from_glib(ffi::gst_video_encoder_allocate_output_frame(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
frame.to_glib_none().0, frame.to_glib_none().0,
size, size,
@ -81,7 +79,7 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
unsafe { unsafe {
let mut allocator = ptr::null_mut(); let mut allocator = ptr::null_mut();
let mut params = mem::zeroed(); let mut params = mem::zeroed();
gst_video_sys::gst_video_encoder_get_allocator( ffi::gst_video_encoder_get_allocator(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
&mut allocator, &mut allocator,
&mut params, &mut params,
@ -95,7 +93,7 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
frame: Option<VideoCodecFrame>, frame: Option<VideoCodecFrame>,
) -> Result<gst::FlowSuccess, gst::FlowError> { ) -> Result<gst::FlowSuccess, gst::FlowError> {
let ret: gst::FlowReturn = unsafe { let ret: gst::FlowReturn = unsafe {
from_glib(gst_video_sys::gst_video_encoder_finish_frame( from_glib(ffi::gst_video_encoder_finish_frame(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
frame.map(|f| f.into_ptr()).unwrap_or(ptr::null_mut()), frame.map(|f| f.into_ptr()).unwrap_or(ptr::null_mut()),
)) ))
@ -107,7 +105,7 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
fn finish_subframe(&self, frame: &VideoCodecFrame) -> Result<gst::FlowSuccess, gst::FlowError> { fn finish_subframe(&self, frame: &VideoCodecFrame) -> Result<gst::FlowSuccess, gst::FlowError> {
let ret: gst::FlowReturn = unsafe { let ret: gst::FlowReturn = unsafe {
from_glib(gst_video_sys::gst_video_encoder_finish_subframe( from_glib(ffi::gst_video_encoder_finish_subframe(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
frame.to_glib_none().0, frame.to_glib_none().0,
)) ))
@ -116,11 +114,11 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
} }
fn get_latency(&self) -> (gst::ClockTime, gst::ClockTime) { fn get_latency(&self) -> (gst::ClockTime, gst::ClockTime) {
let mut min_latency = gst_sys::GST_CLOCK_TIME_NONE; let mut min_latency = gst::ffi::GST_CLOCK_TIME_NONE;
let mut max_latency = gst_sys::GST_CLOCK_TIME_NONE; let mut max_latency = gst::ffi::GST_CLOCK_TIME_NONE;
unsafe { unsafe {
gst_video_sys::gst_video_encoder_get_latency( ffi::gst_video_encoder_get_latency(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
&mut min_latency, &mut min_latency,
&mut max_latency, &mut max_latency,
@ -132,7 +130,7 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) { fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) {
unsafe { unsafe {
gst_video_sys::gst_video_encoder_set_latency( ffi::gst_video_encoder_set_latency(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
min_latency.to_glib(), min_latency.to_glib(),
max_latency.to_glib(), max_latency.to_glib(),
@ -142,7 +140,7 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
fn get_frame(&self, frame_number: i32) -> Option<VideoCodecFrame> { fn get_frame(&self, frame_number: i32) -> Option<VideoCodecFrame> {
let frame = unsafe { let frame = unsafe {
gst_video_sys::gst_video_encoder_get_frame(self.as_ref().to_glib_none().0, frame_number) ffi::gst_video_encoder_get_frame(self.as_ref().to_glib_none().0, frame_number)
}; };
if frame.is_null() { if frame.is_null() {
@ -154,9 +152,8 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
fn get_frames(&self) -> Vec<VideoCodecFrame> { fn get_frames(&self) -> Vec<VideoCodecFrame> {
unsafe { unsafe {
let frames = let frames = ffi::gst_video_encoder_get_frames(self.as_ref().to_glib_none().0);
gst_video_sys::gst_video_encoder_get_frames(self.as_ref().to_glib_none().0); let mut iter: *const glib::ffi::GList = frames;
let mut iter: *const glib_sys::GList = frames;
let mut vec = Vec::new(); let mut vec = Vec::new();
while !iter.is_null() { while !iter.is_null() {
@ -167,15 +164,14 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
iter = (*iter).next; iter = (*iter).next;
} }
glib_sys::g_list_free(frames); glib::ffi::g_list_free(frames);
vec vec
} }
} }
fn get_oldest_frame(&self) -> Option<VideoCodecFrame> { fn get_oldest_frame(&self) -> Option<VideoCodecFrame> {
let frame = unsafe { let frame =
gst_video_sys::gst_video_encoder_get_oldest_frame(self.as_ref().to_glib_none().0) unsafe { ffi::gst_video_encoder_get_oldest_frame(self.as_ref().to_glib_none().0) };
};
if frame.is_null() { if frame.is_null() {
None None
@ -185,9 +181,8 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
} }
fn get_output_state(&self) -> Option<VideoCodecState<'static, Readable>> { fn get_output_state(&self) -> Option<VideoCodecState<'static, Readable>> {
let state = unsafe { let state =
gst_video_sys::gst_video_encoder_get_output_state(self.as_ref().to_glib_none().0) unsafe { ffi::gst_video_encoder_get_output_state(self.as_ref().to_glib_none().0) };
};
if state.is_null() { if state.is_null() {
None None
@ -206,7 +201,7 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
Some(reference) => reference.as_mut_ptr(), Some(reference) => reference.as_mut_ptr(),
None => ptr::null_mut(), None => ptr::null_mut(),
}; };
gst_video_sys::gst_video_encoder_set_output_state( ffi::gst_video_encoder_set_output_state(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
caps.into_ptr(), caps.into_ptr(),
reference, reference,
@ -225,11 +220,11 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
output_state: VideoCodecState<'a, InNegotiation<'a>>, output_state: VideoCodecState<'a, InNegotiation<'a>>,
) -> Result<(), gst::FlowError> { ) -> Result<(), gst::FlowError> {
// Consume output_state so user won't be able to modify it anymore // Consume output_state so user won't be able to modify it anymore
let self_ptr = self.to_glib_none().0 as *const gst_sys::GstElement; let self_ptr = self.to_glib_none().0 as *const gst::ffi::GstElement;
assert_eq!(output_state.context.get_element_as_ptr(), self_ptr); assert_eq!(output_state.context.get_element_as_ptr(), self_ptr);
let ret = unsafe { let ret = unsafe {
from_glib(gst_video_sys::gst_video_encoder_negotiate( from_glib(ffi::gst_video_encoder_negotiate(
self.as_ref().to_glib_none().0, self.as_ref().to_glib_none().0,
)) ))
}; };
@ -242,13 +237,13 @@ impl<O: IsA<VideoEncoder>> VideoEncoderExtManual for O {
} }
impl HasStreamLock for VideoEncoder { impl HasStreamLock for VideoEncoder {
fn get_stream_lock(&self) -> *mut glib_sys::GRecMutex { fn get_stream_lock(&self) -> *mut glib::ffi::GRecMutex {
let encoder_sys: *const gstreamer_video_sys::GstVideoEncoder = self.to_glib_none().0; let encoder_sys: *const ffi::GstVideoEncoder = self.to_glib_none().0;
unsafe { &(*encoder_sys).stream_lock as *const _ as usize as *mut _ } unsafe { &(*encoder_sys).stream_lock as *const _ as usize as *mut _ }
} }
fn get_element_as_ptr(&self) -> *const gst_sys::GstElement { fn get_element_as_ptr(&self) -> *const gst::ffi::GstElement {
let encoder_sys: *const gstreamer_video_sys::GstVideoEncoder = self.to_glib_none().0; let encoder_sys: *const ffi::GstVideoEncoder = self.to_glib_none().0;
encoder_sys as *const gst_sys::GstElement encoder_sys as *const gst::ffi::GstElement
} }
} }

66
gstreamer-video/src/video_event.rs
View file

@ -6,12 +6,8 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use gst_sys;
use gst_video_sys;
use glib::translate::{from_glib, from_glib_full, ToGlib}; use glib::translate::{from_glib, from_glib_full, ToGlib};
use glib::ToSendValue; use glib::ToSendValue;
use gst;
use std::mem; use std::mem;
// FIXME: Copy from gstreamer/src/event.rs // FIXME: Copy from gstreamer/src/event.rs
@ -48,16 +44,16 @@ macro_rules! event_builder_generic_impl {
unsafe { unsafe {
let event = $new_fn(&mut self); let event = $new_fn(&mut self);
if let Some(seqnum) = self.seqnum { if let Some(seqnum) = self.seqnum {
gst_sys::gst_event_set_seqnum(event, seqnum.to_glib()); gst::ffi::gst_event_set_seqnum(event, seqnum.to_glib());
} }
if let Some(running_time_offset) = self.running_time_offset { if let Some(running_time_offset) = self.running_time_offset {
gst_sys::gst_event_set_running_time_offset(event, running_time_offset); gst::ffi::gst_event_set_running_time_offset(event, running_time_offset);
} }
{ {
let s = gst::StructureRef::from_glib_borrow_mut( let s = gst::StructureRef::from_glib_borrow_mut(
gst_sys::gst_event_writable_structure(event), gst::ffi::gst_event_writable_structure(event),
); );
for (k, v) in self.other_fields { for (k, v) in self.other_fields {
@ -127,7 +123,7 @@ impl<'a> DownstreamForceKeyUnitEventBuilder<'a> {
} }
event_builder_generic_impl!(|s: &mut Self| { event_builder_generic_impl!(|s: &mut Self| {
gst_video_sys::gst_video_event_new_downstream_force_key_unit( ffi::gst_video_event_new_downstream_force_key_unit(
s.timestamp.to_glib(), s.timestamp.to_glib(),
s.stream_time.to_glib(), s.stream_time.to_glib(),
s.running_time.to_glib(), s.running_time.to_glib(),
@ -162,16 +158,14 @@ impl DownstreamForceKeyUnitEvent {
let mut all_headers = mem::MaybeUninit::uninit(); let mut all_headers = mem::MaybeUninit::uninit();
let mut count = mem::MaybeUninit::uninit(); let mut count = mem::MaybeUninit::uninit();
let res: bool = from_glib( let res: bool = from_glib(ffi::gst_video_event_parse_downstream_force_key_unit(
gst_video_sys::gst_video_event_parse_downstream_force_key_unit( event.as_mut_ptr(),
event.as_mut_ptr(), timestamp.as_mut_ptr(),
timestamp.as_mut_ptr(), stream_time.as_mut_ptr(),
stream_time.as_mut_ptr(), running_time.as_mut_ptr(),
running_time.as_mut_ptr(), all_headers.as_mut_ptr(),
all_headers.as_mut_ptr(), count.as_mut_ptr(),
count.as_mut_ptr(), ));
),
);
if res { if res {
Ok(DownstreamForceKeyUnitEvent { Ok(DownstreamForceKeyUnitEvent {
timestamp: from_glib(timestamp.assume_init()), timestamp: from_glib(timestamp.assume_init()),
@ -181,7 +175,7 @@ impl DownstreamForceKeyUnitEvent {
count: count.assume_init(), count: count.assume_init(),
}) })
} else { } else {
Err(glib_bool_error!("Failed to parse GstEvent")) Err(glib::glib_bool_error!("Failed to parse GstEvent"))
} }
} }
} }
@ -228,7 +222,7 @@ impl<'a> UpstreamForceKeyUnitEventBuilder<'a> {
} }
event_builder_generic_impl!(|s: &mut Self| { event_builder_generic_impl!(|s: &mut Self| {
gst_video_sys::gst_video_event_new_upstream_force_key_unit( ffi::gst_video_event_new_upstream_force_key_unit(
s.running_time.to_glib(), s.running_time.to_glib(),
s.all_headers.to_glib(), s.all_headers.to_glib(),
s.count, s.count,
@ -257,14 +251,12 @@ impl UpstreamForceKeyUnitEvent {
let mut all_headers = mem::MaybeUninit::uninit(); let mut all_headers = mem::MaybeUninit::uninit();
let mut count = mem::MaybeUninit::uninit(); let mut count = mem::MaybeUninit::uninit();
let res: bool = from_glib( let res: bool = from_glib(ffi::gst_video_event_parse_upstream_force_key_unit(
gst_video_sys::gst_video_event_parse_upstream_force_key_unit( event.as_mut_ptr(),
event.as_mut_ptr(), running_time.as_mut_ptr(),
running_time.as_mut_ptr(), all_headers.as_mut_ptr(),
all_headers.as_mut_ptr(), count.as_mut_ptr(),
count.as_mut_ptr(), ));
),
);
if res { if res {
Ok(UpstreamForceKeyUnitEvent { Ok(UpstreamForceKeyUnitEvent {
running_time: from_glib(running_time.assume_init()), running_time: from_glib(running_time.assume_init()),
@ -272,7 +264,7 @@ impl UpstreamForceKeyUnitEvent {
count: count.assume_init(), count: count.assume_init(),
}) })
} else { } else {
Err(glib_bool_error!("Failed to parse GstEvent")) Err(glib::glib_bool_error!("Failed to parse GstEvent"))
} }
} }
} }
@ -287,11 +279,7 @@ pub enum ForceKeyUnitEvent {
impl ForceKeyUnitEvent { impl ForceKeyUnitEvent {
pub fn is(event: &gst::EventRef) -> bool { pub fn is(event: &gst::EventRef) -> bool {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe { from_glib(ffi::gst_video_event_is_force_key_unit(event.as_mut_ptr())) }
from_glib(gst_video_sys::gst_video_event_is_force_key_unit(
event.as_mut_ptr(),
))
}
} }
pub fn parse(event: &gst::EventRef) -> Result<ForceKeyUnitEvent, glib::error::BoolError> { pub fn parse(event: &gst::EventRef) -> Result<ForceKeyUnitEvent, glib::error::BoolError> {
@ -322,9 +310,9 @@ impl<'a> StillFrameEventBuilder<'a> {
} }
} }
event_builder_generic_impl!( event_builder_generic_impl!(|s: &mut Self| ffi::gst_video_event_new_still_frame(
|s: &mut Self| gst_video_sys::gst_video_event_new_still_frame(s.in_still.to_glib()) s.in_still.to_glib()
); ));
} }
#[derive(Clone, PartialEq, Eq, Debug)] #[derive(Clone, PartialEq, Eq, Debug)]
@ -343,7 +331,7 @@ impl StillFrameEvent {
unsafe { unsafe {
let mut in_still = mem::MaybeUninit::uninit(); let mut in_still = mem::MaybeUninit::uninit();
let res: bool = from_glib(gst_video_sys::gst_video_event_parse_still_frame( let res: bool = from_glib(ffi::gst_video_event_parse_still_frame(
event.as_mut_ptr(), event.as_mut_ptr(),
in_still.as_mut_ptr(), in_still.as_mut_ptr(),
)); ));
@ -352,7 +340,7 @@ impl StillFrameEvent {
in_still: from_glib(in_still.assume_init()), in_still: from_glib(in_still.assume_init()),
}) })
} else { } else {
Err(glib_bool_error!("Invalid still-frame event")) Err(glib::glib_bool_error!("Invalid still-frame event"))
} }
} }
} }

439
gstreamer-video/src/video_format.rs
View file

@ -6,8 +6,6 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use gst_video_sys;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use std::ffi::CStr; use std::ffi::CStr;
use std::fmt; use std::fmt;
@ -16,10 +14,10 @@ use std::str;
use glib::translate::{from_glib, FromGlib, ToGlib, ToGlibPtr}; use glib::translate::{from_glib, FromGlib, ToGlib, ToGlibPtr};
#[cfg(feature = "v1_18")] #[cfg(feature = "v1_18")]
pub static VIDEO_FORMATS_ALL: Lazy<Box<[::VideoFormat]>> = Lazy::new(|| unsafe { pub static VIDEO_FORMATS_ALL: Lazy<Box<[crate::VideoFormat]>> = Lazy::new(|| unsafe {
let mut len: u32 = 0; let mut len: u32 = 0;
let mut res = Vec::with_capacity(len as usize); let mut res = Vec::with_capacity(len as usize);
let formats = gst_video_sys::gst_video_formats_raw(&mut len); let formats = ffi::gst_video_formats_raw(&mut len);
for i in 0..len { for i in 0..len {
let format = formats.offset(i as isize); let format = formats.offset(i as isize);
res.push(from_glib(*format)); res.push(from_glib(*format));
@ -28,233 +26,233 @@ pub static VIDEO_FORMATS_ALL: Lazy<Box<[::VideoFormat]>> = Lazy::new(|| unsafe {
}); });
#[cfg(not(feature = "v1_18"))] #[cfg(not(feature = "v1_18"))]
pub static VIDEO_FORMATS_ALL: Lazy<Box<[::VideoFormat]>> = Lazy::new(|| { pub static VIDEO_FORMATS_ALL: Lazy<Box<[crate::VideoFormat]>> = Lazy::new(|| {
#[cfg(target_endian = "little")] #[cfg(target_endian = "little")]
{ {
Box::new([ Box::new([
::VideoFormat::Ayuv64, crate::VideoFormat::Ayuv64,
::VideoFormat::Argb64, crate::VideoFormat::Argb64,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra12le, crate::VideoFormat::Gbra12le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra12be, crate::VideoFormat::Gbra12be,
::VideoFormat::A44410le, crate::VideoFormat::A44410le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra10le, crate::VideoFormat::Gbra10le,
::VideoFormat::A44410be, crate::VideoFormat::A44410be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra10be, crate::VideoFormat::Gbra10be,
::VideoFormat::A42210le, crate::VideoFormat::A42210le,
::VideoFormat::A42210be, crate::VideoFormat::A42210be,
::VideoFormat::A42010le, crate::VideoFormat::A42010le,
::VideoFormat::A42010be, crate::VideoFormat::A42010be,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Bgr10a2Le, crate::VideoFormat::Bgr10a2Le,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Y410, crate::VideoFormat::Y410,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra, crate::VideoFormat::Gbra,
::VideoFormat::Abgr, crate::VideoFormat::Abgr,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Vuya, crate::VideoFormat::Vuya,
::VideoFormat::Bgra, crate::VideoFormat::Bgra,
::VideoFormat::Ayuv, crate::VideoFormat::Ayuv,
::VideoFormat::Argb, crate::VideoFormat::Argb,
::VideoFormat::Rgba, crate::VideoFormat::Rgba,
::VideoFormat::A420, crate::VideoFormat::A420,
::VideoFormat::V216, crate::VideoFormat::V216,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Y44412le, crate::VideoFormat::Y44412le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbr12le, crate::VideoFormat::Gbr12le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Y44412be, crate::VideoFormat::Y44412be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbr12be, crate::VideoFormat::Gbr12be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42212le, crate::VideoFormat::I42212le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42212be, crate::VideoFormat::I42212be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42012le, crate::VideoFormat::I42012le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42012be, crate::VideoFormat::I42012be,
::VideoFormat::Y44410le, crate::VideoFormat::Y44410le,
::VideoFormat::Gbr10le, crate::VideoFormat::Gbr10le,
::VideoFormat::Y44410be, crate::VideoFormat::Y44410be,
::VideoFormat::Gbr10be, crate::VideoFormat::Gbr10be,
::VideoFormat::R210, crate::VideoFormat::R210,
::VideoFormat::I42210le, crate::VideoFormat::I42210le,
::VideoFormat::I42210be, crate::VideoFormat::I42210be,
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
::VideoFormat::Nv1610le32, crate::VideoFormat::Nv1610le32,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Y210, crate::VideoFormat::Y210,
::VideoFormat::V210, crate::VideoFormat::V210,
::VideoFormat::Uyvp, crate::VideoFormat::Uyvp,
::VideoFormat::I42010le, crate::VideoFormat::I42010le,
::VideoFormat::I42010be, crate::VideoFormat::I42010be,
#[cfg(feature = "v1_10")] #[cfg(feature = "v1_10")]
::VideoFormat::P01010le, crate::VideoFormat::P01010le,
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
::VideoFormat::Nv1210le32, crate::VideoFormat::Nv1210le32,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Nv1210le40, crate::VideoFormat::Nv1210le40,
#[cfg(feature = "v1_10")] #[cfg(feature = "v1_10")]
::VideoFormat::P01010be, crate::VideoFormat::P01010be,
::VideoFormat::Y444, crate::VideoFormat::Y444,
::VideoFormat::Gbr, crate::VideoFormat::Gbr,
::VideoFormat::Nv24, crate::VideoFormat::Nv24,
::VideoFormat::Xbgr, crate::VideoFormat::Xbgr,
::VideoFormat::Bgrx, crate::VideoFormat::Bgrx,
::VideoFormat::Xrgb, crate::VideoFormat::Xrgb,
::VideoFormat::Rgbx, crate::VideoFormat::Rgbx,
::VideoFormat::Bgr, crate::VideoFormat::Bgr,
#[cfg(feature = "v1_10")] #[cfg(feature = "v1_10")]
::VideoFormat::Iyu2, crate::VideoFormat::Iyu2,
::VideoFormat::V308, crate::VideoFormat::V308,
::VideoFormat::Rgb, crate::VideoFormat::Rgb,
::VideoFormat::Y42b, crate::VideoFormat::Y42b,
::VideoFormat::Nv61, crate::VideoFormat::Nv61,
::VideoFormat::Nv16, crate::VideoFormat::Nv16,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Vyuy, crate::VideoFormat::Vyuy,
::VideoFormat::Uyvy, crate::VideoFormat::Uyvy,
::VideoFormat::Yvyu, crate::VideoFormat::Yvyu,
::VideoFormat::Yuy2, crate::VideoFormat::Yuy2,
::VideoFormat::I420, crate::VideoFormat::I420,
::VideoFormat::Yv12, crate::VideoFormat::Yv12,
::VideoFormat::Nv21, crate::VideoFormat::Nv21,
::VideoFormat::Nv12, crate::VideoFormat::Nv12,
::VideoFormat::Nv1264z32, crate::VideoFormat::Nv1264z32,
::VideoFormat::Y41b, crate::VideoFormat::Y41b,
::VideoFormat::Iyu1, crate::VideoFormat::Iyu1,
::VideoFormat::Yvu9, crate::VideoFormat::Yvu9,
::VideoFormat::Yuv9, crate::VideoFormat::Yuv9,
::VideoFormat::Rgb16, crate::VideoFormat::Rgb16,
::VideoFormat::Bgr16, crate::VideoFormat::Bgr16,
::VideoFormat::Rgb15, crate::VideoFormat::Rgb15,
::VideoFormat::Bgr15, crate::VideoFormat::Bgr15,
::VideoFormat::Rgb8p, crate::VideoFormat::Rgb8p,
::VideoFormat::Gray16Le, crate::VideoFormat::Gray16Le,
::VideoFormat::Gray16Be, crate::VideoFormat::Gray16Be,
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
::VideoFormat::Gray10Le32, crate::VideoFormat::Gray10Le32,
::VideoFormat::Gray8, crate::VideoFormat::Gray8,
]) ])
} }
#[cfg(target_endian = "big")] #[cfg(target_endian = "big")]
{ {
Box::new([ Box::new([
::VideoFormat::Ayuv64, crate::VideoFormat::Ayuv64,
::VideoFormat::Argb64, crate::VideoFormat::Argb64,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra12be, crate::VideoFormat::Gbra12be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra12le, crate::VideoFormat::Gbra12le,
::VideoFormat::A44410be, crate::VideoFormat::A44410be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra10be, crate::VideoFormat::Gbra10be,
::VideoFormat::A44410le, crate::VideoFormat::A44410le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra10le, crate::VideoFormat::Gbra10le,
::VideoFormat::A42210be, crate::VideoFormat::A42210be,
::VideoFormat::A42210le, crate::VideoFormat::A42210le,
::VideoFormat::A42010be, crate::VideoFormat::A42010be,
::VideoFormat::A42010le, crate::VideoFormat::A42010le,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Y410, crate::VideoFormat::Y410,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Bgr10a2Le, crate::VideoFormat::Bgr10a2Le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbra, crate::VideoFormat::Gbra,
::VideoFormat::Abgr, crate::VideoFormat::Abgr,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Vuya, crate::VideoFormat::Vuya,
::VideoFormat::Bgra, crate::VideoFormat::Bgra,
::VideoFormat::Ayuv, crate::VideoFormat::Ayuv,
::VideoFormat::Argb, crate::VideoFormat::Argb,
::VideoFormat::Rgba, crate::VideoFormat::Rgba,
::VideoFormat::A420, crate::VideoFormat::A420,
::VideoFormat::V216, crate::VideoFormat::V216,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Y44412be, crate::VideoFormat::Y44412be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbr12be, crate::VideoFormat::Gbr12be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Y44412le, crate::VideoFormat::Y44412le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Gbr12le, crate::VideoFormat::Gbr12le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42212be, crate::VideoFormat::I42212be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42212le, crate::VideoFormat::I42212le,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42012be, crate::VideoFormat::I42012be,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::I42012le, crate::VideoFormat::I42012le,
::VideoFormat::Y44410be, crate::VideoFormat::Y44410be,
::VideoFormat::Gbr10be, crate::VideoFormat::Gbr10be,
::VideoFormat::Y44410le, crate::VideoFormat::Y44410le,
::VideoFormat::Gbr10le, crate::VideoFormat::Gbr10le,
::VideoFormat::R210, crate::VideoFormat::R210,
::VideoFormat::I42210be, crate::VideoFormat::I42210be,
::VideoFormat::I42210le, crate::VideoFormat::I42210le,
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
::VideoFormat::Nv1610le32, crate::VideoFormat::Nv1610le32,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Y210, crate::VideoFormat::Y210,
::VideoFormat::V210, crate::VideoFormat::V210,
::VideoFormat::Uyvp, crate::VideoFormat::Uyvp,
::VideoFormat::I42010be, crate::VideoFormat::I42010be,
::VideoFormat::I42010le, crate::VideoFormat::I42010le,
#[cfg(feature = "v1_10")] #[cfg(feature = "v1_10")]
::VideoFormat::P01010be, crate::VideoFormat::P01010be,
#[cfg(feature = "v1_10")] #[cfg(feature = "v1_10")]
::VideoFormat::P01010le, crate::VideoFormat::P01010le,
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
::VideoFormat::Nv1210le32, crate::VideoFormat::Nv1210le32,
#[cfg(feature = "v1_16")] #[cfg(feature = "v1_16")]
::VideoFormat::Nv1210le40, crate::VideoFormat::Nv1210le40,
::VideoFormat::Y444, crate::VideoFormat::Y444,
::VideoFormat::Gbr, crate::VideoFormat::Gbr,
::VideoFormat::Nv24, crate::VideoFormat::Nv24,
::VideoFormat::Xbgr, crate::VideoFormat::Xbgr,
::VideoFormat::Bgrx, crate::VideoFormat::Bgrx,
::VideoFormat::Xrgb, crate::VideoFormat::Xrgb,
::VideoFormat::Rgbx, crate::VideoFormat::Rgbx,
::VideoFormat::Bgr, crate::VideoFormat::Bgr,
#[cfg(feature = "v1_10")] #[cfg(feature = "v1_10")]
::VideoFormat::Iyu2, crate::VideoFormat::Iyu2,
::VideoFormat::V308, crate::VideoFormat::V308,
::VideoFormat::Rgb, crate::VideoFormat::Rgb,
::VideoFormat::Y42b, crate::VideoFormat::Y42b,
::VideoFormat::Nv61, crate::VideoFormat::Nv61,
::VideoFormat::Nv16, crate::VideoFormat::Nv16,
#[cfg(feature = "v1_12")] #[cfg(feature = "v1_12")]
::VideoFormat::Vyuy, crate::VideoFormat::Vyuy,
::VideoFormat::Uyvy, crate::VideoFormat::Uyvy,
::VideoFormat::Yvyu, crate::VideoFormat::Yvyu,
::VideoFormat::Yuy2, crate::VideoFormat::Yuy2,
::VideoFormat::I420, crate::VideoFormat::I420,
::VideoFormat::Yv12, crate::VideoFormat::Yv12,
::VideoFormat::Nv21, crate::VideoFormat::Nv21,
::VideoFormat::Nv12, crate::VideoFormat::Nv12,
::VideoFormat::Nv1264z32, crate::VideoFormat::Nv1264z32,
::VideoFormat::Y41b, crate::VideoFormat::Y41b,
::VideoFormat::Iyu1, crate::VideoFormat::Iyu1,
::VideoFormat::Yvu9, crate::VideoFormat::Yvu9,
::VideoFormat::Yuv9, crate::VideoFormat::Yuv9,
::VideoFormat::Rgb16, crate::VideoFormat::Rgb16,
::VideoFormat::Bgr16, crate::VideoFormat::Bgr16,
::VideoFormat::Rgb15, crate::VideoFormat::Rgb15,
::VideoFormat::Bgr15, crate::VideoFormat::Bgr15,
::VideoFormat::Rgb8p, crate::VideoFormat::Rgb8p,
::VideoFormat::Gray16Be, crate::VideoFormat::Gray16Be,
::VideoFormat::Gray16Le, crate::VideoFormat::Gray16Le,
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
::VideoFormat::Gray10Le32, crate::VideoFormat::Gray10Le32,
::VideoFormat::Gray8, crate::VideoFormat::Gray8,
]) ])
} }
}); });
@ -290,26 +288,26 @@ impl ToGlib for VideoEndianness {
} }
} }
impl ::VideoFormat { impl crate::VideoFormat {
pub fn from_fourcc(fourcc: u32) -> ::VideoFormat { pub fn from_fourcc(fourcc: u32) -> crate::VideoFormat {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { from_glib(gst_video_sys::gst_video_format_from_fourcc(fourcc)) } unsafe { from_glib(ffi::gst_video_format_from_fourcc(fourcc)) }
} }
pub fn from_masks( pub fn from_masks(
depth: u32, depth: u32,
bpp: u32, bpp: u32,
endianness: ::VideoEndianness, endianness: crate::VideoEndianness,
red_mask: u32, red_mask: u32,
blue_mask: u32, blue_mask: u32,
green_mask: u32, green_mask: u32,
alpha_mask: u32, alpha_mask: u32,
) -> ::VideoFormat { ) -> crate::VideoFormat {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib(gst_video_sys::gst_video_format_from_masks( from_glib(ffi::gst_video_format_from_masks(
depth as i32, depth as i32,
bpp as i32, bpp as i32,
endianness.to_glib(), endianness.to_glib(),
@ -322,12 +320,12 @@ impl ::VideoFormat {
} }
pub fn to_str<'a>(self) -> &'a str { pub fn to_str<'a>(self) -> &'a str {
if self == ::VideoFormat::Unknown { if self == crate::VideoFormat::Unknown {
return "UNKNOWN"; return "UNKNOWN";
} }
unsafe { unsafe {
CStr::from_ptr(gst_video_sys::gst_video_format_to_string(self.to_glib())) CStr::from_ptr(ffi::gst_video_format_to_string(self.to_glib()))
.to_str() .to_str()
.unwrap() .unwrap()
} }
@ -338,19 +336,21 @@ impl ::VideoFormat {
} }
} }
impl str::FromStr for ::VideoFormat { impl str::FromStr for crate::VideoFormat {
type Err = glib::BoolError; type Err = glib::BoolError;
fn from_str(s: &str) -> Result<Self, glib::BoolError> { fn from_str(s: &str) -> Result<Self, glib::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let fmt = ::VideoFormat::from_glib(gst_video_sys::gst_video_format_from_string( let fmt = crate::VideoFormat::from_glib(ffi::gst_video_format_from_string(
s.to_glib_none().0, s.to_glib_none().0,
)); ));
if fmt == ::VideoFormat::Unknown { if fmt == crate::VideoFormat::Unknown {
Err(glib_bool_error!("Failed to parse video format from string")) Err(glib::glib_bool_error!(
"Failed to parse video format from string"
))
} else { } else {
Ok(fmt) Ok(fmt)
} }
@ -358,21 +358,22 @@ impl str::FromStr for ::VideoFormat {
} }
} }
impl fmt::Display for ::VideoFormat { impl fmt::Display for crate::VideoFormat {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.write_str((*self).to_str()) f.write_str((*self).to_str())
} }
} }
impl PartialOrd for ::VideoFormat { impl PartialOrd for crate::VideoFormat {
fn partial_cmp(&self, other: &::VideoFormat) -> Option<std::cmp::Ordering> { fn partial_cmp(&self, other: &crate::VideoFormat) -> Option<std::cmp::Ordering> {
::VideoFormatInfo::from_format(*self).partial_cmp(&::VideoFormatInfo::from_format(*other)) crate::VideoFormatInfo::from_format(*self)
.partial_cmp(&crate::VideoFormatInfo::from_format(*other))
} }
} }
impl Ord for ::VideoFormat { impl Ord for crate::VideoFormat {
fn cmp(&self, other: &::VideoFormat) -> std::cmp::Ordering { fn cmp(&self, other: &crate::VideoFormat) -> std::cmp::Ordering {
::VideoFormatInfo::from_format(*self).cmp(&::VideoFormatInfo::from_format(*other)) crate::VideoFormatInfo::from_format(*self).cmp(&crate::VideoFormatInfo::from_format(*other))
} }
} }
@ -391,7 +392,7 @@ impl Default for VideoFormatIterator {
} }
impl Iterator for VideoFormatIterator { impl Iterator for VideoFormatIterator {
type Item = ::VideoFormat; type Item = crate::VideoFormat;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
if self.idx >= self.len { if self.idx >= self.len {
@ -433,12 +434,12 @@ pub trait VideoFormatIteratorExt {
impl<T> VideoFormatIteratorExt for T impl<T> VideoFormatIteratorExt for T
where where
T: Iterator<Item = ::VideoFormat>, T: Iterator<Item = crate::VideoFormat>,
{ {
fn into_video_caps(self) -> Option<gst::caps::Builder<gst::caps::NoFeature>> { fn into_video_caps(self) -> Option<gst::caps::Builder<gst::caps::NoFeature>> {
let formats: Vec<::VideoFormat> = self.collect(); let formats: Vec<crate::VideoFormat> = self.collect();
if !formats.is_empty() { if !formats.is_empty() {
Some(::functions::video_make_raw_caps(&formats)) Some(crate::functions::video_make_raw_caps(&formats))
} else { } else {
None None
} }
@ -451,12 +452,12 @@ pub trait VideoFormatIteratorExtRef {
impl<'a, T> VideoFormatIteratorExtRef for T impl<'a, T> VideoFormatIteratorExtRef for T
where where
T: Iterator<Item = &'a ::VideoFormat>, T: Iterator<Item = &'a crate::VideoFormat>,
{ {
fn into_video_caps(self) -> Option<gst::caps::Builder<gst::caps::NoFeature>> { fn into_video_caps(self) -> Option<gst::caps::Builder<gst::caps::NoFeature>> {
let formats: Vec<::VideoFormat> = self.copied().collect(); let formats: Vec<crate::VideoFormat> = self.copied().collect();
if !formats.is_empty() { if !formats.is_empty() {
Some(::functions::video_make_raw_caps(&formats)) Some(crate::functions::video_make_raw_caps(&formats))
} else { } else {
None None
} }
@ -465,13 +466,12 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use gst;
#[test] #[test]
fn test_display() { fn test_display() {
gst::init().unwrap(); gst::init().unwrap();
format!("{}", ::VideoFormat::Nv16); format!("{}", crate::VideoFormat::Nv16);
} }
#[test] #[test]
@ -479,13 +479,13 @@ mod tests {
use super::*; use super::*;
gst::init().unwrap(); gst::init().unwrap();
assert!(::VideoFormat::iter_raw().count() > 0); assert!(crate::VideoFormat::iter_raw().count() > 0);
assert_eq!( assert_eq!(
::VideoFormat::iter_raw().count(), crate::VideoFormat::iter_raw().count(),
::VideoFormat::iter_raw().len() crate::VideoFormat::iter_raw().len()
); );
let mut i = ::VideoFormat::iter_raw(); let mut i = crate::VideoFormat::iter_raw();
let mut count = 0; let mut count = 0;
loop { loop {
if i.next().is_none() { if i.next().is_none() {
@ -497,25 +497,25 @@ mod tests {
} }
count += 1; count += 1;
} }
assert_eq!(count, ::VideoFormat::iter_raw().len()); assert_eq!(count, crate::VideoFormat::iter_raw().len());
assert!(::VideoFormat::iter_raw().any(|f| f == ::VideoFormat::Nv12)); assert!(crate::VideoFormat::iter_raw().any(|f| f == crate::VideoFormat::Nv12));
assert!(::VideoFormat::iter_raw() assert!(crate::VideoFormat::iter_raw()
.find(|f| *f == ::VideoFormat::Encoded) .find(|f| *f == crate::VideoFormat::Encoded)
.is_none()); .is_none());
let caps = ::VideoFormat::iter_raw().into_video_caps(); let caps = crate::VideoFormat::iter_raw().into_video_caps();
assert!(caps.is_some()); assert!(caps.is_some());
let caps = ::VideoFormat::iter_raw() let caps = crate::VideoFormat::iter_raw()
.filter(|f| ::VideoFormatInfo::from_format(*f).is_gray()) .filter(|f| crate::VideoFormatInfo::from_format(*f).is_gray())
.into_video_caps(); .into_video_caps();
assert!(caps.is_some()); assert!(caps.is_some());
let caps = ::VideoFormat::iter_raw().skip(1000).into_video_caps(); let caps = crate::VideoFormat::iter_raw().skip(1000).into_video_caps();
assert!(caps.is_none()); assert!(caps.is_none());
let caps = [::VideoFormat::Nv12, ::VideoFormat::Nv16] let caps = [crate::VideoFormat::Nv12, crate::VideoFormat::Nv16]
.iter() .iter()
.into_video_caps() .into_video_caps()
.unwrap() .unwrap()
@ -531,16 +531,17 @@ mod tests {
gst::init().unwrap(); gst::init().unwrap();
assert!( assert!(
::VideoFormatInfo::from_format(::VideoFormat::Nv16) crate::VideoFormatInfo::from_format(crate::VideoFormat::Nv16)
> ::VideoFormatInfo::from_format(::VideoFormat::Nv12) > crate::VideoFormatInfo::from_format(crate::VideoFormat::Nv12)
); );
assert!(::VideoFormat::I420 > ::VideoFormat::Yv12); assert!(crate::VideoFormat::I420 > crate::VideoFormat::Yv12);
let sorted: Vec<::VideoFormat> = ::VideoFormat::iter_raw().sorted().rev().collect(); let sorted: Vec<crate::VideoFormat> =
crate::VideoFormat::iter_raw().sorted().rev().collect();
// FIXME: use is_sorted_by() once API is in stable // FIXME: use is_sorted_by() once API is in stable
assert_eq!( assert_eq!(
sorted, sorted,
::VideoFormat::iter_raw().collect::<Vec<::VideoFormat>>() crate::VideoFormat::iter_raw().collect::<Vec<crate::VideoFormat>>()
); );
} }
} }

100
gstreamer-video/src/video_format_info.rs
View file

@ -6,31 +6,28 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use gst_video_sys;
use std::cmp::Ordering; use std::cmp::Ordering;
use std::ffi::CStr; use std::ffi::CStr;
use std::fmt; use std::fmt;
use std::str; use std::str;
use glib;
use glib::translate::{from_glib, ToGlib}; use glib::translate::{from_glib, ToGlib};
pub struct VideoFormatInfo(&'static gst_video_sys::GstVideoFormatInfo); pub struct VideoFormatInfo(&'static ffi::GstVideoFormatInfo);
impl VideoFormatInfo { impl VideoFormatInfo {
pub fn from_format(format: ::VideoFormat) -> VideoFormatInfo { pub fn from_format(format: crate::VideoFormat) -> VideoFormatInfo {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let info = gst_video_sys::gst_video_format_get_info(format.to_glib()); let info = ffi::gst_video_format_get_info(format.to_glib());
assert!(!info.is_null()); assert!(!info.is_null());
VideoFormatInfo(&*info) VideoFormatInfo(&*info)
} }
} }
pub fn format(&self) -> ::VideoFormat { pub fn format(&self) -> crate::VideoFormat {
from_glib(self.0.format) from_glib(self.0.format)
} }
@ -42,7 +39,7 @@ impl VideoFormatInfo {
unsafe { CStr::from_ptr(self.0.description).to_str().unwrap() } unsafe { CStr::from_ptr(self.0.description).to_str().unwrap() }
} }
pub fn flags(&self) -> ::VideoFormatFlags { pub fn flags(&self) -> crate::VideoFormatFlags {
from_glib(self.0.flags) from_glib(self.0.flags)
} }
@ -86,7 +83,7 @@ impl VideoFormatInfo {
&self.0.h_sub[0..(self.0.n_components as usize)] &self.0.h_sub[0..(self.0.n_components as usize)]
} }
pub fn tile_mode(&self) -> ::VideoTileMode { pub fn tile_mode(&self) -> crate::VideoTileMode {
from_glib(self.0.tile_mode) from_glib(self.0.tile_mode)
} }
@ -98,7 +95,7 @@ impl VideoFormatInfo {
self.0.tile_hs self.0.tile_hs
} }
pub fn unpack_format(&self) -> ::VideoFormat { pub fn unpack_format(&self) -> crate::VideoFormat {
from_glib(self.0.unpack_format) from_glib(self.0.unpack_format)
} }
@ -107,35 +104,35 @@ impl VideoFormatInfo {
} }
pub fn has_alpha(&self) -> bool { pub fn has_alpha(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_ALPHA != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_ALPHA != 0
} }
pub fn has_palette(&self) -> bool { pub fn has_palette(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_PALETTE != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_PALETTE != 0
} }
pub fn is_complex(&self) -> bool { pub fn is_complex(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_COMPLEX != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_COMPLEX != 0
} }
pub fn is_gray(&self) -> bool { pub fn is_gray(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_GRAY != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_GRAY != 0
} }
pub fn is_le(&self) -> bool { pub fn is_le(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_LE != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_LE != 0
} }
pub fn is_rgb(&self) -> bool { pub fn is_rgb(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_RGB != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_RGB != 0
} }
pub fn is_tiled(&self) -> bool { pub fn is_tiled(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_TILED != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_TILED != 0
} }
pub fn is_yuv(&self) -> bool { pub fn is_yuv(&self) -> bool {
self.0.flags & gst_video_sys::GST_VIDEO_FORMAT_FLAG_YUV != 0 self.0.flags & ffi::GST_VIDEO_FORMAT_FLAG_YUV != 0
} }
pub fn scale_width(&self, component: u8, width: u32) -> u32 { pub fn scale_width(&self, component: u8, width: u32) -> u32 {
@ -149,7 +146,7 @@ impl VideoFormatInfo {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn unpack( pub fn unpack(
&self, &self,
flags: ::VideoPackFlags, flags: crate::VideoPackFlags,
dest: &mut [u8], dest: &mut [u8],
src: &[&[u8]], src: &[&[u8]],
stride: &[i32], stride: &[i32],
@ -203,8 +200,7 @@ impl VideoFormatInfo {
unsafe { unsafe {
use std::ptr; use std::ptr;
let mut src_ptr = let mut src_ptr = [ptr::null() as *const u8; ffi::GST_VIDEO_MAX_PLANES as usize];
[ptr::null() as *const u8; gst_video_sys::GST_VIDEO_MAX_PLANES as usize];
for plane in 0..(self.n_planes()) { for plane in 0..(self.n_planes()) {
src_ptr[plane as usize] = src[plane as usize].as_ptr(); src_ptr[plane as usize] = src[plane as usize].as_ptr();
} }
@ -225,12 +221,12 @@ impl VideoFormatInfo {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn pack( pub fn pack(
&self, &self,
flags: ::VideoPackFlags, flags: crate::VideoPackFlags,
src: &[u8], src: &[u8],
src_stride: i32, src_stride: i32,
dest: &mut [&mut [u8]], dest: &mut [&mut [u8]],
dest_stride: &[i32], dest_stride: &[i32],
chroma_site: ::VideoChromaSite, chroma_site: crate::VideoChromaSite,
y: i32, y: i32,
width: i32, width: i32,
) { ) {
@ -280,8 +276,7 @@ impl VideoFormatInfo {
unsafe { unsafe {
use std::ptr; use std::ptr;
let mut dest_ptr = let mut dest_ptr = [ptr::null_mut() as *mut u8; ffi::GST_VIDEO_MAX_PLANES as usize];
[ptr::null_mut() as *mut u8; gst_video_sys::GST_VIDEO_MAX_PLANES as usize];
for plane in 0..(self.n_planes()) { for plane in 0..(self.n_planes()) {
dest_ptr[plane as usize] = dest[plane as usize].as_mut_ptr(); dest_ptr[plane as usize] = dest[plane as usize].as_mut_ptr();
} }
@ -330,8 +325,8 @@ impl Ord for VideoFormatInfo {
.then_with(|| { .then_with(|| {
// Format using native endianess is considered as bigger // Format using native endianess is considered as bigger
match ( match (
self.flags().contains(::VideoFormatFlags::LE), self.flags().contains(crate::VideoFormatFlags::LE),
other.flags().contains(::VideoFormatFlags::LE), other.flags().contains(crate::VideoFormatFlags::LE),
) { ) {
(true, false) => { (true, false) => {
// a LE, b BE // a LE, b BE
@ -363,8 +358,8 @@ impl Ord for VideoFormatInfo {
.then_with(|| { .then_with(|| {
// Prefer non-complex formats // Prefer non-complex formats
match ( match (
self.flags().contains(::VideoFormatFlags::COMPLEX), self.flags().contains(crate::VideoFormatFlags::COMPLEX),
other.flags().contains(::VideoFormatFlags::COMPLEX), other.flags().contains(crate::VideoFormatFlags::COMPLEX),
) { ) {
(true, false) => Ordering::Less, (true, false) => Ordering::Less,
(false, true) => Ordering::Greater, (false, true) => Ordering::Greater,
@ -373,12 +368,12 @@ impl Ord for VideoFormatInfo {
}) })
.then_with(|| { .then_with(|| {
// tiebreaker: YUV > RGB // tiebreaker: YUV > RGB
if self.flags().contains(::VideoFormatFlags::RGB) if self.flags().contains(crate::VideoFormatFlags::RGB)
&& other.flags().contains(::VideoFormatFlags::YUV) && other.flags().contains(crate::VideoFormatFlags::YUV)
{ {
Ordering::Less Ordering::Less
} else if self.flags().contains(::VideoFormatFlags::YUV) } else if self.flags().contains(crate::VideoFormatFlags::YUV)
&& other.flags().contains(::VideoFormatFlags::RGB) && other.flags().contains(crate::VideoFormatFlags::RGB)
{ {
Ordering::Greater Ordering::Greater
} else { } else {
@ -389,8 +384,8 @@ impl Ord for VideoFormatInfo {
// Manual tiebreaker // Manual tiebreaker
match (self.format(), other.format()) { match (self.format(), other.format()) {
// I420 is more commonly used in GStreamer // I420 is more commonly used in GStreamer
(::VideoFormat::I420, ::VideoFormat::Yv12) => Ordering::Greater, (crate::VideoFormat::I420, crate::VideoFormat::Yv12) => Ordering::Greater,
(::VideoFormat::Yv12, ::VideoFormat::I420) => Ordering::Less, (crate::VideoFormat::Yv12, crate::VideoFormat::I420) => Ordering::Less,
_ => Ordering::Equal, _ => Ordering::Equal,
} }
}) })
@ -433,7 +428,7 @@ impl fmt::Display for VideoFormatInfo {
} }
} }
impl str::FromStr for ::VideoFormatInfo { impl str::FromStr for crate::VideoFormatInfo {
type Err = glib::BoolError; type Err = glib::BoolError;
fn from_str(s: &str) -> Result<Self, glib::BoolError> { fn from_str(s: &str) -> Result<Self, glib::BoolError> {
@ -443,8 +438,8 @@ impl str::FromStr for ::VideoFormatInfo {
} }
} }
impl From<::VideoFormat> for VideoFormatInfo { impl From<crate::VideoFormat> for VideoFormatInfo {
fn from(f: ::VideoFormat) -> Self { fn from(f: crate::VideoFormat) -> Self {
skip_assert_initialized!(); skip_assert_initialized!();
Self::from_format(f) Self::from_format(f)
} }
@ -452,30 +447,26 @@ impl From<::VideoFormat> for VideoFormatInfo {
#[doc(hidden)] #[doc(hidden)]
impl glib::translate::GlibPtrDefault for VideoFormatInfo { impl glib::translate::GlibPtrDefault for VideoFormatInfo {
type GlibType = *mut gst_video_sys::GstVideoFormatInfo; type GlibType = *mut ffi::GstVideoFormatInfo;
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> glib::translate::ToGlibPtr<'a, *const gst_video_sys::GstVideoFormatInfo> impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstVideoFormatInfo> for VideoFormatInfo {
for VideoFormatInfo
{
type Storage = &'a VideoFormatInfo; type Storage = &'a VideoFormatInfo;
fn to_glib_none( fn to_glib_none(&'a self) -> glib::translate::Stash<'a, *const ffi::GstVideoFormatInfo, Self> {
&'a self,
) -> glib::translate::Stash<'a, *const gst_video_sys::GstVideoFormatInfo, Self> {
glib::translate::Stash(self.0, self) glib::translate::Stash(self.0, self)
} }
fn to_glib_full(&self) -> *const gst_video_sys::GstVideoFormatInfo { fn to_glib_full(&self) -> *const ffi::GstVideoFormatInfo {
unimplemented!() unimplemented!()
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl glib::translate::FromGlibPtrNone<*mut gst_video_sys::GstVideoFormatInfo> for VideoFormatInfo { impl glib::translate::FromGlibPtrNone<*mut ffi::GstVideoFormatInfo> for VideoFormatInfo {
#[inline] #[inline]
unsafe fn from_glib_none(ptr: *mut gst_video_sys::GstVideoFormatInfo) -> Self { unsafe fn from_glib_none(ptr: *mut ffi::GstVideoFormatInfo) -> Self {
VideoFormatInfo(&*ptr) VideoFormatInfo(&*ptr)
} }
} }
@ -483,13 +474,12 @@ impl glib::translate::FromGlibPtrNone<*mut gst_video_sys::GstVideoFormatInfo> fo
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use gst;
#[test] #[test]
fn test_get() { fn test_get() {
gst::init().unwrap(); gst::init().unwrap();
let info = VideoFormatInfo::from_format(::VideoFormat::I420); let info = VideoFormatInfo::from_format(crate::VideoFormat::I420);
assert_eq!(info.name(), "I420"); assert_eq!(info.name(), "I420");
let other_info = "I420".parse().unwrap(); let other_info = "I420".parse().unwrap();
@ -511,10 +501,10 @@ mod tests {
// One line of 320 pixel I420 // One line of 320 pixel I420
let output = &mut [&mut [0; 320][..], &mut [0; 160][..], &mut [0; 160][..]]; let output = &mut [&mut [0; 320][..], &mut [0; 160][..], &mut [0; 160][..]];
let info = VideoFormatInfo::from_format(::VideoFormat::I420); let info = VideoFormatInfo::from_format(crate::VideoFormat::I420);
assert_eq!(info.unpack_format(), ::VideoFormat::Ayuv); assert_eq!(info.unpack_format(), crate::VideoFormat::Ayuv);
info.unpack( info.unpack(
::VideoPackFlags::empty(), crate::VideoPackFlags::empty(),
intermediate, intermediate,
input, input,
&[320, 160, 160][..], &[320, 160, 160][..],
@ -528,12 +518,12 @@ mod tests {
} }
info.pack( info.pack(
::VideoPackFlags::empty(), crate::VideoPackFlags::empty(),
&intermediate[..(4 * 320)], &intermediate[..(4 * 320)],
4 * 320, 4 * 320,
output, output,
&[320, 160, 160][..], &[320, 160, 160][..],
::VideoChromaSite::NONE, crate::VideoChromaSite::NONE,
0, 0,
320, 320,
); );

226
gstreamer-video/src/video_frame.rs
View file

@ -6,12 +6,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use gst_sys;
use gst_video_sys;
use glib;
use glib::translate::{from_glib, from_glib_none, Borrowed, ToGlibPtr}; use glib::translate::{from_glib, from_glib_none, Borrowed, ToGlibPtr};
use gst;
use std::fmt; use std::fmt;
use std::marker::PhantomData; use std::marker::PhantomData;
@ -24,9 +19,9 @@ pub enum Readable {}
pub enum Writable {} pub enum Writable {}
pub struct VideoFrame<T> { pub struct VideoFrame<T> {
frame: gst_video_sys::GstVideoFrame, frame: ffi::GstVideoFrame,
buffer: Option<gst::Buffer>, buffer: Option<gst::Buffer>,
info: ::VideoInfo, info: crate::VideoInfo,
phantom: PhantomData<T>, phantom: PhantomData<T>,
} }
@ -45,11 +40,11 @@ impl<T> fmt::Debug for VideoFrame<T> {
} }
impl<T> VideoFrame<T> { impl<T> VideoFrame<T> {
pub fn info(&self) -> &::VideoInfo { pub fn info(&self) -> &crate::VideoInfo {
&self.info &self.info
} }
pub fn flags(&self) -> ::VideoFrameFlags { pub fn flags(&self) -> crate::VideoFrameFlags {
from_glib(self.frame.flags) from_glib(self.frame.flags)
} }
@ -63,14 +58,11 @@ impl<T> VideoFrame<T> {
pub fn copy(&self, dest: &mut VideoFrame<Writable>) -> Result<(), glib::BoolError> { pub fn copy(&self, dest: &mut VideoFrame<Writable>) -> Result<(), glib::BoolError> {
unsafe { unsafe {
let res: bool = from_glib(gst_video_sys::gst_video_frame_copy( let res: bool = from_glib(ffi::gst_video_frame_copy(&mut dest.frame, &self.frame));
&mut dest.frame,
&self.frame,
));
if res { if res {
Ok(()) Ok(())
} else { } else {
Err(glib_bool_error!("Failed to copy video frame")) Err(glib::glib_bool_error!("Failed to copy video frame"))
} }
} }
} }
@ -83,7 +75,7 @@ impl<T> VideoFrame<T> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let res: bool = from_glib(gst_video_sys::gst_video_frame_copy_plane( let res: bool = from_glib(ffi::gst_video_frame_copy_plane(
&mut dest.frame, &mut dest.frame,
&self.frame, &self.frame,
plane, plane,
@ -91,16 +83,16 @@ impl<T> VideoFrame<T> {
if res { if res {
Ok(()) Ok(())
} else { } else {
Err(glib_bool_error!("Failed to copy video frame plane")) Err(glib::glib_bool_error!("Failed to copy video frame plane"))
} }
} }
} }
pub fn format(&self) -> ::VideoFormat { pub fn format(&self) -> crate::VideoFormat {
self.info().format() self.info().format()
} }
pub fn format_info(&self) -> ::VideoFormatInfo { pub fn format_info(&self) -> crate::VideoFormatInfo {
self.info().format_info() self.info().format_info()
} }
@ -117,19 +109,19 @@ impl<T> VideoFrame<T> {
} }
pub fn is_interlaced(&self) -> bool { pub fn is_interlaced(&self) -> bool {
self.flags().contains(::VideoFrameFlags::INTERLACED) self.flags().contains(crate::VideoFrameFlags::INTERLACED)
} }
pub fn is_tff(&self) -> bool { pub fn is_tff(&self) -> bool {
self.flags().contains(::VideoFrameFlags::TFF) self.flags().contains(crate::VideoFrameFlags::TFF)
} }
pub fn is_rff(&self) -> bool { pub fn is_rff(&self) -> bool {
self.flags().contains(::VideoFrameFlags::RFF) self.flags().contains(crate::VideoFrameFlags::RFF)
} }
pub fn is_onefield(&self) -> bool { pub fn is_onefield(&self) -> bool {
self.flags().contains(::VideoFrameFlags::ONEFIELD) self.flags().contains(crate::VideoFrameFlags::ONEFIELD)
} }
pub fn n_planes(&self) -> u32 { pub fn n_planes(&self) -> u32 {
@ -154,7 +146,9 @@ impl<T> VideoFrame<T> {
pub fn plane_data(&self, plane: u32) -> Result<&[u8], glib::BoolError> { pub fn plane_data(&self, plane: u32) -> Result<&[u8], glib::BoolError> {
if plane >= self.n_planes() { if plane >= self.n_planes() {
return Err(glib_bool_error!("Plane index higher than number of planes")); return Err(glib::glib_bool_error!(
"Plane index higher than number of planes"
));
} }
let format_info = self.format_info(); let format_info = self.format_info();
@ -182,8 +176,8 @@ impl<T> VideoFrame<T> {
} }
} }
pub unsafe fn from_glib_full(frame: gst_video_sys::GstVideoFrame) -> Self { pub unsafe fn from_glib_full(frame: ffi::GstVideoFrame) -> Self {
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
let buffer = gst::Buffer::from_glib_none(frame.buffer); let buffer = gst::Buffer::from_glib_none(frame.buffer);
VideoFrame { VideoFrame {
frame, frame,
@ -204,7 +198,7 @@ impl<T> VideoFrame<T> {
} }
} }
pub fn as_ptr(&self) -> *const gst_video_sys::GstVideoFrame { pub fn as_ptr(&self) -> *const ffi::GstVideoFrame {
&self.frame &self.frame
} }
} }
@ -212,7 +206,7 @@ impl<T> VideoFrame<T> {
impl<T> Drop for VideoFrame<T> { impl<T> Drop for VideoFrame<T> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gst_video_sys::gst_video_frame_unmap(&mut self.frame); ffi::gst_video_frame_unmap(&mut self.frame);
} }
} }
} }
@ -220,7 +214,7 @@ impl<T> Drop for VideoFrame<T> {
impl VideoFrame<Readable> { impl VideoFrame<Readable> {
pub fn from_buffer_readable( pub fn from_buffer_readable(
buffer: gst::Buffer, buffer: gst::Buffer,
info: &::VideoInfo, info: &crate::VideoInfo,
) -> Result<VideoFrame<Readable>, gst::Buffer> { ) -> Result<VideoFrame<Readable>, gst::Buffer> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -228,18 +222,18 @@ impl VideoFrame<Readable> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map( let res: bool = from_glib(ffi::gst_video_frame_map(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.to_glib_none().0, buffer.to_glib_none().0,
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst_sys::GST_MAP_READ, ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst::ffi::GST_MAP_READ,
)); ));
if !res { if !res {
Err(buffer) Err(buffer)
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrame { Ok(VideoFrame {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -253,7 +247,7 @@ impl VideoFrame<Readable> {
pub fn from_buffer_id_readable( pub fn from_buffer_id_readable(
buffer: gst::Buffer, buffer: gst::Buffer,
id: i32, id: i32,
info: &::VideoInfo, info: &crate::VideoInfo,
) -> Result<VideoFrame<Readable>, gst::Buffer> { ) -> Result<VideoFrame<Readable>, gst::Buffer> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -261,19 +255,19 @@ impl VideoFrame<Readable> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id( let res: bool = from_glib(ffi::gst_video_frame_map_id(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.to_glib_none().0, buffer.to_glib_none().0,
id, id,
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst_sys::GST_MAP_READ, ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst::ffi::GST_MAP_READ,
)); ));
if !res { if !res {
Err(buffer) Err(buffer)
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrame { Ok(VideoFrame {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -292,7 +286,7 @@ impl VideoFrame<Readable> {
impl VideoFrame<Writable> { impl VideoFrame<Writable> {
pub fn from_buffer_writable( pub fn from_buffer_writable(
buffer: gst::Buffer, buffer: gst::Buffer,
info: &::VideoInfo, info: &crate::VideoInfo,
) -> Result<VideoFrame<Writable>, gst::Buffer> { ) -> Result<VideoFrame<Writable>, gst::Buffer> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -300,20 +294,20 @@ impl VideoFrame<Writable> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map( let res: bool = from_glib(ffi::gst_video_frame_map(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.to_glib_none().0, buffer.to_glib_none().0,
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
| gst_sys::GST_MAP_READ | gst::ffi::GST_MAP_READ
| gst_sys::GST_MAP_WRITE, | gst::ffi::GST_MAP_WRITE,
)); ));
if !res { if !res {
Err(buffer) Err(buffer)
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrame { Ok(VideoFrame {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -327,7 +321,7 @@ impl VideoFrame<Writable> {
pub fn from_buffer_id_writable( pub fn from_buffer_id_writable(
buffer: gst::Buffer, buffer: gst::Buffer,
id: i32, id: i32,
info: &::VideoInfo, info: &crate::VideoInfo,
) -> Result<VideoFrame<Writable>, gst::Buffer> { ) -> Result<VideoFrame<Writable>, gst::Buffer> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -335,21 +329,21 @@ impl VideoFrame<Writable> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id( let res: bool = from_glib(ffi::gst_video_frame_map_id(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.to_glib_none().0, buffer.to_glib_none().0,
id, id,
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
| gst_sys::GST_MAP_READ | gst::ffi::GST_MAP_READ
| gst_sys::GST_MAP_WRITE, | gst::ffi::GST_MAP_WRITE,
)); ));
if !res { if !res {
Err(buffer) Err(buffer)
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrame { Ok(VideoFrame {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -366,7 +360,9 @@ impl VideoFrame<Writable> {
pub fn plane_data_mut(&mut self, plane: u32) -> Result<&mut [u8], glib::BoolError> { pub fn plane_data_mut(&mut self, plane: u32) -> Result<&mut [u8], glib::BoolError> {
if plane >= self.n_planes() { if plane >= self.n_planes() {
return Err(glib_bool_error!("Plane index higher than number of planes")); return Err(glib::glib_bool_error!(
"Plane index higher than number of planes"
));
} }
let format_info = self.format_info(); let format_info = self.format_info();
@ -405,25 +401,25 @@ impl VideoFrame<Writable> {
} }
} }
pub fn as_mut_ptr(&mut self) -> *mut gst_video_sys::GstVideoFrame { pub fn as_mut_ptr(&mut self) -> *mut ffi::GstVideoFrame {
&mut self.frame &mut self.frame
} }
} }
#[derive(Debug)] #[derive(Debug)]
pub struct VideoFrameRef<T> { pub struct VideoFrameRef<T> {
frame: gst_video_sys::GstVideoFrame, frame: ffi::GstVideoFrame,
buffer: Option<T>, buffer: Option<T>,
info: ::VideoInfo, info: crate::VideoInfo,
unmap: bool, unmap: bool,
} }
impl<T> VideoFrameRef<T> { impl<T> VideoFrameRef<T> {
pub fn info(&self) -> &::VideoInfo { pub fn info(&self) -> &crate::VideoInfo {
&self.info &self.info
} }
pub fn flags(&self) -> ::VideoFrameFlags { pub fn flags(&self) -> crate::VideoFrameFlags {
from_glib(self.frame.flags) from_glib(self.frame.flags)
} }
@ -436,14 +432,11 @@ impl<T> VideoFrameRef<T> {
dest: &mut VideoFrameRef<&mut gst::BufferRef>, dest: &mut VideoFrameRef<&mut gst::BufferRef>,
) -> Result<(), glib::BoolError> { ) -> Result<(), glib::BoolError> {
unsafe { unsafe {
let res: bool = from_glib(gst_video_sys::gst_video_frame_copy( let res: bool = from_glib(ffi::gst_video_frame_copy(&mut dest.frame, &self.frame));
&mut dest.frame,
&self.frame,
));
if res { if res {
Ok(()) Ok(())
} else { } else {
Err(glib_bool_error!("Failed to copy video frame")) Err(glib::glib_bool_error!("Failed to copy video frame"))
} }
} }
} }
@ -456,7 +449,7 @@ impl<T> VideoFrameRef<T> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let res: bool = from_glib(gst_video_sys::gst_video_frame_copy_plane( let res: bool = from_glib(ffi::gst_video_frame_copy_plane(
&mut dest.frame, &mut dest.frame,
&self.frame, &self.frame,
plane, plane,
@ -464,16 +457,16 @@ impl<T> VideoFrameRef<T> {
if res { if res {
Ok(()) Ok(())
} else { } else {
Err(glib_bool_error!("Failed to copy video frame plane")) Err(glib::glib_bool_error!("Failed to copy video frame plane"))
} }
} }
} }
pub fn format(&self) -> ::VideoFormat { pub fn format(&self) -> crate::VideoFormat {
self.info().format() self.info().format()
} }
pub fn format_info(&self) -> ::VideoFormatInfo { pub fn format_info(&self) -> crate::VideoFormatInfo {
self.info().format_info() self.info().format_info()
} }
@ -490,19 +483,19 @@ impl<T> VideoFrameRef<T> {
} }
pub fn is_interlaced(&self) -> bool { pub fn is_interlaced(&self) -> bool {
self.flags().contains(::VideoFrameFlags::INTERLACED) self.flags().contains(crate::VideoFrameFlags::INTERLACED)
} }
pub fn is_tff(&self) -> bool { pub fn is_tff(&self) -> bool {
self.flags().contains(::VideoFrameFlags::TFF) self.flags().contains(crate::VideoFrameFlags::TFF)
} }
pub fn is_rff(&self) -> bool { pub fn is_rff(&self) -> bool {
self.flags().contains(::VideoFrameFlags::RFF) self.flags().contains(crate::VideoFrameFlags::RFF)
} }
pub fn is_onefield(&self) -> bool { pub fn is_onefield(&self) -> bool {
self.flags().contains(::VideoFrameFlags::ONEFIELD) self.flags().contains(crate::VideoFrameFlags::ONEFIELD)
} }
pub fn n_planes(&self) -> u32 { pub fn n_planes(&self) -> u32 {
@ -523,7 +516,9 @@ impl<T> VideoFrameRef<T> {
pub fn plane_data(&self, plane: u32) -> Result<&[u8], glib::BoolError> { pub fn plane_data(&self, plane: u32) -> Result<&[u8], glib::BoolError> {
if plane >= self.n_planes() { if plane >= self.n_planes() {
return Err(glib_bool_error!("Plane index higher than number of planes")); return Err(glib::glib_bool_error!(
"Plane index higher than number of planes"
));
} }
let format_info = self.format_info(); let format_info = self.format_info();
@ -551,17 +546,17 @@ impl<T> VideoFrameRef<T> {
} }
} }
pub fn as_ptr(&self) -> *const gst_video_sys::GstVideoFrame { pub fn as_ptr(&self) -> *const ffi::GstVideoFrame {
&self.frame &self.frame
} }
} }
impl<'a> VideoFrameRef<&'a gst::BufferRef> { impl<'a> VideoFrameRef<&'a gst::BufferRef> {
pub unsafe fn from_glib_borrow(frame: *const gst_video_sys::GstVideoFrame) -> Borrowed<Self> { pub unsafe fn from_glib_borrow(frame: *const ffi::GstVideoFrame) -> Borrowed<Self> {
assert!(!frame.is_null()); assert!(!frame.is_null());
let frame = ptr::read(frame); let frame = ptr::read(frame);
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
let buffer = gst::BufferRef::from_ptr(frame.buffer); let buffer = gst::BufferRef::from_ptr(frame.buffer);
Borrowed::new(VideoFrameRef { Borrowed::new(VideoFrameRef {
frame, frame,
@ -571,8 +566,8 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
}) })
} }
pub unsafe fn from_glib_full(frame: gst_video_sys::GstVideoFrame) -> Self { pub unsafe fn from_glib_full(frame: ffi::GstVideoFrame) -> Self {
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
let buffer = gst::BufferRef::from_ptr(frame.buffer); let buffer = gst::BufferRef::from_ptr(frame.buffer);
VideoFrameRef { VideoFrameRef {
frame, frame,
@ -584,7 +579,7 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
pub fn from_buffer_ref_readable<'b>( pub fn from_buffer_ref_readable<'b>(
buffer: &'a gst::BufferRef, buffer: &'a gst::BufferRef,
info: &'b ::VideoInfo, info: &'b crate::VideoInfo,
) -> Result<VideoFrameRef<&'a gst::BufferRef>, glib::BoolError> { ) -> Result<VideoFrameRef<&'a gst::BufferRef>, glib::BoolError> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -592,18 +587,18 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map( let res: bool = from_glib(ffi::gst_video_frame_map(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst_sys::GST_MAP_READ, ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst::ffi::GST_MAP_READ,
)); ));
if !res { if !res {
Err(glib_bool_error!("Failed to map VideoFrame")) Err(glib::glib_bool_error!("Failed to map VideoFrame"))
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrameRef { Ok(VideoFrameRef {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -617,7 +612,7 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
pub fn from_buffer_ref_id_readable<'b>( pub fn from_buffer_ref_id_readable<'b>(
buffer: &'a gst::BufferRef, buffer: &'a gst::BufferRef,
id: i32, id: i32,
info: &'b ::VideoInfo, info: &'b crate::VideoInfo,
) -> Result<VideoFrameRef<&'a gst::BufferRef>, glib::BoolError> { ) -> Result<VideoFrameRef<&'a gst::BufferRef>, glib::BoolError> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -625,19 +620,19 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id( let res: bool = from_glib(ffi::gst_video_frame_map_id(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
id, id,
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst_sys::GST_MAP_READ, ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF | gst::ffi::GST_MAP_READ,
)); ));
if !res { if !res {
Err(glib_bool_error!("Failed to map VideoFrame")) Err(glib::glib_bool_error!("Failed to map VideoFrame"))
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrameRef { Ok(VideoFrameRef {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -654,11 +649,11 @@ impl<'a> VideoFrameRef<&'a gst::BufferRef> {
} }
impl<'a> VideoFrameRef<&'a mut gst::BufferRef> { impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
pub unsafe fn from_glib_borrow_mut(frame: *mut gst_video_sys::GstVideoFrame) -> Borrowed<Self> { pub unsafe fn from_glib_borrow_mut(frame: *mut ffi::GstVideoFrame) -> Borrowed<Self> {
assert!(!frame.is_null()); assert!(!frame.is_null());
let frame = ptr::read(frame); let frame = ptr::read(frame);
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
let buffer = gst::BufferRef::from_mut_ptr(frame.buffer); let buffer = gst::BufferRef::from_mut_ptr(frame.buffer);
Borrowed::new(VideoFrameRef { Borrowed::new(VideoFrameRef {
frame, frame,
@ -668,8 +663,8 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
}) })
} }
pub unsafe fn from_glib_full_mut(frame: gst_video_sys::GstVideoFrame) -> Self { pub unsafe fn from_glib_full_mut(frame: ffi::GstVideoFrame) -> Self {
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
let buffer = gst::BufferRef::from_mut_ptr(frame.buffer); let buffer = gst::BufferRef::from_mut_ptr(frame.buffer);
VideoFrameRef { VideoFrameRef {
frame, frame,
@ -681,7 +676,7 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
pub fn from_buffer_ref_writable<'b>( pub fn from_buffer_ref_writable<'b>(
buffer: &'a mut gst::BufferRef, buffer: &'a mut gst::BufferRef,
info: &'b ::VideoInfo, info: &'b crate::VideoInfo,
) -> Result<VideoFrameRef<&'a mut gst::BufferRef>, glib::BoolError> { ) -> Result<VideoFrameRef<&'a mut gst::BufferRef>, glib::BoolError> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -689,20 +684,20 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map( let res: bool = from_glib(ffi::gst_video_frame_map(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
| gst_sys::GST_MAP_READ | gst::ffi::GST_MAP_READ
| gst_sys::GST_MAP_WRITE, | gst::ffi::GST_MAP_WRITE,
)); ));
if !res { if !res {
Err(glib_bool_error!("Failed to map VideoFrame")) Err(glib::glib_bool_error!("Failed to map VideoFrame"))
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrameRef { Ok(VideoFrameRef {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -716,7 +711,7 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
pub fn from_buffer_ref_id_writable<'b>( pub fn from_buffer_ref_id_writable<'b>(
buffer: &'a mut gst::BufferRef, buffer: &'a mut gst::BufferRef,
id: i32, id: i32,
info: &'b ::VideoInfo, info: &'b crate::VideoInfo,
) -> Result<VideoFrameRef<&'a mut gst::BufferRef>, glib::BoolError> { ) -> Result<VideoFrameRef<&'a mut gst::BufferRef>, glib::BoolError> {
skip_assert_initialized!(); skip_assert_initialized!();
@ -724,21 +719,21 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
unsafe { unsafe {
let mut frame = mem::MaybeUninit::zeroed(); let mut frame = mem::MaybeUninit::zeroed();
let res: bool = from_glib(gst_video_sys::gst_video_frame_map_id( let res: bool = from_glib(ffi::gst_video_frame_map_id(
frame.as_mut_ptr(), frame.as_mut_ptr(),
info.to_glib_none().0 as *mut _, info.to_glib_none().0 as *mut _,
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
id, id,
gst_video_sys::GST_VIDEO_FRAME_MAP_FLAG_NO_REF ffi::GST_VIDEO_FRAME_MAP_FLAG_NO_REF
| gst_sys::GST_MAP_READ | gst::ffi::GST_MAP_READ
| gst_sys::GST_MAP_WRITE, | gst::ffi::GST_MAP_WRITE,
)); ));
if !res { if !res {
Err(glib_bool_error!("Failed to map VideoFrame")) Err(glib::glib_bool_error!("Failed to map VideoFrame"))
} else { } else {
let frame = frame.assume_init(); let frame = frame.assume_init();
let info = ::VideoInfo(ptr::read(&frame.info)); let info = crate::VideoInfo(ptr::read(&frame.info));
Ok(VideoFrameRef { Ok(VideoFrameRef {
frame, frame,
buffer: Some(buffer), buffer: Some(buffer),
@ -755,7 +750,9 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
pub fn plane_data_mut(&mut self, plane: u32) -> Result<&mut [u8], glib::BoolError> { pub fn plane_data_mut(&mut self, plane: u32) -> Result<&mut [u8], glib::BoolError> {
if plane >= self.n_planes() { if plane >= self.n_planes() {
return Err(glib_bool_error!("Plane index higher than number of planes")); return Err(glib::glib_bool_error!(
"Plane index higher than number of planes"
));
} }
let format_info = self.format_info(); let format_info = self.format_info();
@ -783,7 +780,7 @@ impl<'a> VideoFrameRef<&'a mut gst::BufferRef> {
} }
} }
pub fn as_mut_ptr(&mut self) -> *mut gst_video_sys::GstVideoFrame { pub fn as_mut_ptr(&mut self) -> *mut ffi::GstVideoFrame {
&mut self.frame &mut self.frame
} }
} }
@ -806,34 +803,34 @@ impl<T> Drop for VideoFrameRef<T> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
if self.unmap { if self.unmap {
gst_video_sys::gst_video_frame_unmap(&mut self.frame); ffi::gst_video_frame_unmap(&mut self.frame);
} }
} }
} }
} }
pub trait VideoBufferExt { pub trait VideoBufferExt {
fn get_video_flags(&self) -> ::VideoBufferFlags; fn get_video_flags(&self) -> crate::VideoBufferFlags;
fn set_video_flags(&mut self, flags: ::VideoBufferFlags); fn set_video_flags(&mut self, flags: crate::VideoBufferFlags);
fn unset_video_flags(&mut self, flags: ::VideoBufferFlags); fn unset_video_flags(&mut self, flags: crate::VideoBufferFlags);
} }
impl VideoBufferExt for gst::BufferRef { impl VideoBufferExt for gst::BufferRef {
fn get_video_flags(&self) -> ::VideoBufferFlags { fn get_video_flags(&self) -> crate::VideoBufferFlags {
unsafe { unsafe {
let ptr = self.as_mut_ptr(); let ptr = self.as_mut_ptr();
::VideoBufferFlags::from_bits_truncate((*ptr).mini_object.flags) crate::VideoBufferFlags::from_bits_truncate((*ptr).mini_object.flags)
} }
} }
fn set_video_flags(&mut self, flags: ::VideoBufferFlags) { fn set_video_flags(&mut self, flags: crate::VideoBufferFlags) {
unsafe { unsafe {
let ptr = self.as_mut_ptr(); let ptr = self.as_mut_ptr();
(*ptr).mini_object.flags |= flags.bits(); (*ptr).mini_object.flags |= flags.bits();
} }
} }
fn unset_video_flags(&mut self, flags: ::VideoBufferFlags) { fn unset_video_flags(&mut self, flags: crate::VideoBufferFlags) {
unsafe { unsafe {
let ptr = self.as_mut_ptr(); let ptr = self.as_mut_ptr();
(*ptr).mini_object.flags &= !flags.bits(); (*ptr).mini_object.flags &= !flags.bits();
@ -844,13 +841,12 @@ impl VideoBufferExt for gst::BufferRef {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use gst;
#[test] #[test]
fn test_map_read() { fn test_map_read() {
gst::init().unwrap(); gst::init().unwrap();
let info = ::VideoInfo::builder(::VideoFormat::Gray8, 320, 240) let info = crate::VideoInfo::builder(crate::VideoFormat::Gray8, 320, 240)
.build() .build()
.unwrap(); .unwrap();
let buffer = gst::Buffer::with_size(info.size()).unwrap(); let buffer = gst::Buffer::with_size(info.size()).unwrap();
@ -880,7 +876,7 @@ mod tests {
fn test_map_write() { fn test_map_write() {
gst::init().unwrap(); gst::init().unwrap();
let info = ::VideoInfo::builder(::VideoFormat::Gray8, 320, 240) let info = crate::VideoInfo::builder(crate::VideoFormat::Gray8, 320, 240)
.build() .build()
.unwrap(); .unwrap();
let buffer = gst::Buffer::with_size(info.size()).unwrap(); let buffer = gst::Buffer::with_size(info.size()).unwrap();
@ -910,7 +906,7 @@ mod tests {
fn test_map_ref_read() { fn test_map_ref_read() {
gst::init().unwrap(); gst::init().unwrap();
let info = ::VideoInfo::builder(::VideoFormat::Gray8, 320, 240) let info = crate::VideoInfo::builder(crate::VideoFormat::Gray8, 320, 240)
.build() .build()
.unwrap(); .unwrap();
let buffer = gst::Buffer::with_size(info.size()).unwrap(); let buffer = gst::Buffer::with_size(info.size()).unwrap();
@ -926,7 +922,7 @@ mod tests {
fn test_map_ref_write() { fn test_map_ref_write() {
gst::init().unwrap(); gst::init().unwrap();
let info = ::VideoInfo::builder(::VideoFormat::Gray8, 320, 240) let info = crate::VideoInfo::builder(crate::VideoFormat::Gray8, 320, 240)
.build() .build()
.unwrap(); .unwrap();
let mut buffer = gst::Buffer::with_size(info.size()).unwrap(); let mut buffer = gst::Buffer::with_size(info.size()).unwrap();

358
gstreamer-video/src/video_info.rs
View file

@ -6,16 +6,10 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use glib_sys;
use gobject_sys;
use gst_video_sys;
use glib;
use glib::translate::{ use glib::translate::{
from_glib, from_glib_full, from_glib_none, FromGlib, FromGlibPtrFull, FromGlibPtrNone, ToGlib, from_glib, from_glib_full, from_glib_none, FromGlib, FromGlibPtrFull, FromGlibPtrNone, ToGlib,
ToGlibPtr, ToGlibPtrMut, ToGlibPtr, ToGlibPtrMut,
}; };
use gst;
use gst::prelude::*; use gst::prelude::*;
use std::ffi::CStr; use std::ffi::CStr;
@ -24,7 +18,7 @@ use std::mem;
use std::ptr; use std::ptr;
use std::str; use std::str;
pub const VIDEO_MAX_PLANES: usize = gst_video_sys::GST_VIDEO_MAX_PLANES as usize; pub const VIDEO_MAX_PLANES: usize = ffi::GST_VIDEO_MAX_PLANES as usize;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum VideoColorRange { pub enum VideoColorRange {
@ -37,21 +31,21 @@ pub enum VideoColorRange {
#[doc(hidden)] #[doc(hidden)]
impl ToGlib for VideoColorRange { impl ToGlib for VideoColorRange {
type GlibType = gst_video_sys::GstVideoColorRange; type GlibType = ffi::GstVideoColorRange;
fn to_glib(&self) -> gst_video_sys::GstVideoColorRange { fn to_glib(&self) -> ffi::GstVideoColorRange {
match *self { match *self {
VideoColorRange::Unknown => gst_video_sys::GST_VIDEO_COLOR_RANGE_UNKNOWN, VideoColorRange::Unknown => ffi::GST_VIDEO_COLOR_RANGE_UNKNOWN,
VideoColorRange::Range0255 => gst_video_sys::GST_VIDEO_COLOR_RANGE_0_255, VideoColorRange::Range0255 => ffi::GST_VIDEO_COLOR_RANGE_0_255,
VideoColorRange::Range16235 => gst_video_sys::GST_VIDEO_COLOR_RANGE_16_235, VideoColorRange::Range16235 => ffi::GST_VIDEO_COLOR_RANGE_16_235,
VideoColorRange::__Unknown(value) => value, VideoColorRange::__Unknown(value) => value,
} }
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlib<gst_video_sys::GstVideoColorRange> for VideoColorRange { impl FromGlib<ffi::GstVideoColorRange> for VideoColorRange {
fn from_glib(value: gst_video_sys::GstVideoColorRange) -> Self { fn from_glib(value: ffi::GstVideoColorRange) -> Self {
skip_assert_initialized!(); skip_assert_initialized!();
match value as i32 { match value as i32 {
0 => VideoColorRange::Unknown, 0 => VideoColorRange::Unknown,
@ -64,7 +58,7 @@ impl FromGlib<gst_video_sys::GstVideoColorRange> for VideoColorRange {
impl glib::StaticType for VideoColorRange { impl glib::StaticType for VideoColorRange {
fn static_type() -> glib::Type { fn static_type() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_color_range_get_type()) } unsafe { from_glib(ffi::gst_video_color_range_get_type()) }
} }
} }
@ -76,29 +70,29 @@ impl<'a> glib::value::FromValueOptional<'a> for VideoColorRange {
impl<'a> glib::value::FromValue<'a> for VideoColorRange { impl<'a> glib::value::FromValue<'a> for VideoColorRange {
unsafe fn from_value(value: &glib::value::Value) -> Self { unsafe fn from_value(value: &glib::value::Value) -> Self {
from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
} }
} }
impl glib::value::SetValue for VideoColorRange { impl glib::value::SetValue for VideoColorRange {
unsafe fn set_value(value: &mut glib::value::Value, this: &Self) { unsafe fn set_value(value: &mut glib::value::Value, this: &Self) {
gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib() as i32) glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib() as i32)
} }
} }
pub struct VideoColorimetry(gst_video_sys::GstVideoColorimetry); pub struct VideoColorimetry(ffi::GstVideoColorimetry);
impl VideoColorimetry { impl VideoColorimetry {
pub fn new( pub fn new(
range: VideoColorRange, range: VideoColorRange,
matrix: ::VideoColorMatrix, matrix: crate::VideoColorMatrix,
transfer: ::VideoTransferFunction, transfer: crate::VideoTransferFunction,
primaries: ::VideoColorPrimaries, primaries: crate::VideoColorPrimaries,
) -> Self { ) -> Self {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
let colorimetry = unsafe { let colorimetry = unsafe {
let mut colorimetry: gst_video_sys::GstVideoColorimetry = mem::zeroed(); let mut colorimetry: ffi::GstVideoColorimetry = mem::zeroed();
colorimetry.range = range.to_glib(); colorimetry.range = range.to_glib();
colorimetry.matrix = matrix.to_glib(); colorimetry.matrix = matrix.to_glib();
@ -111,19 +105,19 @@ impl VideoColorimetry {
VideoColorimetry(colorimetry) VideoColorimetry(colorimetry)
} }
pub fn range(&self) -> ::VideoColorRange { pub fn range(&self) -> crate::VideoColorRange {
from_glib(self.0.range) from_glib(self.0.range)
} }
pub fn matrix(&self) -> ::VideoColorMatrix { pub fn matrix(&self) -> crate::VideoColorMatrix {
from_glib(self.0.matrix) from_glib(self.0.matrix)
} }
pub fn transfer(&self) -> ::VideoTransferFunction { pub fn transfer(&self) -> crate::VideoTransferFunction {
from_glib(self.0.transfer) from_glib(self.0.transfer)
} }
pub fn primaries(&self) -> ::VideoColorPrimaries { pub fn primaries(&self) -> crate::VideoColorPrimaries {
from_glib(self.0.primaries) from_glib(self.0.primaries)
} }
} }
@ -136,17 +130,13 @@ impl Clone for VideoColorimetry {
impl PartialEq for VideoColorimetry { impl PartialEq for VideoColorimetry {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
unsafe { unsafe { from_glib(ffi::gst_video_colorimetry_is_equal(&self.0, &other.0)) }
from_glib(gst_video_sys::gst_video_colorimetry_is_equal(
&self.0, &other.0,
))
}
} }
} }
impl Eq for VideoColorimetry {} impl Eq for VideoColorimetry {}
impl str::FromStr for ::VideoColorimetry { impl str::FromStr for crate::VideoColorimetry {
type Err = glib::error::BoolError; type Err = glib::error::BoolError;
fn from_str(s: &str) -> Result<Self, glib::error::BoolError> { fn from_str(s: &str) -> Result<Self, glib::error::BoolError> {
@ -154,20 +144,20 @@ impl str::FromStr for ::VideoColorimetry {
unsafe { unsafe {
let mut colorimetry = mem::MaybeUninit::zeroed(); let mut colorimetry = mem::MaybeUninit::zeroed();
let valid: bool = from_glib(gst_video_sys::gst_video_colorimetry_from_string( let valid: bool = from_glib(ffi::gst_video_colorimetry_from_string(
colorimetry.as_mut_ptr(), colorimetry.as_mut_ptr(),
s.to_glib_none().0, s.to_glib_none().0,
)); ));
if valid { if valid {
Ok(VideoColorimetry(colorimetry.assume_init())) Ok(VideoColorimetry(colorimetry.assume_init()))
} else { } else {
Err(glib_bool_error!("Invalid colorimetry info")) Err(glib::glib_bool_error!("Invalid colorimetry info"))
} }
} }
} }
} }
impl fmt::Debug for ::VideoColorimetry { impl fmt::Debug for crate::VideoColorimetry {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.debug_struct("VideoColorimetry") f.debug_struct("VideoColorimetry")
.field("range", &self.0.range) .field("range", &self.0.range)
@ -178,27 +168,24 @@ impl fmt::Debug for ::VideoColorimetry {
} }
} }
impl fmt::Display for ::VideoColorimetry { impl fmt::Display for crate::VideoColorimetry {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
let s = unsafe { let s =
glib::GString::from_glib_full(gst_video_sys::gst_video_colorimetry_to_string(&self.0)) unsafe { glib::GString::from_glib_full(ffi::gst_video_colorimetry_to_string(&self.0)) };
};
f.write_str(&s) f.write_str(&s)
} }
} }
impl str::FromStr for ::VideoChromaSite { impl str::FromStr for crate::VideoChromaSite {
type Err = glib::error::BoolError; type Err = glib::error::BoolError;
fn from_str(s: &str) -> Result<Self, glib::error::BoolError> { fn from_str(s: &str) -> Result<Self, glib::error::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let chroma_site = from_glib(gst_video_sys::gst_video_chroma_from_string( let chroma_site = from_glib(ffi::gst_video_chroma_from_string(s.to_glib_none().0));
s.to_glib_none().0, if chroma_site == crate::VideoChromaSite::empty() {
)); Err(glib::glib_bool_error!("Invalid chroma site"))
if chroma_site == ::VideoChromaSite::empty() {
Err(glib_bool_error!("Invalid chroma site"))
} else { } else {
Ok(chroma_site) Ok(chroma_site)
} }
@ -206,25 +193,27 @@ impl str::FromStr for ::VideoChromaSite {
} }
} }
impl fmt::Display for ::VideoChromaSite { impl fmt::Display for crate::VideoChromaSite {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
let s = unsafe { let s = unsafe {
glib::GString::from_glib_full(gst_video_sys::gst_video_chroma_to_string(self.to_glib())) glib::GString::from_glib_full(ffi::gst_video_chroma_to_string(self.to_glib()))
}; };
f.write_str(&s) f.write_str(&s)
} }
} }
impl ::VideoTransferFunction { impl crate::VideoTransferFunction {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn from_iso(iso: u32) -> Result<::VideoTransferFunction, glib::BoolError> { pub fn from_iso(iso: u32) -> Result<crate::VideoTransferFunction, glib::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let value = from_glib(gst_video_sys::gst_video_transfer_function_from_iso(iso)); let value = from_glib(ffi::gst_video_transfer_function_from_iso(iso));
match value { match value {
::VideoTransferFunction::__Unknown(_) => Err(glib_bool_error!("Invalid ISO value")), crate::VideoTransferFunction::__Unknown(_) => {
Err(glib::glib_bool_error!("Invalid ISO value"))
}
_ => Ok(value), _ => Ok(value),
} }
} }
@ -233,7 +222,7 @@ impl ::VideoTransferFunction {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn to_iso(&self) -> u32 { pub fn to_iso(&self) -> u32 {
unsafe { gst_video_sys::gst_video_transfer_function_to_iso(self.to_glib()) } unsafe { ffi::gst_video_transfer_function_to_iso(self.to_glib()) }
} }
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
@ -241,11 +230,11 @@ impl ::VideoTransferFunction {
pub fn is_equivalent( pub fn is_equivalent(
&self, &self,
from_bpp: u32, from_bpp: u32,
to_func: ::VideoTransferFunction, to_func: crate::VideoTransferFunction,
to_bpp: u32, to_bpp: u32,
) -> bool { ) -> bool {
unsafe { unsafe {
from_glib(gst_video_sys::gst_video_transfer_function_is_equivalent( from_glib(ffi::gst_video_transfer_function_is_equivalent(
self.to_glib(), self.to_glib(),
from_bpp, from_bpp,
to_func.to_glib(), to_func.to_glib(),
@ -255,16 +244,18 @@ impl ::VideoTransferFunction {
} }
} }
impl ::VideoColorMatrix { impl crate::VideoColorMatrix {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn from_iso(iso: u32) -> Result<::VideoColorMatrix, glib::BoolError> { pub fn from_iso(iso: u32) -> Result<crate::VideoColorMatrix, glib::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let value = from_glib(gst_video_sys::gst_video_color_matrix_from_iso(iso)); let value = from_glib(ffi::gst_video_color_matrix_from_iso(iso));
match value { match value {
::VideoColorMatrix::__Unknown(_) => Err(glib_bool_error!("Invalid ISO value")), crate::VideoColorMatrix::__Unknown(_) => {
Err(glib::glib_bool_error!("Invalid ISO value"))
}
_ => Ok(value), _ => Ok(value),
} }
} }
@ -273,20 +264,22 @@ impl ::VideoColorMatrix {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn to_iso(&self) -> u32 { pub fn to_iso(&self) -> u32 {
unsafe { gst_video_sys::gst_video_color_matrix_to_iso(self.to_glib()) } unsafe { ffi::gst_video_color_matrix_to_iso(self.to_glib()) }
} }
} }
impl ::VideoColorPrimaries { impl crate::VideoColorPrimaries {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn from_iso(iso: u32) -> Result<::VideoColorPrimaries, glib::BoolError> { pub fn from_iso(iso: u32) -> Result<crate::VideoColorPrimaries, glib::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let value = from_glib(gst_video_sys::gst_video_color_primaries_from_iso(iso)); let value = from_glib(ffi::gst_video_color_primaries_from_iso(iso));
match value { match value {
::VideoColorPrimaries::__Unknown(_) => Err(glib_bool_error!("Invalid ISO value")), crate::VideoColorPrimaries::__Unknown(_) => {
Err(glib::glib_bool_error!("Invalid ISO value"))
}
_ => Ok(value), _ => Ok(value),
} }
} }
@ -295,34 +288,36 @@ impl ::VideoColorPrimaries {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn to_iso(&self) -> u32 { pub fn to_iso(&self) -> u32 {
unsafe { gst_video_sys::gst_video_color_primaries_to_iso(self.to_glib()) } unsafe { ffi::gst_video_color_primaries_to_iso(self.to_glib()) }
} }
} }
impl From<::VideoMultiviewFramePacking> for ::VideoMultiviewMode { impl From<crate::VideoMultiviewFramePacking> for crate::VideoMultiviewMode {
fn from(v: ::VideoMultiviewFramePacking) -> Self { fn from(v: crate::VideoMultiviewFramePacking) -> Self {
skip_assert_initialized!(); skip_assert_initialized!();
from_glib(v.to_glib()) from_glib(v.to_glib())
} }
} }
impl std::convert::TryFrom<::VideoMultiviewMode> for ::VideoMultiviewFramePacking { impl std::convert::TryFrom<crate::VideoMultiviewMode> for crate::VideoMultiviewFramePacking {
type Error = glib::BoolError; type Error = glib::BoolError;
fn try_from(v: ::VideoMultiviewMode) -> Result<::VideoMultiviewFramePacking, glib::BoolError> { fn try_from(
v: crate::VideoMultiviewMode,
) -> Result<crate::VideoMultiviewFramePacking, glib::BoolError> {
skip_assert_initialized!(); skip_assert_initialized!();
let v2 = from_glib(v.to_glib()); let v2 = from_glib(v.to_glib());
if let ::VideoMultiviewFramePacking::__Unknown(_) = v2 { if let crate::VideoMultiviewFramePacking::__Unknown(_) = v2 {
Err(glib_bool_error!("Invalid frame packing mode")) Err(glib::glib_bool_error!("Invalid frame packing mode"))
} else { } else {
Ok(v2) Ok(v2)
} }
} }
} }
pub struct VideoInfo(pub(crate) gst_video_sys::GstVideoInfo); pub struct VideoInfo(pub(crate) ffi::GstVideoInfo);
impl fmt::Debug for VideoInfo { impl fmt::Debug for VideoInfo {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
@ -354,24 +349,24 @@ impl fmt::Debug for VideoInfo {
#[derive(Debug)] #[derive(Debug)]
pub struct VideoInfoBuilder<'a> { pub struct VideoInfoBuilder<'a> {
format: ::VideoFormat, format: crate::VideoFormat,
width: u32, width: u32,
height: u32, height: u32,
interlace_mode: Option<::VideoInterlaceMode>, interlace_mode: Option<crate::VideoInterlaceMode>,
flags: Option<::VideoFlags>, flags: Option<crate::VideoFlags>,
size: Option<usize>, size: Option<usize>,
views: Option<u32>, views: Option<u32>,
chroma_site: Option<::VideoChromaSite>, chroma_site: Option<crate::VideoChromaSite>,
colorimetry: Option<&'a ::VideoColorimetry>, colorimetry: Option<&'a crate::VideoColorimetry>,
par: Option<gst::Fraction>, par: Option<gst::Fraction>,
fps: Option<gst::Fraction>, fps: Option<gst::Fraction>,
offset: Option<&'a [usize]>, offset: Option<&'a [usize]>,
stride: Option<&'a [i32]>, stride: Option<&'a [i32]>,
multiview_mode: Option<::VideoMultiviewMode>, multiview_mode: Option<crate::VideoMultiviewMode>,
multiview_flags: Option<::VideoMultiviewFlags>, multiview_flags: Option<crate::VideoMultiviewFlags>,
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
field_order: Option<::VideoFieldOrder>, field_order: Option<crate::VideoFieldOrder>,
} }
impl<'a> VideoInfoBuilder<'a> { impl<'a> VideoInfoBuilder<'a> {
@ -379,11 +374,11 @@ impl<'a> VideoInfoBuilder<'a> {
unsafe { unsafe {
let mut info = mem::MaybeUninit::uninit(); let mut info = mem::MaybeUninit::uninit();
cfg_if! { cfg_if::cfg_if! {
if #[cfg(feature = "v1_16")] { if #[cfg(feature = "v1_16")] {
let res: bool = { let res: bool = {
from_glib(if let Some(interlace_mode) = self.interlace_mode { from_glib(if let Some(interlace_mode) = self.interlace_mode {
gst_video_sys::gst_video_info_set_interlaced_format( ffi::gst_video_info_set_interlaced_format(
info.as_mut_ptr(), info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
interlace_mode.to_glib(), interlace_mode.to_glib(),
@ -391,7 +386,7 @@ impl<'a> VideoInfoBuilder<'a> {
self.height, self.height,
) )
} else { } else {
gst_video_sys::gst_video_info_set_format( ffi::gst_video_info_set_format(
info.as_mut_ptr(), info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
self.width, self.width,
@ -401,7 +396,7 @@ impl<'a> VideoInfoBuilder<'a> {
}; };
} else if #[cfg(feature = "v1_12")] { } else if #[cfg(feature = "v1_12")] {
let res: bool = { let res: bool = {
let res = from_glib(gst_video_sys::gst_video_info_set_format( let res = from_glib(ffi::gst_video_info_set_format(
info.as_mut_ptr(), info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
self.width, self.width,
@ -422,7 +417,7 @@ impl<'a> VideoInfoBuilder<'a> {
// The bool return value is new with 1.11.1, see // The bool return value is new with 1.11.1, see
// https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/commit/17cdd369e6f2f73329d27dfceb50011f40f1ceb0 // https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/commit/17cdd369e6f2f73329d27dfceb50011f40f1ceb0
let res = if gst::version() < (1, 11, 1, 0) { let res = if gst::version() < (1, 11, 1, 0) {
gst_video_sys::gst_video_info_set_format( ffi::gst_video_info_set_format(
info.as_mut_ptr(), info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
self.width, self.width,
@ -431,7 +426,7 @@ impl<'a> VideoInfoBuilder<'a> {
true true
} else { } else {
from_glib(gst_video_sys::gst_video_info_set_format( from_glib(ffi::gst_video_info_set_format(
info.as_mut_ptr(), info.as_mut_ptr(),
self.format.to_glib(), self.format.to_glib(),
self.width, self.width,
@ -452,13 +447,13 @@ impl<'a> VideoInfoBuilder<'a> {
} }
if !res { if !res {
return Err(glib_bool_error!("Failed to build VideoInfo")); return Err(glib::glib_bool_error!("Failed to build VideoInfo"));
} }
let mut info = info.assume_init(); let mut info = info.assume_init();
if info.finfo.is_null() || info.width <= 0 || info.height <= 0 { if info.finfo.is_null() || info.width <= 0 || info.height <= 0 {
return Err(glib_bool_error!("Failed to build VideoInfo")); return Err(glib::glib_bool_error!("Failed to build VideoInfo"));
} }
if let Some(flags) = self.flags { if let Some(flags) = self.flags {
@ -493,7 +488,7 @@ impl<'a> VideoInfoBuilder<'a> {
if let Some(offset) = self.offset { if let Some(offset) = self.offset {
if offset.len() != ((*info.finfo).n_planes as usize) { if offset.len() != ((*info.finfo).n_planes as usize) {
return Err(glib_bool_error!("Failed to build VideoInfo")); return Err(glib::glib_bool_error!("Failed to build VideoInfo"));
} }
let n_planes = (*info.finfo).n_planes as usize; let n_planes = (*info.finfo).n_planes as usize;
@ -502,7 +497,7 @@ impl<'a> VideoInfoBuilder<'a> {
if let Some(stride) = self.stride { if let Some(stride) = self.stride {
if stride.len() != ((*info.finfo).n_planes as usize) { if stride.len() != ((*info.finfo).n_planes as usize) {
return Err(glib_bool_error!("Failed to build VideoInfo")); return Err(glib::glib_bool_error!("Failed to build VideoInfo"));
} }
let n_planes = (*info.finfo).n_planes as usize; let n_planes = (*info.finfo).n_planes as usize;
@ -529,14 +524,14 @@ impl<'a> VideoInfoBuilder<'a> {
} }
} }
pub fn interlace_mode(self, interlace_mode: ::VideoInterlaceMode) -> VideoInfoBuilder<'a> { pub fn interlace_mode(self, interlace_mode: crate::VideoInterlaceMode) -> VideoInfoBuilder<'a> {
Self { Self {
interlace_mode: Some(interlace_mode), interlace_mode: Some(interlace_mode),
..self ..self
} }
} }
pub fn flags(self, flags: ::VideoFlags) -> Self { pub fn flags(self, flags: crate::VideoFlags) -> Self {
Self { Self {
flags: Some(flags), flags: Some(flags),
..self ..self
@ -557,14 +552,14 @@ impl<'a> VideoInfoBuilder<'a> {
} }
} }
pub fn chroma_site(self, chroma_site: ::VideoChromaSite) -> Self { pub fn chroma_site(self, chroma_site: crate::VideoChromaSite) -> Self {
Self { Self {
chroma_site: Some(chroma_site), chroma_site: Some(chroma_site),
..self ..self
} }
} }
pub fn colorimetry(self, colorimetry: &'a ::VideoColorimetry) -> VideoInfoBuilder<'a> { pub fn colorimetry(self, colorimetry: &'a crate::VideoColorimetry) -> VideoInfoBuilder<'a> {
Self { Self {
colorimetry: Some(colorimetry), colorimetry: Some(colorimetry),
..self ..self
@ -599,14 +594,14 @@ impl<'a> VideoInfoBuilder<'a> {
} }
} }
pub fn multiview_mode(self, multiview_mode: ::VideoMultiviewMode) -> Self { pub fn multiview_mode(self, multiview_mode: crate::VideoMultiviewMode) -> Self {
Self { Self {
multiview_mode: Some(multiview_mode), multiview_mode: Some(multiview_mode),
..self ..self
} }
} }
pub fn multiview_flags(self, multiview_flags: ::VideoMultiviewFlags) -> Self { pub fn multiview_flags(self, multiview_flags: crate::VideoMultiviewFlags) -> Self {
Self { Self {
multiview_flags: Some(multiview_flags), multiview_flags: Some(multiview_flags),
..self ..self
@ -615,7 +610,7 @@ impl<'a> VideoInfoBuilder<'a> {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
pub fn field_order(self, field_order: ::VideoFieldOrder) -> Self { pub fn field_order(self, field_order: crate::VideoFieldOrder) -> Self {
Self { Self {
field_order: Some(field_order), field_order: Some(field_order),
..self ..self
@ -624,10 +619,14 @@ impl<'a> VideoInfoBuilder<'a> {
} }
impl VideoInfo { impl VideoInfo {
pub fn builder<'a>(format: ::VideoFormat, width: u32, height: u32) -> VideoInfoBuilder<'a> { pub fn builder<'a>(
format: crate::VideoFormat,
width: u32,
height: u32,
) -> VideoInfoBuilder<'a> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
cfg_if! { cfg_if::cfg_if! {
if #[cfg(any(feature = "v1_12", feature = "dox"))] { if #[cfg(any(feature = "v1_12", feature = "dox"))] {
VideoInfoBuilder { VideoInfoBuilder {
format, format,
@ -678,39 +677,41 @@ impl VideoInfo {
unsafe { unsafe {
let mut info = mem::MaybeUninit::uninit(); let mut info = mem::MaybeUninit::uninit();
if from_glib(gst_video_sys::gst_video_info_from_caps( if from_glib(ffi::gst_video_info_from_caps(
info.as_mut_ptr(), info.as_mut_ptr(),
caps.as_ptr(), caps.as_ptr(),
)) { )) {
Ok(VideoInfo(info.assume_init())) Ok(VideoInfo(info.assume_init()))
} else { } else {
Err(glib_bool_error!("Failed to create VideoInfo from caps")) Err(glib::glib_bool_error!(
"Failed to create VideoInfo from caps"
))
} }
} }
} }
pub fn to_caps(&self) -> Result<gst::Caps, glib::error::BoolError> { pub fn to_caps(&self) -> Result<gst::Caps, glib::error::BoolError> {
unsafe { unsafe {
let result = from_glib_full(gst_video_sys::gst_video_info_to_caps( let result = from_glib_full(ffi::gst_video_info_to_caps(&self.0 as *const _ as *mut _));
&self.0 as *const _ as *mut _,
));
match result { match result {
Some(c) => Ok(c), Some(c) => Ok(c),
None => Err(glib_bool_error!("Failed to create caps from VideoInfo")), None => Err(glib::glib_bool_error!(
"Failed to create caps from VideoInfo"
)),
} }
} }
} }
pub fn format(&self) -> ::VideoFormat { pub fn format(&self) -> crate::VideoFormat {
if self.0.finfo.is_null() { if self.0.finfo.is_null() {
return ::VideoFormat::Unknown; return crate::VideoFormat::Unknown;
} }
unsafe { from_glib((*self.0.finfo).format) } unsafe { from_glib((*self.0.finfo).format) }
} }
pub fn format_info(&self) -> ::VideoFormatInfo { pub fn format_info(&self) -> crate::VideoFormatInfo {
::VideoFormatInfo::from_format(self.format()) crate::VideoFormatInfo::from_format(self.format())
} }
pub fn width(&self) -> u32 { pub fn width(&self) -> u32 {
@ -724,18 +725,18 @@ impl VideoInfo {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn field_height(&self) -> u32 { pub fn field_height(&self) -> u32 {
if self.0.interlace_mode == gst_video_sys::GST_VIDEO_INTERLACE_MODE_ALTERNATE { if self.0.interlace_mode == ffi::GST_VIDEO_INTERLACE_MODE_ALTERNATE {
(self.0.height as u32 + 1) / 2 (self.0.height as u32 + 1) / 2
} else { } else {
self.0.height as u32 self.0.height as u32
} }
} }
pub fn interlace_mode(&self) -> ::VideoInterlaceMode { pub fn interlace_mode(&self) -> crate::VideoInterlaceMode {
from_glib(self.0.interlace_mode) from_glib(self.0.interlace_mode)
} }
pub fn flags(&self) -> ::VideoFlags { pub fn flags(&self) -> crate::VideoFlags {
from_glib(self.0.flags) from_glib(self.0.flags)
} }
@ -747,7 +748,7 @@ impl VideoInfo {
self.0.views as u32 self.0.views as u32
} }
pub fn chroma_site(&self) -> ::VideoChromaSite { pub fn chroma_site(&self) -> crate::VideoChromaSite {
from_glib(self.0.chroma_site) from_glib(self.0.chroma_site)
} }
@ -771,14 +772,14 @@ impl VideoInfo {
&self.0.stride[0..(self.format_info().n_planes() as usize)] &self.0.stride[0..(self.format_info().n_planes() as usize)]
} }
pub fn multiview_mode(&self) -> ::VideoMultiviewMode { pub fn multiview_mode(&self) -> crate::VideoMultiviewMode {
unsafe { unsafe {
let ptr = &self.0.ABI._gst_reserved as *const _ as *const i32; let ptr = &self.0.ABI._gst_reserved as *const _ as *const i32;
from_glib(ptr::read(ptr.offset(0))) from_glib(ptr::read(ptr.offset(0)))
} }
} }
pub fn multiview_flags(&self) -> ::VideoMultiviewFlags { pub fn multiview_flags(&self) -> crate::VideoMultiviewFlags {
unsafe { unsafe {
let ptr = &self.0.ABI._gst_reserved as *const _ as *const u32; let ptr = &self.0.ABI._gst_reserved as *const _ as *const u32;
from_glib(ptr::read(ptr.offset(1))) from_glib(ptr::read(ptr.offset(1)))
@ -787,7 +788,7 @@ impl VideoInfo {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
pub fn field_order(&self) -> ::VideoFieldOrder { pub fn field_order(&self) -> crate::VideoFieldOrder {
unsafe { unsafe {
let ptr = &self.0.ABI._gst_reserved as *const _ as *const i32; let ptr = &self.0.ABI._gst_reserved as *const _ as *const i32;
from_glib(ptr::read(ptr.offset(2))) from_glib(ptr::read(ptr.offset(2)))
@ -811,7 +812,7 @@ impl VideoInfo {
} }
pub fn is_interlaced(&self) -> bool { pub fn is_interlaced(&self) -> bool {
self.interlace_mode() != ::VideoInterlaceMode::Progressive self.interlace_mode() != crate::VideoInterlaceMode::Progressive
} }
pub fn n_planes(&self) -> u32 { pub fn n_planes(&self) -> u32 {
@ -831,7 +832,7 @@ impl VideoInfo {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::MaybeUninit::uninit(); let mut dest_val = mem::MaybeUninit::uninit();
if from_glib(gst_video_sys::gst_video_info_convert( if from_glib(ffi::gst_video_info_convert(
&self.0 as *const _ as *mut _, &self.0 as *const _ as *mut _,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
@ -855,7 +856,7 @@ impl VideoInfo {
let src_val = src_val.into(); let src_val = src_val.into();
unsafe { unsafe {
let mut dest_val = mem::MaybeUninit::uninit(); let mut dest_val = mem::MaybeUninit::uninit();
if from_glib(gst_video_sys::gst_video_info_convert( if from_glib(ffi::gst_video_info_convert(
&self.0 as *const _ as *mut _, &self.0 as *const _ as *mut _,
src_val.get_format().to_glib(), src_val.get_format().to_glib(),
src_val.to_raw_value(), src_val.to_raw_value(),
@ -872,11 +873,11 @@ impl VideoInfo {
} }
} }
pub fn align(&mut self, align: &mut ::VideoAlignment) -> bool { pub fn align(&mut self, align: &mut crate::VideoAlignment) -> bool {
cfg_if! { cfg_if::cfg_if! {
if #[cfg(feature = "v1_12")] { if #[cfg(feature = "v1_12")] {
unsafe { unsafe {
from_glib(gst_video_sys::gst_video_info_align( from_glib(ffi::gst_video_info_align(
&mut self.0, &mut self.0,
&mut align.0, &mut align.0,
)) ))
@ -886,11 +887,11 @@ impl VideoInfo {
// The bool return value is new with 1.11.1, see // The bool return value is new with 1.11.1, see
// https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/commit/17cdd369e6f2f73329d27dfceb50011f40f1ceb0 // https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/commit/17cdd369e6f2f73329d27dfceb50011f40f1ceb0
if gst::version() < (1, 11, 1, 0) { if gst::version() < (1, 11, 1, 0) {
gst_video_sys::gst_video_info_align(&mut self.0, &mut align.0); ffi::gst_video_info_align(&mut self.0, &mut align.0);
true true
} else { } else {
from_glib(gst_video_sys::gst_video_info_align( from_glib(ffi::gst_video_info_align(
&mut self.0, &mut self.0,
&mut align.0, &mut align.0,
)) ))
@ -909,7 +910,7 @@ impl Clone for VideoInfo {
impl PartialEq for VideoInfo { impl PartialEq for VideoInfo {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
unsafe { from_glib(gst_video_sys::gst_video_info_is_equal(&self.0, &other.0)) } unsafe { from_glib(ffi::gst_video_info_is_equal(&self.0, &other.0)) }
} }
} }
@ -920,25 +921,26 @@ unsafe impl Sync for VideoInfo {}
impl glib::types::StaticType for VideoInfo { impl glib::types::StaticType for VideoInfo {
fn static_type() -> glib::types::Type { fn static_type() -> glib::types::Type {
unsafe { glib::translate::from_glib(gst_video_sys::gst_video_info_get_type()) } unsafe { glib::translate::from_glib(ffi::gst_video_info_get_type()) }
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> glib::value::FromValueOptional<'a> for VideoInfo { impl<'a> glib::value::FromValueOptional<'a> for VideoInfo {
unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> { unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
Option::<VideoInfo>::from_glib_none(gobject_sys::g_value_get_boxed(value.to_glib_none().0) Option::<VideoInfo>::from_glib_none(glib::gobject_ffi::g_value_get_boxed(
as *mut gst_video_sys::GstVideoInfo) value.to_glib_none().0,
) as *mut ffi::GstVideoInfo)
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl glib::value::SetValue for VideoInfo { impl glib::value::SetValue for VideoInfo {
unsafe fn set_value(value: &mut glib::Value, this: &Self) { unsafe fn set_value(value: &mut glib::Value, this: &Self) {
gobject_sys::g_value_set_boxed( glib::gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0, value.to_glib_none_mut().0,
glib::translate::ToGlibPtr::<*const gst_video_sys::GstVideoInfo>::to_glib_none(this).0 glib::translate::ToGlibPtr::<*const ffi::GstVideoInfo>::to_glib_none(this).0
as glib_sys::gpointer, as glib::ffi::gpointer,
) )
} }
} }
@ -946,10 +948,10 @@ impl glib::value::SetValue for VideoInfo {
#[doc(hidden)] #[doc(hidden)]
impl glib::value::SetValueOptional for VideoInfo { impl glib::value::SetValueOptional for VideoInfo {
unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) { unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) {
gobject_sys::g_value_set_boxed( glib::gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0, value.to_glib_none_mut().0,
glib::translate::ToGlibPtr::<*const gst_video_sys::GstVideoInfo>::to_glib_none(&this).0 glib::translate::ToGlibPtr::<*const ffi::GstVideoInfo>::to_glib_none(&this).0
as glib_sys::gpointer, as glib::ffi::gpointer,
) )
} }
} }
@ -963,66 +965,62 @@ impl glib::translate::Uninitialized for VideoInfo {
#[doc(hidden)] #[doc(hidden)]
impl glib::translate::GlibPtrDefault for VideoInfo { impl glib::translate::GlibPtrDefault for VideoInfo {
type GlibType = *mut gst_video_sys::GstVideoInfo; type GlibType = *mut ffi::GstVideoInfo;
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> glib::translate::ToGlibPtr<'a, *const gst_video_sys::GstVideoInfo> for VideoInfo { impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstVideoInfo> for VideoInfo {
type Storage = &'a VideoInfo; type Storage = &'a VideoInfo;
fn to_glib_none( fn to_glib_none(&'a self) -> glib::translate::Stash<'a, *const ffi::GstVideoInfo, Self> {
&'a self,
) -> glib::translate::Stash<'a, *const gst_video_sys::GstVideoInfo, Self> {
glib::translate::Stash(&self.0, self) glib::translate::Stash(&self.0, self)
} }
fn to_glib_full(&self) -> *const gst_video_sys::GstVideoInfo { fn to_glib_full(&self) -> *const ffi::GstVideoInfo {
unimplemented!() unimplemented!()
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl glib::translate::FromGlibPtrNone<*mut gst_video_sys::GstVideoInfo> for VideoInfo { impl glib::translate::FromGlibPtrNone<*mut ffi::GstVideoInfo> for VideoInfo {
#[inline] #[inline]
unsafe fn from_glib_none(ptr: *mut gst_video_sys::GstVideoInfo) -> Self { unsafe fn from_glib_none(ptr: *mut ffi::GstVideoInfo) -> Self {
VideoInfo(ptr::read(ptr)) VideoInfo(ptr::read(ptr))
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl glib::translate::FromGlibPtrFull<*mut gst_video_sys::GstVideoInfo> for VideoInfo { impl glib::translate::FromGlibPtrFull<*mut ffi::GstVideoInfo> for VideoInfo {
#[inline] #[inline]
unsafe fn from_glib_full(ptr: *mut gst_video_sys::GstVideoInfo) -> Self { unsafe fn from_glib_full(ptr: *mut ffi::GstVideoInfo) -> Self {
let info = from_glib_none(ptr); let info = from_glib_none(ptr);
glib_sys::g_free(ptr as *mut _); glib::ffi::g_free(ptr as *mut _);
info info
} }
} }
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
impl ::VideoFieldOrder { impl crate::VideoFieldOrder {
pub fn to_str<'a>(self) -> &'a str { pub fn to_str<'a>(self) -> &'a str {
unsafe { unsafe {
CStr::from_ptr(gst_video_sys::gst_video_field_order_to_string( CStr::from_ptr(ffi::gst_video_field_order_to_string(self.to_glib()))
self.to_glib(), .to_str()
)) .unwrap()
.to_str()
.unwrap()
} }
} }
} }
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
impl str::FromStr for ::VideoFieldOrder { impl str::FromStr for crate::VideoFieldOrder {
type Err = glib::error::BoolError; type Err = glib::error::BoolError;
fn from_str(s: &str) -> Result<Self, glib::error::BoolError> { fn from_str(s: &str) -> Result<Self, glib::error::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
Ok(from_glib(gst_video_sys::gst_video_field_order_from_string( Ok(from_glib(ffi::gst_video_field_order_from_string(
s.to_glib_none().0, s.to_glib_none().0,
))) )))
} }
@ -1031,39 +1029,37 @@ impl str::FromStr for ::VideoFieldOrder {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
impl fmt::Display for ::VideoFieldOrder { impl fmt::Display for crate::VideoFieldOrder {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.write_str((*self).to_str()) f.write_str((*self).to_str())
} }
} }
impl ::VideoInterlaceMode { impl crate::VideoInterlaceMode {
pub fn to_str<'a>(self) -> &'a str { pub fn to_str<'a>(self) -> &'a str {
unsafe { unsafe {
CStr::from_ptr(gst_video_sys::gst_video_interlace_mode_to_string( CStr::from_ptr(ffi::gst_video_interlace_mode_to_string(self.to_glib()))
self.to_glib(), .to_str()
)) .unwrap()
.to_str()
.unwrap()
} }
} }
} }
impl str::FromStr for ::VideoInterlaceMode { impl str::FromStr for crate::VideoInterlaceMode {
type Err = glib::error::BoolError; type Err = glib::error::BoolError;
fn from_str(s: &str) -> Result<Self, glib::error::BoolError> { fn from_str(s: &str) -> Result<Self, glib::error::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
Ok(from_glib( Ok(from_glib(ffi::gst_video_interlace_mode_from_string(
gst_video_sys::gst_video_interlace_mode_from_string(s.to_glib_none().0), s.to_glib_none().0,
)) )))
} }
} }
} }
impl fmt::Display for ::VideoInterlaceMode { impl fmt::Display for crate::VideoInterlaceMode {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.write_str((*self).to_str()) f.write_str((*self).to_str())
} }
@ -1072,40 +1068,39 @@ impl fmt::Display for ::VideoInterlaceMode {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use gst;
#[test] #[test]
fn test_new() { fn test_new() {
gst::init().unwrap(); gst::init().unwrap();
let info = VideoInfo::builder(::VideoFormat::I420, 320, 240) let info = VideoInfo::builder(crate::VideoFormat::I420, 320, 240)
.build() .build()
.unwrap(); .unwrap();
assert_eq!(info.format(), ::VideoFormat::I420); assert_eq!(info.format(), crate::VideoFormat::I420);
assert_eq!(info.width(), 320); assert_eq!(info.width(), 320);
assert_eq!(info.height(), 240); assert_eq!(info.height(), 240);
assert_eq!(info.size(), 320 * 240 + 2 * 160 * 120); assert_eq!(info.size(), 320 * 240 + 2 * 160 * 120);
assert_eq!(info.multiview_mode(), ::VideoMultiviewMode::None); assert_eq!(info.multiview_mode(), crate::VideoMultiviewMode::None);
assert_eq!(&info.offset(), &[0, 320 * 240, 320 * 240 + 160 * 120]); assert_eq!(&info.offset(), &[0, 320 * 240, 320 * 240 + 160 * 120]);
assert_eq!(&info.stride(), &[320, 160, 160]); assert_eq!(&info.stride(), &[320, 160, 160]);
let offsets = [0, 640 * 240 + 16, 640 * 240 + 16 + 320 * 120 + 16]; let offsets = [0, 640 * 240 + 16, 640 * 240 + 16 + 320 * 120 + 16];
let strides = [640, 320, 320]; let strides = [640, 320, 320];
let info = VideoInfo::builder(::VideoFormat::I420, 320, 240) let info = VideoInfo::builder(crate::VideoFormat::I420, 320, 240)
.offset(&offsets) .offset(&offsets)
.stride(&strides) .stride(&strides)
.size(640 * 240 + 16 + 320 * 120 + 16 + 320 * 120 + 16) .size(640 * 240 + 16 + 320 * 120 + 16 + 320 * 120 + 16)
.multiview_mode(::VideoMultiviewMode::SideBySide) .multiview_mode(crate::VideoMultiviewMode::SideBySide)
.build() .build()
.unwrap(); .unwrap();
assert_eq!(info.format(), ::VideoFormat::I420); assert_eq!(info.format(), crate::VideoFormat::I420);
assert_eq!(info.width(), 320); assert_eq!(info.width(), 320);
assert_eq!(info.height(), 240); assert_eq!(info.height(), 240);
assert_eq!( assert_eq!(
info.size(), info.size(),
640 * 240 + 16 + 320 * 120 + 16 + 320 * 120 + 16 640 * 240 + 16 + 320 * 120 + 16 + 320 * 120 + 16
); );
assert_eq!(info.multiview_mode(), ::VideoMultiviewMode::SideBySide); assert_eq!(info.multiview_mode(), crate::VideoMultiviewMode::SideBySide);
assert_eq!( assert_eq!(
&info.offset(), &info.offset(),
&[0, 640 * 240 + 16, 640 * 240 + 16 + 320 * 120 + 16] &[0, 640 * 240 + 16, 640 * 240 + 16 + 320 * 120 + 16]
@ -1131,12 +1126,15 @@ mod tests {
], ],
); );
let info = VideoInfo::from_caps(&caps).unwrap(); let info = VideoInfo::from_caps(&caps).unwrap();
assert_eq!(info.format(), ::VideoFormat::I420); assert_eq!(info.format(), crate::VideoFormat::I420);
assert_eq!(info.width(), 320); assert_eq!(info.width(), 320);
assert_eq!(info.height(), 240); assert_eq!(info.height(), 240);
assert_eq!(info.fps(), gst::Fraction::new(30, 1)); assert_eq!(info.fps(), gst::Fraction::new(30, 1));
assert_eq!(info.interlace_mode(), ::VideoInterlaceMode::Progressive); assert_eq!(
assert_eq!(info.chroma_site(), ::VideoChromaSite::MPEG2); info.interlace_mode(),
crate::VideoInterlaceMode::Progressive
);
assert_eq!(info.chroma_site(), crate::VideoChromaSite::MPEG2);
assert_eq!(info.colorimetry(), "bt709".parse().unwrap()); assert_eq!(info.colorimetry(), "bt709".parse().unwrap());
let caps2 = info.to_caps().unwrap(); let caps2 = info.to_caps().unwrap();
@ -1152,14 +1150,14 @@ mod tests {
fn test_video_align() { fn test_video_align() {
gst::init().unwrap(); gst::init().unwrap();
let mut info = ::VideoInfo::builder(::VideoFormat::Nv16, 1920, 1080) let mut info = crate::VideoInfo::builder(crate::VideoFormat::Nv16, 1920, 1080)
.build() .build()
.expect("Failed to create VideoInfo"); .expect("Failed to create VideoInfo");
assert_eq!(info.stride(), [1920, 1920]); assert_eq!(info.stride(), [1920, 1920]);
assert_eq!(info.offset(), [0, 2_073_600]); assert_eq!(info.offset(), [0, 2_073_600]);
let mut align = ::VideoAlignment::new(0, 0, 0, 8, &[0; VIDEO_MAX_PLANES]); let mut align = crate::VideoAlignment::new(0, 0, 0, 8, &[0; VIDEO_MAX_PLANES]);
assert!(info.align(&mut align)); assert!(info.align(&mut align));
assert_eq!(info.stride(), [1928, 1928]); assert_eq!(info.stride(), [1928, 1928]);
@ -1174,8 +1172,8 @@ mod tests {
gst::init().unwrap(); gst::init().unwrap();
format!("{}", ::VideoColorimetry::from_str("sRGB").unwrap()); format!("{}", crate::VideoColorimetry::from_str("sRGB").unwrap());
format!("{}", ::VideoFieldOrder::TopFieldFirst); format!("{}", crate::VideoFieldOrder::TopFieldFirst);
format!("{}", ::VideoInterlaceMode::Progressive); format!("{}", crate::VideoInterlaceMode::Progressive);
} }
} }

179
gstreamer-video/src/video_meta.rs
View file

@ -9,15 +9,11 @@
use std::fmt; use std::fmt;
use std::ptr; use std::ptr;
use glib;
use glib::translate::{from_glib, from_glib_none, FromGlib, ToGlib, ToGlibPtr}; use glib::translate::{from_glib, from_glib_none, FromGlib, ToGlib, ToGlibPtr};
use gst;
use gst::prelude::*; use gst::prelude::*;
use gst_sys;
use gst_video_sys;
#[repr(transparent)] #[repr(transparent)]
pub struct VideoMeta(gst_video_sys::GstVideoMeta); pub struct VideoMeta(ffi::GstVideoMeta);
unsafe impl Send for VideoMeta {} unsafe impl Send for VideoMeta {}
unsafe impl Sync for VideoMeta {} unsafe impl Sync for VideoMeta {}
@ -25,25 +21,28 @@ unsafe impl Sync for VideoMeta {}
impl VideoMeta { impl VideoMeta {
pub fn add( pub fn add(
buffer: &mut gst::BufferRef, buffer: &mut gst::BufferRef,
flags: ::VideoFrameFlags, flags: crate::VideoFrameFlags,
format: ::VideoFormat, format: crate::VideoFormat,
width: u32, width: u32,
height: u32, height: u32,
) -> Result<gst::MetaRefMut<Self, gst::meta::Standalone>, glib::BoolError> { ) -> Result<gst::MetaRefMut<Self, gst::meta::Standalone>, glib::BoolError> {
skip_assert_initialized!(); skip_assert_initialized!();
if format == ::VideoFormat::Unknown || format == ::VideoFormat::Encoded { if format == crate::VideoFormat::Unknown || format == crate::VideoFormat::Encoded {
return Err(glib_bool_error!("Unsupported video format {}", format)); return Err(glib::glib_bool_error!(
"Unsupported video format {}",
format
));
} }
let info = ::VideoInfo::builder(format, width, height).build()?; let info = crate::VideoInfo::builder(format, width, height).build()?;
if !info.is_valid() { if !info.is_valid() {
return Err(glib_bool_error!("Invalid video info")); return Err(glib::glib_bool_error!("Invalid video info"));
} }
if buffer.get_size() < info.size() { if buffer.get_size() < info.size() {
return Err(glib_bool_error!( return Err(glib::glib_bool_error!(
"Buffer smaller than required frame size ({} < {})", "Buffer smaller than required frame size ({} < {})",
buffer.get_size(), buffer.get_size(),
info.size() info.size()
@ -51,7 +50,7 @@ impl VideoMeta {
} }
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_meta( let meta = ffi::gst_buffer_add_video_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
flags.to_glib(), flags.to_glib(),
format.to_glib(), format.to_glib(),
@ -60,7 +59,7 @@ impl VideoMeta {
); );
if meta.is_null() { if meta.is_null() {
return Err(glib_bool_error!("Failed to add video meta")); return Err(glib::glib_bool_error!("Failed to add video meta"));
} }
Ok(Self::from_mut_ptr(buffer, meta)) Ok(Self::from_mut_ptr(buffer, meta))
@ -69,8 +68,8 @@ impl VideoMeta {
pub fn add_full<'a>( pub fn add_full<'a>(
buffer: &'a mut gst::BufferRef, buffer: &'a mut gst::BufferRef,
flags: ::VideoFrameFlags, flags: crate::VideoFrameFlags,
format: ::VideoFormat, format: crate::VideoFormat,
width: u32, width: u32,
height: u32, height: u32,
offset: &[usize], offset: &[usize],
@ -78,22 +77,25 @@ impl VideoMeta {
) -> Result<gst::MetaRefMut<'a, Self, gst::meta::Standalone>, glib::BoolError> { ) -> Result<gst::MetaRefMut<'a, Self, gst::meta::Standalone>, glib::BoolError> {
skip_assert_initialized!(); skip_assert_initialized!();
if format == ::VideoFormat::Unknown || format == ::VideoFormat::Encoded { if format == crate::VideoFormat::Unknown || format == crate::VideoFormat::Encoded {
return Err(glib_bool_error!("Unsupported video format {}", format)); return Err(glib::glib_bool_error!(
"Unsupported video format {}",
format
));
} }
let n_planes = offset.len() as u32; let n_planes = offset.len() as u32;
let info = ::VideoInfo::builder(format, width, height) let info = crate::VideoInfo::builder(format, width, height)
.offset(offset) .offset(offset)
.stride(stride) .stride(stride)
.build()?; .build()?;
if !info.is_valid() { if !info.is_valid() {
return Err(glib_bool_error!("Invalid video info")); return Err(glib::glib_bool_error!("Invalid video info"));
} }
if buffer.get_size() < info.size() { if buffer.get_size() < info.size() {
return Err(glib_bool_error!( return Err(glib::glib_bool_error!(
"Buffer smaller than required frame size ({} < {})", "Buffer smaller than required frame size ({} < {})",
buffer.get_size(), buffer.get_size(),
info.size() info.size()
@ -101,7 +103,7 @@ impl VideoMeta {
} }
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_meta_full( let meta = ffi::gst_buffer_add_video_meta_full(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
flags.to_glib(), flags.to_glib(),
format.to_glib(), format.to_glib(),
@ -113,18 +115,18 @@ impl VideoMeta {
); );
if meta.is_null() { if meta.is_null() {
return Err(glib_bool_error!("Failed to add video meta")); return Err(glib::glib_bool_error!("Failed to add video meta"));
} }
Ok(Self::from_mut_ptr(buffer, meta)) Ok(Self::from_mut_ptr(buffer, meta))
} }
} }
pub fn get_flags(&self) -> ::VideoFrameFlags { pub fn get_flags(&self) -> crate::VideoFrameFlags {
from_glib(self.0.flags) from_glib(self.0.flags)
} }
pub fn get_format(&self) -> ::VideoFormat { pub fn get_format(&self) -> crate::VideoFormat {
from_glib(self.0.format) from_glib(self.0.format)
} }
@ -154,10 +156,10 @@ impl VideoMeta {
} }
unsafe impl MetaAPI for VideoMeta { unsafe impl MetaAPI for VideoMeta {
type GstType = gst_video_sys::GstVideoMeta; type GstType = ffi::GstVideoMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_meta_api_get_type()) }
} }
} }
@ -177,7 +179,7 @@ impl fmt::Debug for VideoMeta {
} }
#[repr(transparent)] #[repr(transparent)]
pub struct VideoCropMeta(gst_video_sys::GstVideoCropMeta); pub struct VideoCropMeta(ffi::GstVideoCropMeta);
unsafe impl Send for VideoCropMeta {} unsafe impl Send for VideoCropMeta {}
unsafe impl Sync for VideoCropMeta {} unsafe impl Sync for VideoCropMeta {}
@ -189,11 +191,11 @@ impl VideoCropMeta {
) -> gst::MetaRefMut<Self, gst::meta::Standalone> { ) -> gst::MetaRefMut<Self, gst::meta::Standalone> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let meta = gst_sys::gst_buffer_add_meta( let meta = gst::ffi::gst_buffer_add_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
gst_video_sys::gst_video_crop_meta_get_info(), ffi::gst_video_crop_meta_get_info(),
ptr::null_mut(), ptr::null_mut(),
) as *mut gst_video_sys::GstVideoCropMeta; ) as *mut ffi::GstVideoCropMeta;
{ {
let meta = &mut *meta; let meta = &mut *meta;
@ -220,10 +222,10 @@ impl VideoCropMeta {
} }
unsafe impl MetaAPI for VideoCropMeta { unsafe impl MetaAPI for VideoCropMeta {
type GstType = gst_video_sys::GstVideoCropMeta; type GstType = ffi::GstVideoCropMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_crop_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_crop_meta_api_get_type()) }
} }
} }
@ -236,7 +238,7 @@ impl fmt::Debug for VideoCropMeta {
} }
#[repr(transparent)] #[repr(transparent)]
pub struct VideoRegionOfInterestMeta(gst_video_sys::GstVideoRegionOfInterestMeta); pub struct VideoRegionOfInterestMeta(ffi::GstVideoRegionOfInterestMeta);
unsafe impl Send for VideoRegionOfInterestMeta {} unsafe impl Send for VideoRegionOfInterestMeta {}
unsafe impl Sync for VideoRegionOfInterestMeta {} unsafe impl Sync for VideoRegionOfInterestMeta {}
@ -249,7 +251,7 @@ impl VideoRegionOfInterestMeta {
) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> { ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_region_of_interest_meta( let meta = ffi::gst_buffer_add_video_region_of_interest_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
roi_type.to_glib_none().0, roi_type.to_glib_none().0,
rect.0, rect.0,
@ -309,7 +311,7 @@ impl VideoRegionOfInterestMeta {
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
pub fn add_param(&mut self, s: gst::Structure) { pub fn add_param(&mut self, s: gst::Structure) {
unsafe { unsafe {
gst_video_sys::gst_video_region_of_interest_meta_add_param(&mut self.0, s.into_ptr()); ffi::gst_video_region_of_interest_meta_add_param(&mut self.0, s.into_ptr());
} }
} }
} }
@ -317,7 +319,7 @@ impl VideoRegionOfInterestMeta {
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
pub struct ParamsIter<'a> { pub struct ParamsIter<'a> {
_meta: &'a VideoRegionOfInterestMeta, _meta: &'a VideoRegionOfInterestMeta,
list: *const glib_sys::GList, list: *const glib::ffi::GList,
} }
#[cfg(feature = "v1_14")] #[cfg(feature = "v1_14")]
@ -334,7 +336,7 @@ impl<'a> Iterator for ParamsIter<'a> {
assert!(!data.is_null()); assert!(!data.is_null());
self.list = (*self.list).next; self.list = (*self.list).next;
let s = gst::StructureRef::from_glib_borrow(data as *const gst_sys::GstStructure); let s = gst::StructureRef::from_glib_borrow(data as *const gst::ffi::GstStructure);
Some(s) Some(s)
} }
@ -342,10 +344,10 @@ impl<'a> Iterator for ParamsIter<'a> {
} }
unsafe impl MetaAPI for VideoRegionOfInterestMeta { unsafe impl MetaAPI for VideoRegionOfInterestMeta {
type GstType = gst_video_sys::GstVideoRegionOfInterestMeta; type GstType = ffi::GstVideoRegionOfInterestMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_region_of_interest_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_region_of_interest_meta_api_get_type()) }
} }
} }
@ -368,7 +370,7 @@ impl fmt::Debug for VideoRegionOfInterestMeta {
} }
#[repr(transparent)] #[repr(transparent)]
pub struct VideoAffineTransformationMeta(gst_video_sys::GstVideoAffineTransformationMeta); pub struct VideoAffineTransformationMeta(ffi::GstVideoAffineTransformationMeta);
unsafe impl Send for VideoAffineTransformationMeta {} unsafe impl Send for VideoAffineTransformationMeta {}
unsafe impl Sync for VideoAffineTransformationMeta {} unsafe impl Sync for VideoAffineTransformationMeta {}
@ -380,11 +382,11 @@ impl VideoAffineTransformationMeta {
) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> { ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let meta = gst_sys::gst_buffer_add_meta( let meta = gst::ffi::gst_buffer_add_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
gst_video_sys::gst_video_affine_transformation_meta_get_info(), ffi::gst_video_affine_transformation_meta_get_info(),
ptr::null_mut(), ptr::null_mut(),
) as *mut gst_video_sys::GstVideoAffineTransformationMeta; ) as *mut ffi::GstVideoAffineTransformationMeta;
if let Some(matrix) = matrix { if let Some(matrix) = matrix {
let meta = &mut *meta; let meta = &mut *meta;
@ -405,16 +407,16 @@ impl VideoAffineTransformationMeta {
pub fn apply_matrix(&mut self, matrix: &[f32; 16]) { pub fn apply_matrix(&mut self, matrix: &[f32; 16]) {
unsafe { unsafe {
gst_video_sys::gst_video_affine_transformation_meta_apply_matrix(&mut self.0, matrix); ffi::gst_video_affine_transformation_meta_apply_matrix(&mut self.0, matrix);
} }
} }
} }
unsafe impl MetaAPI for VideoAffineTransformationMeta { unsafe impl MetaAPI for VideoAffineTransformationMeta {
type GstType = gst_video_sys::GstVideoAffineTransformationMeta; type GstType = ffi::GstVideoAffineTransformationMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_affine_transformation_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_affine_transformation_meta_api_get_type()) }
} }
} }
@ -427,7 +429,7 @@ impl fmt::Debug for VideoAffineTransformationMeta {
} }
#[repr(transparent)] #[repr(transparent)]
pub struct VideoOverlayCompositionMeta(gst_video_sys::GstVideoOverlayCompositionMeta); pub struct VideoOverlayCompositionMeta(ffi::GstVideoOverlayCompositionMeta);
unsafe impl Send for VideoOverlayCompositionMeta {} unsafe impl Send for VideoOverlayCompositionMeta {}
unsafe impl Sync for VideoOverlayCompositionMeta {} unsafe impl Sync for VideoOverlayCompositionMeta {}
@ -435,11 +437,11 @@ unsafe impl Sync for VideoOverlayCompositionMeta {}
impl VideoOverlayCompositionMeta { impl VideoOverlayCompositionMeta {
pub fn add<'a>( pub fn add<'a>(
buffer: &'a mut gst::BufferRef, buffer: &'a mut gst::BufferRef,
overlay: &::VideoOverlayComposition, overlay: &crate::VideoOverlayComposition,
) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> { ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_overlay_composition_meta( let meta = ffi::gst_buffer_add_video_overlay_composition_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
overlay.as_mut_ptr(), overlay.as_mut_ptr(),
); );
@ -448,28 +450,29 @@ impl VideoOverlayCompositionMeta {
} }
} }
pub fn get_overlay(&self) -> &::VideoOverlayCompositionRef { pub fn get_overlay(&self) -> &crate::VideoOverlayCompositionRef {
unsafe { ::VideoOverlayCompositionRef::from_ptr(self.0.overlay) } unsafe { crate::VideoOverlayCompositionRef::from_ptr(self.0.overlay) }
} }
pub fn get_overlay_owned(&self) -> ::VideoOverlayComposition { pub fn get_overlay_owned(&self) -> crate::VideoOverlayComposition {
unsafe { from_glib_none(self.get_overlay().as_ptr()) } unsafe { from_glib_none(self.get_overlay().as_ptr()) }
} }
pub fn set_overlay(&mut self, overlay: &::VideoOverlayComposition) { pub fn set_overlay(&mut self, overlay: &crate::VideoOverlayComposition) {
#![allow(clippy::cast_ptr_alignment)] #![allow(clippy::cast_ptr_alignment)]
unsafe { unsafe {
gst_sys::gst_mini_object_unref(self.0.overlay as *mut _); gst::ffi::gst_mini_object_unref(self.0.overlay as *mut _);
self.0.overlay = gst_sys::gst_mini_object_ref(overlay.as_mut_ptr() as *mut _) as *mut _; self.0.overlay =
gst::ffi::gst_mini_object_ref(overlay.as_mut_ptr() as *mut _) as *mut _;
} }
} }
} }
unsafe impl MetaAPI for VideoOverlayCompositionMeta { unsafe impl MetaAPI for VideoOverlayCompositionMeta {
type GstType = gst_video_sys::GstVideoOverlayCompositionMeta; type GstType = ffi::GstVideoOverlayCompositionMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_overlay_composition_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_overlay_composition_meta_api_get_type()) }
} }
} }
@ -484,7 +487,7 @@ impl fmt::Debug for VideoOverlayCompositionMeta {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
#[repr(transparent)] #[repr(transparent)]
pub struct VideoCaptionMeta(gst_video_sys::GstVideoCaptionMeta); pub struct VideoCaptionMeta(ffi::GstVideoCaptionMeta);
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
@ -498,13 +501,13 @@ unsafe impl Sync for VideoCaptionMeta {}
impl VideoCaptionMeta { impl VideoCaptionMeta {
pub fn add<'a>( pub fn add<'a>(
buffer: &'a mut gst::BufferRef, buffer: &'a mut gst::BufferRef,
caption_type: ::VideoCaptionType, caption_type: crate::VideoCaptionType,
data: &[u8], data: &[u8],
) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> { ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
skip_assert_initialized!(); skip_assert_initialized!();
assert!(!data.is_empty()); assert!(!data.is_empty());
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_caption_meta( let meta = ffi::gst_buffer_add_video_caption_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
caption_type.to_glib(), caption_type.to_glib(),
data.as_ptr(), data.as_ptr(),
@ -515,7 +518,7 @@ impl VideoCaptionMeta {
} }
} }
pub fn get_caption_type(&self) -> ::VideoCaptionType { pub fn get_caption_type(&self) -> crate::VideoCaptionType {
from_glib(self.0.caption_type) from_glib(self.0.caption_type)
} }
@ -531,10 +534,10 @@ impl VideoCaptionMeta {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
unsafe impl MetaAPI for VideoCaptionMeta { unsafe impl MetaAPI for VideoCaptionMeta {
type GstType = gst_video_sys::GstVideoCaptionMeta; type GstType = ffi::GstVideoCaptionMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_caption_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_caption_meta_api_get_type()) }
} }
} }
@ -552,7 +555,7 @@ impl fmt::Debug for VideoCaptionMeta {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[repr(transparent)] #[repr(transparent)]
pub struct VideoAFDMeta(gst_video_sys::GstVideoAFDMeta); pub struct VideoAFDMeta(ffi::GstVideoAFDMeta);
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
@ -567,13 +570,13 @@ impl VideoAFDMeta {
pub fn add( pub fn add(
buffer: &mut gst::BufferRef, buffer: &mut gst::BufferRef,
field: u8, field: u8,
spec: ::VideoAFDSpec, spec: crate::VideoAFDSpec,
afd: ::VideoAFDValue, afd: crate::VideoAFDValue,
) -> gst::MetaRefMut<Self, gst::meta::Standalone> { ) -> gst::MetaRefMut<Self, gst::meta::Standalone> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_afd_meta( let meta = ffi::gst_buffer_add_video_afd_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
field, field,
spec.to_glib(), spec.to_glib(),
@ -588,11 +591,11 @@ impl VideoAFDMeta {
self.0.field self.0.field
} }
pub fn get_spec(&self) -> ::VideoAFDSpec { pub fn get_spec(&self) -> crate::VideoAFDSpec {
from_glib(self.0.spec) from_glib(self.0.spec)
} }
pub fn get_afd(&self) -> ::VideoAFDValue { pub fn get_afd(&self) -> crate::VideoAFDValue {
from_glib(self.0.afd) from_glib(self.0.afd)
} }
} }
@ -600,10 +603,10 @@ impl VideoAFDMeta {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
unsafe impl MetaAPI for VideoAFDMeta { unsafe impl MetaAPI for VideoAFDMeta {
type GstType = gst_video_sys::GstVideoAFDMeta; type GstType = ffi::GstVideoAFDMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_afd_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_afd_meta_api_get_type()) }
} }
} }
@ -622,7 +625,7 @@ impl fmt::Debug for VideoAFDMeta {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[repr(transparent)] #[repr(transparent)]
pub struct VideoBarMeta(gst_video_sys::GstVideoBarMeta); pub struct VideoBarMeta(ffi::GstVideoBarMeta);
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
@ -644,7 +647,7 @@ impl VideoBarMeta {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_bar_meta( let meta = ffi::gst_buffer_add_video_bar_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
field, field,
is_letterbox.to_glib(), is_letterbox.to_glib(),
@ -676,10 +679,10 @@ impl VideoBarMeta {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
unsafe impl MetaAPI for VideoBarMeta { unsafe impl MetaAPI for VideoBarMeta {
type GstType = gst_video_sys::GstVideoBarMeta; type GstType = ffi::GstVideoBarMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_bar_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_bar_meta_api_get_type()) }
} }
} }
@ -708,15 +711,15 @@ mod tests {
{ {
let meta = VideoMeta::add( let meta = VideoMeta::add(
buffer.get_mut().unwrap(), buffer.get_mut().unwrap(),
::VideoFrameFlags::empty(), crate::VideoFrameFlags::empty(),
::VideoFormat::Argb, crate::VideoFormat::Argb,
320, 320,
240, 240,
) )
.unwrap(); .unwrap();
assert_eq!(meta.get_id(), 0); assert_eq!(meta.get_id(), 0);
assert_eq!(meta.get_flags(), ::VideoFrameFlags::empty()); assert_eq!(meta.get_flags(), crate::VideoFrameFlags::empty());
assert_eq!(meta.get_format(), ::VideoFormat::Argb); assert_eq!(meta.get_format(), crate::VideoFormat::Argb);
assert_eq!(meta.get_width(), 320); assert_eq!(meta.get_width(), 320);
assert_eq!(meta.get_height(), 240); assert_eq!(meta.get_height(), 240);
assert_eq!(meta.get_n_planes(), 1); assert_eq!(meta.get_n_planes(), 1);
@ -727,8 +730,8 @@ mod tests {
{ {
let meta = buffer.get_meta::<VideoMeta>().unwrap(); let meta = buffer.get_meta::<VideoMeta>().unwrap();
assert_eq!(meta.get_id(), 0); assert_eq!(meta.get_id(), 0);
assert_eq!(meta.get_flags(), ::VideoFrameFlags::empty()); assert_eq!(meta.get_flags(), crate::VideoFrameFlags::empty());
assert_eq!(meta.get_format(), ::VideoFormat::Argb); assert_eq!(meta.get_format(), crate::VideoFormat::Argb);
assert_eq!(meta.get_width(), 320); assert_eq!(meta.get_width(), 320);
assert_eq!(meta.get_height(), 240); assert_eq!(meta.get_height(), 240);
assert_eq!(meta.get_n_planes(), 1); assert_eq!(meta.get_n_planes(), 1);
@ -745,8 +748,8 @@ mod tests {
{ {
let meta = VideoMeta::add_full( let meta = VideoMeta::add_full(
buffer.get_mut().unwrap(), buffer.get_mut().unwrap(),
::VideoFrameFlags::empty(), crate::VideoFrameFlags::empty(),
::VideoFormat::Argb, crate::VideoFormat::Argb,
320, 320,
240, 240,
&[0], &[0],
@ -754,8 +757,8 @@ mod tests {
) )
.unwrap(); .unwrap();
assert_eq!(meta.get_id(), 0); assert_eq!(meta.get_id(), 0);
assert_eq!(meta.get_flags(), ::VideoFrameFlags::empty()); assert_eq!(meta.get_flags(), crate::VideoFrameFlags::empty());
assert_eq!(meta.get_format(), ::VideoFormat::Argb); assert_eq!(meta.get_format(), crate::VideoFormat::Argb);
assert_eq!(meta.get_width(), 320); assert_eq!(meta.get_width(), 320);
assert_eq!(meta.get_height(), 240); assert_eq!(meta.get_height(), 240);
assert_eq!(meta.get_n_planes(), 1); assert_eq!(meta.get_n_planes(), 1);
@ -766,8 +769,8 @@ mod tests {
{ {
let meta = buffer.get_meta::<VideoMeta>().unwrap(); let meta = buffer.get_meta::<VideoMeta>().unwrap();
assert_eq!(meta.get_id(), 0); assert_eq!(meta.get_id(), 0);
assert_eq!(meta.get_flags(), ::VideoFrameFlags::empty()); assert_eq!(meta.get_flags(), crate::VideoFrameFlags::empty());
assert_eq!(meta.get_format(), ::VideoFormat::Argb); assert_eq!(meta.get_format(), crate::VideoFormat::Argb);
assert_eq!(meta.get_width(), 320); assert_eq!(meta.get_width(), 320);
assert_eq!(meta.get_height(), 240); assert_eq!(meta.get_height(), 240);
assert_eq!(meta.get_n_planes(), 1); assert_eq!(meta.get_n_planes(), 1);

14
gstreamer-video/src/video_overlay.rs
View file

@ -6,11 +6,9 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use crate::VideoOverlay;
use glib::translate::*; use glib::translate::*;
use gst;
use gst_video_sys;
use libc::uintptr_t; use libc::uintptr_t;
use VideoOverlay;
use glib::IsA; use glib::IsA;
@ -21,19 +19,19 @@ pub trait VideoOverlayExtManual: 'static {
impl<O: IsA<VideoOverlay>> VideoOverlayExtManual for O { impl<O: IsA<VideoOverlay>> VideoOverlayExtManual for O {
unsafe fn set_window_handle(&self, handle: uintptr_t) { unsafe fn set_window_handle(&self, handle: uintptr_t) {
gst_video_sys::gst_video_overlay_set_window_handle(self.as_ref().to_glib_none().0, handle) ffi::gst_video_overlay_set_window_handle(self.as_ref().to_glib_none().0, handle)
} }
unsafe fn got_window_handle(&self, handle: uintptr_t) { unsafe fn got_window_handle(&self, handle: uintptr_t) {
gst_video_sys::gst_video_overlay_got_window_handle(self.as_ref().to_glib_none().0, handle) ffi::gst_video_overlay_got_window_handle(self.as_ref().to_glib_none().0, handle)
} }
} }
pub fn is_video_overlay_prepare_window_handle_message(msg: &gst::MessageRef) -> bool { pub fn is_video_overlay_prepare_window_handle_message(msg: &gst::MessageRef) -> bool {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib( from_glib(ffi::gst_is_video_overlay_prepare_window_handle_message(
gst_video_sys::gst_is_video_overlay_prepare_window_handle_message(msg.as_mut_ptr()), msg.as_mut_ptr(),
) ))
} }
} }

142
gstreamer-video/src/video_overlay_composition.rs
View file

@ -9,17 +9,13 @@
use std::fmt; use std::fmt;
use std::mem; use std::mem;
use gst;
use gst_video_sys;
use glib;
use glib::translate::{from_glib, from_glib_full, from_glib_none, ToGlib, ToGlibPtr}; use glib::translate::{from_glib, from_glib_full, from_glib_none, ToGlib, ToGlibPtr};
gst_define_mini_object_wrapper!( gst::gst_define_mini_object_wrapper!(
VideoOverlayRectangle, VideoOverlayRectangle,
VideoOverlayRectangleRef, VideoOverlayRectangleRef,
gst_video_sys::GstVideoOverlayRectangle, ffi::GstVideoOverlayRectangle,
|| gst_video_sys::gst_video_overlay_rectangle_get_type() || ffi::gst_video_overlay_rectangle_get_type()
); );
impl fmt::Debug for VideoOverlayRectangle { impl fmt::Debug for VideoOverlayRectangle {
@ -45,12 +41,12 @@ impl VideoOverlayRectangle {
render_y: i32, render_y: i32,
render_width: u32, render_width: u32,
render_height: u32, render_height: u32,
flags: ::VideoOverlayFormatFlags, flags: crate::VideoOverlayFormatFlags,
) -> Self { ) -> Self {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
assert!(buffer.get_meta::<::VideoMeta>().is_some()); assert!(buffer.get_meta::<crate::VideoMeta>().is_some());
unsafe { unsafe {
from_glib_full(gst_video_sys::gst_video_overlay_rectangle_new_raw( from_glib_full(ffi::gst_video_overlay_rectangle_new_raw(
buffer.to_glib_none().0, buffer.to_glib_none().0,
render_x, render_x,
render_y, render_y,
@ -63,26 +59,24 @@ impl VideoOverlayRectangle {
} }
impl VideoOverlayRectangleRef { impl VideoOverlayRectangleRef {
pub fn get_flags(&self) -> ::VideoOverlayFormatFlags { pub fn get_flags(&self) -> crate::VideoOverlayFormatFlags {
unsafe { unsafe {
from_glib(gst_video_sys::gst_video_overlay_rectangle_get_flags( from_glib(ffi::gst_video_overlay_rectangle_get_flags(
self.as_mut_ptr(), self.as_mut_ptr(),
)) ))
} }
} }
pub fn get_global_alpha(&self) -> f32 { pub fn get_global_alpha(&self) -> f32 {
unsafe { gst_video_sys::gst_video_overlay_rectangle_get_global_alpha(self.as_mut_ptr()) } unsafe { ffi::gst_video_overlay_rectangle_get_global_alpha(self.as_mut_ptr()) }
} }
pub fn set_global_alpha(&mut self, alpha: f32) { pub fn set_global_alpha(&mut self, alpha: f32) {
unsafe { unsafe { ffi::gst_video_overlay_rectangle_set_global_alpha(self.as_mut_ptr(), alpha) }
gst_video_sys::gst_video_overlay_rectangle_set_global_alpha(self.as_mut_ptr(), alpha)
}
} }
pub fn get_seqnum(&self) -> u32 { pub fn get_seqnum(&self) -> u32 {
unsafe { gst_video_sys::gst_video_overlay_rectangle_get_seqnum(self.as_mut_ptr()) } unsafe { ffi::gst_video_overlay_rectangle_get_seqnum(self.as_mut_ptr()) }
} }
pub fn get_render_rectangle(&self) -> (i32, i32, u32, u32) { pub fn get_render_rectangle(&self) -> (i32, i32, u32, u32) {
@ -92,7 +86,7 @@ impl VideoOverlayRectangleRef {
let mut render_width = mem::MaybeUninit::uninit(); let mut render_width = mem::MaybeUninit::uninit();
let mut render_height = mem::MaybeUninit::uninit(); let mut render_height = mem::MaybeUninit::uninit();
gst_video_sys::gst_video_overlay_rectangle_get_render_rectangle( ffi::gst_video_overlay_rectangle_get_render_rectangle(
self.as_mut_ptr(), self.as_mut_ptr(),
render_x.as_mut_ptr(), render_x.as_mut_ptr(),
render_y.as_mut_ptr(), render_y.as_mut_ptr(),
@ -117,7 +111,7 @@ impl VideoOverlayRectangleRef {
render_height: u32, render_height: u32,
) { ) {
unsafe { unsafe {
gst_video_sys::gst_video_overlay_rectangle_set_render_rectangle( ffi::gst_video_overlay_rectangle_set_render_rectangle(
self.as_mut_ptr(), self.as_mut_ptr(),
render_x, render_x,
render_y, render_y,
@ -127,60 +121,54 @@ impl VideoOverlayRectangleRef {
} }
} }
pub fn get_pixels_unscaled_raw(&self, flags: ::VideoOverlayFormatFlags) -> gst::Buffer { pub fn get_pixels_unscaled_raw(&self, flags: crate::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe { unsafe {
from_glib_none( from_glib_none(ffi::gst_video_overlay_rectangle_get_pixels_unscaled_raw(
gst_video_sys::gst_video_overlay_rectangle_get_pixels_unscaled_raw(
self.as_mut_ptr(),
flags.to_glib(),
),
)
}
}
pub fn get_pixels_unscaled_ayuv(&self, flags: ::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe {
from_glib_none(
gst_video_sys::gst_video_overlay_rectangle_get_pixels_unscaled_ayuv(
self.as_mut_ptr(),
flags.to_glib(),
),
)
}
}
pub fn get_pixels_unscaled_argb(&self, flags: ::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe {
from_glib_none(
gst_video_sys::gst_video_overlay_rectangle_get_pixels_unscaled_argb(
self.as_mut_ptr(),
flags.to_glib(),
),
)
}
}
pub fn get_pixels_raw(&self, flags: ::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe {
from_glib_none(gst_video_sys::gst_video_overlay_rectangle_get_pixels_raw(
self.as_mut_ptr(), self.as_mut_ptr(),
flags.to_glib(), flags.to_glib(),
)) ))
} }
} }
pub fn get_pixels_ayuv(&self, flags: ::VideoOverlayFormatFlags) -> gst::Buffer { pub fn get_pixels_unscaled_ayuv(&self, flags: crate::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe { unsafe {
from_glib_none(gst_video_sys::gst_video_overlay_rectangle_get_pixels_ayuv( from_glib_none(ffi::gst_video_overlay_rectangle_get_pixels_unscaled_ayuv(
self.as_mut_ptr(), self.as_mut_ptr(),
flags.to_glib(), flags.to_glib(),
)) ))
} }
} }
pub fn get_pixels_argb(&self, flags: ::VideoOverlayFormatFlags) -> gst::Buffer { pub fn get_pixels_unscaled_argb(&self, flags: crate::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe { unsafe {
from_glib_none(gst_video_sys::gst_video_overlay_rectangle_get_pixels_argb( from_glib_none(ffi::gst_video_overlay_rectangle_get_pixels_unscaled_argb(
self.as_mut_ptr(),
flags.to_glib(),
))
}
}
pub fn get_pixels_raw(&self, flags: crate::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe {
from_glib_none(ffi::gst_video_overlay_rectangle_get_pixels_raw(
self.as_mut_ptr(),
flags.to_glib(),
))
}
}
pub fn get_pixels_ayuv(&self, flags: crate::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe {
from_glib_none(ffi::gst_video_overlay_rectangle_get_pixels_ayuv(
self.as_mut_ptr(),
flags.to_glib(),
))
}
}
pub fn get_pixels_argb(&self, flags: crate::VideoOverlayFormatFlags) -> gst::Buffer {
unsafe {
from_glib_none(ffi::gst_video_overlay_rectangle_get_pixels_argb(
self.as_mut_ptr(), self.as_mut_ptr(),
flags.to_glib(), flags.to_glib(),
)) ))
@ -188,11 +176,11 @@ impl VideoOverlayRectangleRef {
} }
} }
gst_define_mini_object_wrapper!( gst::gst_define_mini_object_wrapper!(
VideoOverlayComposition, VideoOverlayComposition,
VideoOverlayCompositionRef, VideoOverlayCompositionRef,
gst_video_sys::GstVideoOverlayComposition, ffi::GstVideoOverlayComposition,
|| gst_video_sys::gst_video_overlay_composition_get_type() || ffi::gst_video_overlay_composition_get_type()
); );
impl fmt::Debug for VideoOverlayComposition { impl fmt::Debug for VideoOverlayComposition {
@ -216,16 +204,19 @@ impl VideoOverlayComposition {
let mut iter = rects.into_iter(); let mut iter = rects.into_iter();
let first = match iter.next() { let first = match iter.next() {
None => return Err(glib_bool_error!("Failed to create VideoOverlayComposition")), None => {
return Err(glib::glib_bool_error!(
"Failed to create VideoOverlayComposition"
))
}
Some(first) => first, Some(first) => first,
}; };
let composition = Self::from_glib_full( let composition =
gst_video_sys::gst_video_overlay_composition_new(first.as_mut_ptr()), Self::from_glib_full(ffi::gst_video_overlay_composition_new(first.as_mut_ptr()));
);
for rect in iter { for rect in iter {
gst_video_sys::gst_video_overlay_composition_add_rectangle( ffi::gst_video_overlay_composition_add_rectangle(
composition.as_mut_ptr(), composition.as_mut_ptr(),
rect.as_mut_ptr(), rect.as_mut_ptr(),
); );
@ -238,39 +229,36 @@ impl VideoOverlayComposition {
impl VideoOverlayCompositionRef { impl VideoOverlayCompositionRef {
pub fn n_rectangles(&self) -> u32 { pub fn n_rectangles(&self) -> u32 {
unsafe { gst_video_sys::gst_video_overlay_composition_n_rectangles(self.as_mut_ptr()) } unsafe { ffi::gst_video_overlay_composition_n_rectangles(self.as_mut_ptr()) }
} }
pub fn get_rectangle(&self, idx: u32) -> Result<VideoOverlayRectangle, glib::error::BoolError> { pub fn get_rectangle(&self, idx: u32) -> Result<VideoOverlayRectangle, glib::error::BoolError> {
if idx >= self.n_rectangles() { if idx >= self.n_rectangles() {
return Err(glib_bool_error!("Invalid index")); return Err(glib::glib_bool_error!("Invalid index"));
} }
unsafe { unsafe {
match from_glib_none(gst_video_sys::gst_video_overlay_composition_get_rectangle( match from_glib_none(ffi::gst_video_overlay_composition_get_rectangle(
self.as_mut_ptr(), self.as_mut_ptr(),
idx, idx,
)) { )) {
Some(r) => Ok(r), Some(r) => Ok(r),
None => Err(glib_bool_error!("Failed to get rectangle")), None => Err(glib::glib_bool_error!("Failed to get rectangle")),
} }
} }
} }
pub fn get_seqnum(&self) -> u32 { pub fn get_seqnum(&self) -> u32 {
unsafe { gst_video_sys::gst_video_overlay_composition_get_seqnum(self.as_mut_ptr()) } unsafe { ffi::gst_video_overlay_composition_get_seqnum(self.as_mut_ptr()) }
} }
pub fn blend( pub fn blend(
&self, &self,
frame: &mut ::VideoFrameRef<&mut gst::BufferRef>, frame: &mut crate::VideoFrameRef<&mut gst::BufferRef>,
) -> Result<(), glib::BoolError> { ) -> Result<(), glib::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!( glib::glib_result_from_gboolean!(
gst_video_sys::gst_video_overlay_composition_blend( ffi::gst_video_overlay_composition_blend(self.as_mut_ptr(), frame.as_mut_ptr()),
self.as_mut_ptr(),
frame.as_mut_ptr()
),
"Failed to blend overlay composition", "Failed to blend overlay composition",
) )
} }

9
gstreamer-video/src/video_rectangle.rs
View file

@ -7,7 +7,6 @@
// except according to those terms. // except according to those terms.
use glib::translate::ToGlib; use glib::translate::ToGlib;
use gst_video_sys;
#[derive(Clone, Debug, Eq, PartialEq, Hash)] #[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub struct VideoRectangle { pub struct VideoRectangle {
@ -30,26 +29,26 @@ pub fn center_video_rectangle(
scale: bool, scale: bool,
) -> VideoRectangle { ) -> VideoRectangle {
skip_assert_initialized!(); skip_assert_initialized!();
let mut result = gst_video_sys::GstVideoRectangle { let mut result = ffi::GstVideoRectangle {
x: 0, x: 0,
y: 0, y: 0,
w: 0, w: 0,
h: 0, h: 0,
}; };
let src_rect = gst_video_sys::GstVideoRectangle { let src_rect = ffi::GstVideoRectangle {
x: src.x, x: src.x,
y: src.y, y: src.y,
w: src.w, w: src.w,
h: src.h, h: src.h,
}; };
let dst_rect = gst_video_sys::GstVideoRectangle { let dst_rect = ffi::GstVideoRectangle {
x: dst.x, x: dst.x,
y: dst.y, y: dst.y,
w: dst.w, w: dst.w,
h: dst.h, h: dst.h,
}; };
unsafe { unsafe {
gst_video_sys::gst_video_sink_center_rect(src_rect, dst_rect, &mut result, scale.to_glib()); ffi::gst_video_sink_center_rect(src_rect, dst_rect, &mut result, scale.to_glib());
} }
VideoRectangle::new(result.x, result.y, result.w, result.h) VideoRectangle::new(result.x, result.y, result.w, result.h)
} }

143
gstreamer-video/src/video_time_code.rs
View file

@ -6,15 +6,10 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use glib;
use glib::prelude::*; use glib::prelude::*;
use glib::translate::*; use glib::translate::*;
use glib::value; use glib::value;
use glib_sys;
use gobject_sys;
use gst;
use gst::prelude::*; use gst::prelude::*;
use gst_video_sys;
use std::cmp; use std::cmp;
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
use std::fmt; use std::fmt;
@ -24,20 +19,20 @@ use std::ptr;
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
use std::str; use std::str;
use VideoTimeCodeFlags; use crate::VideoTimeCodeFlags;
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
use VideoTimeCodeInterval; use crate::VideoTimeCodeInterval;
pub struct VideoTimeCode(gst_video_sys::GstVideoTimeCode); pub struct VideoTimeCode(ffi::GstVideoTimeCode);
pub struct ValidVideoTimeCode(gst_video_sys::GstVideoTimeCode); pub struct ValidVideoTimeCode(ffi::GstVideoTimeCode);
impl VideoTimeCode { impl VideoTimeCode {
pub fn new_empty() -> VideoTimeCode { pub fn new_empty() -> VideoTimeCode {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut v = mem::MaybeUninit::zeroed(); let mut v = mem::MaybeUninit::zeroed();
gst_video_sys::gst_video_time_code_clear(v.as_mut_ptr()); ffi::gst_video_time_code_clear(v.as_mut_ptr());
VideoTimeCode(v.assume_init()) VideoTimeCode(v.assume_init())
} }
} }
@ -56,7 +51,7 @@ impl VideoTimeCode {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut v = mem::MaybeUninit::zeroed(); let mut v = mem::MaybeUninit::zeroed();
gst_video_sys::gst_video_time_code_init( ffi::gst_video_time_code_init(
v.as_mut_ptr(), v.as_mut_ptr(),
*fps.numer() as u32, *fps.numer() as u32,
*fps.denom() as u32, *fps.denom() as u32,
@ -85,7 +80,7 @@ impl VideoTimeCode {
assert!(*fps.denom() > 0); assert!(*fps.denom() > 0);
unsafe { unsafe {
let mut v = mem::MaybeUninit::zeroed(); let mut v = mem::MaybeUninit::zeroed();
let res = gst_video_sys::gst_video_time_code_init_from_date_time_full( let res = ffi::gst_video_time_code_init_from_date_time_full(
v.as_mut_ptr(), v.as_mut_ptr(),
*fps.numer() as u32, *fps.numer() as u32,
*fps.denom() as u32, *fps.denom() as u32,
@ -94,8 +89,8 @@ impl VideoTimeCode {
field_count, field_count,
); );
if res == glib_sys::GFALSE { if res == glib::ffi::GFALSE {
Err(glib_bool_error!("Failed to init video time code")) Err(glib::glib_bool_error!("Failed to init video time code"))
} else { } else {
Ok(VideoTimeCode(v.assume_init())) Ok(VideoTimeCode(v.assume_init()))
} }
@ -103,11 +98,7 @@ impl VideoTimeCode {
} }
pub fn is_valid(&self) -> bool { pub fn is_valid(&self) -> bool {
unsafe { unsafe { from_glib(ffi::gst_video_time_code_is_valid(self.to_glib_none().0)) }
from_glib(gst_video_sys::gst_video_time_code_is_valid(
self.to_glib_none().0,
))
}
} }
pub fn set_fps(&mut self, fps: gst::Fraction) { pub fn set_fps(&mut self, fps: gst::Fraction) {
@ -181,7 +172,9 @@ impl ValidVideoTimeCode {
); );
match tc.try_into() { match tc.try_into() {
Ok(v) => Ok(v), Ok(v) => Ok(v),
Err(_) => Err(glib_bool_error!("Failed to create new ValidVideoTimeCode")), Err(_) => Err(glib::glib_bool_error!(
"Failed to create new ValidVideoTimeCode"
)),
} }
} }
@ -200,7 +193,7 @@ impl ValidVideoTimeCode {
pub fn add_frames(&mut self, frames: i64) { pub fn add_frames(&mut self, frames: i64) {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
gst_video_sys::gst_video_time_code_add_frames(self.to_glib_none_mut().0, frames); ffi::gst_video_time_code_add_frames(self.to_glib_none_mut().0, frames);
} }
} }
@ -211,43 +204,39 @@ impl ValidVideoTimeCode {
tc_inter: &VideoTimeCodeInterval, tc_inter: &VideoTimeCodeInterval,
) -> Result<ValidVideoTimeCode, glib::error::BoolError> { ) -> Result<ValidVideoTimeCode, glib::error::BoolError> {
unsafe { unsafe {
match from_glib_full(gst_video_sys::gst_video_time_code_add_interval( match from_glib_full(ffi::gst_video_time_code_add_interval(
self.to_glib_none().0, self.to_glib_none().0,
tc_inter.to_glib_none().0, tc_inter.to_glib_none().0,
)) { )) {
Some(i) => Ok(i), Some(i) => Ok(i),
None => Err(glib_bool_error!("Failed to add interval")), None => Err(glib::glib_bool_error!("Failed to add interval")),
} }
} }
} }
fn compare(&self, tc2: &ValidVideoTimeCode) -> i32 { fn compare(&self, tc2: &ValidVideoTimeCode) -> i32 {
unsafe { unsafe { ffi::gst_video_time_code_compare(self.to_glib_none().0, tc2.to_glib_none().0) }
gst_video_sys::gst_video_time_code_compare(self.to_glib_none().0, tc2.to_glib_none().0)
}
} }
pub fn frames_since_daily_jam(&self) -> u64 { pub fn frames_since_daily_jam(&self) -> u64 {
unsafe { gst_video_sys::gst_video_time_code_frames_since_daily_jam(self.to_glib_none().0) } unsafe { ffi::gst_video_time_code_frames_since_daily_jam(self.to_glib_none().0) }
} }
pub fn increment_frame(&mut self) { pub fn increment_frame(&mut self) {
unsafe { unsafe {
gst_video_sys::gst_video_time_code_increment_frame(self.to_glib_none_mut().0); ffi::gst_video_time_code_increment_frame(self.to_glib_none_mut().0);
} }
} }
pub fn nsec_since_daily_jam(&self) -> u64 { pub fn nsec_since_daily_jam(&self) -> u64 {
unsafe { gst_video_sys::gst_video_time_code_nsec_since_daily_jam(self.to_glib_none().0) } unsafe { ffi::gst_video_time_code_nsec_since_daily_jam(self.to_glib_none().0) }
} }
pub fn to_date_time(&self) -> Result<glib::DateTime, glib::error::BoolError> { pub fn to_date_time(&self) -> Result<glib::DateTime, glib::error::BoolError> {
unsafe { unsafe {
match from_glib_full(gst_video_sys::gst_video_time_code_to_date_time( match from_glib_full(ffi::gst_video_time_code_to_date_time(self.to_glib_none().0)) {
self.to_glib_none().0,
)) {
Some(d) => Ok(d), Some(d) => Ok(d),
None => Err(glib_bool_error!( None => Err(glib::glib_bool_error!(
"Failed to convert VideoTimeCode to date time" "Failed to convert VideoTimeCode to date time"
)), )),
} }
@ -293,7 +282,7 @@ macro_rules! generic_impl {
pub fn set_latest_daily_jam(&mut self, latest_daily_jam: Option<&glib::DateTime>) { pub fn set_latest_daily_jam(&mut self, latest_daily_jam: Option<&glib::DateTime>) {
unsafe { unsafe {
if !self.0.config.latest_daily_jam.is_null() { if !self.0.config.latest_daily_jam.is_null() {
glib_sys::g_date_time_unref(self.0.config.latest_daily_jam); glib::ffi::g_date_time_unref(self.0.config.latest_daily_jam);
} }
self.0.config.latest_daily_jam = latest_daily_jam.to_glib_full() self.0.config.latest_daily_jam = latest_daily_jam.to_glib_full()
@ -306,7 +295,7 @@ macro_rules! generic_impl {
unsafe { unsafe {
let v = self.0; let v = self.0;
if !v.config.latest_daily_jam.is_null() { if !v.config.latest_daily_jam.is_null() {
glib_sys::g_date_time_ref(v.config.latest_daily_jam); glib::ffi::g_date_time_ref(v.config.latest_daily_jam);
} }
$name(v) $name(v)
@ -318,7 +307,7 @@ macro_rules! generic_impl {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
if !self.0.config.latest_daily_jam.is_null() { if !self.0.config.latest_daily_jam.is_null() {
glib_sys::g_date_time_unref(self.0.config.latest_daily_jam); glib::ffi::g_date_time_unref(self.0.config.latest_daily_jam);
} }
} }
} }
@ -343,7 +332,7 @@ macro_rules! generic_impl {
#[inline] #[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let s = unsafe { let s = unsafe {
glib::GString::from_glib_full(gst_video_sys::gst_video_time_code_to_string( glib::GString::from_glib_full(ffi::gst_video_time_code_to_string(
self.to_glib_none().0, self.to_glib_none().0,
)) ))
}; };
@ -356,45 +345,43 @@ macro_rules! generic_impl {
#[doc(hidden)] #[doc(hidden)]
impl GlibPtrDefault for $name { impl GlibPtrDefault for $name {
type GlibType = *mut gst_video_sys::GstVideoTimeCode; type GlibType = *mut ffi::GstVideoTimeCode;
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> ToGlibPtr<'a, *const gst_video_sys::GstVideoTimeCode> for $name { impl<'a> ToGlibPtr<'a, *const ffi::GstVideoTimeCode> for $name {
type Storage = &'a Self; type Storage = &'a Self;
#[inline] #[inline]
fn to_glib_none(&'a self) -> Stash<'a, *const gst_video_sys::GstVideoTimeCode, Self> { fn to_glib_none(&'a self) -> Stash<'a, *const ffi::GstVideoTimeCode, Self> {
Stash(&self.0 as *const _, self) Stash(&self.0 as *const _, self)
} }
#[inline] #[inline]
fn to_glib_full(&self) -> *const gst_video_sys::GstVideoTimeCode { fn to_glib_full(&self) -> *const ffi::GstVideoTimeCode {
unsafe { gst_video_sys::gst_video_time_code_copy(&self.0 as *const _) } unsafe { ffi::gst_video_time_code_copy(&self.0 as *const _) }
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> ToGlibPtrMut<'a, *mut gst_video_sys::GstVideoTimeCode> for $name { impl<'a> ToGlibPtrMut<'a, *mut ffi::GstVideoTimeCode> for $name {
type Storage = &'a mut Self; type Storage = &'a mut Self;
#[inline] #[inline]
fn to_glib_none_mut( fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::GstVideoTimeCode, Self> {
&'a mut self,
) -> StashMut<'a, *mut gst_video_sys::GstVideoTimeCode, Self> {
let ptr = &mut self.0 as *mut _; let ptr = &mut self.0 as *mut _;
StashMut(ptr, self) StashMut(ptr, self)
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrNone<*mut gst_video_sys::GstVideoTimeCode> for $name { impl FromGlibPtrNone<*mut ffi::GstVideoTimeCode> for $name {
#[inline] #[inline]
unsafe fn from_glib_none(ptr: *mut gst_video_sys::GstVideoTimeCode) -> Self { unsafe fn from_glib_none(ptr: *mut ffi::GstVideoTimeCode) -> Self {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
let v = ptr::read(ptr); let v = ptr::read(ptr);
if !v.config.latest_daily_jam.is_null() { if !v.config.latest_daily_jam.is_null() {
glib_sys::g_date_time_ref(v.config.latest_daily_jam); glib::ffi::g_date_time_ref(v.config.latest_daily_jam);
} }
$name(v) $name(v)
@ -402,13 +389,13 @@ macro_rules! generic_impl {
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrNone<*const gst_video_sys::GstVideoTimeCode> for $name { impl FromGlibPtrNone<*const ffi::GstVideoTimeCode> for $name {
#[inline] #[inline]
unsafe fn from_glib_none(ptr: *const gst_video_sys::GstVideoTimeCode) -> Self { unsafe fn from_glib_none(ptr: *const ffi::GstVideoTimeCode) -> Self {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
let v = ptr::read(ptr); let v = ptr::read(ptr);
if !v.config.latest_daily_jam.is_null() { if !v.config.latest_daily_jam.is_null() {
glib_sys::g_date_time_ref(v.config.latest_daily_jam); glib::ffi::g_date_time_ref(v.config.latest_daily_jam);
} }
$name(v) $name(v)
@ -416,26 +403,24 @@ macro_rules! generic_impl {
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrFull<*mut gst_video_sys::GstVideoTimeCode> for $name { impl FromGlibPtrFull<*mut ffi::GstVideoTimeCode> for $name {
#[inline] #[inline]
unsafe fn from_glib_full(ptr: *mut gst_video_sys::GstVideoTimeCode) -> Self { unsafe fn from_glib_full(ptr: *mut ffi::GstVideoTimeCode) -> Self {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
let v = ptr::read(ptr); let v = ptr::read(ptr);
if !v.config.latest_daily_jam.is_null() { if !v.config.latest_daily_jam.is_null() {
glib_sys::g_date_time_ref(v.config.latest_daily_jam); glib::ffi::g_date_time_ref(v.config.latest_daily_jam);
} }
gst_video_sys::gst_video_time_code_free(ptr); ffi::gst_video_time_code_free(ptr);
$name(v) $name(v)
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrBorrow<*mut gst_video_sys::GstVideoTimeCode> for $name { impl FromGlibPtrBorrow<*mut ffi::GstVideoTimeCode> for $name {
#[inline] #[inline]
unsafe fn from_glib_borrow( unsafe fn from_glib_borrow(ptr: *mut ffi::GstVideoTimeCode) -> Borrowed<Self> {
ptr: *mut gst_video_sys::GstVideoTimeCode,
) -> Borrowed<Self> {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
let v = ptr::read(ptr); let v = ptr::read(ptr);
@ -445,26 +430,26 @@ macro_rules! generic_impl {
impl StaticType for $name { impl StaticType for $name {
fn static_type() -> glib::Type { fn static_type() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_time_code_get_type()) } unsafe { from_glib(ffi::gst_video_time_code_get_type()) }
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> value::FromValueOptional<'a> for $name { impl<'a> value::FromValueOptional<'a> for $name {
unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> { unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
Option::<$name>::from_glib_none(gobject_sys::g_value_get_boxed( Option::<$name>::from_glib_none(glib::gobject_ffi::g_value_get_boxed(
value.to_glib_none().0, value.to_glib_none().0,
) as *mut gst_video_sys::GstVideoTimeCode) ) as *mut ffi::GstVideoTimeCode)
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl value::SetValue for $name { impl value::SetValue for $name {
unsafe fn set_value(value: &mut glib::Value, this: &Self) { unsafe fn set_value(value: &mut glib::Value, this: &Self) {
gobject_sys::g_value_set_boxed( glib::gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0, value.to_glib_none_mut().0,
ToGlibPtr::<*const gst_video_sys::GstVideoTimeCode>::to_glib_none(this).0 ToGlibPtr::<*const ffi::GstVideoTimeCode>::to_glib_none(this).0
as glib_sys::gpointer, as glib::ffi::gpointer,
) )
} }
} }
@ -472,10 +457,10 @@ macro_rules! generic_impl {
#[doc(hidden)] #[doc(hidden)]
impl value::SetValueOptional for $name { impl value::SetValueOptional for $name {
unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) { unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) {
gobject_sys::g_value_set_boxed( glib::gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0, value.to_glib_none_mut().0,
ToGlibPtr::<*const gst_video_sys::GstVideoTimeCode>::to_glib_none(&this).0 ToGlibPtr::<*const ffi::GstVideoTimeCode>::to_glib_none(&this).0
as glib_sys::gpointer, as glib::ffi::gpointer,
) )
} }
} }
@ -493,10 +478,10 @@ impl str::FromStr for VideoTimeCode {
fn from_str(s: &str) -> Result<Self, glib::error::BoolError> { fn from_str(s: &str) -> Result<Self, glib::error::BoolError> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
Option::<VideoTimeCode>::from_glib_full( Option::<VideoTimeCode>::from_glib_full(ffi::gst_video_time_code_new_from_string(
gst_video_sys::gst_video_time_code_new_from_string(s.to_glib_none().0), s.to_glib_none().0,
) ))
.ok_or_else(|| glib_bool_error!("Failed to create VideoTimeCode from string")) .ok_or_else(|| glib::glib_bool_error!("Failed to create VideoTimeCode from string"))
} }
} }
} }
@ -532,7 +517,7 @@ impl From<ValidVideoTimeCode> for VideoTimeCode {
} }
#[repr(transparent)] #[repr(transparent)]
pub struct VideoTimeCodeMeta(gst_video_sys::GstVideoTimeCodeMeta); pub struct VideoTimeCodeMeta(ffi::GstVideoTimeCodeMeta);
unsafe impl Send for VideoTimeCodeMeta {} unsafe impl Send for VideoTimeCodeMeta {}
unsafe impl Sync for VideoTimeCodeMeta {} unsafe impl Sync for VideoTimeCodeMeta {}
@ -544,7 +529,7 @@ impl VideoTimeCodeMeta {
) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> { ) -> gst::MetaRefMut<'a, Self, gst::meta::Standalone> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let meta = gst_video_sys::gst_buffer_add_video_time_code_meta( let meta = ffi::gst_buffer_add_video_time_code_meta(
buffer.as_mut_ptr(), buffer.as_mut_ptr(),
tc.to_glib_none().0 as *mut _, tc.to_glib_none().0 as *mut _,
); );
@ -560,20 +545,20 @@ impl VideoTimeCodeMeta {
pub fn set_tc(&mut self, tc: ValidVideoTimeCode) { pub fn set_tc(&mut self, tc: ValidVideoTimeCode) {
#![allow(clippy::cast_ptr_alignment)] #![allow(clippy::cast_ptr_alignment)]
unsafe { unsafe {
gst_video_sys::gst_video_time_code_clear(&mut self.0.tc); ffi::gst_video_time_code_clear(&mut self.0.tc);
self.0.tc = tc.0; self.0.tc = tc.0;
if !self.0.tc.config.latest_daily_jam.is_null() { if !self.0.tc.config.latest_daily_jam.is_null() {
glib_sys::g_date_time_ref(self.0.tc.config.latest_daily_jam); glib::ffi::g_date_time_ref(self.0.tc.config.latest_daily_jam);
} }
} }
} }
} }
unsafe impl MetaAPI for VideoTimeCodeMeta { unsafe impl MetaAPI for VideoTimeCodeMeta {
type GstType = gst_video_sys::GstVideoTimeCodeMeta; type GstType = ffi::GstVideoTimeCodeMeta;
fn get_meta_api() -> glib::Type { fn get_meta_api() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_time_code_meta_api_get_type()) } unsafe { from_glib(ffi::gst_video_time_code_meta_api_get_type()) }
} }
} }

74
gstreamer-video/src/video_time_code_interval.rs
View file

@ -6,13 +6,9 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use glib;
use glib::prelude::*; use glib::prelude::*;
use glib::translate::*; use glib::translate::*;
use glib::value; use glib::value;
use glib_sys;
use gobject_sys;
use gst_video_sys;
use std::cmp; use std::cmp;
use std::fmt; use std::fmt;
use std::mem; use std::mem;
@ -20,20 +16,14 @@ use std::ptr;
use std::str; use std::str;
#[derive(Clone)] #[derive(Clone)]
pub struct VideoTimeCodeInterval(gst_video_sys::GstVideoTimeCodeInterval); pub struct VideoTimeCodeInterval(ffi::GstVideoTimeCodeInterval);
impl VideoTimeCodeInterval { impl VideoTimeCodeInterval {
pub fn new(hours: u32, minutes: u32, seconds: u32, frames: u32) -> Self { pub fn new(hours: u32, minutes: u32, seconds: u32, frames: u32) -> Self {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut v = mem::MaybeUninit::zeroed(); let mut v = mem::MaybeUninit::zeroed();
gst_video_sys::gst_video_time_code_interval_init( ffi::gst_video_time_code_interval_init(v.as_mut_ptr(), hours, minutes, seconds, frames);
v.as_mut_ptr(),
hours,
minutes,
seconds,
frames,
);
VideoTimeCodeInterval(v.assume_init()) VideoTimeCodeInterval(v.assume_init())
} }
} }
@ -134,82 +124,80 @@ impl str::FromStr for VideoTimeCodeInterval {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
Option::<VideoTimeCodeInterval>::from_glib_full( Option::<VideoTimeCodeInterval>::from_glib_full(
gst_video_sys::gst_video_time_code_interval_new_from_string(s.to_glib_none().0), ffi::gst_video_time_code_interval_new_from_string(s.to_glib_none().0),
) )
.ok_or_else(|| glib_bool_error!("Failed to create VideoTimeCodeInterval from string")) .ok_or_else(|| {
glib::glib_bool_error!("Failed to create VideoTimeCodeInterval from string")
})
} }
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl GlibPtrDefault for VideoTimeCodeInterval { impl GlibPtrDefault for VideoTimeCodeInterval {
type GlibType = *mut gst_video_sys::GstVideoTimeCodeInterval; type GlibType = *mut ffi::GstVideoTimeCodeInterval;
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> ToGlibPtr<'a, *const gst_video_sys::GstVideoTimeCodeInterval> for VideoTimeCodeInterval { impl<'a> ToGlibPtr<'a, *const ffi::GstVideoTimeCodeInterval> for VideoTimeCodeInterval {
type Storage = &'a Self; type Storage = &'a Self;
#[inline] #[inline]
fn to_glib_none(&'a self) -> Stash<'a, *const gst_video_sys::GstVideoTimeCodeInterval, Self> { fn to_glib_none(&'a self) -> Stash<'a, *const ffi::GstVideoTimeCodeInterval, Self> {
Stash(&self.0 as *const _, self) Stash(&self.0 as *const _, self)
} }
#[inline] #[inline]
fn to_glib_full(&self) -> *const gst_video_sys::GstVideoTimeCodeInterval { fn to_glib_full(&self) -> *const ffi::GstVideoTimeCodeInterval {
unsafe { gst_video_sys::gst_video_time_code_interval_copy(&self.0 as *const _) } unsafe { ffi::gst_video_time_code_interval_copy(&self.0 as *const _) }
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> ToGlibPtrMut<'a, *mut gst_video_sys::GstVideoTimeCodeInterval> for VideoTimeCodeInterval { impl<'a> ToGlibPtrMut<'a, *mut ffi::GstVideoTimeCodeInterval> for VideoTimeCodeInterval {
type Storage = &'a mut Self; type Storage = &'a mut Self;
#[inline] #[inline]
fn to_glib_none_mut( fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::GstVideoTimeCodeInterval, Self> {
&'a mut self,
) -> StashMut<'a, *mut gst_video_sys::GstVideoTimeCodeInterval, Self> {
let ptr = &mut self.0 as *mut _; let ptr = &mut self.0 as *mut _;
StashMut(ptr, self) StashMut(ptr, self)
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrNone<*mut gst_video_sys::GstVideoTimeCodeInterval> for VideoTimeCodeInterval { impl FromGlibPtrNone<*mut ffi::GstVideoTimeCodeInterval> for VideoTimeCodeInterval {
#[inline] #[inline]
unsafe fn from_glib_none(ptr: *mut gst_video_sys::GstVideoTimeCodeInterval) -> Self { unsafe fn from_glib_none(ptr: *mut ffi::GstVideoTimeCodeInterval) -> Self {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
VideoTimeCodeInterval(ptr::read(ptr)) VideoTimeCodeInterval(ptr::read(ptr))
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrNone<*const gst_video_sys::GstVideoTimeCodeInterval> for VideoTimeCodeInterval { impl FromGlibPtrNone<*const ffi::GstVideoTimeCodeInterval> for VideoTimeCodeInterval {
#[inline] #[inline]
unsafe fn from_glib_none(ptr: *const gst_video_sys::GstVideoTimeCodeInterval) -> Self { unsafe fn from_glib_none(ptr: *const ffi::GstVideoTimeCodeInterval) -> Self {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
VideoTimeCodeInterval(ptr::read(ptr)) VideoTimeCodeInterval(ptr::read(ptr))
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrFull<*mut gst_video_sys::GstVideoTimeCodeInterval> for VideoTimeCodeInterval { impl FromGlibPtrFull<*mut ffi::GstVideoTimeCodeInterval> for VideoTimeCodeInterval {
#[inline] #[inline]
unsafe fn from_glib_full(ptr: *mut gst_video_sys::GstVideoTimeCodeInterval) -> Self { unsafe fn from_glib_full(ptr: *mut ffi::GstVideoTimeCodeInterval) -> Self {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
let res = VideoTimeCodeInterval(ptr::read(ptr)); let res = VideoTimeCodeInterval(ptr::read(ptr));
gst_video_sys::gst_video_time_code_interval_free(ptr); ffi::gst_video_time_code_interval_free(ptr);
res res
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl FromGlibPtrBorrow<*mut gst_video_sys::GstVideoTimeCodeInterval> for VideoTimeCodeInterval { impl FromGlibPtrBorrow<*mut ffi::GstVideoTimeCodeInterval> for VideoTimeCodeInterval {
#[inline] #[inline]
unsafe fn from_glib_borrow( unsafe fn from_glib_borrow(ptr: *mut ffi::GstVideoTimeCodeInterval) -> Borrowed<Self> {
ptr: *mut gst_video_sys::GstVideoTimeCodeInterval,
) -> Borrowed<Self> {
assert!(!ptr.is_null()); assert!(!ptr.is_null());
Borrowed::new(VideoTimeCodeInterval(ptr::read(ptr))) Borrowed::new(VideoTimeCodeInterval(ptr::read(ptr)))
} }
@ -217,27 +205,27 @@ impl FromGlibPtrBorrow<*mut gst_video_sys::GstVideoTimeCodeInterval> for VideoTi
impl StaticType for VideoTimeCodeInterval { impl StaticType for VideoTimeCodeInterval {
fn static_type() -> glib::Type { fn static_type() -> glib::Type {
unsafe { from_glib(gst_video_sys::gst_video_time_code_interval_get_type()) } unsafe { from_glib(ffi::gst_video_time_code_interval_get_type()) }
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl<'a> value::FromValueOptional<'a> for VideoTimeCodeInterval { impl<'a> value::FromValueOptional<'a> for VideoTimeCodeInterval {
unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> { unsafe fn from_value_optional(value: &glib::Value) -> Option<Self> {
Option::<VideoTimeCodeInterval>::from_glib_full(gobject_sys::g_value_dup_boxed( Option::<VideoTimeCodeInterval>::from_glib_full(glib::gobject_ffi::g_value_dup_boxed(
value.to_glib_none().0, value.to_glib_none().0,
) )
as *mut gst_video_sys::GstVideoTimeCodeInterval) as *mut ffi::GstVideoTimeCodeInterval)
} }
} }
#[doc(hidden)] #[doc(hidden)]
impl value::SetValue for VideoTimeCodeInterval { impl value::SetValue for VideoTimeCodeInterval {
unsafe fn set_value(value: &mut glib::Value, this: &Self) { unsafe fn set_value(value: &mut glib::Value, this: &Self) {
gobject_sys::g_value_set_boxed( glib::gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0, value.to_glib_none_mut().0,
ToGlibPtr::<*const gst_video_sys::GstVideoTimeCodeInterval>::to_glib_none(this).0 ToGlibPtr::<*const ffi::GstVideoTimeCodeInterval>::to_glib_none(this).0
as glib_sys::gpointer, as glib::ffi::gpointer,
) )
} }
} }
@ -245,10 +233,10 @@ impl value::SetValue for VideoTimeCodeInterval {
#[doc(hidden)] #[doc(hidden)]
impl value::SetValueOptional for VideoTimeCodeInterval { impl value::SetValueOptional for VideoTimeCodeInterval {
unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) { unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) {
gobject_sys::g_value_set_boxed( glib::gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0, value.to_glib_none_mut().0,
ToGlibPtr::<*const gst_video_sys::GstVideoTimeCodeInterval>::to_glib_none(&this).0 ToGlibPtr::<*const ffi::GstVideoTimeCodeInterval>::to_glib_none(&this).0
as glib_sys::gpointer, as glib::ffi::gpointer,
) )
} }
} }