Add encoder for same bpf protocols that ir-ctl can encode

Create IRPs for old v4l-utils bpf protocols.

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

Author: seanyoung

Diff for: libirctl/src/bpf_encoder.c

@@ -61,24 +61,24 @@ static void encode_pulse_length(struct keymap *map, uint32_t scancode, int *buf,
 	if (keymap_param(map, "reverse", 0)) {
 		for (i = 0; i < bits; i++) {
 			if (scancode & (1 << i))
-				buf[len++] = keymap_param(map, "bit_1_space", 1625);
+				buf[len++] = keymap_param(map, "bit_1_pulse", 1625);
 			else
-				buf[len++] = keymap_param(map, "bit_0_space", 375);
+				buf[len++] = keymap_param(map, "bit_0_pulse", 375);
 
-			buf[len++] = keymap_param(map, "bit_pulse", 625);
+			buf[len++] = keymap_param(map, "bit_space", 625);
 		}
 	} else {
 		for (i = bits - 1; i >= 0; i--) {
 			if (scancode & (1 << i))
-				buf[len++] = keymap_param(map, "bit_1_space", 1625);
+				buf[len++] = keymap_param(map, "bit_1_pulse", 1625);
 			else
-				buf[len++] = keymap_param(map, "bit_0_space", 375);
+				buf[len++] = keymap_param(map, "bit_0_pulse", 375);
 
-			buf[len++] = keymap_param(map, "bit_pulse", 625);
+			buf[len++] = keymap_param(map, "bit_space", 625);
 		}
 	}
 
-	*length = len;
+	*length = len - 1;
 }
 
 static void manchester_advance_space(int *buf, int *len, unsigned length)
