gstreamer_pbutils/auto/
functions.rs1use crate::{ffi, EncodingTarget};
7use glib::translate::*;
8
9#[doc(alias = "gst_codec_utils_aac_get_channels")]
10pub fn codec_utils_aac_get_channels(audio_config: &[u8]) -> u32 {
11 assert_initialized_main_thread!();
12 let len = audio_config.len() as _;
13 unsafe { ffi::gst_codec_utils_aac_get_channels(audio_config.to_glib_none().0, len) }
14}
15
16#[doc(alias = "gst_codec_utils_aac_get_index_from_sample_rate")]
17pub fn codec_utils_aac_get_index_from_sample_rate(rate: u32) -> i32 {
18 assert_initialized_main_thread!();
19 unsafe { ffi::gst_codec_utils_aac_get_index_from_sample_rate(rate) }
20}
21
22#[doc(alias = "gst_codec_utils_aac_get_level")]
23pub fn codec_utils_aac_get_level(audio_config: &[u8]) -> Result<glib::GString, glib::BoolError> {
24 assert_initialized_main_thread!();
25 let len = audio_config.len() as _;
26 unsafe {
27 Option::<_>::from_glib_none(ffi::gst_codec_utils_aac_get_level(
28 audio_config.to_glib_none().0,
29 len,
30 ))
31 .ok_or_else(|| glib::bool_error!("Failed to get AAC level"))
32 }
33}
34
35#[doc(alias = "gst_codec_utils_aac_get_profile")]
36pub fn codec_utils_aac_get_profile(audio_config: &[u8]) -> Result<glib::GString, glib::BoolError> {
37 assert_initialized_main_thread!();
38 let len = audio_config.len() as _;
39 unsafe {
40 Option::<_>::from_glib_none(ffi::gst_codec_utils_aac_get_profile(
41 audio_config.to_glib_none().0,
42 len,
43 ))
44 .ok_or_else(|| glib::bool_error!("Failed to get AAC profile"))
45 }
46}
47
48#[doc(alias = "gst_codec_utils_aac_get_sample_rate")]
49pub fn codec_utils_aac_get_sample_rate(audio_config: &[u8]) -> u32 {
50 assert_initialized_main_thread!();
51 let len = audio_config.len() as _;
52 unsafe { ffi::gst_codec_utils_aac_get_sample_rate(audio_config.to_glib_none().0, len) }
53}
54
55#[doc(alias = "gst_codec_utils_aac_get_sample_rate_from_index")]
56pub fn codec_utils_aac_get_sample_rate_from_index(sr_idx: u32) -> u32 {
57 assert_initialized_main_thread!();
58 unsafe { ffi::gst_codec_utils_aac_get_sample_rate_from_index(sr_idx) }
59}
60
61#[cfg(feature = "v1_26")]
62#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
63#[doc(alias = "gst_codec_utils_av1_get_level")]
64pub fn codec_utils_av1_get_level(seq_level_idx: u8) -> Result<glib::GString, glib::BoolError> {
65 assert_initialized_main_thread!();
66 unsafe {
67 Option::<_>::from_glib_none(ffi::gst_codec_utils_av1_get_level(seq_level_idx))
68 .ok_or_else(|| glib::bool_error!("Failed to get AV1 level"))
69 }
70}
71
72#[cfg(feature = "v1_26")]
73#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
74#[doc(alias = "gst_codec_utils_av1_get_seq_level_idx")]
75pub fn codec_utils_av1_get_seq_level_idx(level: &str) -> u8 {
76 assert_initialized_main_thread!();
77 unsafe { ffi::gst_codec_utils_av1_get_seq_level_idx(level.to_glib_none().0) }
78}
79
80#[cfg(feature = "v1_22")]
81#[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
82#[doc(alias = "gst_codec_utils_caps_from_mime_codec")]
83pub fn codec_utils_caps_from_mime_codec(codecs_field: &str) -> Option<gst::Caps> {
84 assert_initialized_main_thread!();
85 unsafe {
86 from_glib_full(ffi::gst_codec_utils_caps_from_mime_codec(
87 codecs_field.to_glib_none().0,
88 ))
89 }
90}
91
92#[doc(alias = "gst_codec_utils_h264_get_level")]
93pub fn codec_utils_h264_get_level(sps: &[u8]) -> Result<glib::GString, glib::BoolError> {
94 assert_initialized_main_thread!();
95 let len = sps.len() as _;
96 unsafe {
97 Option::<_>::from_glib_none(ffi::gst_codec_utils_h264_get_level(
98 sps.to_glib_none().0,
99 len,
100 ))
101 .ok_or_else(|| glib::bool_error!("Failed to get H264 level"))
102 }
103}
104
105#[doc(alias = "gst_codec_utils_h264_get_level_idc")]
106pub fn codec_utils_h264_get_level_idc(level: &str) -> u8 {
107 assert_initialized_main_thread!();
108 unsafe { ffi::gst_codec_utils_h264_get_level_idc(level.to_glib_none().0) }
109}
110
111#[doc(alias = "gst_codec_utils_h264_get_profile")]
112pub fn codec_utils_h264_get_profile(sps: &[u8]) -> Result<glib::GString, glib::BoolError> {
113 assert_initialized_main_thread!();
114 let len = sps.len() as _;
115 unsafe {
116 Option::<_>::from_glib_none(ffi::gst_codec_utils_h264_get_profile(
117 sps.to_glib_none().0,
118 len,
119 ))
120 .ok_or_else(|| glib::bool_error!("Failed to get H264 profile"))
121 }
122}
123
124#[doc(alias = "gst_codec_utils_h265_get_level")]
125pub fn codec_utils_h265_get_level(
126 profile_tier_level: &[u8],
127) -> Result<glib::GString, glib::BoolError> {
128 assert_initialized_main_thread!();
129 let len = profile_tier_level.len() as _;
130 unsafe {
131 Option::<_>::from_glib_none(ffi::gst_codec_utils_h265_get_level(
132 profile_tier_level.to_glib_none().0,
133 len,
134 ))
135 .ok_or_else(|| glib::bool_error!("Failed to get H265 level"))
136 }
137}
138
139#[doc(alias = "gst_codec_utils_h265_get_level_idc")]
140pub fn codec_utils_h265_get_level_idc(level: &str) -> u8 {
141 assert_initialized_main_thread!();
142 unsafe { ffi::gst_codec_utils_h265_get_level_idc(level.to_glib_none().0) }
143}
144
145#[doc(alias = "gst_codec_utils_h265_get_profile")]
146pub fn codec_utils_h265_get_profile(
147 profile_tier_level: &[u8],
148) -> Result<glib::GString, glib::BoolError> {
149 assert_initialized_main_thread!();
150 let len = profile_tier_level.len() as _;
151 unsafe {
152 Option::<_>::from_glib_none(ffi::gst_codec_utils_h265_get_profile(
153 profile_tier_level.to_glib_none().0,
154 len,
155 ))
156 .ok_or_else(|| glib::bool_error!("Failed to get H265 profile"))
157 }
158}
159
160#[doc(alias = "gst_codec_utils_h265_get_tier")]
161pub fn codec_utils_h265_get_tier(
162 profile_tier_level: &[u8],
163) -> Result<glib::GString, glib::BoolError> {
164 assert_initialized_main_thread!();
165 let len = profile_tier_level.len() as _;
166 unsafe {
167 Option::<_>::from_glib_none(ffi::gst_codec_utils_h265_get_tier(
168 profile_tier_level.to_glib_none().0,
169 len,
170 ))
171 .ok_or_else(|| glib::bool_error!("Failed to get H265 tier"))
172 }
173}
174
175#[cfg(feature = "v1_26")]
176#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
177#[doc(alias = "gst_codec_utils_h266_get_level")]
178pub fn codec_utils_h266_get_level(ptl_record: &[u8]) -> Result<glib::GString, glib::BoolError> {
179 assert_initialized_main_thread!();
180 let len = ptl_record.len() as _;
181 unsafe {
182 Option::<_>::from_glib_none(ffi::gst_codec_utils_h266_get_level(
183 ptl_record.to_glib_none().0,
184 len,
185 ))
186 .ok_or_else(|| glib::bool_error!("Failed to get H266 level"))
187 }
188}
189
190#[cfg(feature = "v1_26")]
191#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
192#[doc(alias = "gst_codec_utils_h266_get_level_idc")]
193pub fn codec_utils_h266_get_level_idc(level: &str) -> u8 {
194 assert_initialized_main_thread!();
195 unsafe { ffi::gst_codec_utils_h266_get_level_idc(level.to_glib_none().0) }
196}
197
198#[cfg(feature = "v1_26")]
199#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
200#[doc(alias = "gst_codec_utils_h266_get_profile")]
201pub fn codec_utils_h266_get_profile(ptl_record: &[u8]) -> Result<glib::GString, glib::BoolError> {
202 assert_initialized_main_thread!();
203 let len = ptl_record.len() as _;
204 unsafe {
205 Option::<_>::from_glib_none(ffi::gst_codec_utils_h266_get_profile(
206 ptl_record.to_glib_none().0,
207 len,
208 ))
209 .ok_or_else(|| glib::bool_error!("Failed to get H266 profile"))
210 }
211}
212
213#[cfg(feature = "v1_26")]
214#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
215#[doc(alias = "gst_codec_utils_h266_get_tier")]
216pub fn codec_utils_h266_get_tier(ptl_record: &[u8]) -> Result<glib::GString, glib::BoolError> {
217 assert_initialized_main_thread!();
218 let len = ptl_record.len() as _;
219 unsafe {
220 Option::<_>::from_glib_none(ffi::gst_codec_utils_h266_get_tier(
221 ptl_record.to_glib_none().0,
222 len,
223 ))
224 .ok_or_else(|| glib::bool_error!("Failed to get H266 tier"))
225 }
226}
227
228#[doc(alias = "gst_codec_utils_mpeg4video_get_level")]
229pub fn codec_utils_mpeg4video_get_level(
230 vis_obj_seq: &[u8],
231) -> Result<glib::GString, glib::BoolError> {
232 assert_initialized_main_thread!();
233 let len = vis_obj_seq.len() as _;
234 unsafe {
235 Option::<_>::from_glib_none(ffi::gst_codec_utils_mpeg4video_get_level(
236 vis_obj_seq.to_glib_none().0,
237 len,
238 ))
239 .ok_or_else(|| glib::bool_error!("Failed to get MPEG4 video level"))
240 }
241}
242
243#[doc(alias = "gst_codec_utils_mpeg4video_get_profile")]
244pub fn codec_utils_mpeg4video_get_profile(
245 vis_obj_seq: &[u8],
246) -> Result<glib::GString, glib::BoolError> {
247 assert_initialized_main_thread!();
248 let len = vis_obj_seq.len() as _;
249 unsafe {
250 Option::<_>::from_glib_none(ffi::gst_codec_utils_mpeg4video_get_profile(
251 vis_obj_seq.to_glib_none().0,
252 len,
253 ))
254 .ok_or_else(|| glib::bool_error!("Failed to get MPEG4 video profile"))
255 }
256}
257
258#[doc(alias = "gst_encoding_list_all_targets")]
259pub fn encoding_list_all_targets(categoryname: Option<&str>) -> Vec<EncodingTarget> {
260 assert_initialized_main_thread!();
261 unsafe {
262 FromGlibPtrContainer::from_glib_full(ffi::gst_encoding_list_all_targets(
263 categoryname.to_glib_none().0,
264 ))
265 }
266}
267
268#[doc(alias = "gst_encoding_list_available_categories")]
269pub fn encoding_list_available_categories() -> Vec<glib::GString> {
270 assert_initialized_main_thread!();
271 unsafe { FromGlibPtrContainer::from_glib_full(ffi::gst_encoding_list_available_categories()) }
272}
273
274#[doc(alias = "gst_pb_utils_get_element_description")]
275pub fn pb_utils_get_element_description(factory_name: &str) -> glib::GString {
276 assert_initialized_main_thread!();
277 unsafe {
278 from_glib_full(ffi::gst_pb_utils_get_element_description(
279 factory_name.to_glib_none().0,
280 ))
281 }
282}
283
284#[doc(alias = "gst_pb_utils_get_sink_description")]
285pub fn pb_utils_get_sink_description(protocol: &str) -> glib::GString {
286 assert_initialized_main_thread!();
287 unsafe {
288 from_glib_full(ffi::gst_pb_utils_get_sink_description(
289 protocol.to_glib_none().0,
290 ))
291 }
292}
293
294#[doc(alias = "gst_pb_utils_get_source_description")]
295pub fn pb_utils_get_source_description(protocol: &str) -> glib::GString {
296 assert_initialized_main_thread!();
297 unsafe {
298 from_glib_full(ffi::gst_pb_utils_get_source_description(
299 protocol.to_glib_none().0,
300 ))
301 }
302}
303
304#[doc(alias = "gst_plugins_base_version")]
305pub fn plugins_base_version() -> (u32, u32, u32, u32) {
306 skip_assert_initialized!();
307 unsafe {
308 let mut major = std::mem::MaybeUninit::uninit();
309 let mut minor = std::mem::MaybeUninit::uninit();
310 let mut micro = std::mem::MaybeUninit::uninit();
311 let mut nano = std::mem::MaybeUninit::uninit();
312 ffi::gst_plugins_base_version(
313 major.as_mut_ptr(),
314 minor.as_mut_ptr(),
315 micro.as_mut_ptr(),
316 nano.as_mut_ptr(),
317 );
318 (
319 major.assume_init(),
320 minor.assume_init(),
321 micro.assume_init(),
322 nano.assume_init(),
323 )
324 }
325}
326
327#[doc(alias = "gst_plugins_base_version_string")]
328pub fn plugins_base_version_string() -> glib::GString {
329 skip_assert_initialized!();
330 unsafe { from_glib_full(ffi::gst_plugins_base_version_string()) }
331}