rename register_all_codecs to register_all_decoders

diff --git a/nihav-allstuff/src/lib.rs b/nihav-allstuff/src/lib.rs
index 88435c549e03ab3f5ca19420c92025fd090a2fb0..5ef4fe9d55e09f22c9bcb507ea17cd1bd3324206 100644 (file)
--- a/nihav-allstuff/src/lib.rs
+++ b/nihav-allstuff/src/lib.rs
@@ -13,39 +13,39 @@ use nihav_core::codecs::RegisteredEncoders;
 use nihav_core::demuxers::RegisteredDemuxers;
 use nihav_core::muxers::RegisteredMuxers;
 
-use nihav_commonfmt::generic_register_all_codecs;
+use nihav_commonfmt::generic_register_all_decoders;
 use nihav_commonfmt::generic_register_all_demuxers;
 use nihav_commonfmt::generic_register_all_encoders;
 use nihav_commonfmt::generic_register_all_muxers;
 
-use nihav_duck::duck_register_all_codecs;
+use nihav_duck::duck_register_all_decoders;
 
-use nihav_game::game_register_all_codecs;
+use nihav_game::game_register_all_decoders;
 use nihav_game::game_register_all_demuxers;
 
-use nihav_indeo::indeo_register_all_codecs;
+use nihav_indeo::indeo_register_all_decoders;
 
-use nihav_ms::ms_register_all_codecs;
+use nihav_ms::ms_register_all_decoders;
 use nihav_ms::ms_register_all_encoders;
 
-use nihav_qt::qt_register_all_codecs;
+use nihav_qt::qt_register_all_decoders;
 
-use nihav_rad::rad_register_all_codecs;
+use nihav_rad::rad_register_all_decoders;
 use nihav_rad::rad_register_all_demuxers;
 
-use nihav_realmedia::realmedia_register_all_codecs;
+use nihav_realmedia::realmedia_register_all_decoders;
 use nihav_realmedia::realmedia_register_all_demuxers;
 
 /// Registers all known decoders.
