diff --git a/Cargo.toml b/Cargo.toml index 829b8e68a..d9da316bc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,6 +13,7 @@ members = [ "gstreamer-video", "gstreamer-pbutils", "gstreamer-webrtc", + "gstreamer-check", "examples", "tutorials", ] diff --git a/Gir_GstCheck.toml b/Gir_GstCheck.toml index e053f940e..7f71d3bab 100644 --- a/Gir_GstCheck.toml +++ b/Gir_GstCheck.toml @@ -16,7 +16,6 @@ external_libraries = [ ] generate = [ - "GstCheck.TestClock", ] manual = [ @@ -31,3 +30,8 @@ manual = [ name = "Gst.ClockTime" status = "manual" conversion_type = "scalar" + +[[object]] +name = "GstCheck.TestClock" +status = "generate" +trait = false diff --git a/gstreamer-check/Cargo.toml b/gstreamer-check/Cargo.toml new file mode 100644 index 000000000..5dfd6625b --- /dev/null +++ b/gstreamer-check/Cargo.toml @@ -0,0 +1,39 @@ +[package] +name = "gstreamer-check" +version = "0.13.0" +authors = ["Sebastian Dröge "] +categories = ["api-bindings", "multimedia"] +description = "Rust bindings for GStreamer Check library" +repository = "https://github.com/sdroege/gstreamer-rs" +license = "MIT/Apache-2.0" +readme = "README.md" +homepage = "https://gstreamer.freedesktop.org" +documentation = "https://sdroege.github.io/rustdoc/gstreamer/gstreamer_check" +keywords = ["gstreamer", "multimedia", "audio", "video", "gnome"] +build = "build.rs" + +[dependencies] +bitflags = "1.0" +glib-sys = { git = "https://github.com/gtk-rs/sys" } +gobject-sys = { git = "https://github.com/gtk-rs/sys" } +gstreamer-sys = { git = "https://github.com/sdroege/gstreamer-sys", features = ["v1_8"] } +gstreamer-check-sys = { git = "https://github.com/sdroege/gstreamer-sys", features = ["v1_8"] } +glib = { git = "https://github.com/gtk-rs/glib" } +gstreamer = { path = "../gstreamer" } + +[build-dependencies.rustdoc-stripper] +version = "0.1" +optional = true + +[features] +v1_10 = ["gstreamer-sys/v1_10", "gstreamer-check-sys/v1_10"] +v1_12 = ["gstreamer-sys/v1_12", "gstreamer-check-sys/v1_12", "v1_10"] +v1_14 = ["gstreamer-sys/v1_14", "gstreamer-check-sys/v1_14", "v1_12"] +#v1_16 = ["gstreamer-sys/v1_16", "gstreamer-check-sys/v1_16", "v1_14"] +embed-lgpl-docs = ["rustdoc-stripper"] +purge-lgpl-docs = ["rustdoc-stripper"] +dox = ["gstreamer-check-sys/dox", "glib/dox", "gstreamer/dox"] +default-features = [] + +[badges] +travis-ci = { repository = "sdroege/gstreamer-rs", branch = "master" } diff --git a/gstreamer-check/LICENSE-APACHE b/gstreamer-check/LICENSE-APACHE new file mode 100644 index 000000000..16fe87b06 --- /dev/null +++ b/gstreamer-check/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/gstreamer-check/LICENSE-MIT b/gstreamer-check/LICENSE-MIT new file mode 100644 index 000000000..31aa79387 --- /dev/null +++ b/gstreamer-check/LICENSE-MIT @@ -0,0 +1,23 @@ +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/gstreamer-check/README.md b/gstreamer-check/README.md new file mode 100644 index 000000000..3dd942aab --- /dev/null +++ b/gstreamer-check/README.md @@ -0,0 +1,170 @@ +# gstreamer-rs [![crates.io](https://img.shields.io/crates/v/gstreamer-app.svg)](https://crates.io/crates/gstreamer-app) [![Build Status](https://travis-ci.org/sdroege/gstreamer-rs.svg?branch=master)](https://travis-ci.org/sdroege/gstreamer-rs) + +[GStreamer](https://gstreamer.freedesktop.org/) (Check library) bindings for Rust. +Documentation can be found [here](https://sdroege.github.io/rustdoc/gstreamer/gstreamer/). + +These bindings are providing a safe API that can be used to interface with +GStreamer, e.g. for writing GStreamer-based applications. + +For background and motivation, see the [announcement blogpost](https://coaxion.net/blog/2017/07/writing-gstreamer-applications-in-rust/). + +The bindings (since 0.8.0) are autogenerated with [gir](https://github.com/gtk-rs/gir/) +based on the [GObject-Introspection](https://wiki.gnome.org/Projects/GObjectIntrospection/) +API metadata provided by the GStreamer project. Older versions before 0.8.0 were manually +written and the repository can be found [here](https://github.com/arturoc/gstreamer1.0-rs). +The API of the two is incompatible. + +A crate for writing GStreamer plugins in Rust can be found here: https://github.com/sdroege/gst-plugin-rs + +## Table of Contents +1. [Installation](#installation) + 1. [Linux/BSDs](#installation-linux) + 1. [macOS](#installation-macos) + 1. [Windows](#installation-windows) +1. [Getting Started](#getting-started) +1. [License](#license) +1. [Contribution](#contribution) + + + +## Installation + +To build the GStreamer bindings or anything depending on them, you need to +have at least GStreamer 1.8 and gst-plugins-base 1.8 installed. In addition, +some of the examples/tutorials require various GStreamer plugins to be +available, which can be found in gst-plugins-base, gst-plugins-good, +gst-plugins-bad, gst-plugins-ugly and/or gst-libav. + + + +### Linux/BSDs + +You need to install the above mentioned packages with your distributions +package manager, or build them from source. + +On Debian/Ubuntu they can be installed with + +``` +$ apt-get install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \ + gstreamer1.0-plugins-base gstreamer1.0-plugins-good \ + gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly \ + gstreamer1.0-libav +``` + +Package names on other distributions should be similar. +Please submit a pull request with instructions for yours. + + + +### macOS + +You can install GStreamer and the plugins via [Homebrew](https://brew.sh/) or +by installing the [binaries](https://gstreamer.freedesktop.org/data/pkg/osx/) +provided by the GStreamer project. + +#### Homebrew + +``` +$ brew install gstreamer gst-plugins-base gst-plugins-good \ + gst-plugins-bad gst-plugins-ugly gst-libav +``` + +#### GStreamer Binaries + +You need to download the *two* `.pkg` files from the GStreamer website and +install them, e.g. `gstreamer-1.0-1.12.3-x86_64.pkg` and +`gstreamer-1.0-devel-1.12.3-x86_64.pkg`. + +After installation, you also need to install `pkg-config` (e.g. via Homebrew) +and set the `PKG_CONFIG_PATH` environment variable + +``` +$ export PKG_CONFIG_PATH="/Frameworks/GStreamer.framework/Versions/Current/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}" +``` + + + +### Windows + +You can install GStreamer and the plugins via [MSYS2](http://www.msys2.org/) +with `pacman` or by installing the +[binaries](https://gstreamer.freedesktop.org/data/pkg/windows/) provided by +the GStreamer project. + +#### MSYS2 / pacman + +``` +$ pacman -S pkg-config mingw-w64-x86_64-gstreamer mingw-w64-x86_64-gst-plugins-base \ + mingw-w64-x86_64-gst-plugins-good mingw-w64-x86_64-gst-plugins-bad \ + mingw-w64-x86_64-gst-plugins-ugly mingw-w64-x86_64-gst-libav +``` + +#### GStreamer Binaries + +You need to download the *two* `.msi` files for your platform from the +GStreamer website and install them, e.g. `gstreamer-1.0-x86_64-1.12.3.msi` and +`gstreamer-1.0-devel-x86_64-1.12.3.msi`. + +After installation, you also need to install `pkg-config` (e.g. via MSYS2 or +from [here](https://sourceforge.net/projects/pkgconfiglite/)) +and set the `PKG_CONFIG_PATH` environment variable + +``` +$ export PKG_CONFIG_PATH="c:\\gstreamer\\1.0\\x86_64\\lib\\pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}" +``` + + + +## Getting Started + +The API reference can be found +[here](https://sdroege.github.io/rustdoc/gstreamer/gstreamer/), however it is +only the Rust API reference and does not explain any of the concepts. + +For getting started with GStreamer development, the best would be to follow +the [documentation](https://gstreamer.freedesktop.org/documentation/) on the +GStreamer website, especially the [Application Development +Manual](https://gstreamer.freedesktop.org/documentation/application-development/). +While being C-centric, it explains all the fundamental concepts of GStreamer +and the code examples should be relatively easily translatable to Rust. The +API is basically the same, function/struct names are the same and everything +is only more convenient (hopefully) and safer. + +In addition there are +[tutorials](https://gstreamer.freedesktop.org/documentation/tutorials/) on the +GStreamer website. Many of them were ported to Rust already and the code can +be found in the +[tutorials](https://github.com/sdroege/gstreamer-rs/tree/master/tutorials) +directory. + +Some further examples for various aspects of GStreamer and how to use it from +Rust can be found in the +[examples](https://github.com/sdroege/gstreamer-rs/tree/master/examples) +directory. + + + +## LICENSE + +gstreamer-rs and all crates contained in here are licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +GStreamer itself is licensed under the Lesser General Public License version +2.1 or (at your option) any later version: +https://www.gnu.org/licenses/lgpl-2.1.html + + + +## Contribution + +Any kinds of contributions are welcome as a pull request. + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in gstreamer-rs by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/gstreamer-check/build.rs b/gstreamer-check/build.rs new file mode 100644 index 000000000..44c6bab00 --- /dev/null +++ b/gstreamer-check/build.rs @@ -0,0 +1,34 @@ +fn main() { + manage_docs(); +} + +#[cfg(any(feature = "embed-lgpl-docs", feature = "purge-lgpl-docs"))] +fn manage_docs() { + extern crate stripper_lib; + use std::io; + + let path = "src"; + let ignores: &[&str] = &[]; + + stripper_lib::loop_over_files( + path.as_ref(), + &mut |w, s| stripper_lib::strip_comments(w, s, &mut io::sink(), true), + &ignores, + false, + ); + + #[cfg(feature = "embed-lgpl-docs")] + { + let docs = include_str!("../docs/gstreamer-check/docs.md"); + let mut infos = stripper_lib::parse_cmts(docs.lines(), true); + stripper_lib::loop_over_files( + path.as_ref(), + &mut |w, s| stripper_lib::regenerate_comments(w, s, &mut infos, true, true), + &ignores, + false, + ); + } +} + +#[cfg(not(any(feature = "embed-lgpl-docs", feature = "purge-lgpl-docs")))] +fn manage_docs() {} diff --git a/gstreamer-check/src/auto/mod.rs b/gstreamer-check/src/auto/mod.rs index fbae6e9a0..132169bcb 100644 --- a/gstreamer-check/src/auto/mod.rs +++ b/gstreamer-check/src/auto/mod.rs @@ -4,9 +4,7 @@ mod test_clock; pub use self::test_clock::TestClock; -pub use self::test_clock::TestClockExt; #[doc(hidden)] pub mod traits { - pub use super::TestClockExt; } diff --git a/gstreamer-check/src/auto/test_clock.rs b/gstreamer-check/src/auto/test_clock.rs index ba38dcad0..219b75678 100644 --- a/gstreamer-check/src/auto/test_clock.rs +++ b/gstreamer-check/src/auto/test_clock.rs @@ -3,11 +3,9 @@ // DO NOT EDIT use ffi; -use glib; use glib::StaticType; use glib::Value; use glib::object::Downcast; -use glib::object::IsA; use glib::signal::SignalHandlerId; use glib::signal::connect; use glib::translate::*; @@ -46,9 +44,99 @@ impl TestClock { } } + pub fn advance_time(&self, delta: gst::ClockTimeDiff) { + unsafe { + ffi::gst_test_clock_advance_time(self.to_glib_none().0, delta); + } + } + + pub fn crank(&self) -> bool { + unsafe { + from_glib(ffi::gst_test_clock_crank(self.to_glib_none().0)) + } + } + + pub fn get_next_entry_time(&self) -> gst::ClockTime { + unsafe { + from_glib(ffi::gst_test_clock_get_next_entry_time(self.to_glib_none().0)) + } + } + + //pub fn has_id(&self, id: /*Ignored*/gst::ClockID) -> bool { + // unsafe { TODO: call ffi::gst_test_clock_has_id() } + //} + + pub fn peek_id_count(&self) -> u32 { + unsafe { + ffi::gst_test_clock_peek_id_count(self.to_glib_none().0) + } + } + + //pub fn peek_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID) -> bool { + // unsafe { TODO: call ffi::gst_test_clock_peek_next_pending_id() } + //} + + //pub fn process_id_list(&self, pending_list: /*Ignored*/&[&gst::ClockID]) -> u32 { + // unsafe { TODO: call ffi::gst_test_clock_process_id_list() } + //} + + //pub fn process_next_clock_id(&self) -> /*Ignored*/Option { + // unsafe { TODO: call ffi::gst_test_clock_process_next_clock_id() } + //} + + pub fn set_time(&self, new_time: gst::ClockTime) { + unsafe { + ffi::gst_test_clock_set_time(self.to_glib_none().0, new_time.to_glib()); + } + } + + //pub fn wait_for_multiple_pending_ids(&self, count: u32, pending_list: /*Unimplemented*/Vec) { + // unsafe { TODO: call ffi::gst_test_clock_wait_for_multiple_pending_ids() } + //} + + //pub fn wait_for_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID) { + // unsafe { TODO: call ffi::gst_test_clock_wait_for_next_pending_id() } + //} + + pub fn wait_for_pending_id_count(&self, count: u32) { + unsafe { + ffi::gst_test_clock_wait_for_pending_id_count(self.to_glib_none().0, count); + } + } + + pub fn get_property_clock_type(&self) -> gst::ClockType { + unsafe { + let mut value = Value::from_type(::static_type()); + gobject_ffi::g_object_get_property(self.to_glib_none().0, "clock-type".to_glib_none().0, value.to_glib_none_mut().0); + value.get().unwrap() + } + } + + pub fn set_property_clock_type(&self, clock_type: gst::ClockType) { + unsafe { + gobject_ffi::g_object_set_property(self.to_glib_none().0, "clock-type".to_glib_none().0, Value::from(&clock_type).to_glib_none().0); + } + } + + pub fn get_property_start_time(&self) -> u64 { + unsafe { + let mut value = Value::from_type(::static_type()); + gobject_ffi::g_object_get_property(self.to_glib_none().0, "start-time".to_glib_none().0, value.to_glib_none_mut().0); + value.get().unwrap() + } + } + //pub fn id_list_get_latest_time(pending_list: /*Ignored*/&[&gst::ClockID]) -> gst::ClockTime { // unsafe { TODO: call ffi::gst_test_clock_id_list_get_latest_time() } //} + + pub fn connect_property_clock_type_notify(&self, f: F) -> SignalHandlerId { + unsafe { + let f: Box_> = Box_::new(Box_::new(f)); + connect(self.to_glib_none().0, "notify::clock-type", + transmute(notify_clock_type_trampoline as usize), Box_::into_raw(f) as *mut _) + } + } } impl Default for TestClock { @@ -60,134 +148,7 @@ impl Default for TestClock { unsafe impl Send for TestClock {} unsafe impl Sync for TestClock {} -pub trait TestClockExt { - fn advance_time(&self, delta: gst::ClockTimeDiff); - - fn crank(&self) -> bool; - - fn get_next_entry_time(&self) -> gst::ClockTime; - - //fn has_id(&self, id: /*Ignored*/gst::ClockID) -> bool; - - fn peek_id_count(&self) -> u32; - - //fn peek_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID) -> bool; - - //fn process_id_list(&self, pending_list: /*Ignored*/&[&gst::ClockID]) -> u32; - - //fn process_next_clock_id(&self) -> /*Ignored*/Option; - - fn set_time(&self, new_time: gst::ClockTime); - - //fn wait_for_multiple_pending_ids(&self, count: u32, pending_list: /*Unimplemented*/Vec); - - //fn wait_for_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID); - - fn wait_for_pending_id_count(&self, count: u32); - - fn get_property_clock_type(&self) -> gst::ClockType; - - fn set_property_clock_type(&self, clock_type: gst::ClockType); - - fn get_property_start_time(&self) -> u64; - - fn connect_property_clock_type_notify(&self, f: F) -> SignalHandlerId; -} - -impl + IsA> TestClockExt for O { - fn advance_time(&self, delta: gst::ClockTimeDiff) { - unsafe { - ffi::gst_test_clock_advance_time(self.to_glib_none().0, delta); - } - } - - fn crank(&self) -> bool { - unsafe { - from_glib(ffi::gst_test_clock_crank(self.to_glib_none().0)) - } - } - - fn get_next_entry_time(&self) -> gst::ClockTime { - unsafe { - from_glib(ffi::gst_test_clock_get_next_entry_time(self.to_glib_none().0)) - } - } - - //fn has_id(&self, id: /*Ignored*/gst::ClockID) -> bool { - // unsafe { TODO: call ffi::gst_test_clock_has_id() } - //} - - fn peek_id_count(&self) -> u32 { - unsafe { - ffi::gst_test_clock_peek_id_count(self.to_glib_none().0) - } - } - - //fn peek_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID) -> bool { - // unsafe { TODO: call ffi::gst_test_clock_peek_next_pending_id() } - //} - - //fn process_id_list(&self, pending_list: /*Ignored*/&[&gst::ClockID]) -> u32 { - // unsafe { TODO: call ffi::gst_test_clock_process_id_list() } - //} - - //fn process_next_clock_id(&self) -> /*Ignored*/Option { - // unsafe { TODO: call ffi::gst_test_clock_process_next_clock_id() } - //} - - fn set_time(&self, new_time: gst::ClockTime) { - unsafe { - ffi::gst_test_clock_set_time(self.to_glib_none().0, new_time.to_glib()); - } - } - - //fn wait_for_multiple_pending_ids(&self, count: u32, pending_list: /*Unimplemented*/Vec) { - // unsafe { TODO: call ffi::gst_test_clock_wait_for_multiple_pending_ids() } - //} - - //fn wait_for_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID) { - // unsafe { TODO: call ffi::gst_test_clock_wait_for_next_pending_id() } - //} - - fn wait_for_pending_id_count(&self, count: u32) { - unsafe { - ffi::gst_test_clock_wait_for_pending_id_count(self.to_glib_none().0, count); - } - } - - fn get_property_clock_type(&self) -> gst::ClockType { - unsafe { - let mut value = Value::from_type(::static_type()); - gobject_ffi::g_object_get_property(self.to_glib_none().0, "clock-type".to_glib_none().0, value.to_glib_none_mut().0); - value.get().unwrap() - } - } - - fn set_property_clock_type(&self, clock_type: gst::ClockType) { - unsafe { - gobject_ffi::g_object_set_property(self.to_glib_none().0, "clock-type".to_glib_none().0, Value::from(&clock_type).to_glib_none().0); - } - } - - fn get_property_start_time(&self) -> u64 { - unsafe { - let mut value = Value::from_type(::static_type()); - gobject_ffi::g_object_get_property(self.to_glib_none().0, "start-time".to_glib_none().0, value.to_glib_none_mut().0); - value.get().unwrap() - } - } - - fn connect_property_clock_type_notify(&self, f: F) -> SignalHandlerId { - unsafe { - let f: Box_> = Box_::new(Box_::new(f)); - connect(self.to_glib_none().0, "notify::clock-type", - transmute(notify_clock_type_trampoline:: as usize), Box_::into_raw(f) as *mut _) - } - } -} - -unsafe extern "C" fn notify_clock_type_trampoline

(this: *mut ffi::GstTestClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) -where P: IsA { - let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f); - f(&TestClock::from_glib_borrow(this).downcast_unchecked()) +unsafe extern "C" fn notify_clock_type_trampoline(this: *mut ffi::GstTestClock, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) { + let f: &&(Fn(&TestClock) + Send + Sync + 'static) = transmute(f); + f(&from_glib_borrow(this)) } diff --git a/gstreamer-check/src/harness.rs b/gstreamer-check/src/harness.rs index 26a86c8c8..2fb348106 100644 --- a/gstreamer-check/src/harness.rs +++ b/gstreamer-check/src/harness.rs @@ -1,28 +1,36 @@ -// This file was generated by gir (https://github.com/gtk-rs/gir) -// from gir-files (https://github.com/gtk-rs/gir-files) -// DO NOT EDIT +// Copyright (C) 2018 Sebastian Dröge +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. use ffi; #[cfg(any(feature = "v1_14", feature = "dox"))] use glib; use glib::object::IsA; use glib::translate::*; -use glib_ffi; use gst; +use gst::prelude::*; +use std::marker::PhantomData; use std::mem; use std::ptr; use TestClock; -glib_wrapper! { - #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct Harness(Boxed); +#[derive(Debug)] +pub struct Harness(ptr::NonNull, PhantomData); - match fn { - copy => |ptr| ffi::gst_harness_copy(mut_override(ptr)), - free => |ptr| ffi::gst_harness_free(ptr), +impl Drop for Harness { + fn drop(&mut self) { + unsafe { + ffi::gst_harness_teardown(self.0.as_ptr()); + } } } +unsafe impl Send for Harness {} + impl Harness { pub fn add_element_full< 'a, @@ -50,11 +58,11 @@ impl Harness { let element_srcpad_name = element_srcpad_name.to_glib_none(); unsafe { ffi::gst_harness_add_element_full( - self.to_glib_none_mut().0, + self.0.as_ptr(), element.to_glib_none().0, - hsrc.to_glib_none_mut().0, + hsrc.to_glib_none().0 as *mut _, element_sinkpad_name.0, - hsink.to_glib_none_mut().0, + hsink.to_glib_none().0 as *mut _, element_srcpad_name.0, ); } @@ -62,155 +70,152 @@ impl Harness { pub fn add_element_sink_pad>(&mut self, sinkpad: &P) { unsafe { - ffi::gst_harness_add_element_sink_pad( - self.to_glib_none_mut().0, - sinkpad.to_glib_none().0, - ); + ffi::gst_harness_add_element_sink_pad(self.0.as_ptr(), sinkpad.to_glib_none().0); } } pub fn add_element_src_pad>(&mut self, srcpad: &P) { unsafe { - ffi::gst_harness_add_element_src_pad( - self.to_glib_none_mut().0, - srcpad.to_glib_none().0, - ); + ffi::gst_harness_add_element_src_pad(self.0.as_ptr(), srcpad.to_glib_none().0); } } pub fn add_parse(&mut self, launchline: &str) { unsafe { - ffi::gst_harness_add_parse(self.to_glib_none_mut().0, launchline.to_glib_none().0); + ffi::gst_harness_add_parse(self.0.as_ptr(), launchline.to_glib_none().0); } } - //pub fn add_probe(&mut self, element_name: &str, pad_name: &str, mask: /*Ignored*/gst::PadProbeType, callback: /*Unknown conversion*//*Unimplemented*/PadProbeCallback, destroy_data: /*Unknown conversion*//*Unimplemented*/DestroyNotify) { - // unsafe { TODO: call ffi::gst_harness_add_probe() } - //} + pub fn add_probe( + &mut self, + element_name: &str, + pad_name: &str, + mask: gst::PadProbeType, + func: F, + ) where + F: Fn(&gst::Pad, &mut gst::PadProbeInfo) -> gst::PadProbeReturn + Send + Sync + 'static, + { + // Reimplementation of the C code so we don't have to duplicate all the callback code + + let element = self.find_element(element_name).expect("Element not found"); + let pad = element.get_static_pad(pad_name).expect("Pad not found"); + pad.add_probe(mask, func); + } #[cfg(any(feature = "v1_16", feature = "dox"))] - pub fn add_propose_allocation_meta<'a, P: Into>>( + pub fn add_propose_allocation_meta<'a, P: Into>>( &mut self, api: glib::types::Type, params: P, ) { let params = params.into(); - let params = params.to_glib_none(); + let params = params.map(|p| p.as_ptr()).unwrap_or(ptr::null_mut()); unsafe { - ffi::gst_harness_add_propose_allocation_meta( - self.to_glib_none_mut().0, - api.to_glib(), - params.0, - ); + ffi::gst_harness_add_propose_allocation_meta(self.0.as_ptr(), api.to_glib(), params); } } pub fn add_sink(&mut self, sink_element_name: &str) { unsafe { - ffi::gst_harness_add_sink( - self.to_glib_none_mut().0, - sink_element_name.to_glib_none().0, - ); + ffi::gst_harness_add_sink(self.0.as_ptr(), sink_element_name.to_glib_none().0); } } - pub fn add_sink_harness(&mut self, sink_harness: &mut Harness) { + pub fn add_sink_harness(&mut self, sink_harness: Harness) { unsafe { - ffi::gst_harness_add_sink_harness( - self.to_glib_none_mut().0, - sink_harness.to_glib_full(), - ); + ffi::gst_harness_add_sink_harness(self.0.as_ptr(), sink_harness.0.as_ptr()); + + mem::forget(sink_harness); } } pub fn add_sink_parse(&mut self, launchline: &str) { unsafe { - ffi::gst_harness_add_sink_parse(self.to_glib_none_mut().0, launchline.to_glib_none().0); + ffi::gst_harness_add_sink_parse(self.0.as_ptr(), launchline.to_glib_none().0); } } pub fn add_src(&mut self, src_element_name: &str, has_clock_wait: bool) { unsafe { ffi::gst_harness_add_src( - self.to_glib_none_mut().0, + self.0.as_ptr(), src_element_name.to_glib_none().0, has_clock_wait.to_glib(), ); } } - pub fn add_src_harness(&mut self, src_harness: &mut Harness, has_clock_wait: bool) { + pub fn add_src_harness(&mut self, src_harness: Harness, has_clock_wait: bool) { unsafe { ffi::gst_harness_add_src_harness( - self.to_glib_none_mut().0, - src_harness.to_glib_full(), + self.0.as_ptr(), + src_harness.0.as_ptr(), has_clock_wait.to_glib(), ); + + mem::forget(src_harness); } } pub fn add_src_parse(&mut self, launchline: &str, has_clock_wait: bool) { unsafe { ffi::gst_harness_add_src_parse( - self.to_glib_none_mut().0, + self.0.as_ptr(), launchline.to_glib_none().0, has_clock_wait.to_glib(), ); } } - pub fn buffers_in_queue(&mut self) -> u32 { - unsafe { ffi::gst_harness_buffers_in_queue(self.to_glib_none_mut().0) } + pub fn buffers_in_queue(&self) -> u32 { + unsafe { ffi::gst_harness_buffers_in_queue(self.0.as_ptr()) } } - pub fn buffers_received(&mut self) -> u32 { - unsafe { ffi::gst_harness_buffers_received(self.to_glib_none_mut().0) } + pub fn buffers_received(&self) -> u32 { + unsafe { ffi::gst_harness_buffers_received(self.0.as_ptr()) } } - pub fn crank_multiple_clock_waits(&mut self, waits: u32) -> bool { + pub fn crank_multiple_clock_waits(&mut self, waits: u32) -> Result<(), glib::BoolError> { unsafe { - from_glib(ffi::gst_harness_crank_multiple_clock_waits( - self.to_glib_none_mut().0, - waits, - )) + glib::error::BoolError::from_glib( + ffi::gst_harness_crank_multiple_clock_waits(self.0.as_ptr(), waits), + "Failed to crank multiple clock waits", + ) } } - pub fn crank_single_clock_wait(&mut self) -> bool { + pub fn crank_single_clock_wait(&mut self) -> Result<(), glib::BoolError> { unsafe { - from_glib(ffi::gst_harness_crank_single_clock_wait( - self.to_glib_none_mut().0, - )) + glib::error::BoolError::from_glib( + ffi::gst_harness_crank_single_clock_wait(self.0.as_ptr()), + "Failed to crank single clock wait", + ) } } pub fn create_buffer(&mut self, size: usize) -> Option { + unsafe { from_glib_full(ffi::gst_harness_create_buffer(self.0.as_ptr(), size)) } + } + + pub fn dump_to_file>(&mut self, filename: P) { + let filename = filename.as_ref(); unsafe { - from_glib_full(ffi::gst_harness_create_buffer( - self.to_glib_none_mut().0, - size, - )) + ffi::gst_harness_dump_to_file(self.0.as_ptr(), filename.to_glib_none().0); } } - pub fn dump_to_file(&mut self, filename: &str) { - unsafe { - ffi::gst_harness_dump_to_file(self.to_glib_none_mut().0, filename.to_glib_none().0); - } + pub fn events_in_queue(&self) -> u32 { + unsafe { ffi::gst_harness_events_in_queue(self.0.as_ptr()) } } - pub fn events_in_queue(&mut self) -> u32 { - unsafe { ffi::gst_harness_events_in_queue(self.to_glib_none_mut().0) } - } - - pub fn events_received(&mut self) -> u32 { - unsafe { ffi::gst_harness_events_received(self.to_glib_none_mut().0) } + pub fn events_received(&self) -> u32 { + unsafe { ffi::gst_harness_events_received(self.0.as_ptr()) } } pub fn find_element(&mut self, element_name: &str) -> Option { unsafe { from_glib_full(ffi::gst_harness_find_element( - self.to_glib_none_mut().0, + self.0.as_ptr(), element_name.to_glib_none().0, )) } @@ -224,82 +229,73 @@ impl Harness { // unsafe { TODO: call ffi::gst_harness_get_allocator() } //} - pub fn get_last_pushed_timestamp(&mut self) -> gst::ClockTime { - unsafe { ffi::gst_harness_get_last_pushed_timestamp(self.to_glib_none_mut().0) } + pub fn get_last_pushed_timestamp(&self) -> gst::ClockTime { + unsafe { from_glib(ffi::gst_harness_get_last_pushed_timestamp(self.0.as_ptr())) } } - pub fn get_testclock(&mut self) -> Option { - unsafe { from_glib_full(ffi::gst_harness_get_testclock(self.to_glib_none_mut().0)) } + pub fn get_testclock(&self) -> Option { + unsafe { from_glib_full(ffi::gst_harness_get_testclock(self.0.as_ptr())) } } pub fn play(&mut self) { unsafe { - ffi::gst_harness_play(self.to_glib_none_mut().0); + ffi::gst_harness_play(self.0.as_ptr()); } } pub fn pull(&mut self) -> Option { - unsafe { from_glib_full(ffi::gst_harness_pull(self.to_glib_none_mut().0)) } + unsafe { from_glib_full(ffi::gst_harness_pull(self.0.as_ptr())) } } pub fn pull_event(&mut self) -> Option { - unsafe { from_glib_full(ffi::gst_harness_pull_event(self.to_glib_none_mut().0)) } + unsafe { from_glib_full(ffi::gst_harness_pull_event(self.0.as_ptr())) } } pub fn pull_upstream_event(&mut self) -> Option { - unsafe { - from_glib_full(ffi::gst_harness_pull_upstream_event( - self.to_glib_none_mut().0, - )) - } + unsafe { from_glib_full(ffi::gst_harness_pull_upstream_event(self.0.as_ptr())) } } - pub fn push(&mut self, buffer: &mut gst::Buffer) -> gst::FlowReturn { - unsafe { - from_glib(ffi::gst_harness_push( - self.to_glib_none_mut().0, - buffer.to_glib_full(), - )) - } + pub fn push(&mut self, buffer: gst::Buffer) -> gst::FlowReturn { + unsafe { from_glib(ffi::gst_harness_push(self.0.as_ptr(), buffer.into_ptr())) } } - pub fn push_and_pull(&mut self, buffer: &mut gst::Buffer) -> Option { + pub fn push_and_pull(&mut self, buffer: gst::Buffer) -> Option { unsafe { from_glib_full(ffi::gst_harness_push_and_pull( - self.to_glib_none_mut().0, - buffer.to_glib_full(), + self.0.as_ptr(), + buffer.into_ptr(), )) } } - pub fn push_event(&mut self, event: &mut gst::Event) -> bool { + pub fn push_event(&mut self, event: gst::Event) -> bool { unsafe { from_glib(ffi::gst_harness_push_event( - self.to_glib_none_mut().0, - event.to_glib_none_mut().0, + self.0.as_ptr(), + event.into_ptr(), )) } } pub fn push_from_src(&mut self) -> gst::FlowReturn { - unsafe { from_glib(ffi::gst_harness_push_from_src(self.to_glib_none_mut().0)) } + unsafe { from_glib(ffi::gst_harness_push_from_src(self.0.as_ptr())) } } pub fn push_to_sink(&mut self) -> gst::FlowReturn { - unsafe { from_glib(ffi::gst_harness_push_to_sink(self.to_glib_none_mut().0)) } + unsafe { from_glib(ffi::gst_harness_push_to_sink(self.0.as_ptr())) } } - pub fn push_upstream_event(&mut self, event: &mut gst::Event) -> bool { + pub fn push_upstream_event(&mut self, event: gst::Event) -> bool { unsafe { from_glib(ffi::gst_harness_push_upstream_event( - self.to_glib_none_mut().0, - event.to_glib_none_mut().0, + self.0.as_ptr(), + event.into_ptr(), )) } } - pub fn query_latency(&mut self) -> gst::ClockTime { - unsafe { ffi::gst_harness_query_latency(self.to_glib_none_mut().0) } + pub fn query_latency(&self) -> gst::ClockTime { + unsafe { from_glib(ffi::gst_harness_query_latency(self.0.as_ptr())) } } //pub fn set(&mut self, element_name: &str, first_property_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) { @@ -308,24 +304,20 @@ impl Harness { pub fn set_blocking_push_mode(&mut self) { unsafe { - ffi::gst_harness_set_blocking_push_mode(self.to_glib_none_mut().0); + ffi::gst_harness_set_blocking_push_mode(self.0.as_ptr()); } } - pub fn set_caps(&mut self, in_: &mut gst::Caps, out: &mut gst::Caps) { + pub fn set_caps(&mut self, in_: gst::Caps, out: gst::Caps) { unsafe { - ffi::gst_harness_set_caps( - self.to_glib_none_mut().0, - in_.to_glib_full(), - out.to_glib_full(), - ); + ffi::gst_harness_set_caps(self.0.as_ptr(), in_.into_ptr(), out.into_ptr()); } } pub fn set_caps_str(&mut self, in_: &str, out: &str) { unsafe { ffi::gst_harness_set_caps_str( - self.to_glib_none_mut().0, + self.0.as_ptr(), in_.to_glib_none().0, out.to_glib_none().0, ); @@ -334,13 +326,13 @@ impl Harness { pub fn set_drop_buffers(&mut self, drop_buffers: bool) { unsafe { - ffi::gst_harness_set_drop_buffers(self.to_glib_none_mut().0, drop_buffers.to_glib()); + ffi::gst_harness_set_drop_buffers(self.0.as_ptr(), drop_buffers.to_glib()); } } pub fn set_forwarding(&mut self, forwarding: bool) { unsafe { - ffi::gst_harness_set_forwarding(self.to_glib_none_mut().0, forwarding.to_glib()); + ffi::gst_harness_set_forwarding(self.0.as_ptr(), forwarding.to_glib()); } } @@ -348,61 +340,66 @@ impl Harness { // unsafe { TODO: call ffi::gst_harness_set_propose_allocator() } //} - pub fn set_sink_caps(&mut self, caps: &mut gst::Caps) { + pub fn set_sink_caps(&mut self, caps: gst::Caps) { unsafe { - ffi::gst_harness_set_sink_caps(self.to_glib_none_mut().0, caps.to_glib_full()); + ffi::gst_harness_set_sink_caps(self.0.as_ptr(), caps.into_ptr()); } } pub fn set_sink_caps_str(&mut self, str: &str) { unsafe { - ffi::gst_harness_set_sink_caps_str(self.to_glib_none_mut().0, str.to_glib_none().0); + ffi::gst_harness_set_sink_caps_str(self.0.as_ptr(), str.to_glib_none().0); } } - pub fn set_src_caps(&mut self, caps: &mut gst::Caps) { + pub fn set_src_caps(&mut self, caps: gst::Caps) { unsafe { - ffi::gst_harness_set_src_caps(self.to_glib_none_mut().0, caps.to_glib_full()); + ffi::gst_harness_set_src_caps(self.0.as_ptr(), caps.into_ptr()); } } pub fn set_src_caps_str(&mut self, str: &str) { unsafe { - ffi::gst_harness_set_src_caps_str(self.to_glib_none_mut().0, str.to_glib_none().0); + ffi::gst_harness_set_src_caps_str(self.0.as_ptr(), str.to_glib_none().0); } } - pub fn set_time(&mut self, time: gst::ClockTime) -> bool { - unsafe { from_glib(ffi::gst_harness_set_time(self.to_glib_none_mut().0, time)) } + pub fn set_time(&mut self, time: gst::ClockTime) -> Result<(), glib::BoolError> { + unsafe { + glib::error::BoolError::from_glib( + ffi::gst_harness_set_time(self.0.as_ptr(), time.to_glib()), + "Failed to set time", + ) + } } pub fn set_upstream_latency(&mut self, latency: gst::ClockTime) { unsafe { - ffi::gst_harness_set_upstream_latency(self.to_glib_none_mut().0, latency); + ffi::gst_harness_set_upstream_latency(self.0.as_ptr(), latency.to_glib()); } } - pub fn sink_push_many(&mut self, pushes: i32) -> gst::FlowReturn { + pub fn sink_push_many(&mut self, pushes: u32) -> gst::FlowReturn { unsafe { from_glib(ffi::gst_harness_sink_push_many( - self.to_glib_none_mut().0, - pushes, + self.0.as_ptr(), + pushes as i32, )) } } - pub fn src_crank_and_push_many(&mut self, cranks: i32, pushes: i32) -> gst::FlowReturn { + pub fn src_crank_and_push_many(&mut self, cranks: u32, pushes: u32) -> gst::FlowReturn { unsafe { from_glib(ffi::gst_harness_src_crank_and_push_many( - self.to_glib_none_mut().0, - cranks, - pushes, + self.0.as_ptr(), + cranks as i32, + pushes as i32, )) } } pub fn src_push_event(&mut self) -> bool { - unsafe { from_glib(ffi::gst_harness_src_push_event(self.to_glib_none_mut().0)) } + unsafe { from_glib(ffi::gst_harness_src_push_event(self.0.as_ptr())) } } //pub fn stress_custom_start<'a, P: Into>, Q: Into>>(&mut self, init: P, callback: /*Unknown conversion*//*Unimplemented*/Func, data: Q, sleep: libc::c_ulong) -> /*Ignored*/Option { @@ -445,93 +442,75 @@ impl Harness { // unsafe { TODO: call ffi::gst_harness_stress_statechange_start_full() } //} - #[cfg(any(feature = "v1_14", feature = "dox"))] - pub fn take_all_data(&mut self) -> (u8, usize) { - unsafe { - let mut size = mem::uninitialized(); - let ret = ffi::gst_harness_take_all_data(self.to_glib_none_mut().0, &mut size); - (ret, size) - } - } - #[cfg(any(feature = "v1_14", feature = "dox"))] pub fn take_all_data_as_buffer(&mut self) -> Option { - unsafe { - from_glib_full(ffi::gst_harness_take_all_data_as_buffer( - self.to_glib_none_mut().0, - )) - } + unsafe { from_glib_full(ffi::gst_harness_take_all_data_as_buffer(self.0.as_ptr())) } } #[cfg(any(feature = "v1_14", feature = "dox"))] pub fn take_all_data_as_bytes(&mut self) -> Option { - unsafe { - from_glib_full(ffi::gst_harness_take_all_data_as_bytes( - self.to_glib_none_mut().0, - )) - } - } - - pub fn teardown(&mut self) { - unsafe { - ffi::gst_harness_teardown(self.to_glib_none_mut().0); - } + unsafe { from_glib_full(ffi::gst_harness_take_all_data_as_bytes(self.0.as_ptr())) } } pub fn try_pull(&mut self) -> Option { - unsafe { from_glib_full(ffi::gst_harness_try_pull(self.to_glib_none_mut().0)) } + unsafe { from_glib_full(ffi::gst_harness_try_pull(self.0.as_ptr())) } } pub fn try_pull_event(&mut self) -> Option { - unsafe { from_glib_full(ffi::gst_harness_try_pull_event(self.to_glib_none_mut().0)) } + unsafe { from_glib_full(ffi::gst_harness_try_pull_event(self.0.as_ptr())) } } pub fn try_pull_upstream_event(&mut self) -> Option { - unsafe { - from_glib_full(ffi::gst_harness_try_pull_upstream_event( - self.to_glib_none_mut().0, - )) - } + unsafe { from_glib_full(ffi::gst_harness_try_pull_upstream_event(self.0.as_ptr())) } } - pub fn upstream_events_in_queue(&mut self) -> u32 { - unsafe { ffi::gst_harness_upstream_events_in_queue(self.to_glib_none_mut().0) } + pub fn upstream_events_in_queue(&self) -> u32 { + unsafe { ffi::gst_harness_upstream_events_in_queue(self.0.as_ptr()) } } - pub fn upstream_events_received(&mut self) -> u32 { - unsafe { ffi::gst_harness_upstream_events_received(self.to_glib_none_mut().0) } + pub fn upstream_events_received(&self) -> u32 { + unsafe { ffi::gst_harness_upstream_events_received(self.0.as_ptr()) } } pub fn use_systemclock(&mut self) { unsafe { - ffi::gst_harness_use_systemclock(self.to_glib_none_mut().0); + ffi::gst_harness_use_systemclock(self.0.as_ptr()); } } pub fn use_testclock(&mut self) { unsafe { - ffi::gst_harness_use_testclock(self.to_glib_none_mut().0); + ffi::gst_harness_use_testclock(self.0.as_ptr()); } } - pub fn wait_for_clock_id_waits(&mut self, waits: u32, timeout: u32) -> bool { + pub fn wait_for_clock_id_waits( + &mut self, + waits: u32, + timeout: u32, + ) -> Result<(), glib::BoolError> { unsafe { - from_glib(ffi::gst_harness_wait_for_clock_id_waits( - self.to_glib_none_mut().0, - waits, - timeout, - )) + glib::error::BoolError::from_glib( + ffi::gst_harness_wait_for_clock_id_waits(self.0.as_ptr(), waits, timeout), + "Failed to wait for clock id waits", + ) } } - pub fn new(element_name: &str) -> Option { - assert_initialized_main_thread!(); - unsafe { from_glib_full(ffi::gst_harness_new(element_name.to_glib_none().0)) } + unsafe fn from_glib_full(ptr: *mut ffi::GstHarness) -> Harness { + assert!(!ptr.is_null()); + + Harness(ptr::NonNull::new_unchecked(ptr), PhantomData) } - pub fn new_empty() -> Option { + pub fn new(element_name: &str) -> Harness { assert_initialized_main_thread!(); - unsafe { from_glib_full(ffi::gst_harness_new_empty()) } + unsafe { Self::from_glib_full(ffi::gst_harness_new(element_name.to_glib_none().0)) } + } + + pub fn new_empty() -> Harness { + assert_initialized_main_thread!(); + unsafe { Self::from_glib_full(ffi::gst_harness_new_empty()) } } pub fn new_full< @@ -550,7 +529,7 @@ impl Harness { element_sinkpad_name: R, hsink: S, element_srcpad_name: T, - ) -> Option { + ) -> Harness { assert_initialized_main_thread!(); let hsrc = hsrc.into(); let element_sinkpad_name = element_sinkpad_name.into(); @@ -559,19 +538,19 @@ impl Harness { let element_srcpad_name = element_srcpad_name.into(); let element_srcpad_name = element_srcpad_name.to_glib_none(); unsafe { - from_glib_full(ffi::gst_harness_new_full( + Self::from_glib_full(ffi::gst_harness_new_full( element.to_glib_none().0, - hsrc.to_glib_none_mut().0, + hsrc.to_glib_none().0 as *mut _, element_sinkpad_name.0, - hsink.to_glib_none_mut().0, + hsink.to_glib_none().0 as *mut _, element_srcpad_name.0, )) } } - pub fn new_parse(launchline: &str) -> Option { + pub fn new_parse(launchline: &str) -> Harness { assert_initialized_main_thread!(); - unsafe { from_glib_full(ffi::gst_harness_new_parse(launchline.to_glib_none().0)) } + unsafe { Self::from_glib_full(ffi::gst_harness_new_parse(launchline.to_glib_none().0)) } } pub fn new_with_element< @@ -584,14 +563,14 @@ impl Harness { element: &P, element_sinkpad_name: Q, element_srcpad_name: R, - ) -> Option { + ) -> Harness { assert_initialized_main_thread!(); let element_sinkpad_name = element_sinkpad_name.into(); let element_sinkpad_name = element_sinkpad_name.to_glib_none(); let element_srcpad_name = element_srcpad_name.into(); let element_srcpad_name = element_srcpad_name.to_glib_none(); unsafe { - from_glib_full(ffi::gst_harness_new_with_element( + Self::from_glib_full(ffi::gst_harness_new_with_element( element.to_glib_none().0, element_sinkpad_name.0, element_srcpad_name.0, @@ -603,14 +582,14 @@ impl Harness { element_name: &str, element_sinkpad_name: P, element_srcpad_name: Q, - ) -> Option { + ) -> Harness { assert_initialized_main_thread!(); let element_sinkpad_name = element_sinkpad_name.into(); let element_sinkpad_name = element_sinkpad_name.to_glib_none(); let element_srcpad_name = element_srcpad_name.into(); let element_srcpad_name = element_srcpad_name.to_glib_none(); unsafe { - from_glib_full(ffi::gst_harness_new_with_padnames( + Self::from_glib_full(ffi::gst_harness_new_with_padnames( element_name.to_glib_none().0, element_sinkpad_name.0, element_srcpad_name.0, @@ -627,15 +606,15 @@ impl Harness { element_name: &str, hsrc: P, hsink: Q, - ) -> Option { + ) -> Harness { assert_initialized_main_thread!(); let hsrc = hsrc.into(); let hsink = hsink.into(); unsafe { - from_glib_full(ffi::gst_harness_new_with_templates( + Self::from_glib_full(ffi::gst_harness_new_with_templates( element_name.to_glib_none().0, - hsrc.to_glib_none_mut().0, - hsink.to_glib_none_mut().0, + hsrc.to_glib_none().0 as *mut _, + hsink.to_glib_none().0 as *mut _, )) } } @@ -644,3 +623,18 @@ impl Harness { // unsafe { TODO: call ffi::gst_harness_stress_thread_stop() } //} } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_identity_push_pull() { + gst::init().unwrap(); + + let mut h = Harness::new("identity"); + let buf = gst::Buffer::new(); + let buf = h.push_and_pull(buf); + assert!(buf.is_some()); + } +} diff --git a/gstreamer-check/src/lib.rs b/gstreamer-check/src/lib.rs new file mode 100644 index 000000000..fbc5c0943 --- /dev/null +++ b/gstreamer-check/src/lib.rs @@ -0,0 +1,48 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +extern crate glib_sys as glib_ffi; +extern crate gobject_sys as gobject_ffi; +extern crate gstreamer as gst; +extern crate gstreamer_check_sys as ffi; +extern crate gstreamer_sys as gst_ffi; + +#[macro_use] +extern crate glib; + +macro_rules! assert_initialized_main_thread { + () => { + if unsafe { ::gst_ffi::gst_is_initialized() } != ::glib_ffi::GTRUE { + panic!("GStreamer has not been initialized. Call `gst::init` first."); + } + }; +} + +pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue, Value}; + +#[cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))] +#[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))] +#[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))] +#[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))] +#[cfg_attr(feature = "cargo-clippy", allow(type_complexity))] +mod auto; +pub use auto::*; + +mod test_clock; + +mod harness; +pub use harness::*; + +// Re-export all the traits in a prelude module, so that applications +// can always "use gst::prelude::*" without getting conflicts +pub mod prelude { + pub use glib::prelude::*; + pub use gst::prelude::*; + + pub use auto::traits::*; +} diff --git a/gstreamer-check/src/test_clock.rs b/gstreamer-check/src/test_clock.rs new file mode 100644 index 000000000..be2e4092e --- /dev/null +++ b/gstreamer-check/src/test_clock.rs @@ -0,0 +1,60 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use ffi; +#[cfg(any(feature = "v1_14", feature = "dox"))] +use glib::translate::*; +use gst; +use std::ptr; +use TestClock; + +impl TestClock { + pub fn has_id(&self, id: &gst::ClockId) -> bool { + unsafe { from_glib(ffi::gst_test_clock_has_id(self.to_glib_none().0, id.to_glib_none().0)) } + } + + pub fn peek_next_pending_id(&self) -> Option { + unsafe { + let mut id = ptr::null_mut(); + let ret: bool = from_glib(ffi::gst_test_clock_peek_next_pending_id(self.to_glib_none().0, &mut id)); + if ret { + from_glib_full(id) + } else { + None + } + } + } + + pub fn process_id_list(&self, pending_list: &[&gst::ClockId]) -> u32 { + unsafe { + ffi::gst_test_clock_process_id_list(self.to_glib_none().0, pending_list.to_glib_none().0) + } + } + + pub fn process_next_clock_id(&self) -> Option { + unsafe { + from_glib_full(ffi::gst_test_clock_process_next_clock_id(self.to_glib_none().0)) + } + } + + pub fn wait_for_multiple_pending_ids(&self, count: u32) -> Vec { + unsafe { + let mut pending_list = ptr::null_mut(); + ffi::gst_test_clock_wait_for_multiple_pending_ids(self.to_glib_none().0, count, &mut pending_list); + FromGlibPtrContainer::from_glib_full(pending_list) + } + } + + pub fn wait_for_next_pending_id(&self) -> gst::ClockId { + unsafe { + let mut id = ptr::null_mut(); + ffi::gst_test_clock_wait_for_next_pending_id(self.to_glib_none().0, &mut id); + from_glib_full(id) + } + } +}