mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-06-15 04:30:35 +00:00
Code Issues Projects Releases Wiki Activity

Update for glib changes in glib::Value handling

Browse source
This commit is contained in:
Sebastian Dröge 2020-10-20 16:14:10 +03:00 committed by Sebastian Dröge
parent 0207e41160
commit ba719ac90c
11 changed files with 108 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
examples/src/bin/glupload.rs
View file

@ -431,7 +431,7 @@ impl App {
{
let context = context.get_mut().unwrap();
let s = context.get_mut_structure();
s.set_value("context", gl_context.to_send_value());
s.set("context", &gl_context);
}
el.set_context(&context);
}
@ -537,9 +537,9 @@ impl App {
sink.set_property("sink", &appsink)?;
appsink.set_property("enable-last-sample", &false.to_value())?;
appsink.set_property("emit-signals", &false.to_value())?;
appsink.set_property("max-buffers", &1u32.to_value())?;
appsink.set_property("enable-last-sample", &false)?;
appsink.set_property("emit-signals", &false)?;
appsink.set_property("max-buffers", &1u32)?;
let caps = gst::Caps::builder("video/x-raw")
.features(&[&gst_gl::CAPS_FEATURE_MEMORY_GL_MEMORY])

4
examples/src/bin/gtksink.rs
View file

@ -34,9 +34,7 @@ fn create_ui(app: &gtk::Application) {
// video frames to our texture (if they are not already in the GPU). Now we tell the OpenGL-sink
// about our gtkglsink element, form where it will retrieve the OpenGL texture to fill.
let glsinkbin = gst::ElementFactory::make("glsinkbin", None).unwrap();
glsinkbin
.set_property("sink", &gtkglsink.to_value())
.unwrap();
glsinkbin.set_property("sink", &gtkglsink).unwrap();
// The gtkglsink creates the gtk widget for us. This is accessible through a property.
// So we get it and use it later to add it to our gui.
let widget = gtkglsink.get_property("widget").unwrap();

9
examples/src/bin/playbin.rs
View file

@ -29,9 +29,7 @@ fn example_main() {
// Create a new playbin element, and tell it what uri to play back.
let playbin = gst::ElementFactory::make("playbin", None).unwrap();
playbin
.set_property("uri", &glib::Value::from(uri))
.unwrap();
playbin.set_property("uri", &uri).unwrap();
// For flags handling
// With flags, one can configure playbin's behavior such as whether it
@ -79,10 +77,7 @@ fn example_main() {
// application is via properties, signals or action signals (or custom messages, events, queries).
// So what the following code does, is essentially asking playbin to tell us its already
// internally stored tag list for this stream index.
let tags = playbin
.emit("get-audio-tags", &[&idx.to_value()])
.unwrap()
.unwrap();
let tags = playbin.emit("get-audio-tags", &[&idx]).unwrap().unwrap();
let tags = tags.get::<gst::TagList>().expect("tags").unwrap();
if let Some(artist) = tags.get::<gst::tags::Artist>() {

27
examples/src/bin/rtpfecclient.rs
View file

@ -83,12 +83,15 @@ fn connect_rtpbin_srcpad(src_pad: &gst::Pad, sink: &gst::Element) -> Result<(),
fn make_fec_decoder(rtpbin: &gst::Element, sess_id: u32) -> Result<gst::Element, Error> {
let fecdec = make_element("rtpulpfecdec", None)?;
let internal_storage = rtpbin
.emit("get-internal-storage", &[&sess_id.to_value()])
.emit("get-internal-storage", &[&sess_id])
.unwrap()
.unwrap();
.unwrap()
.get::<glib::Object>()
.unwrap()
.expect("No internal-storage");
fecdec.set_property("storage", &internal_storage.to_value())?;
fecdec.set_property("pt", &100u32.to_value())?;
fecdec.set_property("storage", &internal_storage)?;
fecdec.set_property("pt", &100u32)?;
Ok(fecdec)
}
@ -130,7 +133,7 @@ fn example_main() -> Result<(), Error> {
pipeline.add_many(&[&enc, &mux, &sink])?;
gst::Element::link_many(&[&filter, &enc, &mux, &sink])?;
sink.set_property("location", &"out.mkv".to_value())?;
sink.set_property("location", &"out.mkv")?;
enc.set_property_from_str("tune", "zerolatency");
eprintln!("Recording to out.mkv");
}
@ -144,9 +147,7 @@ fn example_main() -> Result<(), Error> {
.get::<gst::Element>()
.expect("rtpbin \"new-storage\" signal values[1]")
.expect("rtpbin \"new-storage\" signal values[1]: no `Element`");
storage
.set_property("size-time", &250_000_000u64.to_value())
.unwrap();
storage.set_property("size-time", &250_000_000u64).unwrap();
None
})?;
@ -234,11 +235,11 @@ fn example_main() -> Result<(), Error> {
let video_caps =
gst::Caps::new_simple("video/x-raw", &[("width", &1920i32), ("height", &1080i32)]);
src.set_property("address", &"127.0.0.1".to_value())?;
src.set_property("caps", &rtp_caps.to_value())?;
netsim.set_property("drop-probability", &drop_probability.to_value())?;
rtpbin.set_property("do-lost", &true.to_value())?;
filter.set_property("caps", &video_caps.to_value())?;
src.set_property("address", &"127.0.0.1")?;
src.set_property("caps", &rtp_caps)?;
netsim.set_property("drop-probability", &drop_probability)?;
rtpbin.set_property("do-lost", &true)?;
filter.set_property("caps", &video_caps)?;
let bus = pipeline
.get_bus()

24
examples/src/bin/rtpfecserver.rs
View file

@ -70,9 +70,9 @@ fn connect_decodebin_pad(src_pad: &gst::Pad, sink: &gst::Element) -> Result<(),
fn make_fec_encoder(fec_percentage: u32) -> Result<gst::Element, Error> {
let fecenc = make_element("rtpulpfecenc", None)?;
fecenc.set_property("pt", &100u32.to_value())?;
fecenc.set_property("multipacket", &true.to_value())?;
fecenc.set_property("percentage", &fec_percentage.to_value())?;
fecenc.set_property("pt", &100u32)?;
fecenc.set_property("multipacket", &true)?;
fecenc.set_property("percentage", &fec_percentage)?;
Ok(fecenc)
}
@ -151,16 +151,16 @@ fn example_main() -> Result<(), Error> {
let video_caps = gst::Caps::new_simple("video/x-raw", &[]);
src.set_property_from_str("pattern", "ball");
sink.set_property("host", &"127.0.0.1".to_value())?;
sink.set_property("sync", &true.to_value())?;
enc.set_property("keyframe-max-dist", &30i32.to_value())?;
enc.set_property("threads", &12i32.to_value())?;
enc.set_property("cpu-used", &(-16i32).to_value())?;
enc.set_property("deadline", &1i64.to_value())?;
sink.set_property("host", &"127.0.0.1")?;
sink.set_property("sync", &true)?;
enc.set_property("keyframe-max-dist", &30i32)?;
enc.set_property("threads", &12i32)?;
enc.set_property("cpu-used", &(-16i32))?;
enc.set_property("deadline", &1i64)?;
enc.set_property_from_str("error-resilient", "default");
src.set_property("expose-all-streams", &false.to_value())?;
src.set_property("caps", &video_caps.to_value())?;
src.set_property("uri", &uri.to_value())?;
src.set_property("expose-all-streams", &false)?;
src.set_property("caps", &video_caps)?;
src.set_property("uri", &uri)?;
let bus = pipeline
.get_bus()

3
examples/src/bin/toc.rs
View file

@ -31,8 +31,7 @@ fn example_main() {
let src = gst::ElementFactory::make("filesrc", None).unwrap();
let decodebin = gst::ElementFactory::make("decodebin", None).unwrap();
src.set_property("location", &glib::Value::from(uri))
.unwrap();
src.set_property("location", &uri).unwrap();
pipeline.add_many(&[&src, &decodebin]).unwrap();
gst::Element::link_many(&[&src, &decodebin]).unwrap();

6
examples/src/bin/transmux.rs
View file

@ -72,13 +72,13 @@ fn example_main() -> Result<(), Error> {
.expect("setting location property failed");
// Increase the queue capacity to 100MB to avoid a stalling pipeline
queue
.set_property("max-size-buffers", &0u32.to_value())
.set_property("max-size-buffers", &0u32)
.expect("changing capacity of multiqueue failed");
queue
.set_property("max-size-time", &0u64.to_value())
.set_property("max-size-time", &0u64)
.expect("changing capacity of multiqueue failed");
queue
.set_property("max-size-bytes", &(1024u32 * 1024 * 100).to_value())
.set_property("max-size-bytes", &(1024u32 * 1024 * 100))
.expect("changing capacity of multiqueue failed");
pipeline

16
gstreamer/src/tags.rs
View file

@ -374,13 +374,21 @@ impl TagListRef {
where
T: ToSendValue,
{
unsafe {
let v = value.to_send_value();
let v = value.to_send_value();
self.add_value(tag_name, &v, mode)
}
pub fn add_value(
&mut self,
tag_name: &str,
value: &glib::SendValue,
mode: TagMergeMode,
) -> Result<(), TagError> {
unsafe {
let tag_name = tag_name.to_glib_none();
let tag_type: glib::Type = from_glib(gst_sys::gst_tag_get_type(tag_name.0));
if tag_type != v.type_() {
if tag_type != value.type_() {
return Err(TagError::TypeMismatch);
}
@ -388,7 +396,7 @@ impl TagListRef {
self.as_mut_ptr(),
mode.to_glib(),
tag_name.0,
v.to_glib_none().0,
value.to_glib_none().0,
);
}

2
gstreamer/src/tags_serde.rs
View file

@ -224,7 +224,7 @@ impl<'de, 'a> Visitor<'de> for TagValuesVisitor<'a> {
match tag_value {
Some(tag_value) => self
.1
.add_generic(self.0, &tag_value, TagMergeMode::Append)
.add_value(self.0, &tag_value, TagMergeMode::Append)
.map_err(|_| {
de::Error::custom(format!("wrong value type for `Tag` {}", self.0))
})?,

12
gstreamer/src/value.rs
View file

@ -586,6 +586,12 @@ impl<'a> Array<'a> {
Array(values.iter().map(|v| v.to_send_value()).collect())
}
pub fn from_borrowed<T: AsRef<[glib::SendValue]>>(values: &'a T) -> Self {
assert_initialized_main_thread!();
Array(Cow::Borrowed(values.as_ref()))
}
pub fn from_owned(values: Vec<glib::SendValue>) -> Self {
assert_initialized_main_thread!();
@ -664,6 +670,12 @@ impl<'a> List<'a> {
List(values.iter().map(|v| v.to_send_value()).collect())
}
pub fn from_borrowed<T: AsRef<[glib::SendValue]>>(values: &'a T) -> Self {
assert_initialized_main_thread!();
List(Cow::Borrowed(values.as_ref()))
}
pub fn from_owned(values: Vec<glib::SendValue>) -> Self {
assert_initialized_main_thread!();

141
gstreamer/src/value_serde.rs
View file

@ -364,8 +364,6 @@ mod tests {
#[test]
fn test_serialize_collections() {
use glib::value::ToValue;
use Fraction;
use List;
@ -375,33 +373,20 @@ mod tests {
pretty_config.new_line = "".to_string();
// Array
let value_13 = Fraction::new(1, 3).to_value();
let send_value_13 = value_13.try_into_send_value::<Fraction>().unwrap();
let value_12 = Fraction::new(1, 2).to_value();
let send_value_12 = value_12.try_into_send_value::<Fraction>().unwrap();
let value_str = "test str".to_value();
let send_value_str = value_str.try_into_send_value::<String>().unwrap();
let str_none: Option<&str> = None;
let value_str_none = str_none.to_value();
let send_value_str_none = value_str_none.try_into_send_value::<String>().unwrap();
let value_date = Date::new_dmy(19, DateMonth::August, 2019).to_value();
let send_value_date = value_date.try_into_send_value::<Date>().unwrap();
let date_none: Option<Date> = None;
let value_date_none = date_none.to_value();
let send_value_date_none = value_date_none.try_into_send_value::<Date>().unwrap();
let value_13 = Fraction::new(1, 3);
let value_12 = Fraction::new(1, 2);
let value_str = "test str";
let value_str_none: Option<&str> = None;
let value_date = Date::new_dmy(19, DateMonth::August, 2019);
let value_date_none: Option<Date> = None;
let array = Array::new(&[
&send_value_13,
&send_value_12,
&send_value_str,
&send_value_str_none,
&send_value_date,
&send_value_date_none,
&value_13,
&value_12,
&value_str,
&value_str_none,
&value_date,
&value_date_none,
]);
let res = ron::ser::to_string_pretty(&array, pretty_config.clone());
@ -428,33 +413,18 @@ mod tests {
);
// List
let value_12 = Fraction::new(1, 2).to_value();
let send_value_12 = value_12.try_into_send_value::<Fraction>().unwrap();
let value_str = "test str".to_value();
let send_value_str = value_str.try_into_send_value::<String>().unwrap();
let str_none: Option<&str> = None;
let value_str_none = str_none.to_value();
let send_value_str_none = value_str_none.try_into_send_value::<String>().unwrap();
let value_date_time = DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64)
.unwrap()
.to_value();
let send_value_date_time = value_date_time.try_into_send_value::<DateTime>().unwrap();
let date_time_none: Option<DateTime> = None;
let value_date_time_none = date_time_none.to_value();
let send_value_date_time_none = value_date_time_none
.try_into_send_value::<DateTime>()
.unwrap();
let value_12 = Fraction::new(1, 2);
let value_str = "test str";
let value_str_none: Option<&str> = None;
let value_date_time = DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64).unwrap();
let value_date_time_none: Option<DateTime> = None;
let list = List::new(&[
&send_value_12,
&send_value_str,
&send_value_str_none,
&send_value_date_time,
&send_value_date_time_none,
&value_12,
&value_str,
&value_str_none,
&value_date_time,
&value_date_time_none,
]);
let res = ron::ser::to_string_pretty(&list, pretty_config);
@ -664,32 +634,23 @@ mod tests {
#[test]
fn test_serde_roundtrip_collection() {
use glib::value::ToValue;
::init().unwrap();
// Array
let value_13 = Fraction::new(1, 3).to_value();
let send_value_13 = value_13.try_into_send_value::<Fraction>().unwrap();
let value_12 = Fraction::new(1, 2).to_value();
let send_value_12 = value_12.try_into_send_value::<Fraction>().unwrap();
let value_str = "test str".to_value();
let send_value_str = value_str.try_into_send_value::<String>().unwrap();
let str_none: Option<&str> = None;
let value_str_none = str_none.to_value();
let send_value_str_none = value_str_none.try_into_send_value::<String>().unwrap();
let value_date = Date::new_dmy(19, DateMonth::August, 2019).to_value();
let send_value_date = value_date.try_into_send_value::<Date>().unwrap();
let date_none: Option<Date> = None;
let value_date_none = date_none.to_value();
let send_value_date_none = value_date_none.try_into_send_value::<Date>().unwrap();
let value_13 = Fraction::new(1, 3);
let value_12 = Fraction::new(1, 2);
let value_str = "test str";
let value_str_none: Option<&str> = None;
let value_date = Date::new_dmy(19, DateMonth::August, 2019);
let value_date_none: Option<Date> = None;
let array = Array::new(&[
&send_value_13,
&send_value_12,
&send_value_str,
&send_value_str_none,
&send_value_date,
&send_value_date_none,
&value_13,
&value_12,
&value_str,
&value_str_none,
&value_date,
&value_date_none,
]);
let array_ser = ron::ser::to_string(&array).unwrap();
@ -723,28 +684,18 @@ mod tests {
assert!(slice[5].get::<Date>().expect("slice[5]").is_none());
// List
let value_12 = Fraction::new(1, 2).to_value();
let send_value_12 = value_12.try_into_send_value::<Fraction>().unwrap();
let value_str = "test str".to_value();
let send_value_str = value_str.try_into_send_value::<String>().unwrap();
let str_none: Option<&str> = None;
let value_str_none = str_none.to_value();
let send_value_str_none = value_str_none.try_into_send_value::<String>().unwrap();
let value_date_time = DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64)
.unwrap()
.to_value();
let send_value_date_time = value_date_time.try_into_send_value::<DateTime>().unwrap();
let date_time_none: Option<DateTime> = None;
let value_date_time_none = date_time_none.to_value();
let send_value_date_time_none = value_date_time_none
.try_into_send_value::<DateTime>()
.unwrap();
let value_12 = Fraction::new(1, 2);
let value_str = "test str";
let value_str_none: Option<&str> = None;
let value_date_time = DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64).unwrap();
let value_date_time_none: Option<DateTime> = None;
let list = List::new(&[
&send_value_12,
&send_value_str,
&send_value_str_none,
&send_value_date_time,
&send_value_date_time_none,
&value_12,
&value_str,
&value_str_none,
&value_date_time,
&value_date_time_none,
]);
let list_ser = ron::ser::to_string(&list).unwrap();