From 9236534dab5cd8dcd06097ef917b62f750d83ce9 Mon Sep 17 00:00:00 2001 From: kageru Date: Sun, 2 Jun 2019 15:31:27 +0200 Subject: [PATCH] rustfmt --- src/grain.rs | 12 ++++----- src/lib.rs | 19 ++++++++------ src/mask.rs | 71 ++++++++++++++++++++++++++++++++++------------------ 3 files changed, 63 insertions(+), 39 deletions(-) diff --git a/src/grain.rs b/src/grain.rs index eb5148f..a3d026b 100644 --- a/src/grain.rs +++ b/src/grain.rs @@ -1,17 +1,17 @@ use failure::Error; use num::Integer; +use rand::distributions::Uniform; use rand::Rng; +use rand_xorshift::XorShiftRng; use vapoursynth::api::API; use vapoursynth::core::CoreRef; use vapoursynth::frame::{FrameRef, FrameRefMut}; use vapoursynth::node::Node; use vapoursynth::plugins::{Filter, FrameContext}; use vapoursynth::video_info::VideoInfo; -use rand::distributions::Uniform; -use rand_xorshift::XorShiftRng; pub struct Grain<'core> { - pub source: Node<'core> + pub source: Node<'core>, } #[inline] @@ -42,9 +42,9 @@ impl<'core> Filter<'core> for Grain<'core> { context: FrameContext, n: usize, ) -> Result, Error> { - let frame = self.source - .get_frame_filter(context, n) - .ok_or_else(|| format_err!("Could not retrieve source frame. This shouldn’t happen."))?; + let frame = self.source.get_frame_filter(context, n).ok_or_else(|| { + format_err!("Could not retrieve source frame. This shouldn’t happen.") + })?; let var = 20i16; // these have to be defined explicitly for lifetime reasons //let mut rng = thread_rng(); diff --git a/src/lib.rs b/src/lib.rs index fa4036f..c8dadaf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -8,23 +8,23 @@ extern crate vapoursynth; mod grain; mod mask; -use self::mask::Mask; use self::grain::Grain; +use self::mask::Mask; use failure::Error; use vapoursynth::api::API; use vapoursynth::core::CoreRef; +use vapoursynth::format::SampleType; use vapoursynth::frame::{FrameRef, FrameRefMut}; use vapoursynth::map::Map; use vapoursynth::node::Node; use vapoursynth::plugins::{Filter, FilterArgument, FrameContext, Metadata}; -use vapoursynth::video_info::{VideoInfo, Property}; -use vapoursynth::format::SampleType; +use vapoursynth::video_info::{Property, VideoInfo}; pub const PLUGIN_NAME: &str = "adaptivegrain"; pub const PLUGIN_IDENTIFIER: &str = "moe.kageru.adaptivegrain"; struct AdaptiveGrain<'core> { - source: Node<'core> + source: Node<'core>, } impl<'core> Filter<'core> for AdaptiveGrain<'core> { @@ -50,12 +50,15 @@ impl<'core> Filter<'core> for AdaptiveGrain<'core> { context: FrameContext, n: usize, ) -> Result, Error> { - let frame = self.source - .get_frame_filter(context, n) - .ok_or_else(|| format_err!("Could not retrieve source frame. This shouldn’t happen."))?; + let frame = self.source.get_frame_filter(context, n).ok_or_else(|| { + format_err!("Could not retrieve source frame. This shouldn’t happen.") + })?; let average = match frame.props().get::("PlaneStatsAverage") { Ok(average) => (average * 256.0) as u8, - Err(_) => panic!(PLUGIN_NAME.to_owned() + ": You need to run std.PlaneStats on the clip before calling this function.") + Err(_) => panic!( + PLUGIN_NAME.to_owned() + + ": You need to run std.PlaneStats on the clip before calling this function." + ), }; let mut frame = FrameRefMut::copy_of(core, &frame); diff --git a/src/mask.rs b/src/mask.rs index 5e0b919..0b5a17b 100644 --- a/src/mask.rs +++ b/src/mask.rs @@ -1,14 +1,14 @@ -use failure::Error; use super::PLUGIN_NAME; +use failure::Error; +use std::fmt::Debug; use vapoursynth::api::API; use vapoursynth::core::CoreRef; +use vapoursynth::format::ColorFamily; use vapoursynth::frame::{FrameRef, FrameRefMut}; use vapoursynth::node::Node; use vapoursynth::plugins::{Filter, FrameContext}; -use vapoursynth::video_info::{VideoInfo, Property}; -use vapoursynth::format::ColorFamily; -use std::fmt::Debug; - +use vapoursynth::video_info::{Property, VideoInfo}; +use std::hint::unreachable_unchecked; pub struct Mask<'core> { pub source: Node<'core>, @@ -17,7 +17,8 @@ pub struct Mask<'core> { lazy_static! { static ref FLOAT_RANGE: Vec = { - [0f32; 1000].iter() + [0f32; 1000] + .iter() .enumerate() .map(|(i, _f)| (i as f32) * 0.001) .collect::>() @@ -26,14 +27,17 @@ lazy_static! { #[inline] fn get_mask_value(x: f32, y: f32, luma_scaling: f32) -> f32 { - f32::powf(1.0 - (x * (1.124 + x * (-9.466 + x * (36.624 + x * (-45.47 + x * 18.188))))), (y * y) * luma_scaling) + f32::powf( + 1.0 - (x * (1.124 + x * (-9.466 + x * (36.624 + x * (-45.47 + x * 18.188))))), + (y * y) * luma_scaling, + ) } #[inline] fn from_property(prop: Property) -> T { match prop { Property::Constant(p) => p, - Property::Variable => panic!() + Property::Variable => unreachable!(), } } @@ -41,17 +45,21 @@ impl<'core> Filter<'core> for Mask<'core> { fn video_info(&self, _api: API, _core: CoreRef<'core>) -> Vec> { let info = self.source.info(); let format = match info.format { - Property::Variable => panic!("adaptivegrain: only constant format input supported"), - Property::Constant(format) => format + Property::Variable => unreachable!(), + Property::Constant(format) => format, }; vec![VideoInfo { - format: Property::Constant(_core.register_format( - ColorFamily::Gray, - format.sample_type(), - format.bits_per_sample(), - 0, - 0, - ).unwrap()), + format: Property::Constant( + _core + .register_format( + ColorFamily::Gray, + format.sample_type(), + format.bits_per_sample(), + 0, + 0, + ) + .unwrap(), + ), flags: info.flags, framerate: info.framerate, num_frames: info.num_frames, @@ -80,21 +88,34 @@ impl<'core> Filter<'core> for Mask<'core> { let new_format = from_property(self.video_info(_api, core)[0].format); let mut frame = unsafe { FrameRefMut::new_uninitialized( - core, None, new_format, from_property(self.source.info().resolution)) + core, + None, + new_format, + from_property(self.source.info().resolution), + ) }; - let src_frame = self.source - .get_frame_filter(context, n) - .ok_or_else(|| format_err!("Could not retrieve source frame. This shouldn’t happen."))?; + let src_frame = self.source.get_frame_filter(context, n).ok_or_else(|| { + format_err!("Could not retrieve source frame. This shouldn’t happen.") + })?; let average = match src_frame.props().get::("PlaneStatsAverage") { Ok(average) => average as f32, - Err(_) => panic!(format!("{}: you need to run std.PlaneStats on the clip before calling this function.", PLUGIN_NAME)) + Err(_) => panic!(format!( + "{}: you need to run std.PlaneStats on the clip before calling this function.", + PLUGIN_NAME + )), }; - let lut: Vec = FLOAT_RANGE.iter().map(|x| get_mask_value(*x, average, self.luma_scaling)).collect(); + let lut: Vec = FLOAT_RANGE + .iter() + .map(|x| get_mask_value(*x, average, self.luma_scaling)) + .collect(); for row in 0..frame.height(0) { - for (pixel, src_pixel) in frame.plane_row_mut::(0, row).iter_mut() - .zip(src_frame.plane_row::(0, row).iter()) { + for (pixel, src_pixel) in frame + .plane_row_mut::(0, row) + .iter_mut() + .zip(src_frame.plane_row::(0, row).iter()) + { *pixel = lut[(src_pixel * 1000f32) as usize]; } }