mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2025-02-20 14:46:24 +00:00
Code Issues Projects Releases Wiki Activity

Fix various new clippy warnings from 1.40

Browse source
This commit is contained in:
Sebastian Dröge 2019-12-22 11:18:30 +02:00
parent bc94cc999e
commit 9772adbfbf
16 changed files with 109 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gst-plugin-audiofx/src/audioecho.rs
View file

@ -296,7 +296,7 @@ impl BaseTransformImpl for AudioEcho {
}
let info = gst_audio::AudioInfo::from_caps(incaps)
.or(Err(gst_loggable_error!(CAT, "Failed to parse input caps")))?;
.or_else(|_| Err(gst_loggable_error!(CAT, "Failed to parse input caps")))?;
let max_delay = self.settings.lock().unwrap().max_delay;
let size = max_delay * (info.rate() as u64) / gst::SECOND_VAL;
let buffer_size = size * (info.channels() as u64);

3
gst-plugin-cdg/tests/cdgdec.rs
View file

@ -94,8 +94,7 @@ fn test_cdgdec() {
err.get_error()
);
eprintln!("Debugging information: {:?}", err.get_debug());
assert!(true);
break;
unreachable!();
}
MessageView::Eos(..) => break,
_ => (),

18
gst-plugin-closedcaption/tests/mcc_parse.rs
View file

@ -85,7 +85,9 @@ fn test_parse() {
} else {
expected_timecode = Some(tc_meta.get_tc());
}
expected_timecode.as_mut().map(|tc| tc.increment_frame());
if let Some(ref mut tc) = expected_timecode {
tc.increment_frame();
}
}
data = &data[l..];
}
@ -108,13 +110,15 @@ fn test_parse() {
} else {
expected_timecode = Some(tc_meta.get_tc());
}
expected_timecode.as_mut().map(|tc| tc.increment_frame());
if let Some(ref mut tc) = expected_timecode {
tc.increment_frame();
}
}
assert!(expected_timecode.is_some());
assert_eq!(input_len, 28818);
assert_eq!(output_len, 42383);
assert_eq!(checksum, 3988480);
assert_eq!(input_len, 28_818);
assert_eq!(output_len, 42_383);
assert_eq!(checksum, 3_988_480);
let caps = h
.get_sinkpad()
@ -174,9 +178,9 @@ fn test_pull() {
1.0,
gst::SeekFlags::FLUSH,
gst::SeekType::Set,
gst::GenericFormattedValue::Time(gst::SECOND.into()),
gst::GenericFormattedValue::Time(gst::SECOND),
gst::SeekType::Set,
gst::GenericFormattedValue::Time((2 * gst::SECOND).into()),
gst::GenericFormattedValue::Time(2 * gst::SECOND),
)
.build(),
);

18
gst-plugin-closedcaption/tests/scc_enc.rs
View file

@ -103,10 +103,10 @@ fn test_encode_multiple_packets() {
gst::Fraction::new(30000, 1001),
None,
gst_video::VideoTimeCodeFlags::DROP_FRAME,
00,
00,
00,
00,
0,
0,
0,
0,
0,
)
.unwrap();
@ -115,10 +115,10 @@ fn test_encode_multiple_packets() {
gst::Fraction::new(30000, 1001),
None,
gst_video::VideoTimeCodeFlags::DROP_FRAME,
00,
00,
0,
0,
14,
01,
1,
0,
)
.unwrap();
@ -200,8 +200,8 @@ fn test_encode_multiple_packets() {
gst::Fraction::new(30000, 1001),
None,
gst_video::VideoTimeCodeFlags::DROP_FRAME,
00,
00,
0,
0,
14,
17,
0,

6
gst-plugin-closedcaption/tests/scc_parse.rs
View file

@ -90,9 +90,9 @@ fn test_parse() {
);
}
assert_eq!(input_len, 241152);
assert_eq!(input_len, 241_152);
assert_eq!(output_len, 89084);
assert_eq!(checksum, 12554799);
assert_eq!(checksum, 12_554_799);
let caps = h
.get_sinkpad()
@ -186,7 +186,7 @@ fn test_timecodes() {
}
assert_eq!(output_len, 1268);
assert_eq!(checksum, 174295);
assert_eq!(checksum, 174_295);
let caps = h
.get_sinkpad()