-pub fn nihav_register_all_codecs(rd: &mut RegisteredDecoders) {
-    generic_register_all_codecs(rd);
-    duck_register_all_codecs(rd);
-    game_register_all_codecs(rd);
-    indeo_register_all_codecs(rd);
-    ms_register_all_codecs(rd);
-    qt_register_all_codecs(rd);
-    rad_register_all_codecs(rd);
-    realmedia_register_all_codecs(rd);
+pub fn nihav_register_all_decoders(rd: &mut RegisteredDecoders) {
+    generic_register_all_decoders(rd);
+    duck_register_all_decoders(rd);
+    game_register_all_decoders(rd);
+    indeo_register_all_decoders(rd);
+    ms_register_all_decoders(rd);
+    qt_register_all_decoders(rd);
+    rad_register_all_decoders(rd);
+    realmedia_register_all_decoders(rd);
 }
 
 /// Registers all known demuxers.
@@ -78,7 +78,7 @@ mod test {
     #[test]
     fn test_descriptions() {
         let mut rd = RegisteredDecoders::new();
-        nihav_register_all_codecs(&mut rd);
+        nihav_register_all_decoders(&mut rd);
         let mut has_missing = false;
         for dec in rd.iter() {
             print!("decoder {} - ", dec.name);

diff --git a/nihav-commonfmt/src/codecs/aac.rs b/nihav-commonfmt/src/codecs/aac.rs
index 54ccef6bc4492c9a31be37bb46e50b5d11f4e4e8..d3f991b4da925f1bee1deec2257bd44c29317389 100644 (file)
--- a/nihav-commonfmt/src/codecs/aac.rs
+++ b/nihav-commonfmt/src/codecs/aac.rs
@@ -1274,14 +1274,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::test_decode_audio;
-    use crate::generic_register_all_codecs;
+    use crate::generic_register_all_decoders;
     use nihav_realmedia::realmedia_register_all_demuxers;
     #[test]
     fn test_aac() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
 
 //        let file = "assets/RV/rv40_weighted_mc.rmvb";
         let file = "assets/RV/rv40_weighted_mc_2.rmvb";

diff --git a/nihav-commonfmt/src/codecs/atrac3.rs b/nihav-commonfmt/src/codecs/atrac3.rs
index 85124825b885d0ebaa1cb65c0ff7fcfdee5a866e..f1b9ef65af1afc37f9b5de60a62b105daa4db849 100644 (file)
--- a/nihav-commonfmt/src/codecs/atrac3.rs
+++ b/nihav-commonfmt/src/codecs/atrac3.rs
@@ -712,14 +712,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::test_decode_audio;
-    use crate::generic_register_all_codecs;
+    use crate::generic_register_all_decoders;
     use nihav_realmedia::realmedia_register_all_demuxers;
     #[test]
     fn test_atrac3() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
 
         let file = "assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm";
 //        let file = "assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm";

diff --git a/nihav-commonfmt/src/codecs/cinepak.rs b/nihav-commonfmt/src/codecs/cinepak.rs
index 8c67c5c4f72bde42c73c8a8f7e1236ed9647edb9..ff1130b16346d363f6ad3348b9109136ddd5158e 100644 (file)
--- a/nihav-commonfmt/src/codecs/cinepak.rs
+++ b/nihav-commonfmt/src/codecs/cinepak.rs
@@ -399,14 +399,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::generic_register_all_codecs;
+    use crate::generic_register_all_decoders;
     use crate::generic_register_all_demuxers;
     #[test]
     fn test_cinepak() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
         test_decoding("avi", "cinepak", "assets/Misc/ot171.avi", Some(10), &dmx_reg,
                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
                         [0xd58326b0, 0xdbfc1dcc, 0x6d66a04c, 0x08a21bbb],
@@ -426,7 +426,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
         test_decoding("mov", "cinepak", "assets/Misc/dday.mov", Some(10), &dmx_reg,
                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
                         [0x2ab229bc, 0xb71308aa, 0x979511c6, 0xcef3ea92],
@@ -446,7 +446,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
         test_decoding("mov", "cinepak", "assets/Misc/catfight Tag team DT.mov", Some(10), &dmx_reg,
                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
                         [0x3f7ec8ea, 0x873a2bc6, 0xcc58336e, 0xe88c4ffd],

diff --git a/nihav-commonfmt/src/codecs/cinepakenc.rs b/nihav-commonfmt/src/codecs/cinepakenc.rs
index 1c134c0e3ace2bfa4b681505b85e62e8a2865980..95994eedae1f73dd2107841a29c52b1fd88371b3 100644 (file)
--- a/nihav-commonfmt/src/codecs/cinepakenc.rs
+++ b/nihav-commonfmt/src/codecs/cinepakenc.rs
@@ -1069,7 +1069,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
         let mut mux_reg = RegisteredMuxers::new();
         generic_register_all_muxers(&mut mux_reg);
         let mut enc_reg = RegisteredEncoders::new();

diff --git a/nihav-commonfmt/src/codecs/clearvideo.rs b/nihav-commonfmt/src/codecs/clearvideo.rs
index 4f24bd4919d3fef0542b7a7ae2e40db35bb6da9d..8b22dad4c194b33bfc8c72d572b622ab61178c1e 100644 (file)
--- a/nihav-commonfmt/src/codecs/clearvideo.rs
+++ b/nihav-commonfmt/src/codecs/clearvideo.rs
@@ -727,14 +727,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::generic_register_all_codecs;
+    use crate::generic_register_all_decoders;
     use crate::generic_register_all_demuxers;
     #[test]
     fn test_clv() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
         test_decoding("avi", "clearvideo", "assets/Misc/TalkingHead_352x288.avi", Some(10), &dmx_reg,
                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
                             [0xb432376c, 0xf1dce57b, 0x8e79c7ee, 0xdd51850d],

diff --git a/nihav-commonfmt/src/codecs/mod.rs b/nihav-commonfmt/src/codecs/mod.rs
index 9cedec97fac190fd83f0b479ffa48a7c4ba9ef65..643e73caaaa8f39be1ec7157d8c535f887df267b 100644 (file)
--- a/nihav-commonfmt/src/codecs/mod.rs
+++ b/nihav-commonfmt/src/codecs/mod.rs
@@ -52,7 +52,7 @@ const DECODERS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn generic_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn generic_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in DECODERS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-commonfmt/src/codecs/sipro.rs b/nihav-commonfmt/src/codecs/sipro.rs
index 86a8bd56a1ab1eb17648618169b86944d9931763..a1a1ed3aac4cc97e9fcc3b98df927177098df64f 100644 (file)
--- a/nihav-commonfmt/src/codecs/sipro.rs
+++ b/nihav-commonfmt/src/codecs/sipro.rs
@@ -750,14 +750,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::test_decode_audio;
-    use crate::generic_register_all_codecs;
+    use crate::generic_register_all_decoders;
     use nihav_realmedia::realmedia_register_all_demuxers;
     #[test]
     fn test_sipro() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
 
         let file = "assets/RV/autahi-vox.rm";
         test_decode_audio("realmedia", file, Some(5000), None/*Some("sipro")*/, &dmx_reg, &dec_reg);

diff --git a/nihav-commonfmt/src/codecs/ts102366.rs b/nihav-commonfmt/src/codecs/ts102366.rs
index ab0e84cd821b37ede616360c4a3a86d18b921a83..c4b18004169c0827f8a6c9828471d60d9ac378b6 100644 (file)
--- a/nihav-commonfmt/src/codecs/ts102366.rs
+++ b/nihav-commonfmt/src/codecs/ts102366.rs
@@ -1256,14 +1256,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::test_decode_audio;
-    use crate::generic_register_all_codecs;
+    use crate::generic_register_all_decoders;
     use nihav_realmedia::realmedia_register_all_demuxers;
     #[test]
     fn test_ts102366() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
 
         let file = "assets/RV/sp_sample1.rm";
         test_decode_audio("realmedia", file, Some(12000), None/*Some("ac3")*/, &dmx_reg, &dec_reg);

diff --git a/nihav-commonfmt/src/lib.rs b/nihav-commonfmt/src/lib.rs
index b5b96d2e756ec7b7b42bc3e220e37dbfc10f36a6..b02cd8157d2572d58961d0928add20331223adbd 100644 (file)
--- a/nihav-commonfmt/src/lib.rs
+++ b/nihav-commonfmt/src/lib.rs
@@ -11,7 +11,7 @@ extern crate nihav_registry;
 mod codecs;
 
 #[cfg(feature="decoders")]
-pub use crate::codecs::generic_register_all_codecs;
+pub use crate::codecs::generic_register_all_decoders;
 #[cfg(feature="encoders")]
 pub use crate::codecs::generic_register_all_encoders;
 

diff --git a/nihav-core/src/codecs/mod.rs b/nihav-core/src/codecs/mod.rs
index c6ee95ec71a844043d449af5b3e6ade48e7dc5ba..58757efaf867ab449f7907e6cae51e343a6ace28 100644 (file)
--- a/nihav-core/src/codecs/mod.rs
+++ b/nihav-core/src/codecs/mod.rs
@@ -102,7 +102,7 @@ pub struct DecoderInfo {
 
 /// Structure for registering known decoders.
 ///
-/// It is supposed to be filled using `register_all_codecs()` from some decoders crate and then it can be used to create decoders for the requested codecs.
+/// It is supposed to be filled using `register_all_decoders()` from some decoders crate and then it can be used to create decoders for the requested codecs.
 #[derive(Default)]
 pub struct RegisteredDecoders {
     decs:   Vec<DecoderInfo>,
@@ -319,7 +319,7 @@ pub struct EncoderInfo {
 
 /// Structure for registering known encoders.
 ///
-/// It is supposed to be filled using `register_all_codecs()` from some encoders crate and then it can be used to create encoders for the requested codecs.
+/// It is supposed to be filled using `register_all_decoders()` from some encoders crate and then it can be used to create encoders for the requested codecs.
 #[derive(Default)]
 pub struct RegisteredEncoders {
     encs:   Vec<EncoderInfo>,

diff --git a/nihav-duck/src/codecs/dkadpcm.rs b/nihav-duck/src/codecs/dkadpcm.rs
index be128db06c3c1cbfdcbb5270f10a5b0fec7a227b..399b4f79b006e923f60a9fdb1035c7cba7d63f44 100644 (file)
--- a/nihav-duck/src/codecs/dkadpcm.rs
+++ b/nihav-duck/src/codecs/dkadpcm.rs
@@ -159,14 +159,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_dk3() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         //let file = "assets/Duck/AVI-DUCK-dk3.duk";
         //test_decode_audio("avi", file, Some(100), None/*Some("dk3")*/, &dmx_reg, &dec_reg);
@@ -178,7 +178,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
 //        let file = "assets/Duck/virtuafighter2-opening1.avi";
 //        test_decode_audio("avi", file, Some(100), None/*Some("dk4")*/, &dmx_reg, &dec_reg);

diff --git a/nihav-duck/src/codecs/mod.rs b/nihav-duck/src/codecs/mod.rs
index c5412e9683912587b95d88a362261af9360e53d9..bfdd44ed705f34a50a57d6875acc2b897a15140a 100644 (file)
--- a/nihav-duck/src/codecs/mod.rs
+++ b/nihav-duck/src/codecs/mod.rs
@@ -91,7 +91,7 @@ const DUCK_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn duck_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn duck_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in DUCK_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-duck/src/codecs/on2avc.rs b/nihav-duck/src/codecs/on2avc.rs
index d65dbd668f2de6c563575c9b691a9a90660882b2..29ead41d3c1ec9ebf7dd3106fef30495d0e6bf23 100644 (file)
--- a/nihav-duck/src/codecs/on2avc.rs
+++ b/nihav-duck/src/codecs/on2avc.rs
@@ -1068,14 +1068,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_avc() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         //let file = "assets/Duck/Cell-140.vp5";
         //let file = "assets/Duck/Chocolat-500.vp5";

diff --git a/nihav-duck/src/codecs/truemotion1.rs b/nihav-duck/src/codecs/truemotion1.rs
index b95b410f35b40449842cfc1dc0ffe8d640062192..e1d0557e792049b8c43d36373acbd490033f6a46 100644 (file)
--- a/nihav-duck/src/codecs/truemotion1.rs
+++ b/nihav-duck/src/codecs/truemotion1.rs
@@ -674,14 +674,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_tm1() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "truemotion1", "assets/Duck/phant2-940.duk", Some(12), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-duck/src/codecs/truemotion2.rs b/nihav-duck/src/codecs/truemotion2.rs
index 09c9844ce45257151be5aae2cec27db9910b707c..bf8aa7df364a7b5946e63ee96b3d44d298caf3a7 100644 (file)
--- a/nihav-duck/src/codecs/truemotion2.rs
+++ b/nihav-duck/src/codecs/truemotion2.rs
@@ -597,14 +597,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_tm2() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "truemotion2", "assets/Duck/tm20.avi", Some(16),
                         &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-duck/src/codecs/truemotion2x.rs b/nihav-duck/src/codecs/truemotion2x.rs
index 76ca244352d82cf0f538661aedcced6623526ba1..7f4ac524062903d4129f13ea9405faeaeb66437c 100644 (file)
--- a/nihav-duck/src/codecs/truemotion2x.rs
+++ b/nihav-duck/src/codecs/truemotion2x.rs
@@ -710,14 +710,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_tm2x() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "truemotion2x", "assets/Duck/TM2x.avi", None,
                         &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-duck/src/codecs/truemotionrt.rs b/nihav-duck/src/codecs/truemotionrt.rs
index 98d885825ed367b60394d6ad73a87a9996f1da17..5ca17bd2ceb971e7278be241742b0448497e4bc0 100644 (file)
--- a/nihav-duck/src/codecs/truemotionrt.rs
+++ b/nihav-duck/src/codecs/truemotionrt.rs
@@ -100,14 +100,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_tmrt() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "truemotionrt", "assets/Duck/tr20_low.avi", Some(10),
                         &dmx_reg, &dec_reg,

diff --git a/nihav-duck/src/codecs/vp3.rs b/nihav-duck/src/codecs/vp3.rs
index c6dc62d2670d4193af7e6db2ba0e0e43ffda1793..9d6ef6aff37bb321f9ef0ebc08609646630dc9dc 100644 (file)
--- a/nihav-duck/src/codecs/vp3.rs
+++ b/nihav-duck/src/codecs/vp3.rs
@@ -1885,7 +1885,7 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
 
     #[test]
@@ -1893,7 +1893,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "vp3", "assets/Duck/vp30-logo.avi", Some(23), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x51aba7df, 0x6e42534d, 0xef6c5b13, 0x26c38d1f]));
@@ -1904,7 +1904,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
 //        let file = "assets/Duck/vp31.avi";
 //        let file = "assets/Duck/vp31_crash.avi";
@@ -1920,7 +1920,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "vp3", "assets/Duck/ot171_vp40.avi", Some(86), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e]));

diff --git a/nihav-duck/src/codecs/vp5.rs b/nihav-duck/src/codecs/vp5.rs
index 36579a5bf1a88c62048cb98ad75a718ad974802c..70c26c6fa77d57f734abb21edb59839f3d0da9c2 100644 (file)
--- a/nihav-duck/src/codecs/vp5.rs
+++ b/nihav-duck/src/codecs/vp5.rs
@@ -293,7 +293,7 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
 
     #[test]
@@ -301,7 +301,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         let file = "assets/Duck/Cell-140.vp5";
         //let file = "assets/Duck/Chocolat-500.vp5";

diff --git a/nihav-duck/src/codecs/vp6.rs b/nihav-duck/src/codecs/vp6.rs
index ddc8e633c0595d23063528e02e62882e34f0840c..93722d303dd9a005332a1e5bba05561971ac8e8a 100644 (file)
--- a/nihav-duck/src/codecs/vp6.rs
+++ b/nihav-duck/src/codecs/vp6.rs
@@ -733,7 +733,7 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
 
     #[test]
@@ -741,7 +741,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "vp6", "assets/Duck/selection_720x576_300kBit_vp60i.avi", Some(16),
                       &dmx_reg, &dec_reg,
@@ -752,7 +752,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "vp6", "assets/Duck/vp6_crash.avi", Some(4),
                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-duck/src/codecs/vp7.rs b/nihav-duck/src/codecs/vp7.rs
index d40a81d0726b1b3e546c715a10f28c5c9083c05e..2632b40283baee3f39859da1e1d2c42cb585aeaf 100644 (file)
--- a/nihav-duck/src/codecs/vp7.rs
+++ b/nihav-duck/src/codecs/vp7.rs
@@ -1439,7 +1439,7 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::duck_register_all_codecs;
+    use crate::duck_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
 
     #[test]
@@ -1447,7 +1447,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        duck_register_all_codecs(&mut dec_reg);
+        duck_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "vp7", "assets/Duck/interlaced_blit_pitch.avi", Some(12), &dmx_reg,
                       &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-duck/src/lib.rs b/nihav-duck/src/lib.rs
index a3d59f0b01b176fb82cb753aa51dca523fc5adac..b0dae19c227bd857bbf47ad97b26cd552921a683 100644 (file)
--- a/nihav-duck/src/lib.rs
+++ b/nihav-duck/src/lib.rs
@@ -8,7 +8,7 @@ extern crate nihav_codec_support;
 #[allow(clippy::verbose_bit_mask)]
 mod codecs;
 
-pub use crate::codecs::duck_register_all_codecs;
+pub use crate::codecs::duck_register_all_decoders;
 
 #[cfg(test)]
 extern crate nihav_commonfmt;

diff --git a/nihav-game/src/codecs/bmv.rs b/nihav-game/src/codecs/bmv.rs
index 2e423906262cb8f6cb4219b7fd6ca483a1429ab4..a407fb9c82c8c4018cd2cf67f740a4d626a8cc89 100644 (file)
--- a/nihav-game/src/codecs/bmv.rs
+++ b/nihav-game/src/codecs/bmv.rs
@@ -320,14 +320,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::game_register_all_codecs;
+    use crate::game_register_all_decoders;
     use crate::game_register_all_demuxers;
     #[test]
     fn test_bmv_video() {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("bmv", "bmv-video", "assets/Game/WILDCAT.BMV", Some(40), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x9e91bb16, 0xc1edafc9, 0x4ef3171f, 0x0f3f6181]));
@@ -337,7 +337,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("bmv", "bmv-audio", "assets/Game/PERFECT.BMV", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x90b9ace4, 0x5fc19938, 0x7f534560, 0x32589cdf]));

diff --git a/nihav-game/src/codecs/bmv3.rs b/nihav-game/src/codecs/bmv3.rs
index cde7892fd512756f6d5de94c7f3bd55f0282dfb8..0140c8c4498d31371018b46a853bb7faec336011 100644 (file)
--- a/nihav-game/src/codecs/bmv3.rs
+++ b/nihav-game/src/codecs/bmv3.rs
@@ -618,14 +618,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::game_register_all_codecs;
+    use crate::game_register_all_decoders;
     use crate::game_register_all_demuxers;
     #[test]
     fn test_bmv_video() {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("bmv3", "bmv3-video", "assets/Game/DW3-Loffnote.bmv", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xfa34b81b, 0xd0ab79e2, 0x78fb25cc, 0x98ae47ff]));
@@ -635,7 +635,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("bmv3", "bmv3-audio", "assets/Game/DW3-Loffnote.bmv", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xd8e743cc, 0x97604bd7, 0x8dbb89c6, 0xb34cad63]));

