JP1 Remotes

Code: Select all

<irp:protocol c-name="DirecTV_P3" name="DirecTV_P3">
        <irp:parameter name="prefer-over">DirecTV</irp:parameter>
        <irp:parameter name="uei-executor" type="xml">
            <rm:deployment executor="DirecTV" pid="0162">
                <rm:protocolName>**DirecTV**</rm:protocolName>
                <rm:assignment target="Parm">3</rm:assignment>
                <rm:assignment target="CmdParms">F</rm:assignment>
                <rm:assignment target="DevParms">100*D + Parm</rm:assignment>
            </rm:deployment>
        </irp:parameter>
        <irp:irp><![CDATA[{38k,600,msb}<1,-1|1,-2|2,-1|2,-2>([10][5],-2,D:4,F:8,C:4,1,-50){C=7*(F:2:6)+5*(F:2:4)+3*(F:2:2)+(F:2)}[D:0..15,F:0..255]]]></irp:irp>
    </irp:protocol>

Code: Select all

<irp:protocols xmlns="http://www.w3.org/1999/xhtml"
               xmlns:xi="http://www.w3.org/2001/XInclude"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:rm="https://www.hifi-remote.com/forums/viewtopic.php?t=101943"
               version="2019-09-11"
               xsi:schemaLocation="http://www.harctoolbox.org/irp-protocols http://www.harctoolbox.org/schemas/irp-protocols.xsd"
               xmlns:irp="http://www.harctoolbox.org/irp-protocols">

Code: Select all

package javaapplication8;

import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.harctoolbox.ircore.*;
import org.harctoolbox.irp.*;
import org.harctoolbox.irp.Decoder.Decode;
import org.harctoolbox.irp.Decoder.DecoderParameters;
import org.w3c.dom.*;

public class directv2 {

