tests for NL1_Sony_D and SVA_NL1_B

Author: Djuffin

data/SVA_NL1_B.264

@@ -3,6 +3,7 @@
 #![allow(clippy::match_like_matches_macro)]
 #![allow(clippy::needless_range_loop)]
 #![allow(clippy::needless_late_init)]
+#![allow(non_snake_case)]
 
 #[macro_use]
 extern crate num_derive;
@@ -12,56 +13,122 @@ pub mod h264;
 pub mod y4m_cmp;
 
 use std::env;
+use std::fmt::Error;
 use std::fs;
 use std::io;
 
 use log::info;
 use v_frame::plane::PlaneOffset;
-use y4m_cmp::{compare_files, compare_frames};
+use y4m_cmp::compare_y4m_buffers;
 
 fn main() {
     diag::init(false);
     let args: Vec<String> = env::args().collect();
-    let mut input_filename = "data/NL1_Sony_D.jsv".to_string();
+    let input_filename: String;
     if args.len() > 1 {
         input_filename = args[1].clone();
+    } else {
+        print!("No input file");
+        return;
     }
 
-    let buf = fs::read(input_filename).unwrap();
+    let encoded_video_buffer =
+        fs::read(&input_filename).expect(format!("can't read file: {input_filename}").as_str());
     let mut decoder = h264::decoder::Decoder::new();
-    decoder.decode(&buf).expect("parsing error");
+    decoder.decode(&encoded_video_buffer).expect("Decoding error");
 
     let first_frame = decoder.get_frame_buffer().first().unwrap();
     let y_plane = &first_frame.planes[0];
     let w = y_plane.cfg.width as u32;
     let h = y_plane.cfg.height as u32;
 
-    let mut writer = io::BufWriter::new(fs::File::create("output.y4m").unwrap());
-    let mut encoder = y4m::encode(w as usize, h as usize, y4m::Ratio { num: 15, den: 1 })
-        .with_colorspace(y4m::Colorspace::C420)
-        .write_header(&mut writer)
-        .unwrap();
-
-    for (num, frame) in decoder.get_frame_buffer().iter().enumerate() {
-        info!("Writing frame #{num} {w} x {h} to y4m");
-
-        let mut planes = Vec::<Vec<u8>>::new();
-        for plane in &frame.planes {
-            let data_size = plane.cfg.width * plane.cfg.height;
-            let mut data = vec![0; data_size];
-            plane.copy_to_raw_u8(&mut data, plane.cfg.width, 1);
-            planes.push(data)
+    let mut decoding_output = Vec::<u8>::new();
+    {
+        let mut writer = io::BufWriter::new(&mut decoding_output);
+        let mut encoder = y4m::encode(w as usize, h as usize, y4m::Ratio { num: 15, den: 1 })
+            .with_colorspace(y4m::Colorspace::C420)
+            .write_header(&mut writer)
+            .unwrap();
+
+        for (num, frame) in decoder.get_frame_buffer().iter().enumerate() {
+            info!("Writing frame #{num} {w} x {h} to y4m");
+
+            let mut planes = Vec::<Vec<u8>>::new();
+            for plane in &frame.planes {
+                let data_size = plane.cfg.width * plane.cfg.height;
+                let mut data = vec![0; data_size];
+                plane.copy_to_raw_u8(&mut data, plane.cfg.width, 1);
+                planes.push(data)
+            }
+
+            let yuv_frame = y4m::Frame::new(
+                [planes[0].as_slice(), planes[1].as_slice(), planes[2].as_slice()],
+                None,
+            );
+            encoder.write_frame(&yuv_frame).unwrap();
+        }
+    }
+    fs::write("output.y4m", decoding_output.as_slice()).expect("can't save decoding result");
+}
+
+#[cfg(test)]
+mod tests {
+    pub use super::*;
+
+    fn test_decoding_against_gold(
+        encoded_file_name: &str,
+        gold_y4m_filename: &str,
+    ) -> Result<(), String> {
+        fn stringify(e: io::Error) -> String {
+            format!("IO error: {e}")
         }
+        let expected_y4m_buffer = fs::read(gold_y4m_filename).map_err(stringify)?;
+        let encoded_video_buffer = fs::read(encoded_file_name).map_err(stringify)?;
+        let mut decoder = h264::decoder::Decoder::new();
+        decoder
+            .decode(&encoded_video_buffer)
+            .map_err(|e| -> String { format!("Decoding error: {e:?}") })?;
+
+        let first_frame = decoder.get_frame_buffer().first().unwrap();
+        let y_plane = &first_frame.planes[0];
+        let w = y_plane.cfg.width as u32;
+        let h = y_plane.cfg.height as u32;
+
+        let mut decoding_output = Vec::<u8>::new();
+        {
+            let mut writer = io::BufWriter::new(&mut decoding_output);
+            let mut encoder = y4m::encode(w as usize, h as usize, y4m::Ratio { num: 15, den: 1 })
+                .with_colorspace(y4m::Colorspace::C420)
+                .write_header(&mut writer)
+                .unwrap();
+
+            for (num, frame) in decoder.get_frame_buffer().iter().enumerate() {
+                let mut planes = Vec::<Vec<u8>>::new();
+                for plane in &frame.planes {
+                    let data_size = plane.cfg.width * plane.cfg.height;
+                    let mut data = vec![0; data_size];
+                    plane.copy_to_raw_u8(&mut data, plane.cfg.width, 1);
+                    planes.push(data)
+                }
+
+                let yuv_frame = y4m::Frame::new(
+                    [planes[0].as_slice(), planes[1].as_slice(), planes[2].as_slice()],
+                    None,
+                );
+                encoder.write_frame(&yuv_frame).unwrap();
+            }
+        }
+
+        compare_y4m_buffers(decoding_output.as_slice(), expected_y4m_buffer.as_slice())
+    }
 
-        let yuv_frame = y4m::Frame::new(
-            [planes[0].as_slice(), planes[1].as_slice(), planes[2].as_slice()],
-            None,
-        );
-        encoder.write_frame(&yuv_frame).unwrap();
+    #[test]
+    pub fn test_NL1_Sony_D() -> Result<(), String> {
+        test_decoding_against_gold("data/NL1_Sony_D.jsv", "data/NL1_Sony_D.y4m")
     }
-    drop(encoder);
 
-    if let Err(message) = compare_files("output.y4m", "data/NL1_Sony_D.y4m") {
-        print!("File comparison result: {message}");
+    #[test]
+    pub fn test_SVA_NL1_B() -> Result<(), String> {
+        test_decoding_against_gold("data/SVA_NL1_B.264", "data/SVA_NL1_B.y4m")
     }
 }

data/SVA_NL1_B.y4m

@@ -27,7 +27,7 @@ fn compare_plane(
     None
 }
 
-pub fn compare_frames(
+fn compare_frames(
     width: usize,
     height: usize,
     actual: &y4m::Frame,
@@ -62,20 +62,15 @@ pub fn compare_frames(
     result
 }
 
-pub fn compare_files(actual_filename: &str, expected_filename: &str) -> Result<(), String> {
-    fn stringify(x: Error) -> String {
-        format!("error code: {x}")
-    }
+pub fn compare_y4m_buffers(actual_y4m_data: &[u8], expected_y4m_data: &[u8]) -> Result<(), String> {
     fn y4m_stringify(x: y4m::Error) -> String {
-        format!("error code: {x}")
+        format!("y4m decoding error: {x:?}")
     }
 
-    let expected_file = fs::File::open(expected_filename).map_err(stringify)?;
-    let expected_reader = io::BufReader::new(expected_file);
+    let expected_reader = io::BufReader::new(expected_y4m_data);
     let mut expected_decoder = y4m::Decoder::new(expected_reader).map_err(y4m_stringify)?;
 
-    let actual_file = fs::File::open(actual_filename).map_err(stringify)?;
-    let actual_reader = io::BufReader::new(actual_file);
+    let actual_reader = io::BufReader::new(actual_y4m_data);
     let mut actual_decoder = y4m::Decoder::new(actual_reader).map_err(y4m_stringify)?;
 
     let expected_h = expected_decoder.get_height();