diff --git a/nihav-game/src/codecs/gremlinvideo.rs b/nihav-game/src/codecs/gremlinvideo.rs
index 4b53ae87a5784ea71bc51bc008a9c96a503ddd3c..7e91ea229b44d92593ffd876cff3cbd37568a5e9 100644 (file)
--- a/nihav-game/src/codecs/gremlinvideo.rs
+++ b/nihav-game/src/codecs/gremlinvideo.rs
@@ -576,7 +576,7 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::game_register_all_codecs;
+    use crate::game_register_all_decoders;
     use crate::game_register_all_demuxers;
 
     #[test]
@@ -584,7 +584,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("gdv", "gdv-video", "assets/Game/intro1.gdv", Some(10), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x7ea302bf, 0xc3e210cf, 0x6e341376, 0x9e976056]));
@@ -594,7 +594,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("gdv", "gdv-audio", "assets/Game/intro1.gdv", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e]));

diff --git a/nihav-game/src/codecs/midivid.rs b/nihav-game/src/codecs/midivid.rs
index 700491e4fe7b5d46ef7820498bb28ea599b17565..ac91fde5dacfa7e9177f53e101716fa9a7059ef5 100644 (file)
--- a/nihav-game/src/codecs/midivid.rs
+++ b/nihav-game/src/codecs/midivid.rs
@@ -192,14 +192,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::game_register_all_codecs;
+    use crate::game_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_midivid_video() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "midivid", "assets/Game/MVDV.avi", Some(16), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-game/src/codecs/midivid3.rs b/nihav-game/src/codecs/midivid3.rs
index 3a3c161d72befedfb2e25a94f5ee677237893b5d..3c06e965243dda6a59862e8d7afaa3f0a56af91b 100644 (file)
--- a/nihav-game/src/codecs/midivid3.rs
+++ b/nihav-game/src/codecs/midivid3.rs
@@ -527,14 +527,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::game_register_all_codecs;
+    use crate::game_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_midivid3_video() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "midivid3", "assets/Game/mv30.avi", Some(16), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-game/src/codecs/mod.rs b/nihav-game/src/codecs/mod.rs
index bd2d6eb9e0920d04c3210e44c6eb60674e20adc9..064b567343717ecce2cc48aa0bb95d9d5dcbbbd2 100644 (file)
--- a/nihav-game/src/codecs/mod.rs
+++ b/nihav-game/src/codecs/mod.rs
@@ -45,7 +45,7 @@ const GAME_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn game_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn game_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in GAME_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-game/src/codecs/vmd.rs b/nihav-game/src/codecs/vmd.rs
index 110548a7917642d84266a666a35a129c6a9201cd..40d8c5e9b8413ac37eecaafb9c9c12aa4aecb4e4 100644 (file)
--- a/nihav-game/src/codecs/vmd.rs
+++ b/nihav-game/src/codecs/vmd.rs
@@ -690,14 +690,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::game_register_all_codecs;
+    use crate::game_register_all_decoders;
     use crate::game_register_all_demuxers;
     #[test]
     fn test_vmd_video() {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("vmd", "vmd-video", "assets/Game/2832.VMD", Some(10), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -718,7 +718,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("vmd", "vmd-video", "assets/Game/HLP1000.VMD", Some(10), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -734,7 +734,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("vmd", "vmd-video", "assets/Game/02C.VMD", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xb580782c, 0xd7fb98c0, 0xaf9b83cc, 0xaea0846b]));
@@ -744,7 +744,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("vmd", "vmd-audio", "assets/Game/1491.VMD", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x75037601, 0xbc7b3976, 0x6e1c948b, 0xf05a3d6c]));
@@ -754,7 +754,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("vmd", "vmd-audio", "assets/Game/2832.VMD", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x32dcdf0e, 0xee058684, 0x43ed5bf1, 0x2ff18b5a]));
@@ -764,7 +764,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("vmd", "vmd-audio", "assets/Game/1000.VMD", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xc36215d3, 0x96530a80, 0x89f1fa8e, 0x49da302b]));
@@ -774,7 +774,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         game_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        game_register_all_codecs(&mut dec_reg);
+        game_register_all_decoders(&mut dec_reg);
 
         test_decoding("vmd", "vmd-audio", "assets/Game/HLP1000.VMD", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x76a00405, 0xe4e5378d, 0x495b2a68, 0x4dffe042]));