    public static void main(String[] args) {
        try {
            IrSignal irSignal = Pronto.parse("0000 006D 000A 000A 00E4 002E 002E 002E 0017 0017 0017 0017 002E 0017 0017 0017 002E 0017 002E 002E 0017 0017 0017 0474 0072 002E 002E 002E 0017 0017 0017 0017 002E 0017 0017 0017 002E 0017 002E 002E 0017 0017 0017 0474");
            DecoderParameters decoderParameters = new DecoderParameters();
            IrpDatabase irpDatabase = new IrpDatabase("../IrpTransmogrifier/src/main/resources/IrpProtocols.xml");
            ExecutorWrapperDatabase executorWrapperDatabase = new ExecutorWrapperDatabase(irpDatabase);
            Decoder decoder = new Decoder(irpDatabase);
            Map<String, Decode> sigDecodes = decoder.decodeIrSignal(irSignal, decoderParameters);
            for (Decode decode : sigDecodes.values()) {
                System.out.println("Orig: " + decode);
                NamedProtocol namedProtocol = decode.getNamedProtocol();
                String protocolName = namedProtocol.getName();
                Map<String, Long> names = decode.getMap();
                NameEngine nameEngine = new NameEngine(names);
                List<ExecutorWrapper> wrapperList = executorWrapperDatabase.get(protocolName);
                if (wrapperList == null)
                    continue;
                for (ExecutorWrapper ew : wrapperList) {
                    Decode newDecode = ew.fixDecode(protocolName, namedProtocol, nameEngine);
                    System.out.println("Fixed: " + newDecode);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private static class ExecutorWrapper {

        private static final String RM_NAMESPACE = "https://www.hifi-remote.com/forums/viewtopic.php?t=101943";

        static List<ExecutorWrapper> parseList(List<DocumentFragment> exec) {
            List<ExecutorWrapper> result = new ArrayList<>(16);
            exec.forEach((fragment) -> {
                result.add(new ExecutorWrapper(fragment));
            });
            return result;
        }

        private String protocolName;
        private final Map<String, Expression> assignments;

        ExecutorWrapper(DocumentFragment fragment) {
            assignments = new LinkedHashMap<>(4); // Important: keeps the order things are put in.
            protocolName = null;
            NodeList children = fragment.getChildNodes();

            // Finding the deployment element
            Element deployment = null;
            for (int i = 0; i < children.getLength(); i++) {
                Node node = children.item(i);
                if (node.getNodeType() != Node.ELEMENT_NODE)
                    continue;
                Element e = (Element) node;
                if (e.getLocalName().equals("deployment")) {
                    deployment = e;
                    break;
                }
            }
            if (deployment == null)
                return;

            // Getting the assignments
            NodeList assignmentNodes = deployment.getElementsByTagNameNS(RM_NAMESPACE, "assignment");
            for (int i = 0; i < assignmentNodes.getLength(); i++) {
                Element e = (Element) assignmentNodes.item(i);

                // Get and parse the Expression contained therein
                Expression exp = Expression.newExpression(e.getTextContent());

                // and stuff it into the map
                String paramName = e.getAttribute("target");
                assignments.put(paramName, exp);
            }

            NodeList nl = deployment.getElementsByTagNameNS(RM_NAMESPACE, "protocolName");
            if (nl.getLength() > 0)
                protocolName = nl.item(0).getTextContent();
        }

        void fixParameters(NameEngine nameEngine) {
            assignments.entrySet().forEach((assgnmnt) -> {
                try {
                    String paramName = assgnmnt.getKey();
                    long value = assgnmnt.getValue().toLong(nameEngine);
                    nameEngine.define(paramName, value);
                } catch (NameUnassignedException | InvalidNameException ex) {
                    Logger.getLogger(directv2.class.getName()).log(Level.SEVERE, null, ex);
                }
            });
        }

        Decode fixDecode(String protocolName, NamedProtocol namedProtocol, NameEngine nameEngine) throws InvalidNameException, UnsupportedRepeatException, NameUnassignedException, IrpInvalidArgumentException {
            if (this.protocolName != null)
                protocolName = this.protocolName;
            fixParameters(nameEngine);
            NamedProtocol np = new NamedProtocol(protocolName, namedProtocol.getIrp(), null); // inefficient...
            Decode fixedDecode = new Decode(np, nameEngine.toMap(), -1, -1, 0);
            return fixedDecode;
        }
    }

    private static class ExecutorWrapperDatabase {

        private final Map<String, List<ExecutorWrapper>> map;

        ExecutorWrapperDatabase(IrpDatabase irpDatabase) {
            map = new HashMap<>(16);
            irpDatabase.getKeys().forEach((protName) -> {
                List<DocumentFragment> exec = irpDatabase.getXmlProperties(protName, "uei-executor");
                if (exec != null) {
                    List<ExecutorWrapper> lies = ExecutorWrapper.parseList(exec);
                    map.put(protName, lies);
                }
            });
        }

        List<ExecutorWrapper> get(String name) {
            return map.get(name.toLowerCase(Locale.US));
        }
    }
}

Code: Select all

The IRP notation as specified in the Second Draft document dated 4 February 2010 is a notation for describing IR protocols.  This Appendix specifies an extension that enables the notation to be used also for identifying, for an IR protocol, an executor capable of generating the IR signals of that protocol.  It does not specify the executors themselves but instead identifies a particular executor from a list of executors and specifies how the numerical values that the protocol transmits should be mapped to input parameters of the executor.

Code: Select all

{40k,600}<1,-1|2,-1>((4,-1,96:8,18:7,^45m)3,(4,-1,195:8,^45m),(4,-1,81:8,^45m),(4,-1,F:8,^45m),
      (4,-1,(F^145):8,11:7,^45m))[F:0..255]

Code: Select all

    <irp:protocol c-name="SonyDSP" name="SonyDSP">
        <irp:parameter name="prefer-over">SonyDSP_relaxed</irp:parameter>
        <irp:parameter name="prefer-over">Sony15</irp:parameter>
        <irp:parameter name="uei-executor">01FF:JP1DSP[;F]</irp:parameter>
        <irp:irp><![CDATA[{40k,600}<1,-1|2,-1>((4,-1,96:8,18:7,^45m)3,(4,-1,195:8,^45m),(4,-1,81:8,^45m),(4,-1,F:8,^45m),
            (4,-1,(F^145):8,11:7,^45m))[F:0..255]]]></irp:irp> 
        <irp:documentation/>
    </irp:protocol>
    <irp:protocol c-name="SonyDSP_relaxed" name="SonyDSP_relaxed">
        <irp:parameter name="prefer-over">Sony15</irp:parameter>
        <irp:parameter name="decode-only">true</irp:parameter>
        <irp:parameter name="uei-executor" type="xml"> 
            <rm:deployment executor="01FF:JP1DSP[;F]"> 
                <rm:protocolName>SonyDSP</rm:protocolName> 
                <rm:commentItem>Final data bit missing</rm:commentItem> 
             </rm:deployment> 
        </irp:parameter> 
        <irp:irp><![CDATA[{40k,600}<1,-1|2,-1>((4,-1,96:8,18:7,^45m)3,(4,-1,195:8,^45m),(4,-1,81:8,^45m),(4,-1,F:8,^45m),
            (4,-1,(F^145):8,11:6))[F:0..255]]]></irp:irp> 
        <irp:documentation/>
    </irp:protocol>

Code: Select all

* New parameters in IrpProtocols.xml: frequency-low & frequency-high. #132.
* IrSignal.setFrequency replaced by IrSignal(IrSignal, double). #143.
* Reorganized the contributed directory.
* Fixed protocol Humax 4Phase. #142.
* Cleanup/efficiency fix in Protocol.toIrSequence(NameEngine, Pass).
* IrSequence.approximatelyEquals(IrSequence): much stricter default tolerances.
* Bugfix: Number.toString(int) now behaves properly also for Integers etc.
* Implement index reversal for large bitspecs. #141.
* Major refacoring of decoding, using Equation and BitwiseParameter. #127, #137.
* IrpProtocols.xml/irp:protocol[@name="NEC1-f16"]: set reject-repeatless to true.
* IrpProtocols.xml: rename protocol Ortek -> Ortek_NEClike.
* Remove attribute c-name in IrpProtocols.xml; add an explaining comment. #140.
* Refactored much of the Decoder stuff.
* Implemented predicates for prefer-overs. #134.
* Adjusted prefer-overs in IrpProtocols.xml to be compatible with the past.
* Improvements to list --check-sorted (previously --checksorted).
* Better user messages for no decodes.
* Improved logging, in particular for rendering.
* Move --override to common options.
* "New protocol" F12_relaxed.
* Moved irp from NamedProtocol to Protocol.
* Move ProtocolNotDecodableException and ProtocolNotRenderableException from NamedProtocol to Protocol.
* Encapsulate (hide) expansion in IrpDatabase. #139.
* Fix implementation of the short circuiting operators && and ||. #138.
* Fixed render --decode in the presence of defaults. #135.
* Extended API of IrpDatabase. #136.
* IrpDatabase now implements Iterable<NamedProtocol>. Cf. #136.
* Comment character of --input and --namedinput now settable using --commentStart. #133.
* Bugfix: render --decode misbehaved on protocol with definitions. #135