@@ -101,6 +101,14 @@ static void encode_manchester(struct keymap *map, uint32_t scancode, int *buf, i
 {
 	int len = 0, bits, i;
 
+	int header_pulse = keymap_param(map, "header_pulse", 0);
+	int header_space = keymap_param(map, "header_space", 0);
+
+	if (header_pulse > 0) {
+		manchester_advance_pulse(buf, &len, header_pulse);
+		manchester_advance_space(buf, &len, header_space);
+	}
+
 	bits = keymap_param(map, "bits", 14);
 
 	for (i = bits - 1; i >= 0; i--) {

Diff for: libirctl/src/lib.rs

@@ -45,7 +45,7 @@ pub struct raw_entry {
 }
 
 extern "C" {
-    pub fn parse_keymap(fname: *const c_char, keymap: *const *const keymap, verbose: bool) -> i32;
+    pub fn parse_keymap(fname: *const c_char, keymap: *mut *mut keymap, verbose: bool) -> i32;
     pub fn free_keymap(keymap: *const keymap);
     pub fn keymap_param(keymap: *const keymap, name: *const c_char, fallback: i32) -> i32;
 }

Diff for: src/keymap.rs

@@ -1,6 +1,6 @@
 //! Parse linux rc keymaps
 
-use std::{collections::HashMap, ffi::OsStr, path::Path};
+use std::{collections::HashMap, ffi::OsStr, fmt::Write, path::Path};
 use toml::{Table, Value};
 
 #[derive(PartialEq, Eq, Debug, Default)]
@@ -9,6 +9,7 @@ pub struct Protocol {
     pub protocol: String,
     pub variant: Option<String>,
     pub irp: Option<String>,
+    pub rc_protocol: Option<u16>,
     pub raw: Option<Vec<Raw>>,
     pub scancodes: Option<HashMap<String, String>>,
 }
@@ -120,6 +121,18 @@ fn parse_toml(contents: &str, filename: &Path) -> Result<Keymap, String> {
             variant = Some(entry.to_owned());
         }
 
+        let mut rc_protocol = None;
+        if let Some(Value::Integer(n)) = entry.get("rc_protocol") {
+            if let Ok(n) = (*n).try_into() {
+                rc_protocol = Some(n);
+            } else {
+                return Err(format!(
+                    "{}: rc_protocol {n} must be 16 bit value",
+                    filename.display()
+                ));
+            }
+        }
+
         let mut irp = None;
         let mut raw = None;
         let mut scancodes = None;
@@ -184,6 +197,11 @@ fn parse_toml(contents: &str, filename: &Path) -> Result<Keymap, String> {
                 if let Some(Value::String(entry)) = entry.get("irp") {
                     irp = Some(entry.to_owned());
                 }
+            } else if entry.get("irp").is_some() {
+                return Err("set the protocol to irp when using irp".to_string());
+            } else if let Some(rewrite) = bpf_protocol_irp(protocol, entry.as_table().unwrap()) {
+                log::info!("{}: protocol {protocol} has been rewritten to irp {rewrite}", filename.display());
+                irp = Some(rewrite);
             }
 
             if let Some(Value::Table(codes)) = entry.get("scancodes") {
@@ -206,6 +224,7 @@ fn parse_toml(contents: &str, filename: &Path) -> Result<Keymap, String> {
             protocol: protocol.to_owned(),
             variant,
             raw,
+            rc_protocol,
             scancodes,
             irp,
         });
@@ -214,6 +233,185 @@ fn parse_toml(contents: &str, filename: &Path) -> Result<Keymap, String> {
     Ok(Keymap { protocols: res })
 }
 
+fn bpf_protocol_irp(protocol: &str, entry: &Table) -> Option<String> {
+    let param = |name: &str, default: i64| -> i64 {
+        if let Some(Value::Integer(n)) = entry.get(name) {
+            *n
+        } else {
+            default
+        }
+    };
+
+    match protocol {
+        "pulse_distance" => {
+            let mut irp = "{".to_owned();
+            let bits = param("bits", 4);
+
+            if param("reverse", 0) == 0 {
+                irp.push_str("msb,");
+            }
+
+            if entry.contains_key("carrier") {
+                write!(irp, "{}Hz,", param("carrier", 0)).unwrap();
+            }
+
+            if irp.ends_with(',') {
+                irp.pop();
+            }
+
+            write!(
+                irp,
+                "}}<{},-{}|{},-{}>({},-{},CODE:{},{},-40m",
+                param("bit_pulse", 625),
+                param("bit_0_space", 375),
+                param("bit_pulse", 625),
+                param("bit_1_space", 1625),
+                param("header_pulse", 2125),
+                param("header_space", 1875),
+                bits,
+                param("trailer_pulse", 625),
+            )
+            .unwrap();
+
+            let header_optional = param("header_optional", 0);
+
+            if header_optional > 0 {
+                write!(
+                    irp,
+                    ",(CODE:{},{},-40m)*",
+                    bits,
+                    param("trailer_pulse", 625),
+                )
+                .unwrap();
+            } else {
+                let repeat_pulse = param("repeat_pulse", 0);
+                if repeat_pulse > 0 {
+                    write!(
+                        irp,
+                        ",({},-{},{},-40)*",
+                        repeat_pulse,
+                        param("repeat_space", 0),
+                        param("trailer_pulse", 625)
+                    )
+                    .unwrap();
+                }
+            }
+
+            write!(irp, ") [CODE:0..{}]", gen_mask(bits)).unwrap();
+
+            Some(irp)
+        }
+        "pulse_length" => {
+            let mut irp = "{".to_owned();
+            let bits = param("bits", 4);
+
+            if param("reverse", 0) == 0 {
+                irp.push_str("msb,");
+            }
+
+            if entry.contains_key("carrier") {
+                write!(irp, "{}Hz,", param("carrier", 0)).unwrap();
+            }
+
+            if irp.ends_with(',') {
+                irp.pop();
+            }
+
+            write!(
+                irp,
+                "}}<{},-{}|{},-{}>({},-{},CODE:{},-40m",
+                param("bit_0_pulse", 375),
+                param("bit_space", 625),
+                param("bit_1_pulse", 1625),
+                param("bit_space", 625),
+                param("header_pulse", 2125),
+                param("header_space", 1875),
+                bits,
+            )
+            .unwrap();
+
+            let header_optional = param("header_optional", 0);
+
+            if header_optional > 0 {
+                write!(irp, ",(CODE:{},-40m)*", bits).unwrap();
+            } else {
+                let repeat_pulse = param("repeat_pulse", 0);
+                if repeat_pulse > 0 {
+                    write!(
+                        irp,
+                        ",({},-{},{},-40)*",
+                        repeat_pulse,
+                        param("repeat_space", 0),
+                        param("trailer_pulse", 625)
+                    )
+                    .unwrap();
+                }
+            }
+
+            write!(irp, ") [CODE:0..{}]", gen_mask(bits)).unwrap();
+
+            Some(irp)
+        }
+        "manchester" => {
+            let mut irp = "{msb,".to_owned();
+            let bits = param("bits", 14);
+            let toggle_bit = param("toggle_bit", 100);
+
+            if entry.contains_key("carrier") {
+                write!(irp, "{}Hz,", param("carrier", 0)).unwrap();
+            }
+
+            if irp.ends_with(',') {
+                irp.pop();
+            }
+
+            write!(
+                irp,
+                "}}<-{},{}|{},-{}>(",
+                param("zero_space", 888),
+                param("zero_pulse", 888),
+                param("one_pulse", 888),
+                param("one_space", 888),
+            )
+            .unwrap();
+
+            let header_pulse = param("header_pulse", 0);
+            let header_space = param("header_space", 0);
+
+            if header_pulse > 0 && header_space > 0 {
+                write!(irp, "{},-{},", header_pulse, header_space).unwrap();
+            }
+
+            if toggle_bit >= bits {
+                write!(irp, "CODE:{},-40m", bits,).unwrap();
+            } else {
+                let leading = bits - toggle_bit;
+                if leading > 1 {
+                    write!(irp, "CODE:{}:{},", leading - 1, toggle_bit + 1).unwrap();
+                }
+                write!(irp, "T:1,").unwrap();
+                if toggle_bit > 0 {
+                    write!(irp, "CODE:{},", toggle_bit).unwrap();
+                }
+                irp.pop();
+            }
+
+            write!(irp, ",-40m) [CODE:0..{}]", gen_mask(bits)).unwrap();
+
+            Some(irp)
+        }
+        _ => None,
+    }
+}
+
+fn gen_mask(v: i64) -> u64 {
+    if v < 64 {
+        (1u64 << v) - 1
+    } else {
+        u64::MAX
+    }
+}
+
 #[test]
 fn parse_toml_test() {
     let s = r#"
@@ -358,3 +556,52 @@ fn parse_text_test() {
         }
     }
 }
+
+#[test]
+fn parse_bpf_toml_test() {
+    let s = r#"
+    [[protocols]]
+    name = "meh"
+    protocol = "manchester"
+    toggle_bit = 12
+    [protocols.scancodes]
+    0x1e3b = "KEY_SELECT"
+    0x1e3d = "KEY_POWER2"
+    0x1e1c = "KEY_TV"
+    "#;
+
+    let k = parse(s, Path::new("x.toml")).unwrap();
+
+    assert_eq!(k.protocols[0].name, "meh");
+    assert_eq!(k.protocols[0].protocol, "manchester");
+    assert_eq!(
+        k.protocols[0].irp,
+        Some("{msb}<-888,888|888,-888>(CODE:1:13,T:1,CODE:12,-40m) [CODE:0..16383]".into())
+    );
+
+    let s = r#"
+    [[protocols]]
+    name = "meh"
+    protocol = "manchester"
+    toggle_bit = 1
+    carrier = 38000
+    header_pulse = 300
+    header_space = 350
+    [protocols.scancodes]
+    0x1e3b = "KEY_SELECT"
+    0x1e3d = "KEY_POWER2"
+    0x1e1c = "KEY_TV"
+    "#;
+
+    let k = parse(s, Path::new("x.toml")).unwrap();
+
+    assert_eq!(k.protocols[0].name, "meh");
+    assert_eq!(k.protocols[0].protocol, "manchester");
+    assert_eq!(
+        k.protocols[0].irp,
+        Some(
+            "{msb,38000Hz}<-888,888|888,-888>(300,-350,CODE:12:2,T:1,CODE:1,-40m) [CODE:0..16383]"
+                .into()
+        )
+    );
+}

Diff for: testdata/rc_keymaps/RM-687C.toml

@@ -0,0 +1,35 @@
+[[protocols]]
+name = 'Sony_RM-687C'
+protocol = 'pulse_length'
+header_pulse = 2369
+header_space = 637
+bits = 12
+bit_space = 637
+bit_1_pulse = 1166
+bit_0_pulse = 565
+[protocols.scancodes]
+0xa90 = 'KEY_STANDBY'
+0x290 = 'KEY_MUTE'
+0x5d0 = 'KEY_DISPLAY'
+0x010 = 'KEY_1'
+0x810 = 'KEY_2'
+0x410 = 'KEY_3'
+0xc10 = 'KEY_4'
+0x210 = 'KEY_5'
+0xa10 = 'KEY_6'
+0x610 = 'KEY_7'
+0xe10 = 'KEY_8'
+0x110 = 'KEY_9'
+0x310 = 'KEY_1-'
+0x910 = 'KEY_0'
+0xb10 = 'KEY_2-'
+0x6d0 = 'KEY_SLEEP'
+0x3f0 = 'KEY_SELECT'
+0x2f0 = 'KEY_KPPLUS'
+0x690 = 'KEY_NORMAL'
+0xaf0 = 'KEY_KPMINUS'
+0x490 = 'KEY_VOLUMEUP'
+0x090 = 'KEY_CHANNELUP'
+0xa50 = 'KEY_TV/VIDEO'
+0xc90 = 'KEY_VOLUMEDOWN'
+0x890 = 'KEY_CHANNELDOWN'