diff --git a/nihav-game/src/lib.rs b/nihav-game/src/lib.rs
index f619cb919087039176ebcf1d1b61d05faec8698f..310e3f7bdf080acfd138e20f974012f6c45c3da4 100644 (file)
--- a/nihav-game/src/lib.rs
+++ b/nihav-game/src/lib.rs
@@ -7,7 +7,7 @@ extern crate nihav_codec_support;
 #[allow(clippy::unreadable_literal)]
 #[allow(clippy::useless_let_if_seq)]
 mod codecs;
-pub use crate::codecs::game_register_all_codecs;
+pub use crate::codecs::game_register_all_decoders;
 #[allow(clippy::collapsible_if)]
 #[allow(clippy::needless_range_loop)]
 #[allow(clippy::unreadable_literal)]

diff --git a/nihav-indeo/src/codecs/imc.rs b/nihav-indeo/src/codecs/imc.rs
index 6840739628c081d97d4fd5a70441c532c91bee03..ea84d0ab01977f91285045264d60488f5df197d7 100644 (file)
--- a/nihav-indeo/src/codecs/imc.rs
+++ b/nihav-indeo/src/codecs/imc.rs
@@ -1119,14 +1119,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::indeo_register_all_codecs;
+    use crate::indeo_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_imc() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        indeo_register_all_codecs(&mut dec_reg);
+        indeo_register_all_decoders(&mut dec_reg);
 
 //        let file = "assets/Indeo/neal73_saber.avi";
 //        let file = "assets/Indeo/IMC/hvalen.avi";

diff --git a/nihav-indeo/src/codecs/indeo2.rs b/nihav-indeo/src/codecs/indeo2.rs
index 960bc0b4c9a01708ade3edb2a10f533e41f24a21..32e54f854c3b10bd7a2d222b3b882a65d76f99fe 100644 (file)
--- a/nihav-indeo/src/codecs/indeo2.rs
+++ b/nihav-indeo/src/codecs/indeo2.rs
@@ -380,14 +380,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::indeo_register_all_codecs;
+    use crate::indeo_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_indeo2() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        indeo_register_all_codecs(&mut dec_reg);
+        indeo_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "indeo2", "assets/Indeo/laser05.avi", Some(10),
                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-indeo/src/codecs/indeo3.rs b/nihav-indeo/src/codecs/indeo3.rs
index 1705a432605cdd0594eb125eb7e445c7840d25c2..cc3bed877c9cf6dd6863960bb0f3fdad7e0edb53 100644 (file)
--- a/nihav-indeo/src/codecs/indeo3.rs
+++ b/nihav-indeo/src/codecs/indeo3.rs
@@ -808,14 +808,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::indeo_register_all_codecs;
+    use crate::indeo_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_indeo3() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        indeo_register_all_codecs(&mut dec_reg);
+        indeo_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "indeo3", "assets/Indeo/iv32_example.avi", Some(10),
                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-indeo/src/codecs/indeo4.rs b/nihav-indeo/src/codecs/indeo4.rs
index 879f850f27eed70df639992242a073eb0765a63d..474a8d5c7b159a21f620d7df5520d9b4cdc097da 100644 (file)
--- a/nihav-indeo/src/codecs/indeo4.rs
+++ b/nihav-indeo/src/codecs/indeo4.rs
@@ -777,14 +777,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::indeo_register_all_codecs;
+    use crate::indeo_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_indeo4() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        indeo_register_all_codecs(&mut dec_reg);
+        indeo_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "indeo4", "assets/Indeo/IV4/volcano.avi", Some(16),
                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-indeo/src/codecs/indeo5.rs b/nihav-indeo/src/codecs/indeo5.rs
index 5eedd14ecd84ca49a0303f75aac7c454b99ec2ff..3527906e2839fc0c643cbb87f82a47f633f2ee48 100644 (file)
--- a/nihav-indeo/src/codecs/indeo5.rs
+++ b/nihav-indeo/src/codecs/indeo5.rs
@@ -731,14 +731,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::indeo_register_all_codecs;
+    use crate::indeo_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_indeo5() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        indeo_register_all_codecs(&mut dec_reg);
+        indeo_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "indeo5", "assets/Indeo/IV5/sample.avi", Some(100),
                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-indeo/src/codecs/intel263.rs b/nihav-indeo/src/codecs/intel263.rs
index acedfb4419783f32104f4fae6acd6bc6852661fd..ff55e65ce8e07f0909a734ca118b9cc1c920d210 100644 (file)
--- a/nihav-indeo/src/codecs/intel263.rs
+++ b/nihav-indeo/src/codecs/intel263.rs
@@ -749,14 +749,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::indeo_register_all_codecs;
+    use crate::indeo_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_intel263() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        indeo_register_all_codecs(&mut dec_reg);
+        indeo_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "intel263", "assets/Indeo/neal73_saber.avi", Some(16),
                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-indeo/src/codecs/mod.rs b/nihav-indeo/src/codecs/mod.rs
