Add lircd decode test

Signed-off-by: Sean Young <[email protected]>

src/bin/commands/decode.rs

@@ -145,7 +145,7 @@ fn decode_irp(matches: &clap::ArgMatches) {
 
     let mut feed_decoder = |raw: &[InfraredData]| {
         for (index, ir) in raw.iter().enumerate() {
-            decoder.dfa_input(*ir, &dfa, |event, var| {
+            decoder.nfa_input(*ir, &nfa, |event, var| {
                 let mut var: Vec<(String, i64)> = var.into_iter().collect();
                 var.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
                 println!(
@@ -353,7 +353,7 @@ fn decode_lircd(matches: &clap::ArgMatches) {
     let mut decoders = remotes
         .iter()
         .map(|remote| {
-            let decoder = remote.decoder(abs_tolerance, rel_tolerance, max_gap);
+            let decoder = remote.decoder(Some(abs_tolerance), Some(rel_tolerance), max_gap);
 
             if graphviz {
                 let filename = format!("{}_nfa.dot", remote.name);
@@ -369,15 +369,8 @@ fn decode_lircd(matches: &clap::ArgMatches) {
     let mut feed_decoder = |raw: &[InfraredData]| {
         for (index, ir) in raw.iter().enumerate() {
             for decoder in &mut decoders {
-                decoder.input(*ir, |bits, code| {
-                    if let Some(code) = code {
-                        println!(
-                            "decoded: remote:{} value:{:#x} code:{}",
-                            decoder.remote.name, bits, code.name
-                        );
-                    } else {
-                        println!("decoded: remote:{} value:{:#x}", decoder.remote.name, bits,);
-                    }
+                decoder.input(*ir, |code| {
+                    println!("decoded: remote:{} code:{}", decoder.remote.name, code.name);
                 });
 
                 if graphviz_step {

src/lircd_conf/decode.rs

@@ -10,7 +10,12 @@ pub struct LircDecoder<'a> {
 
 impl Remote {
     /// Create a decoder for this remote
-    pub fn decoder(&self, abs_tolerance: u32, rel_tolerance: u32, max_gap: u32) -> LircDecoder {
+    pub fn decoder(
+        &self,
+        abs_tolerance: Option<u32>,
+        rel_tolerance: Option<u32>,
+        max_gap: u32,
+    ) -> LircDecoder {
         let irp = self.decode_irp();
 
         debug!("decoding irp {irp} for remote {}", self.name);
@@ -20,8 +25,8 @@ impl Remote {
         let nfa = irp.build_nfa().unwrap();
 
         let decoder = Decoder::new(
-            abs_tolerance.max(self.aeps as u32),
-            rel_tolerance.max(self.eps as u32),
+            abs_tolerance.unwrap_or(self.aeps as u32),
+            rel_tolerance.unwrap_or(self.eps as u32),
             max_gap,
         );
 
@@ -36,18 +41,21 @@ impl Remote {
 impl<'a> LircDecoder<'a> {
     pub fn input<F>(&mut self, ir: InfraredData, mut callback: F)
     where
-        F: FnMut(u64, Option<&'a Code>),
+        F: FnMut(&'a Code),
     {
         self.decoder.nfa_input(ir, &self.nfa, |_, vars| {
-            let decoded = vars["CODE"] as u64;
-
-            callback(
-                decoded,
-                self.remote
-                    .codes
-                    .iter()
-                    .find(|code| code.code[0] == decoded),
-            );
+            if let Some(decoded) = vars.get("CODE") {
+                let decoded = *decoded as u64;
+                if let Some(key_code) = self.remote.codes.iter().find(|code| {
+                    code.code[0] == decoded || code.code[0] == (decoded ^ self.remote.repeat_mask)
+                }) {
+                    callback(key_code);
+                }
+            }
         })
     }
+
+    pub fn reset(&mut self) {
+        self.decoder.reset();
+    }
 }

tests/lircd_conf_encode.rs → tests/lircd_conf_tests.rs

@@ -1,5 +1,5 @@
 use cir::lircd_conf::parse;
-use irp::Message;
+use irp::{InfraredData, Message};
 use liblircd::LircdConf;
 use num_integer::Integer;
 use std::{
@@ -20,12 +20,12 @@ fn recurse(path: &Path) {
         if e.metadata().unwrap().file_type().is_dir() {
             recurse(&path);
         } else if path.to_string_lossy().ends_with(".lircd.conf") {
-            lircd_encode(&path);
+            lircd_encode_decode(&path);
         }
     }
 }
 
-fn lircd_encode(path: &Path) {
+fn lircd_encode_decode(path: &Path) {
     println!("Testing {}", path.display());
 
     let data = read(path).unwrap();
@@ -91,6 +91,7 @@ fn lircd_encode(path: &Path) {
         if !our_remote.codes.is_empty() {
             let irp = our_remote.encode_irp();
             println!("remote {} irp:{}", our_remote.name, irp);
+            let mut decoder = our_remote.decoder(Some(10), Some(1), 200000);
 
             for (our_code, lircd_code) in our_remote.codes.iter().zip(lircd_remote.codes_iter()) {
                 if our_code.dup {
@@ -193,6 +194,42 @@ fn lircd_encode(path: &Path) {
                         );
                     }
                 }
+
+                let mut decoded = Vec::new();
+
+                decoder.reset();
+
+                // needs trailing space
+                let message = our_remote
+                    .encode(our_code, 0)
+                    .expect("encode should succeed");
+
+                for ir in InfraredData::from_u32_slice(&message.raw) {
+                    decoder.input(ir, |code| {
+                        decoded.push(code.code[0]);
+                    });
+                }
+
+                if decoded != expect {
+                    // is decoded and expected all the same value?
+                    let all_the_same = if !decoded.is_empty() && !expect.is_empty() {
+                        decoded
+                            .iter()
+                            .chain(expect.iter())
+                            .all(|v| *v == decoded[0])
+                    } else {
+                        false
+                    };
+
+                    if !all_the_same {
+                        println!("{}", message.print_rawir());
+                        println!("irp: {}", our_remote.decode_irp());
+                        println!(
+                            "DECODE MISMATCH got: {decoded:#x?} expected: {:#x?}",
+                            expect
+                        );
+                    }
+                }
             }
         }
     }