1 // Take a look at the license at the top of the repository in the LICENSE file. 2 3 use glib::translate::ToGlibPtr; 4 5 use std::convert; 6 use std::ops; 7 use std::ptr; 8 9 #[derive(Debug)] 10 #[doc(alias = "GstVideoConverter")] 11 pub struct VideoConverter(ptr::NonNull<ffi::GstVideoConverter>); 12 13 impl Drop for VideoConverter { drop(&mut self)14 fn drop(&mut self) { 15 unsafe { 16 ffi::gst_video_converter_free(self.0.as_ptr()); 17 } 18 } 19 } 20 21 unsafe impl Send for VideoConverter {} 22 unsafe impl Sync for VideoConverter {} 23 24 impl VideoConverter { 25 #[doc(alias = "gst_video_converter_new")] new( in_info: &crate::VideoInfo, out_info: &crate::VideoInfo, config: Option<VideoConverterConfig>, ) -> Result<Self, glib::BoolError>26 pub fn new( 27 in_info: &crate::VideoInfo, 28 out_info: &crate::VideoInfo, 29 config: Option<VideoConverterConfig>, 30 ) -> Result<Self, glib::BoolError> { 31 assert_initialized_main_thread!(); 32 if in_info.fps() != out_info.fps() { 33 return Err(glib::bool_error!("Can't do framerate conversion")); 34 } 35 36 if in_info.interlace_mode() != out_info.interlace_mode() { 37 return Err(glib::bool_error!("Can't do interlacing conversion")); 38 } 39 40 unsafe { 41 let ptr = ffi::gst_video_converter_new( 42 in_info.to_glib_none().0 as *mut _, 43 out_info.to_glib_none().0 as *mut _, 44 config.map(|s| s.0.into_ptr()).unwrap_or(ptr::null_mut()), 45 ); 46 if ptr.is_null() { 47 Err(glib::bool_error!("Failed to create video converter")) 48 } else { 49 Ok(Self(ptr::NonNull::new_unchecked(ptr))) 50 } 51 } 52 } 53 54 #[doc(alias = "get_config")] 55 #[doc(alias = "gst_video_converter_get_config")] config(&self) -> VideoConverterConfig56 pub fn config(&self) -> VideoConverterConfig { 57 unsafe { 58 VideoConverterConfig( 59 gst::StructureRef::from_glib_borrow(ffi::gst_video_converter_get_config( 60 self.0.as_ptr(), 61 )) 62 .to_owned(), 63 ) 64 } 65 } 66 67 #[doc(alias = "gst_video_converter_set_config")] set_config(&mut self, config: VideoConverterConfig)68 pub fn set_config(&mut self, config: VideoConverterConfig) { 69 unsafe { 70 ffi::gst_video_converter_set_config(self.0.as_ptr(), config.0.into_ptr()); 71 } 72 } 73 74 #[doc(alias = "gst_video_converter_frame")] frame<T>( &self, src: &crate::VideoFrame<T>, dest: &mut crate::VideoFrame<crate::video_frame::Writable>, )75 pub fn frame<T>( 76 &self, 77 src: &crate::VideoFrame<T>, 78 dest: &mut crate::VideoFrame<crate::video_frame::Writable>, 79 ) { 80 unsafe { 81 ffi::gst_video_converter_frame(self.0.as_ptr(), src.as_ptr(), dest.as_mut_ptr()); 82 } 83 } 84 frame_ref<T>( &self, src: &crate::VideoFrameRef<T>, dest: &mut crate::VideoFrameRef<&mut gst::BufferRef>, )85 pub fn frame_ref<T>( 86 &self, 87 src: &crate::VideoFrameRef<T>, 88 dest: &mut crate::VideoFrameRef<&mut gst::BufferRef>, 89 ) { 90 unsafe { 91 ffi::gst_video_converter_frame(self.0.as_ptr(), src.as_ptr(), dest.as_mut_ptr()); 92 } 93 } 94 } 95 96 #[derive(Debug, Clone, PartialEq, Eq)] 97 pub struct VideoConverterConfig(gst::Structure); 98 99 impl ops::Deref for VideoConverterConfig { 100 type Target = gst::StructureRef; 101 deref(&self) -> &gst::StructureRef102 fn deref(&self) -> &gst::StructureRef { 103 self.0.deref() 104 } 105 } 106 107 impl ops::DerefMut for VideoConverterConfig { deref_mut(&mut self) -> &mut gst::StructureRef108 fn deref_mut(&mut self) -> &mut gst::StructureRef { 109 self.0.deref_mut() 110 } 111 } 112 113 impl AsRef<gst::StructureRef> for VideoConverterConfig { as_ref(&self) -> &gst::StructureRef114 fn as_ref(&self) -> &gst::StructureRef { 115 self.0.as_ref() 116 } 117 } 118 119 impl AsMut<gst::StructureRef> for VideoConverterConfig { as_mut(&mut self) -> &mut gst::StructureRef120 fn as_mut(&mut self) -> &mut gst::StructureRef { 121 self.0.as_mut() 122 } 123 } 124 125 impl Default for VideoConverterConfig { default() -> Self126 fn default() -> Self { 127 Self::new() 128 } 129 } 130 131 impl convert::TryFrom<gst::Structure> for VideoConverterConfig { 132 type Error = glib::BoolError; 133 try_from(v: gst::Structure) -> Result<Self, Self::Error>134 fn try_from(v: gst::Structure) -> Result<Self, Self::Error> { 135 skip_assert_initialized!(); 136 if v.name() == "GstVideoConverter" { 137 Ok(Self(v)) 138 } else { 139 Err(glib::bool_error!("Structure is no VideoConverterConfig")) 140 } 141 } 142 } 143 144 impl<'a> convert::TryFrom<&'a gst::StructureRef> for VideoConverterConfig { 145 type Error = glib::BoolError; 146 try_from(v: &'a gst::StructureRef) -> Result<Self, Self::Error>147 fn try_from(v: &'a gst::StructureRef) -> Result<Self, Self::Error> { 148 skip_assert_initialized!(); 149 Self::try_from(v.to_owned()) 150 } 151 } 152 153 impl From<VideoConverterConfig> for gst::Structure { from(v: VideoConverterConfig) -> Self154 fn from(v: VideoConverterConfig) -> Self { 155 skip_assert_initialized!(); 156 v.0 157 } 158 } 159 160 impl VideoConverterConfig { new() -> Self161 pub fn new() -> Self { 162 Self(gst::Structure::new_empty("GstVideoConverter")) 163 } 164 set_resampler_method(&mut self, v: crate::VideoResamplerMethod)165 pub fn set_resampler_method(&mut self, v: crate::VideoResamplerMethod) { 166 self.0.set("GstVideoConverter.resampler-method", &v); 167 } 168 169 #[doc(alias = "get_resampler_method")] resampler_method(&self) -> crate::VideoResamplerMethod170 pub fn resampler_method(&self) -> crate::VideoResamplerMethod { 171 self.0 172 .get_optional("GstVideoConverter.resampler-method") 173 .expect("Wrong type") 174 .unwrap_or(crate::VideoResamplerMethod::Cubic) 175 } 176 set_chroma_resampler_method(&mut self, v: crate::VideoResamplerMethod)177 pub fn set_chroma_resampler_method(&mut self, v: crate::VideoResamplerMethod) { 178 self.0.set("GstVideoConverter.chroma-resampler-method", &v); 179 } 180 181 #[doc(alias = "get_chroma_resampler_method")] chroma_resampler_method(&self) -> crate::VideoResamplerMethod182 pub fn chroma_resampler_method(&self) -> crate::VideoResamplerMethod { 183 self.0 184 .get_optional("GstVideoConverter.chroma-resampler-method") 185 .expect("Wrong type") 186 .unwrap_or(crate::VideoResamplerMethod::Linear) 187 } 188 set_resampler_taps(&mut self, v: u32)189 pub fn set_resampler_taps(&mut self, v: u32) { 190 self.0.set("GstVideoConverter.resampler-taps", &v); 191 } 192 193 #[doc(alias = "get_resampler_taps")] resampler_taps(&self) -> u32194 pub fn resampler_taps(&self) -> u32 { 195 self.0 196 .get_optional("GstVideoConverter.resampler-taps") 197 .expect("Wrong type") 198 .unwrap_or(0) 199 } 200 set_dither_method(&mut self, v: crate::VideoDitherMethod)201 pub fn set_dither_method(&mut self, v: crate::VideoDitherMethod) { 202 self.0.set("GstVideoConverter.dither-method", &v); 203 } 204 205 #[doc(alias = "get_dither_method")] dither_method(&self) -> crate::VideoDitherMethod206 pub fn dither_method(&self) -> crate::VideoDitherMethod { 207 self.0 208 .get_optional("GstVideoConverter.dither-method") 209 .expect("Wrong type") 210 .unwrap_or(crate::VideoDitherMethod::Bayer) 211 } 212 set_dither_quantization(&mut self, v: u32)213 pub fn set_dither_quantization(&mut self, v: u32) { 214 self.0.set("GstVideoConverter.dither-quantization", &v); 215 } 216 217 #[doc(alias = "get_dither_quantization")] dither_quantization(&self) -> u32218 pub fn dither_quantization(&self) -> u32 { 219 self.0 220 .get_optional("GstVideoConverter.dither-quantization") 221 .expect("Wrong type") 222 .unwrap_or(1) 223 } 224 set_src_x(&mut self, v: i32)225 pub fn set_src_x(&mut self, v: i32) { 226 self.0.set("GstVideoConverter.src-x", &v); 227 } 228 229 #[doc(alias = "get_src_x")] src_x(&self) -> i32230 pub fn src_x(&self) -> i32 { 231 self.0 232 .get_optional("GstVideoConverter.src-x") 233 .expect("Wrong type") 234 .unwrap_or(0) 235 } 236 set_src_y(&mut self, v: i32)237 pub fn set_src_y(&mut self, v: i32) { 238 self.0.set("GstVideoConverter.src-y", &v); 239 } 240 241 #[doc(alias = "get_src_y")] src_y(&self) -> i32242 pub fn src_y(&self) -> i32 { 243 self.0 244 .get_optional("GstVideoConverter.src-y") 245 .expect("Wrong type") 246 .unwrap_or(0) 247 } 248 set_src_width(&mut self, v: Option<i32>)249 pub fn set_src_width(&mut self, v: Option<i32>) { 250 if let Some(v) = v { 251 self.0.set("GstVideoConverter.src-width", &v); 252 } else { 253 self.0.remove_field("GstVideoConverter.src-width"); 254 } 255 } 256 257 #[doc(alias = "get_src_width")] src_width(&self) -> Option<i32>258 pub fn src_width(&self) -> Option<i32> { 259 self.0 260 .get_optional("GstVideoConverter.src-width") 261 .expect("Wrong type") 262 } 263 set_src_height(&mut self, v: Option<i32>)264 pub fn set_src_height(&mut self, v: Option<i32>) { 265 if let Some(v) = v { 266 self.0.set("GstVideoConverter.src-height", &v); 267 } else { 268 self.0.remove_field("GstVideoConverter.src-height"); 269 } 270 } 271 272 #[doc(alias = "get_src_height")] src_height(&self) -> Option<i32>273 pub fn src_height(&self) -> Option<i32> { 274 self.0 275 .get_optional("GstVideoConverter.src-height") 276 .expect("Wrong type") 277 } 278 set_dest_x(&mut self, v: i32)279 pub fn set_dest_x(&mut self, v: i32) { 280 self.0.set("GstVideoConverter.dest-x", &v); 281 } 282 283 #[doc(alias = "get_dest_x")] dest_x(&self) -> i32284 pub fn dest_x(&self) -> i32 { 285 self.0 286 .get_optional("GstVideoConverter.dest-x") 287 .expect("Wrong type") 288 .unwrap_or(0) 289 } 290 set_dest_y(&mut self, v: i32)291 pub fn set_dest_y(&mut self, v: i32) { 292 self.0.set("GstVideoConverter.dest-y", &v); 293 } 294 295 #[doc(alias = "get_dest_y")] dest_y(&self) -> i32296 pub fn dest_y(&self) -> i32 { 297 self.0 298 .get_optional("GstVideoConverter.dest-y") 299 .expect("Wrong type") 300 .unwrap_or(0) 301 } 302 set_dest_width(&mut self, v: Option<i32>)303 pub fn set_dest_width(&mut self, v: Option<i32>) { 304 if let Some(v) = v { 305 self.0.set("GstVideoConverter.dest-width", &v); 306 } else { 307 self.0.remove_field("GstVideoConverter.dest-width"); 308 } 309 } 310 311 #[doc(alias = "get_dest_width")] dest_width(&self) -> Option<i32>312 pub fn dest_width(&self) -> Option<i32> { 313 self.0 314 .get_optional("GstVideoConverter.dest-width") 315 .expect("Wrong type") 316 } 317 set_dest_height(&mut self, v: Option<i32>)318 pub fn set_dest_height(&mut self, v: Option<i32>) { 319 if let Some(v) = v { 320 self.0.set("GstVideoConverter.dest-height", &v); 321 } else { 322 self.0.remove_field("GstVideoConverter.dest-height"); 323 } 324 } 325 326 #[doc(alias = "get_dest_height")] dest_height(&self) -> Option<i32>327 pub fn dest_height(&self) -> Option<i32> { 328 self.0 329 .get_optional("GstVideoConverter.dest-height") 330 .expect("Wrong type") 331 } 332 set_fill_border(&mut self, v: bool)333 pub fn set_fill_border(&mut self, v: bool) { 334 self.0.set("GstVideoConverter.fill-border", &v); 335 } 336 337 #[doc(alias = "get_fill_border")] fills_border(&self) -> bool338 pub fn fills_border(&self) -> bool { 339 self.0 340 .get_optional("GstVideoConverter.fill-border") 341 .expect("Wrong type") 342 .unwrap_or(true) 343 } 344 set_alpha_value(&mut self, v: f64)345 pub fn set_alpha_value(&mut self, v: f64) { 346 self.0.set("GstVideoConverter.alpha-value", &v); 347 } 348 349 #[doc(alias = "get_alpha_value")] alpha_value(&self) -> f64350 pub fn alpha_value(&self) -> f64 { 351 self.0 352 .get_optional("GstVideoConverter.alpha-value") 353 .expect("Wrong type") 354 .unwrap_or(1.0) 355 } 356 set_alpha_mode(&mut self, v: crate::VideoAlphaMode)357 pub fn set_alpha_mode(&mut self, v: crate::VideoAlphaMode) { 358 self.0.set("GstVideoConverter.alpha-mode", &v); 359 } 360 361 #[doc(alias = "get_alpha_mode")] alpha_mode(&self) -> crate::VideoAlphaMode362 pub fn alpha_mode(&self) -> crate::VideoAlphaMode { 363 self.0 364 .get_optional("GstVideoConverter.alpha-mode") 365 .expect("Wrong type") 366 .unwrap_or(crate::VideoAlphaMode::Copy) 367 } 368 set_border_argb(&mut self, v: u32)369 pub fn set_border_argb(&mut self, v: u32) { 370 self.0.set("GstVideoConverter.border-argb", &v); 371 } 372 373 #[doc(alias = "get_border_argb")] border_argb(&self) -> u32374 pub fn border_argb(&self) -> u32 { 375 self.0 376 .get_optional("GstVideoConverter.border-argb") 377 .expect("Wrong type") 378 .unwrap_or(0xff_00_00_00) 379 } 380 set_chroma_mode(&mut self, v: crate::VideoChromaMode)381 pub fn set_chroma_mode(&mut self, v: crate::VideoChromaMode) { 382 self.0.set("GstVideoConverter.chroma-mode", &v); 383 } 384 385 #[doc(alias = "get_chroma_mode")] chroma_mode(&self) -> crate::VideoChromaMode386 pub fn chroma_mode(&self) -> crate::VideoChromaMode { 387 self.0 388 .get_optional("GstVideoConverter.chroma-mode") 389 .expect("Wrong type") 390 .unwrap_or(crate::VideoChromaMode::Full) 391 } 392 set_matrix_mode(&mut self, v: crate::VideoMatrixMode)393 pub fn set_matrix_mode(&mut self, v: crate::VideoMatrixMode) { 394 self.0.set("GstVideoConverter.matrix-mode", &v); 395 } 396 397 #[doc(alias = "get_matrix_mode")] matrix_mode(&self) -> crate::VideoMatrixMode398 pub fn matrix_mode(&self) -> crate::VideoMatrixMode { 399 self.0 400 .get_optional("GstVideoConverter.matrix-mode") 401 .expect("Wrong type") 402 .unwrap_or(crate::VideoMatrixMode::Full) 403 } 404 set_gamma_mode(&mut self, v: crate::VideoGammaMode)405 pub fn set_gamma_mode(&mut self, v: crate::VideoGammaMode) { 406 self.0.set("GstVideoConverter.gamma-mode", &v); 407 } 408 409 #[doc(alias = "get_gamma_mode")] gamma_mode(&self) -> crate::VideoGammaMode410 pub fn gamma_mode(&self) -> crate::VideoGammaMode { 411 self.0 412 .get_optional("GstVideoConverter.gamma-mode") 413 .expect("Wrong type") 414 .unwrap_or(crate::VideoGammaMode::None) 415 } 416 set_primaries_mode(&mut self, v: crate::VideoPrimariesMode)417 pub fn set_primaries_mode(&mut self, v: crate::VideoPrimariesMode) { 418 self.0.set("GstVideoConverter.primaries-mode", &v); 419 } 420 421 #[doc(alias = "get_primaries_mode")] primaries_mode(&self) -> crate::VideoPrimariesMode422 pub fn primaries_mode(&self) -> crate::VideoPrimariesMode { 423 self.0 424 .get_optional("GstVideoConverter.primaries-mode") 425 .expect("Wrong type") 426 .unwrap_or(crate::VideoPrimariesMode::None) 427 } 428 set_threads(&mut self, v: u32)429 pub fn set_threads(&mut self, v: u32) { 430 self.0.set("GstVideoConverter.threads", &v); 431 } 432 433 #[doc(alias = "get_threads")] threads(&self) -> u32434 pub fn threads(&self) -> u32 { 435 self.0 436 .get_optional("GstVideoConverter.threads") 437 .expect("Wrong type") 438 .unwrap_or(1) 439 } 440 } 441