index 4ab5e8fec4a712e037cc28d10860293479a51614..321fe3844ff794e657f5dbcb60008de86eab4d58 100644 (file)
--- a/nihav-indeo/src/codecs/mod.rs
+++ b/nihav-indeo/src/codecs/mod.rs
@@ -47,7 +47,7 @@ const INDEO_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn indeo_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn indeo_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in INDEO_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-indeo/src/lib.rs b/nihav-indeo/src/lib.rs
index 21b4cd924faa95de979f70ad8fa554fb3f89e7df..c920ea40b4ed01596562514656fcf9b355ffa47a 100644 (file)
--- a/nihav-indeo/src/lib.rs
+++ b/nihav-indeo/src/lib.rs
@@ -9,7 +9,7 @@ extern crate nihav_codec_support;
 #[allow(clippy::verbose_bit_mask)]
 mod codecs;
 
-pub use crate::codecs::indeo_register_all_codecs;
+pub use crate::codecs::indeo_register_all_decoders;
 
 #[cfg(test)]
 extern crate nihav_commonfmt;
\ No newline at end of file

diff --git a/nihav-ms/src/codecs/imaadpcm.rs b/nihav-ms/src/codecs/imaadpcm.rs
index 2ee538de13799c797a8fda0daf0d42117b6585ef..d58ef36f8d66efc01d30261bdcc587e67fa50570 100644 (file)
--- a/nihav-ms/src/codecs/imaadpcm.rs
+++ b/nihav-ms/src/codecs/imaadpcm.rs
@@ -97,14 +97,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::ms_register_all_codecs;
+    use crate::ms_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_ima_adpcm_ms() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "ima-adpcm-ms", "assets/MS/IMAG0006.AVI", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x0cdc640f, 0xb00df235, 0x1ec4a280, 0x065b5e9e]));

diff --git a/nihav-ms/src/codecs/mod.rs b/nihav-ms/src/codecs/mod.rs
index 3ed99b4914a853f8c64b468ee08cfbed27f63437..e01a6bb946ae01c74f707ee7e23e1f6878026d4c 100644 (file)
--- a/nihav-ms/src/codecs/mod.rs
+++ b/nihav-ms/src/codecs/mod.rs
@@ -28,7 +28,7 @@ const MS_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn ms_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn ms_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in MS_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-ms/src/codecs/msadpcm.rs b/nihav-ms/src/codecs/msadpcm.rs
index aff49790ec4a646662e5dadd2ada5dc722ab16af..44baedbe3fa487af1030dfcabd2b1744379c6efb 100644 (file)
--- a/nihav-ms/src/codecs/msadpcm.rs
+++ b/nihav-ms/src/codecs/msadpcm.rs
@@ -419,7 +419,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "ms-adpcm", "assets/MS/dance.avi", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xf5e3fc84, 0xbcabc11c, 0x33c6874e, 0xe05ecd14]));
@@ -430,8 +430,8 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
-        ms_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
         let mut mux_reg = RegisteredMuxers::new();
         generic_register_all_muxers(&mut mux_reg);
         let mut enc_reg = RegisteredEncoders::new();

diff --git a/nihav-ms/src/codecs/msrle.rs b/nihav-ms/src/codecs/msrle.rs
index 0c2fc9c0aa94ff7010fef1623bf173db0998ef4a..e58691002e78ec3790e087c8ccdd40819ed12152 100644 (file)
--- a/nihav-ms/src/codecs/msrle.rs
+++ b/nihav-ms/src/codecs/msrle.rs
@@ -260,14 +260,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::ms_register_all_codecs;
+    use crate::ms_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_ms_rle_8bit() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "msrle", "assets/MS/workcycl-64color.avi", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -284,7 +284,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "msrle", "assets/MS/suzie_appl_rle8.avi", Some(2), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -297,7 +297,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "msrle", "assets/MS/mplayer-msrle-4bit.avi", Some(2), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -310,7 +310,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "msrle", "assets/MS/suzie_appl_rle4.avi", Some(2), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xb5d38296, 0xdae25407, 0x985973f0, 0xb1da9c94]));

diff --git a/nihav-ms/src/codecs/msvideo1.rs b/nihav-ms/src/codecs/msvideo1.rs
index a3bfebcb026481261fc7c032e9d49a1285c9c1f1..2fb77130cb2ce84c18f99e810857651e9efeba3e 100644 (file)
--- a/nihav-ms/src/codecs/msvideo1.rs
+++ b/nihav-ms/src/codecs/msvideo1.rs
@@ -263,14 +263,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::ms_register_all_codecs;
+    use crate::ms_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_ms_video1_8bit() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "msvideo1", "assets/MS/toon.avi", Some(66), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x0c26ec42, 0xb75bfea7, 0x1e6342ae, 0xb14dcfa3]));
@@ -280,7 +280,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        ms_register_all_codecs(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
 
         test_decoding("avi", "msvideo1", "assets/MS/clock-cram16.avi", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x03381fa4, 0x5b294fec, 0xb97a7575, 0xa1a3ffe9]));

diff --git a/nihav-ms/src/codecs/msvideo1enc.rs b/nihav-ms/src/codecs/msvideo1enc.rs
index 49be39efa07fbb8d0f7888250f1e1e81712e7462..b2233c230b7de7061dba27371da5c2fb12d72fee 100644 (file)
--- a/nihav-ms/src/codecs/msvideo1enc.rs
+++ b/nihav-ms/src/codecs/msvideo1enc.rs
@@ -534,8 +534,8 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        generic_register_all_codecs(&mut dec_reg);
-        ms_register_all_codecs(&mut dec_reg);
+        generic_register_all_decoders(&mut dec_reg);
+        ms_register_all_decoders(&mut dec_reg);
         let mut mux_reg = RegisteredMuxers::new();
         generic_register_all_muxers(&mut mux_reg);
         let mut enc_reg = RegisteredEncoders::new();

diff --git a/nihav-ms/src/lib.rs b/nihav-ms/src/lib.rs
index 6bfdad6440053db9297c7e6a8afe8a65b19745fd..ebc84f583df957ef656b702749c99e1d13ea3e98 100644 (file)
--- a/nihav-ms/src/lib.rs
+++ b/nihav-ms/src/lib.rs
@@ -5,5 +5,5 @@ extern crate nihav_codec_support;
 #[allow(clippy::single_match)]
 #[allow(clippy::verbose_bit_mask)]
 mod codecs;
-pub use crate::codecs::ms_register_all_codecs;
+pub use crate::codecs::ms_register_all_decoders;
 pub use crate::codecs::ms_register_all_encoders;

diff --git a/nihav-qt/src/codecs/imaadpcm.rs b/nihav-qt/src/codecs/imaadpcm.rs
index 1d1a6474b8bd2af5de3f3c0f73bf8fa2b577b7f2..636f8828608e31243aac37ab46e458a0919e2d8a 100644 (file)
--- a/nihav-qt/src/codecs/imaadpcm.rs
+++ b/nihav-qt/src/codecs/imaadpcm.rs
@@ -94,14 +94,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_ima_adpcm_qt() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "ima-adpcm-qt", "assets/QT/shuffle-ima41.mov", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xba2ad472, 0xd6aee026, 0xb915dd7d, 0xac51314c]));

diff --git a/nihav-qt/src/codecs/mace.rs b/nihav-qt/src/codecs/mace.rs
index d3fc9534f33821df9782a9166e975b865738936b..1166d92c61e304774b55425bc552a3bc32986691 100644 (file)
--- a/nihav-qt/src/codecs/mace.rs
+++ b/nihav-qt/src/codecs/mace.rs
@@ -181,14 +181,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_mace3() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "mace-3", "assets/QT/surge-1-8-MAC3.mov", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x2df88db3, 0xa6167019, 0x6d4c64e7, 0xc89da2a5]));
@@ -198,7 +198,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "mace-6", "assets/QT/surge-1-8-MAC6.mov", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xc32857e2, 0xc1ea1ce8, 0x2d77dacf, 0xef504f1f]));

