gstreamer_pbutils/auto/
functions.rs1use crate::{EncodingTarget, ffi};
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#[cfg(feature = "v1_30")]
259#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
260#[doc(alias = "gst_codec_utils_vp9_get_level")]
261pub fn codec_utils_vp9_get_level(level_idc: u8) -> Option<glib::GString> {
262 assert_initialized_main_thread!();
263 unsafe { from_glib_none(ffi::gst_codec_utils_vp9_get_level(level_idc)) }
264}
265
266#[cfg(feature = "v1_30")]
267#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
268#[doc(alias = "gst_codec_utils_vp9_get_level_idc")]
269pub fn codec_utils_vp9_get_level_idc(level: &str) -> u8 {
270 assert_initialized_main_thread!();
271 unsafe { ffi::gst_codec_utils_vp9_get_level_idc(level.to_glib_none().0) }
272}
273
274#[cfg(feature = "v1_30")]
275#[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
276#[doc(alias = "gst_codec_utils_vpx_caps_set_format_fields")]
277pub fn codec_utils_vpx_caps_set_format_fields(
278 caps: &gst::Caps,
279 profile: i32,
280 level: i32,
281 bit_depth: i32,
282 chroma_subsampling: i32,
283) -> bool {
284 assert_initialized_main_thread!();
285 unsafe {
286 from_glib(ffi::gst_codec_utils_vpx_caps_set_format_fields(
287 caps.to_glib_none().0,
288 profile,
289 level,
290 bit_depth,
291 chroma_subsampling,
292 ))
293 }
294}
295
296#[doc(alias = "gst_encoding_list_all_targets")]
297pub fn encoding_list_all_targets(categoryname: Option<&str>) -> Vec<EncodingTarget> {
298 assert_initialized_main_thread!();
299 unsafe {
300 FromGlibPtrContainer::from_glib_full(ffi::gst_encoding_list_all_targets(
301 categoryname.to_glib_none().0,
302 ))
303 }
304}
305
306#[doc(alias = "gst_encoding_list_available_categories")]
307pub fn encoding_list_available_categories() -> Vec<glib::GString> {
308 assert_initialized_main_thread!();
309 unsafe { FromGlibPtrContainer::from_glib_full(ffi::gst_encoding_list_available_categories()) }
310}
311
312#[doc(alias = "gst_pb_utils_get_element_description")]
313pub fn pb_utils_get_element_description(factory_name: &str) -> glib::GString {
314 assert_initialized_main_thread!();
315 unsafe {
316 from_glib_full(ffi::gst_pb_utils_get_element_description(
317 factory_name.to_glib_none().0,
318 ))
319 }
320}
321
322#[doc(alias = "gst_pb_utils_get_sink_description")]
323pub fn pb_utils_get_sink_description(protocol: &str) -> glib::GString {
324 assert_initialized_main_thread!();
325 unsafe {
326 from_glib_full(ffi::gst_pb_utils_get_sink_description(
327 protocol.to_glib_none().0,
328 ))
329 }
330}
331
332#[doc(alias = "gst_pb_utils_get_source_description")]
333pub fn pb_utils_get_source_description(protocol: &str) -> glib::GString {
334 assert_initialized_main_thread!();
335 unsafe {
336 from_glib_full(ffi::gst_pb_utils_get_source_description(
337 protocol.to_glib_none().0,
338 ))
339 }
340}
341
342#[doc(alias = "gst_plugins_base_version")]
343pub fn plugins_base_version() -> (u32, u32, u32, u32) {
344 skip_assert_initialized!();
345 unsafe {
346 let mut major = std::mem::MaybeUninit::uninit();
347 let mut minor = std::mem::MaybeUninit::uninit();
348 let mut micro = std::mem::MaybeUninit::uninit();
349 let mut nano = std::mem::MaybeUninit::uninit();
350 ffi::gst_plugins_base_version(
351 major.as_mut_ptr(),
352 minor.as_mut_ptr(),
353 micro.as_mut_ptr(),
354 nano.as_mut_ptr(),
355 );
356 (
357 major.assume_init(),
358 minor.assume_init(),
359 micro.assume_init(),
360 nano.assume_init(),
361 )
362 }
363}
364
365#[doc(alias = "gst_plugins_base_version_string")]
366pub fn plugins_base_version_string() -> glib::GString {
367 skip_assert_initialized!();
368 unsafe { from_glib_full(ffi::gst_plugins_base_version_string()) }
369}