6
gst-plugin-fallbackswitch/examples/gtk_fallbackswitch.rs
View file

@ -161,10 +161,8 @@ fn create_ui(app: &gtk::Application) {
*drop_id = video_src_pad
.add_probe(gst::PadProbeType::BUFFER, |_, _| gst::PadProbeReturn::Drop);
}
} else {
if let Some(drop_id) = drop_id.borrow_mut().take() {
video_src_pad.remove_probe(drop_id);
}
} else if let Some(drop_id) = drop_id.borrow_mut().take() {
video_src_pad.remove_probe(drop_id);
}
});

83
gst-plugin-fallbackswitch/tests/fallbackswitch.rs
View file

@ -65,15 +65,15 @@ macro_rules! assert_buffer {
fn test_no_fallback_no_drops() {
let pipeline = setup_pipeline(None);
push_buffer(&pipeline, 0 * gst::SECOND);
set_time(&pipeline, 0 * gst::SECOND);
push_buffer(&pipeline, 0.into());
set_time(&pipeline, 0.into());
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 0 * gst::SECOND);
assert_buffer!(buffer, 0.into());
push_buffer(&pipeline, 1 * gst::SECOND);
set_time(&pipeline, 1 * gst::SECOND);
push_buffer(&pipeline, gst::SECOND);
set_time(&pipeline, gst::SECOND);
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 1 * gst::SECOND);
assert_buffer!(buffer, gst::SECOND);
push_buffer(&pipeline, 2 * gst::SECOND);
set_time(&pipeline, 2 * gst::SECOND);
@ -99,17 +99,17 @@ fn test_no_drops_not_live() {
fn test_no_drops(live: bool) {
let pipeline = setup_pipeline(Some(live));
push_buffer(&pipeline, 0 * gst::SECOND);
push_fallback_buffer(&pipeline, 0 * gst::SECOND);
set_time(&pipeline, 0 * gst::SECOND);
push_buffer(&pipeline, 0.into());
push_fallback_buffer(&pipeline, 0.into());
set_time(&pipeline, 0.into());
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 0 * gst::SECOND);
assert_buffer!(buffer, 0.into());
push_fallback_buffer(&pipeline, 1 * gst::SECOND);
push_buffer(&pipeline, 1 * gst::SECOND);
set_time(&pipeline, 1 * gst::SECOND);
push_fallback_buffer(&pipeline, gst::SECOND);
push_buffer(&pipeline, gst::SECOND);
set_time(&pipeline, gst::SECOND);
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 1 * gst::SECOND);
assert_buffer!(buffer, gst::SECOND);
push_buffer(&pipeline, 2 * gst::SECOND);
push_fallback_buffer(&pipeline, 2 * gst::SECOND);
@ -137,17 +137,17 @@ fn test_no_drops_but_no_fallback_frames_not_live() {
fn test_no_drops_but_no_fallback_frames(live: bool) {
let pipeline = setup_pipeline(Some(live));
push_buffer(&pipeline, 0 * gst::SECOND);
push_buffer(&pipeline, 0.into());
// +10ms needed here because the immediate timeout will be always at running time 0, but
// aggregator also adds the latency to it so we end up at 10ms instead.
set_time(&pipeline, 0 * gst::SECOND + 10 * gst::MSECOND);
set_time(&pipeline, 10 * gst::MSECOND);
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 0 * gst::SECOND);
assert_buffer!(buffer, 0.into());
push_buffer(&pipeline, 1 * gst::SECOND);
set_time(&pipeline, 1 * gst::SECOND);
push_buffer(&pipeline, gst::SECOND);
set_time(&pipeline, gst::SECOND);
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 1 * gst::SECOND);
assert_buffer!(buffer, gst::SECOND);
push_buffer(&pipeline, 2 * gst::SECOND);
set_time(&pipeline, 2 * gst::SECOND);
@ -174,17 +174,17 @@ fn test_short_drop_not_live() {
fn test_short_drop(live: bool) {
let pipeline = setup_pipeline(Some(live));
push_buffer(&pipeline, 0 * gst::SECOND);
push_fallback_buffer(&pipeline, 0 * gst::SECOND);
set_time(&pipeline, 0 * gst::SECOND);
push_buffer(&pipeline, 0.into());
push_fallback_buffer(&pipeline, 0.into());
set_time(&pipeline, 0.into());
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 0 * gst::SECOND);
assert_buffer!(buffer, 0.into());
// A timeout at 1s will get rid of the fallback buffer
// but not output anything
push_fallback_buffer(&pipeline, 1 * gst::SECOND);
push_fallback_buffer(&pipeline, gst::SECOND);
// Time out the fallback buffer at +10ms
set_time(&pipeline, 1 * gst::SECOND + 10 * gst::MSECOND);
set_time(&pipeline, gst::SECOND + 10 * gst::MSECOND);
push_fallback_buffer(&pipeline, 2 * gst::SECOND);
push_buffer(&pipeline, 2 * gst::SECOND);
@ -213,15 +213,15 @@ fn test_long_drop_and_eos(live: bool) {
let pipeline = setup_pipeline(Some(live));
// Produce the first frame
push_buffer(&pipeline, 0 * gst::SECOND);
push_fallback_buffer(&pipeline, 0 * gst::SECOND);
set_time(&pipeline, 0 * gst::SECOND);
push_buffer(&pipeline, 0.into());
push_fallback_buffer(&pipeline, 0.into());
set_time(&pipeline, 0.into());
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 0 * gst::SECOND);
assert_buffer!(buffer, 0.into());
// Produce a second frame but only from the fallback source
push_fallback_buffer(&pipeline, 1 * gst::SECOND);
set_time(&pipeline, 1 * gst::SECOND + 10 * gst::MSECOND);
push_fallback_buffer(&pipeline, gst::SECOND);
set_time(&pipeline, gst::SECOND + 10 * gst::MSECOND);
// Produce a third frame but only from the fallback source
push_fallback_buffer(&pipeline, 2 * gst::SECOND);
@ -263,15 +263,15 @@ fn test_long_drop_and_recover(live: bool) {
let pipeline = setup_pipeline(Some(live));
// Produce the first frame
push_buffer(&pipeline, 0 * gst::SECOND);
push_fallback_buffer(&pipeline, 0 * gst::SECOND);
set_time(&pipeline, 0 * gst::SECOND);
push_buffer(&pipeline, 0.into());
push_fallback_buffer(&pipeline, 0.into());
set_time(&pipeline, 0.into());
let buffer = pull_buffer(&pipeline);
assert_buffer!(buffer, 0 * gst::SECOND);
assert_buffer!(buffer, 0.into());
// Produce a second frame but only from the fallback source
push_fallback_buffer(&pipeline, 1 * gst::SECOND);
set_time(&pipeline, 1 * gst::SECOND + 10 * gst::MSECOND);
push_fallback_buffer(&pipeline, gst::SECOND);
set_time(&pipeline, gst::SECOND + 10 * gst::MSECOND);
// Produce a third frame but only from the fallback source
push_fallback_buffer(&pipeline, 2 * gst::SECOND);
@ -339,14 +339,14 @@ fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
gst_debug!(TEST_CAT, "Setting up pipeline");
let clock = gst_check::TestClock::new();
clock.set_time(0 * gst::SECOND);
clock.set_time(0.into());
let pipeline = gst::Pipeline::new(None);
// Running time 0 in our pipeline is going to be clock time 1s. All
// clock ids before 1s are used for signalling to our clock advancing
// thread.
pipeline.use_clock(Some(&clock));
pipeline.set_base_time(1 * gst::SECOND);
pipeline.set_base_time(gst::SECOND);
pipeline.set_start_time(gst::CLOCK_TIME_NONE);
let src = gst::ElementFactory::make("appsrc", Some("src"))
@ -416,10 +416,7 @@ fn setup_pipeline(with_live_fallback: Option<bool>) -> Pipeline {
pipeline.set_state(gst::State::Playing).unwrap();
let clock_clone = clock.clone();
let clock_join_handle = std::thread::spawn(move || {
let clock = clock_clone;
loop {
while let Some(clock_id) = clock.peek_next_pending_id().and_then(|clock_id| {
// Process if the clock ID is in the past or now

20
gst-plugin-reqwest/tests/reqwesthttpsrc.rs
View file

@ -925,10 +925,7 @@ fn test_seek_after_ready() {
});
let segment = h.wait_for_segment(false);
assert_eq!(
gst::format::Bytes::from(segment.get_start()),
gst::format::Bytes::from(123)
);
assert_eq!(segment.get_start(), gst::format::Bytes::from(123));
let mut expected_output = vec![0; 8192 - 123];
for (i, d) in expected_output.iter_mut().enumerate() {
@ -1006,10 +1003,7 @@ fn test_seek_after_buffer_received() {
});
let segment = h.wait_for_segment(true);
assert_eq!(
gst::format::Bytes::from(segment.get_start()),
gst::format::Bytes::from(123)
);
assert_eq!(segment.get_start(), gst::format::Bytes::from(123));
let mut expected_output = vec![0; 8192 - 123];
for (i, d) in expected_output.iter_mut().enumerate() {
@ -1094,14 +1088,8 @@ fn test_seek_with_stop_position() {
});
let segment = h.wait_for_segment(true);
assert_eq!(
gst::format::Bytes::from(segment.get_start()),
gst::format::Bytes::from(123)
);
assert_eq!(
gst::format::Bytes::from(segment.get_stop()),
gst::format::Bytes::from(131)
);
assert_eq!(segment.get_start(), gst::format::Bytes::from(123));
assert_eq!(segment.get_stop(), gst::format::Bytes::from(131));
let mut expected_output = vec![0; 8];
for (i, d) in expected_output.iter_mut().enumerate() {

13
gst-plugin-sodium/examples/generate_keys.rs
View file

@ -48,9 +48,10 @@ impl Keys {
path.into()
};
let file = File::create(&path).expect(&format!("Failed to create file at {}", path));
let file =
File::create(&path).unwrap_or_else(|_| panic!("Failed to create file at {}", path));
serde_json::to_writer(file, &self)
.expect(&format!("Failed to write to file at {}", path));
.unwrap_or_else(|_| panic!("Failed to write to file at {}", path));
} else {
use std::io::Write;
use std::path::PathBuf;
@ -58,16 +59,16 @@ impl Keys {
let mut private = PathBuf::from(path);
private.set_extension("prv");
let mut file = File::create(&private)
.expect(&format!("Failed to create file at {}", private.display()));
.unwrap_or_else(|_| panic!("Failed to create file at {}", private.display()));
file.write_all(&self.private.0)
.expect(&format!("Failed to write to file at {}", private.display()));
.unwrap_or_else(|_| panic!("Failed to write to file at {}", private.display()));
let mut public = PathBuf::from(path);
public.set_extension("pub");
let mut file = File::create(&public)
.expect(&format!("Failed to create file at {}", public.display()));
.unwrap_or_else(|_| panic!("Failed to create file at {}", public.display()));
file.write_all(self.public.as_ref())
.expect(&format!("Failed to write to file at {}", public.display()));
.unwrap_or_else(|_| panic!("Failed to write to file at {}", public.display()));
}
}
}

5
gst-plugin-sodium/tests/decrypter.rs
View file

@ -135,8 +135,7 @@ fn test_pipeline() {
err.get_error()
);
eprintln!("Debugging information: {:?}", err.get_debug());
assert!(true);
break;
unreachable!();
}
MessageView::Eos(..) => break,
_ => (),
@ -268,7 +267,7 @@ fn test_pull_range() {
assert_eq!(res, Err(gst::FlowError::Eos));
// read 100 bytes way past eos
let res = srcpad.get_range(424242, 100);
let res = srcpad.get_range(424_242, 100);
assert_eq!(res, Err(gst::FlowError::Eos));
// read 10 bytes at eos -1, should return a single byte

5
gst-plugin-threadshare/examples/tcpclientsrc_benchmark_sender.rs
View file

@ -33,12 +33,11 @@ fn main() {
let buffer = [0; 160];
let wait = time::Duration::from_millis(20);
let streams = sockets.clone();
loop {
let now = time::Instant::now();
for mut stream in streams.lock().unwrap().iter() {
let _ = stream.write(&buffer);
for mut socket in sockets.lock().unwrap().iter() {
let _ = socket.write(&buffer);
}
let elapsed = now.elapsed();

3
gst-plugin-threadshare/src/runtime/executor.rs
View file

@ -372,11 +372,10 @@ mod tests {
let sender: Arc<Mutex<mpsc::Sender<Item>>> = Arc::new(Mutex::new(sender));
let ctx_weak = context.downgrade();
let queue_id_clone = queue_id.clone();
let add_task = move |item| {
let sender_task = Arc::clone(&sender);
let context = ctx_weak.upgrade().unwrap();
context.add_task(queue_id_clone, async move {
context.add_task(queue_id, async move {
sender_task
.lock()
.await

26
gst-plugin-threadshare/tests/pipeline.rs
View file

@ -142,13 +142,12 @@ fn multiple_contexts_queue() {
match msg.view() {
MessageView::StateChanged(state_changed) => {
if let Some(source) = state_changed.get_src() {
if source.get_type() == gst::Pipeline::static_type() {
if state_changed.get_old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing
{
if let Some(test_scenario) = test_scenario.take() {
std::thread::spawn(test_scenario);
}
if source.get_type() == gst::Pipeline::static_type()
&& state_changed.get_old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing
{
if let Some(test_scenario) = test_scenario.take() {
std::thread::spawn(test_scenario);
}
}
}
@ -302,13 +301,12 @@ fn multiple_contexts_proxy() {
match msg.view() {
MessageView::StateChanged(state_changed) => {
if let Some(source) = state_changed.get_src() {
if source.get_type() == gst::Pipeline::static_type() {
if state_changed.get_old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing
{
if let Some(test_scenario) = test_scenario.take() {
std::thread::spawn(test_scenario);
}
if source.get_type() == gst::Pipeline::static_type()
&& state_changed.get_old() == gst::State::Paused
&& state_changed.get_current() == gst::State::Playing
{
if let Some(test_scenario) = test_scenario.take() {
std::thread::spawn(test_scenario);
}
}
}

14
gst-plugin-threadshare/tests/tcpclientsrc.rs
View file

@ -48,14 +48,12 @@ fn test_push() {
use std::net;
let listener = net::TcpListener::bind("0.0.0.0:5000").unwrap();
for stream in listener.incoming() {
let buffer = [0; 160];
let mut socket = stream.unwrap();
for _ in 0..3 {
let _ = socket.write(&buffer);
thread::sleep(time::Duration::from_millis(20));
}
break;
let stream = listener.incoming().next().unwrap();
let buffer = [0; 160];
let mut socket = stream.unwrap();
for _ in 0..3 {
let _ = socket.write(&buffer);
thread::sleep(time::Duration::from_millis(20));
}
});

1
gst-plugin-togglerecord/tests/tests.rs
View file

@ -46,6 +46,7 @@ enum SendData {
Eos,
}
#[allow(clippy::type_complexity)]
fn setup_sender_receiver(
pipeline: &gst::Pipeline,
togglerecord: &gst::Element,

12
gst-plugin-tutorial/src/sinesrc.rs
View file

@ -440,11 +440,13 @@ impl BaseSrcImpl for SineSrc {
) -> Result<(), gst::LoggableError> {
use std::f64::consts::PI;
let info = gst_audio::AudioInfo::from_caps(caps).or(Err(gst_loggable_error!(
CAT,
"Failed to build `AudioInfo` from caps {}",
caps
)))?;
let info = gst_audio::AudioInfo::from_caps(caps).or_else(|_| {
Err(gst_loggable_error!(
CAT,
"Failed to build `AudioInfo` from caps {}",
caps
))
})?;
gst_debug!(CAT, obj: element, "Configuring for caps {}", caps);