diff --git a/nihav-qt/src/codecs/mod.rs b/nihav-qt/src/codecs/mod.rs
index 733d5993da637fa2bd6bc478d3c26a464d8914ef..0e91176095346a5ef145daf840277729221c95c1 100644 (file)
--- a/nihav-qt/src/codecs/mod.rs
+++ b/nihav-qt/src/codecs/mod.rs
@@ -86,7 +86,7 @@ const QT_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn qt_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn qt_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in QT_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-qt/src/codecs/qdm2.rs b/nihav-qt/src/codecs/qdm2.rs
index ff9a3370443041c13eda2200f2ce186fa578b6e4..5edd336e7d437e6c3924484bedfc3bbfd4705be3 100644 (file)
--- a/nihav-qt/src/codecs/qdm2.rs
+++ b/nihav-qt/src/codecs/qdm2.rs
@@ -293,14 +293,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_qdm2() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         //test_decode_audio("mov", "assets/QT/0-22050HzSweep8kb.mov", None, Some("qdm2"), &dmx_reg, &dec_reg);
         test_decoding("mov", "qdesign-music2", "assets/QT/0-22050HzSweep10kb.mov", None, &dmx_reg, &dec_reg,

diff --git a/nihav-qt/src/codecs/qdmc.rs b/nihav-qt/src/codecs/qdmc.rs
index 818b02fc92f80bfee3d87d1757503d4645c34914..f8aaecd81e370d16453b0b8f52ad018540faf32f 100644 (file)
--- a/nihav-qt/src/codecs/qdmc.rs
+++ b/nihav-qt/src/codecs/qdmc.rs
@@ -387,14 +387,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_qdmc() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qdesign-music", "assets/QT/rumcoke.mov", Some(32), &dmx_reg, &dec_reg,
                       ExpectedTestResult::Decodes);

diff --git a/nihav-qt/src/codecs/rle.rs b/nihav-qt/src/codecs/rle.rs
index 929476ec834df2e07f5b8db42ffb43e44fe0e5be..969c104e8a4f712e08047bdbffb2dd74a3c4065d 100644 (file)
--- a/nihav-qt/src/codecs/rle.rs
+++ b/nihav-qt/src/codecs/rle.rs
@@ -511,14 +511,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_qt_rle_1bit() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
 //test_file_decoding("mov", "assets/QT/Animation-Monochrome.mov", Some(6), true, false, Some("qtrle-mono"), &dmx_reg, &dec_reg);
         test_decoding("mov", "qt-rle", "assets/QT/Animation-Monochrome.mov", Some(6), &dmx_reg, &dec_reg,
@@ -536,7 +536,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qt-rle", "assets/QT/Animation-16Greys.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -553,7 +553,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qt-rle", "assets/QT/Animation-256Greys.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -570,7 +570,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qt-rle", "assets/QT/Animation-Highcolour.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -587,7 +587,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qt-rle", "assets/QT/Animation-Truecolour.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -604,7 +604,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qt-rle", "assets/QT/Jag-finder-renaming.mov", Some(10), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-qt/src/codecs/rpza.rs b/nihav-qt/src/codecs/rpza.rs
index a3b2e5fafd784bdf89d5198619450f424a3e86f6..cbea562cec36e322d77c73a5d55ff2caeba3d0f5 100644 (file)
--- a/nihav-qt/src/codecs/rpza.rs
+++ b/nihav-qt/src/codecs/rpza.rs
@@ -195,14 +195,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_rpza() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "apple-video", "assets/QT/aletrek-rpza.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-qt/src/codecs/smc.rs b/nihav-qt/src/codecs/smc.rs
index 96fcba2b67ed0846dc1d3eff414c3a85f94e02b1..b78c46ba325dd0bcb8ab808e2fbe4646512d9dcf 100644 (file)
--- a/nihav-qt/src/codecs/smc.rs
+++ b/nihav-qt/src/codecs/smc.rs
@@ -290,14 +290,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_smc() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qt-smc", "assets/QT/aletrek-smc.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -314,7 +314,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "qt-smc", "assets/QT/aletrek-smc-gray.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-qt/src/codecs/svq1.rs b/nihav-qt/src/codecs/svq1.rs
index 68db3a3b9774c73ab046eb7e3d3cc9dc91218ef7..a6735bb9640e34e5d4c7de29790a840bae3bd775 100644 (file)
--- a/nihav-qt/src/codecs/svq1.rs
+++ b/nihav-qt/src/codecs/svq1.rs
@@ -495,14 +495,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_svq1() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
         test_decoding("mov", "sorenson-video", "assets/QT/adpcm-bug.mov", Some(6), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-qt/src/codecs/svq3.rs b/nihav-qt/src/codecs/svq3.rs
index 6d65e65daf6bd53bb1af4bed07d4f69261dc2db5..d166723dcd218c1653d5846aed37a2deec877e31 100644 (file)
--- a/nihav-qt/src/codecs/svq3.rs
+++ b/nihav-qt/src/codecs/svq3.rs
@@ -1217,14 +1217,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::qt_register_all_codecs;
+    use crate::qt_register_all_decoders;
     use nihav_commonfmt::generic_register_all_demuxers;
     #[test]
     fn test_svq3() {
         let mut dmx_reg = RegisteredDemuxers::new();
         generic_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        qt_register_all_codecs(&mut dec_reg);
+        qt_register_all_decoders(&mut dec_reg);
 
 //let file = "assets/QT/cristinreel.mov";
 //let file = "assets/QT/broken_sword_Large.mov";

diff --git a/nihav-qt/src/lib.rs b/nihav-qt/src/lib.rs
index 1996c60c8c16b5dd44a54833761f9c9099d6822f..29180f0e48e47c263669306cb3cb998e06c4c3cf 100644 (file)
--- a/nihav-qt/src/lib.rs
+++ b/nihav-qt/src/lib.rs
@@ -3,4 +3,4 @@ extern crate nihav_codec_support;
 
 #[allow(clippy::single_match)]
 mod codecs;
-pub use crate::codecs::qt_register_all_codecs;
+pub use crate::codecs::qt_register_all_decoders;

diff --git a/nihav-rad/src/codecs/bink2.rs b/nihav-rad/src/codecs/bink2.rs
index 2b6ca26a6bd12e1ec9886b79b2a489892aca783b..9ae02a710468ddaa349d0f004dc1e2d526557424 100644 (file)
--- a/nihav-rad/src/codecs/bink2.rs
+++ b/nihav-rad/src/codecs/bink2.rs
@@ -1959,14 +1959,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::rad_register_all_codecs;
+    use crate::rad_register_all_decoders;
     use crate::rad_register_all_demuxers;
     #[test]
     fn test_bink2() {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         //let file = "assets/RAD/Open_Logos_partial.bik";
         //let file = "assets/RAD/sc13_01_partial.bk2";

diff --git a/nihav-rad/src/codecs/binkaud.rs b/nihav-rad/src/codecs/binkaud.rs
index c94f39d2a33b2246faecf4858527dc3a077ef0e8..1cdb0a1ddbf2c7d6334414786946f8577606cdbf 100644 (file)
--- a/nihav-rad/src/codecs/binkaud.rs
+++ b/nihav-rad/src/codecs/binkaud.rs
@@ -298,7 +298,7 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::rad_register_all_codecs;
+    use crate::rad_register_all_decoders;
     use crate::rad_register_all_demuxers;
 
     #[test]
@@ -306,7 +306,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         let file = "assets/RAD/ActivisionLogo.bik";
         test_decode_audio("bink", file, None, None/*Some("bink")*/, &dmx_reg, &dec_reg);
@@ -316,7 +316,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         let file = "assets/RAD/NWCLOGO.BIK";
         test_decode_audio("bink", file, None, None/*Some("bink")*/, &dmx_reg, &dec_reg);

diff --git a/nihav-rad/src/codecs/binkvid.rs b/nihav-rad/src/codecs/binkvid.rs
index 0c23480700cf29a4fad557c1eb451eac51cb8d66..5f5bb566aa528603e7b3515f5f813f4bdd468e2f 100644 (file)
--- a/nihav-rad/src/codecs/binkvid.rs
+++ b/nihav-rad/src/codecs/binkvid.rs
@@ -1264,14 +1264,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::rad_register_all_codecs;
+    use crate::rad_register_all_decoders;
     use crate::rad_register_all_demuxers;
     #[test]
     fn test_binkvid_b() {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         test_decoding("bink", "bink-video", "assets/RAD/NEW.BIK", Some(16), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -1298,7 +1298,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         test_decoding("bink", "bink-video", "assets/RAD/ActivisionLogo.bik", Some(42),
                       &dmx_reg, &dec_reg,

diff --git a/nihav-rad/src/codecs/mod.rs b/nihav-rad/src/codecs/mod.rs
index 2e279b619d757bcd516571fc9d5eab80f03251dc..a11f5c536563b4c04e8c76fdc9258159bcaea809 100644 (file)
--- a/nihav-rad/src/codecs/mod.rs
+++ b/nihav-rad/src/codecs/mod.rs
@@ -29,7 +29,7 @@ const RAD_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn rad_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn rad_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in RAD_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-rad/src/codecs/smacker.rs b/nihav-rad/src/codecs/smacker.rs
index 14e51252f2135c4fdea1cddfa30baef2cdc26f07..0d681dc19809b1c792b69e26386f435bd37cf692 100644 (file)
--- a/nihav-rad/src/codecs/smacker.rs
+++ b/nihav-rad/src/codecs/smacker.rs
@@ -616,14 +616,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::rad_register_all_codecs;
+    use crate::rad_register_all_decoders;
     use crate::rad_register_all_demuxers;
     #[test]
     fn test_smkvid() {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         test_decoding("smacker", "smacker-video", "assets/RAD/credits.smk", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![
@@ -643,7 +643,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         test_decoding("smacker", "smacker-audio", "assets/RAD/wetlogo.smk", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0xc686b833, 0x0a203038, 0x012f6d9b, 0xa4186d44]));
@@ -653,7 +653,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         rad_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        rad_register_all_codecs(&mut dec_reg);
+        rad_register_all_decoders(&mut dec_reg);
 
         test_decoding("smacker", "smacker-audio", "assets/RAD/20130507_audio-distortion.smk", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x942a0922, 0x182bb5fd, 0x94ab7a59, 0x2028d810]));

diff --git a/nihav-rad/src/lib.rs b/nihav-rad/src/lib.rs
index 65b94e6eae050b49950c31c357b629c813bab80d..6ce3702ecd55d4a4d6217c942780bf9d725675a2 100644 (file)
--- a/nihav-rad/src/lib.rs
+++ b/nihav-rad/src/lib.rs
@@ -12,7 +12,7 @@ extern crate nihav_codec_support;
 #[allow(clippy::useless_let_if_seq)]
 mod codecs;
 #[cfg(feature="decoders")]
-pub use crate::codecs::rad_register_all_codecs;
+pub use crate::codecs::rad_register_all_decoders;
 
 #[cfg(feature="demuxers")]
 #[allow(clippy::cast_lossless)]

diff --git a/nihav-realmedia/src/codecs/cook.rs b/nihav-realmedia/src/codecs/cook.rs
index 2ac7a66c3b98d361cfeac5915afdc0c7f3ec835e..c3e82767a34c3263044f78197a3b97dd2d529cea 100644 (file)
--- a/nihav-realmedia/src/codecs/cook.rs
+++ b/nihav-realmedia/src/codecs/cook.rs
@@ -691,14 +691,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_cook() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
 //        let file = "assets/RV/rv30_weighted_mc.rm";
         let file = "assets/RV/multichannel.rma";

diff --git a/nihav-realmedia/src/codecs/mod.rs b/nihav-realmedia/src/codecs/mod.rs
index b8ad7bed1a91da7600eca7360ecfae291c33f343..d8a36d4b75ed514b0d748e87a7ebb9b849c963aa 100644 (file)
--- a/nihav-realmedia/src/codecs/mod.rs
+++ b/nihav-realmedia/src/codecs/mod.rs
@@ -73,7 +73,7 @@ const RM_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn realmedia_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn realmedia_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in RM_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-realmedia/src/codecs/ra144.rs b/nihav-realmedia/src/codecs/ra144.rs
index 31f2c01b9e9dec7c58952867bf8cd029b230adbe..5cae66cfba421425975a4c69041b0eccf33d10f3 100644 (file)
--- a/nihav-realmedia/src/codecs/ra144.rs
+++ b/nihav-realmedia/src/codecs/ra144.rs
@@ -326,14 +326,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_ra144() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         let file = "assets/RV/ra3_in_rm_file.rm";
         test_decode_audio("realmedia", file, Some(5000), None/*Some("ra14.4")*/, &dmx_reg, &dec_reg);

diff --git a/nihav-realmedia/src/codecs/ra288.rs b/nihav-realmedia/src/codecs/ra288.rs
index 1d983313b6b56520eb42abe849872d304485a1e7..624769dd04fc816bec4069789bca69c53c2d1006 100644 (file)
--- a/nihav-realmedia/src/codecs/ra288.rs
+++ b/nihav-realmedia/src/codecs/ra288.rs
@@ -216,14 +216,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_ra288() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         let file = "assets/RV/A0000044.rm";
         test_decode_audio("realmedia", file, Some(5000), None/*Some("ra28.8")*/, &dmx_reg, &dec_reg);

diff --git a/nihav-realmedia/src/codecs/ralf.rs b/nihav-realmedia/src/codecs/ralf.rs
index 56af9671fed5c4eb9a456cec36166bec3b236fe7..be256b33dc0e682f0170df7623014041f4da3d15 100644 (file)
--- a/nihav-realmedia/src/codecs/ralf.rs
+++ b/nihav-realmedia/src/codecs/ralf.rs
@@ -486,14 +486,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_ralf() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         test_decoding("realmedia", "ralf", "assets/RV/rv40_ralf.rmvb", None, &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5([0x6cf18361, 0x9548b5ce, 0x5dfc0b5c, 0x2bd6f392]));

diff --git a/nihav-realmedia/src/codecs/rv10.rs b/nihav-realmedia/src/codecs/rv10.rs
index e729b0def25fec5f4622f772c9d1b8ad5c02d3ac..7c317af52db93c91fe1f30de49cdf0118f7ad1bf 100644 (file)
--- a/nihav-realmedia/src/codecs/rv10.rs
+++ b/nihav-realmedia/src/codecs/rv10.rs
@@ -476,14 +476,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_rv10_old() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         test_decoding("realmedia", "realvideo1", "assets/RV/thankyou.rm",
                       Some(1000), &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
@@ -501,7 +501,7 @@ mod test {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         test_decoding("realmedia", "realvideo1",
                       "assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm",

diff --git a/nihav-realmedia/src/codecs/rv20.rs b/nihav-realmedia/src/codecs/rv20.rs
index 39254db6a206a5f586aef1b56b27d6c103858362..88b1a600a265cb348d8f0264317ece12703acb6a 100644 (file)
--- a/nihav-realmedia/src/codecs/rv20.rs
+++ b/nihav-realmedia/src/codecs/rv20.rs
@@ -693,14 +693,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_rv20() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         test_decoding("realmedia", "realvideo2",
                       "assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm",

diff --git a/nihav-realmedia/src/codecs/rv30.rs b/nihav-realmedia/src/codecs/rv30.rs
index 1827980c101991042df65a48bfe34b3bd97e8ff0..f5a894b2a2d4fb84a4f956e712416f1a4e0b0727 100644 (file)
--- a/nihav-realmedia/src/codecs/rv30.rs
+++ b/nihav-realmedia/src/codecs/rv30.rs
@@ -180,14 +180,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_rv30() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         test_decoding("realmedia", "realvideo3", "assets/RV/rv30_weighted_mc.rm", Some(700),
                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-realmedia/src/codecs/rv40.rs b/nihav-realmedia/src/codecs/rv40.rs
index 95e232541d6fb652624f10eef1f723ddf7933cc5..bcd600b83dba6a1ae98f1b05ae636f094eec764d 100644 (file)
--- a/nihav-realmedia/src/codecs/rv40.rs
+++ b/nihav-realmedia/src/codecs/rv40.rs
@@ -373,14 +373,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_rv40() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         test_decoding("realmedia", "realvideo4", "assets/RV/rv40_weighted_mc.rmvb", Some(1500),
                       &dmx_reg, &dec_reg,ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-realmedia/src/codecs/rv60.rs b/nihav-realmedia/src/codecs/rv60.rs
index ecc400a7c821128a599e864d90aa0ca3994cf8b8..d1e7c53dada77d102a882dfa013cf532ae36f270 100644 (file)
--- a/nihav-realmedia/src/codecs/rv60.rs
+++ b/nihav-realmedia/src/codecs/rv60.rs
@@ -1589,14 +1589,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::realmedia_register_all_codecs;
+    use crate::realmedia_register_all_decoders;
     use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_rv60() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
         test_decoding("realmedia", "realvideo6", "assets/RV/RV60.rmhd", Some(1000), &dmx_reg, &dec_reg,
                       ExpectedTestResult::MD5Frames(vec![

diff --git a/nihav-realmedia/src/lib.rs b/nihav-realmedia/src/lib.rs
index 634e3b2e95a71a5e19a96132f96493d11dbbe247..0155eac4a912ab20de3e191b92bb5f83a56c3037 100644 (file)
--- a/nihav-realmedia/src/lib.rs
+++ b/nihav-realmedia/src/lib.rs
@@ -13,7 +13,7 @@ extern crate nihav_codec_support;
 #[allow(clippy::useless_let_if_seq)]
 mod codecs;
 #[cfg(feature="decoders")]
-pub use crate::codecs::realmedia_register_all_codecs;
+pub use crate::codecs::realmedia_register_all_decoders;
 
 #[cfg(feature="demuxers")]
 #[allow(clippy::cast_lossless)]

diff --git a/nihav-vivo/src/codecs/g723_1.rs b/nihav-vivo/src/codecs/g723_1.rs
index 1b6d8c626952c4bc795188f2a1328da926387e00..42dda3a5dbb783802288d04160c7ce843c392ff5 100644 (file)
--- a/nihav-vivo/src/codecs/g723_1.rs
+++ b/nihav-vivo/src/codecs/g723_1.rs
@@ -975,14 +975,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::vivo_register_all_codecs;
+    use crate::vivo_register_all_decoders;
     use crate::vivo_register_all_demuxers;
     #[test]
     fn test_g723_1() {
         let mut dmx_reg = RegisteredDemuxers::new();
         vivo_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        vivo_register_all_codecs(&mut dec_reg);
+        vivo_register_all_decoders(&mut dec_reg);
 
         let file = "assets/Misc/adalogo.viv";
         //let file = "assets/Misc/gr_al.viv";

diff --git a/nihav-vivo/src/codecs/mod.rs b/nihav-vivo/src/codecs/mod.rs
index 62d4448f24bebcb3677464161e9fcfc809db34ce..354f585f65c22fcb56d22bc2c633f94c9f4a9326 100644 (file)
--- a/nihav-vivo/src/codecs/mod.rs
+++ b/nihav-vivo/src/codecs/mod.rs
@@ -30,7 +30,7 @@ const VIVO_CODECS: &[DecoderInfo] = &[
 ];
 
 /// Registers all available codecs provided by this crate.
-pub fn vivo_register_all_codecs(rd: &mut RegisteredDecoders) {
+pub fn vivo_register_all_decoders(rd: &mut RegisteredDecoders) {
     for decoder in VIVO_CODECS.iter() {
         rd.add_decoder(decoder.clone());
     }

diff --git a/nihav-vivo/src/codecs/siren.rs b/nihav-vivo/src/codecs/siren.rs
index 79c821b95da7c6048d2cf974515db3bb8d2c6136..0b23f18e15404750c3ffeee28d0744bff1462490 100644 (file)
--- a/nihav-vivo/src/codecs/siren.rs
+++ b/nihav-vivo/src/codecs/siren.rs
@@ -395,14 +395,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::vivo_register_all_codecs;
+    use crate::vivo_register_all_decoders;
     use crate::vivo_register_all_demuxers;
     #[test]
     fn test_siren() {
         let mut dmx_reg = RegisteredDemuxers::new();
         vivo_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        vivo_register_all_codecs(&mut dec_reg);
+        vivo_register_all_decoders(&mut dec_reg);
 
         let file = "assets/Misc/favmovie.viv";
         //let file = "assets/Misc/gr_al.viv";

diff --git a/nihav-vivo/src/codecs/vivo.rs b/nihav-vivo/src/codecs/vivo.rs
index 33de1793437a5b1086c49a4500b00657cf7445dc..9963cc4fcbe4861302b2a081df7951fbbcf89935 100644 (file)
--- a/nihav-vivo/src/codecs/vivo.rs
+++ b/nihav-vivo/src/codecs/vivo.rs
@@ -492,14 +492,14 @@ mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
     use nihav_codec_support::test::dec_video::*;
-    use crate::vivo_register_all_codecs;
+    use crate::vivo_register_all_decoders;
     use crate::vivo_register_all_demuxers;
     #[test]
     fn test_vivo1() {
         let mut dmx_reg = RegisteredDemuxers::new();
         vivo_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        vivo_register_all_codecs(&mut dec_reg);
+        vivo_register_all_decoders(&mut dec_reg);
 
 test_file_decoding("vivo", "assets/Misc/gr_al.viv", Some(16), true, false, Some("viv1"), &dmx_reg, &dec_reg);
 //        test_decoding("vivo", "vivo1", "assets/Misc/gr_al.viv", Some(16),
@@ -510,7 +510,7 @@ test_file_decoding("vivo", "assets/Misc/gr_al.viv", Some(16), true, false, Some(
         let mut dmx_reg = RegisteredDemuxers::new();
         vivo_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        vivo_register_all_codecs(&mut dec_reg);
+        vivo_register_all_decoders(&mut dec_reg);
 
 test_file_decoding("vivo", "assets/Misc/02-KimagureOrangeRoad.viv", Some(50), true, false, Some("viv2"), &dmx_reg, &dec_reg);
 panic!("end");

diff --git a/nihav-vivo/src/lib.rs b/nihav-vivo/src/lib.rs
index 74bdb982e9ab15c77713c4e222277c2c41e80885..97a238bc99db7e379492d220c2cf1eb9bb86aa10 100644 (file)
--- a/nihav-vivo/src/lib.rs
+++ b/nihav-vivo/src/lib.rs
@@ -4,5 +4,5 @@ extern crate nihav_codec_support;
 mod codecs;
 mod demuxers;
 
-pub use crate::codecs::vivo_register_all_codecs;
+pub use crate::codecs::vivo_register_all_decoders;
 pub use crate::demuxers::vivo_register_all_demuxers;