Merge pull request #9 from jwetzell/feat/lighting-decode

add support for decoding RTTrPL

src/decoders/index.ts

@@ -1,3 +1,8 @@
+import ChannelBlock from './lighting/channel-block';
+import LightingOutput from './lighting/lighting-output';
+import RTTrPL from './lighting/rttrpl';
+import Spot from './lighting/spot';
+import Universe from './lighting/universe';
 import CentroidAccelVelocity from './motion/centroid-accel-velocity';
 import CentroidPosition from './motion/centroid-position';
 import OrientationEuler from './motion/orientation-euler';
@@ -13,6 +18,7 @@ import RTTrPHeader from './rttrp-header';
 export const Decoders = {
   RTTrPHeader,
   RTTrPM,
+  RTTrPL,
   Trackable,
   CentroidPosition,
   CentroidAccelVelocity,
@@ -22,4 +28,8 @@ export const Decoders = {
   OrientationEuler,
   ZoneCollisionDetection,
   ZoneObject,
+  Spot,
+  ChannelBlock,
+  Universe,
+  LightingOutput,
 };

src/decoders/lighting/channel-block.ts

@@ -0,0 +1,20 @@
+import { ChannelBlock } from '../../models';
+
+export default (bytes: Uint8Array, isLittleEndian: boolean = false): ChannelBlock => {
+  if (bytes.length !== 5) {
+    throw new Error('Channel Block module must be 5 bytes');
+  }
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  const offset = view.getUint16(0);
+
+  const fade = view.getUint16(2, isLittleEndian);
+
+  const value = view.getUint8(4);
+  return {
+    offset,
+    fade,
+    value,
+  };
+};

src/decoders/lighting/lighting-output.ts

@@ -0,0 +1,46 @@
+import { Decoders } from '..';
+import { LightingOutput, Universe } from '../../models';
+
+export default (bytes: Uint8Array, isLittleEndian: boolean = false): LightingOutput => {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  let dataOffset = 0;
+  const type = view.getUint8(dataOffset);
+  dataOffset += 1;
+  if (type !== 0x07) {
+    throw new Error('Lighting Output module must have a type of 0x09');
+  }
+
+  const size = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+  if (size < bytes.byteLength) {
+    throw new Error('Lighting Output module size mismatch');
+  }
+  const sequence = view.getUint32(dataOffset, isLittleEndian);
+  dataOffset += 4;
+  const action = view.getUint8(dataOffset);
+  dataOffset += 1;
+  const holdTime = view.getUint32(dataOffset, isLittleEndian);
+  dataOffset += 4;
+  const numberOfUniverses = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+
+  const universes: Universe[] = [];
+  let universeOffset = dataOffset;
+
+  for (let index = 0; index < numberOfUniverses; index++) {
+    const universeData = bytes.subarray(universeOffset);
+    const universe = Decoders.Universe(universeData);
+    universes.push(universe);
+    universeOffset += universe.size;
+  }
+  return {
+    type,
+    size,
+    sequence,
+    action,
+    holdTime,
+    numberOfUniverses,
+    universes,
+  };
+};

src/decoders/lighting/rttrpl.ts

@@ -0,0 +1,37 @@
+import { Decoders } from '..';
+import { LightingOutput, RTTrPL } from '../../models';
+
+export default (bytes: Uint8Array): RTTrPL => {
+  if (bytes.byteLength < 18) {
+    throw new Error('RTTrPL packet must be at least 18 bytes long');
+  }
+  const header = Decoders.RTTrPHeader(bytes.subarray(0, 18));
+
+  if (bytes.byteLength !== header.size) {
+    throw new Error('RTTrPL packet size mismatch');
+  }
+
+  const modules: LightingOutput[] = [];
+  let packetModuleOffset = 18;
+
+  for (let index = 0; index < header.subModuleCount; index++) {
+    const moduleData = bytes.subarray(packetModuleOffset);
+    const moduleType = moduleData[0];
+    switch (moduleType) {
+      case 0x07: {
+        const module = Decoders.LightingOutput(moduleData, header.isLittleEndian);
+        modules.push(module);
+        packetModuleOffset += module.size;
+        break;
+      }
+      default:
+        console.error(`unknown RTTrPL submodule type: ${moduleType}`);
+        break;
+    }
+  }
+
+  return {
+    header,
+    modules,
+  };
+};

src/decoders/lighting/spot.ts

@@ -0,0 +1,43 @@
+import { Decoders } from '..';
+import { ChannelBlock, Spot } from '../../models';
+
+export default (bytes: Uint8Array, isLittleEndian: boolean = false): Spot => {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  let dataOffset = 0;
+  const type = view.getUint8(dataOffset);
+  dataOffset += 1;
+  if (type !== 0x0a) {
+    throw new Error('Spot module must have a type of 0x0a');
+  }
+
+  const size = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+  if (size < bytes.byteLength) {
+    throw new Error('Spot module size mismatch');
+  }
+  const id = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+  const offset = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+  const numberOfChannelBlocks = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+
+  const channelBlocks: ChannelBlock[] = [];
+  let zoneObjectOffset = dataOffset;
+
+  for (let index = 0; index < numberOfChannelBlocks; index++) {
+    const channelBlockData = bytes.subarray(zoneObjectOffset, zoneObjectOffset + 5);
+    const channelBlock = Decoders.ChannelBlock(channelBlockData);
+    channelBlocks.push(channelBlock);
+    zoneObjectOffset += channelBlockData.byteLength;
+  }
+  return {
+    type,
+    size,
+    id,
+    offset,
+    numberOfChannelBlocks,
+    channelBlocks,
+  };
+};

src/decoders/lighting/universe.ts

@@ -0,0 +1,40 @@
+import { Decoders } from '..';
+import { Spot, Universe } from '../../models';
+
+export default (bytes: Uint8Array, isLittleEndian: boolean = false): Universe => {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  let dataOffset = 0;
+  const type = view.getUint8(dataOffset);
+  dataOffset += 1;
+  if (type !== 0x09) {
+    throw new Error('Universe module must have a type of 0x09');
+  }
+
+  const size = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+  if (size < bytes.byteLength) {
+    throw new Error('Universe module size mismatch');
+  }
+  const id = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+  const numberOfSpots = view.getUint16(dataOffset, isLittleEndian);
+  dataOffset += 2;
+
+  const spots: Spot[] = [];
+  let spotOffset = dataOffset;
+
+  for (let index = 0; index < numberOfSpots; index++) {
+    const spotData = bytes.subarray(spotOffset);
+    const spot = Decoders.Spot(spotData);
+    spots.push(spot);
+    spotOffset += spot.size;
+  }
+  return {
+    type,
+    size,
+    id,
+    numberOfSpots,
+    spots,
+  };
+};

src/models.ts

@@ -15,6 +15,11 @@ export type RTTrPM = {
   modules: Trackable[];
 };
 
+export type RTTrPL = {
+  header: RTTrPHeader;
+  modules: LightingOutput[];
+};
+
 export type TrackableModule =
   | CentroidPosition
   | CentroidAccelVelocity
@@ -114,3 +119,36 @@ export type ZoneObject = {
   nameLength: number;
   name: string;
 };
+
+export type LightingOutput = {
+  type: number;
+  size: number;
+  sequence: number;
+  action: number;
+  holdTime: number;
+  numberOfUniverses: number;
+  universes: Universe[];
+};
+
+export type Universe = {
+  type: number;
+  size: number;
+  id: number;
+  numberOfSpots: number;
+  spots: Spot[];
+};
+
+export type Spot = {
+  type: number;
+  size: number;
+  id: number;
+  offset: number;
+  numberOfChannelBlocks: number;
+  channelBlocks: ChannelBlock[];
+};
+
+export type ChannelBlock = {
+  offset: number;
+  fade: number;
+  value: number;
+};

tests/decode.test.js

@@ -251,6 +251,161 @@ const goodTests = [
     },
     decoder: Decoders.RTTrPM,
   },
+  {
+    description: 'RTTrPL + Lighting Output + Universe + Spot + Single Channel Block',
+    bytes: new Uint8Array([
+      65, 84, 0x44, 0x34, 0, 2, 0, 0, 0, 1, 0, 0, 53, 18, 52, 86, 120, 1, 0x07, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01,
+      0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x01, 0x09, 0x00, 0x15, 0x12, 0x34, 0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34,
+      0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40,
+    ]),
+    expected: {
+      header: {
+        intHeader: 0x4154,
+        floatHeader: 0x4434,
+        version: 2,
+        packetID: 1,
+        packetFormat: 0,
+        size: 53,
+        context: 0x12345678,
+        subModuleCount: 1,
+        isLittleEndian: false,
+      },
+      modules: [
+        {
+          type: 0x07,
+          size: 35,
+          sequence: 1,
+          action: 1,
+          holdTime: 100,
+          numberOfUniverses: 1,
+          universes: [
+            {
+              type: 0x09,
+              size: 21,
+              id: 0x1234,
+              numberOfSpots: 1,
+              spots: [
+                {
+                  type: 0x0a,
+                  size: 14,
+                  id: 0x1234,
+                  offset: 1,
+                  numberOfChannelBlocks: 1,
+                  channelBlocks: [
+                    {
+                      offset: 0x08,
+                      fade: 0x06,
+                      value: 0x40,
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    decoder: Decoders.RTTrPL,
+  },
+  {
+    description: 'Lighting Output + Universe + Spot + Single Channel Block',
+    bytes: new Uint8Array([
+      0x07, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x01, 0x09, 0x00, 0x15, 0x12, 0x34,
+      0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40,
+    ]),
+    expected: {
+      type: 0x07,
+      size: 35,
+      sequence: 1,
+      action: 1,
+      holdTime: 100,
+      numberOfUniverses: 1,
+      universes: [
+        {
+          type: 0x09,
+          size: 21,
+          id: 0x1234,
+          numberOfSpots: 1,
+          spots: [
+            {
+              type: 0x0a,
+              size: 14,
+              id: 0x1234,
+              offset: 1,
+              numberOfChannelBlocks: 1,
+              channelBlocks: [
+                {
+                  offset: 0x08,
+                  fade: 0x06,
+                  value: 0x40,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    decoder: Decoders.LightingOutput,
+  },
+  {
+    description: 'Universe + Spot + Single Channel Block',
+    bytes: new Uint8Array([
+      0x09, 0x00, 0x15, 0x12, 0x34, 0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00,
+      0x06, 0x40,
+    ]),
+    expected: {
+      type: 0x09,
+      size: 21,
+      id: 0x1234,
+      numberOfSpots: 1,
+      spots: [
+        {
+          type: 0x0a,
+          size: 14,
+          id: 0x1234,
+          offset: 1,
+          numberOfChannelBlocks: 1,
+          channelBlocks: [
+            {
+              offset: 0x08,
+              fade: 0x06,
+              value: 0x40,
+            },
+          ],
+        },
+      ],
+    },
+    decoder: Decoders.Universe,
+  },
+  {
+    description: 'Spot + Single Channel Block',
+    bytes: new Uint8Array([0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40]),
+    expected: {
+      type: 0x0a,
+      size: 14,
+      id: 0x1234,
+      offset: 1,
+      numberOfChannelBlocks: 1,
+      channelBlocks: [
+        {
+          offset: 0x08,
+          fade: 0x06,
+          value: 0x40,
+        },
+      ],
+    },
+    decoder: Decoders.Spot,
+  },
+  {
+    description: 'Channel Block',
+    bytes: new Uint8Array([0x00, 0x08, 0x00, 0x06, 0x40]),
+    expected: {
+      offset: 0x08,
+      fade: 0x06,
+      value: 0x40,
+    },
+    decoder: Decoders.ChannelBlock,
+  },
 ];
 
 describe('RTTrP Bytes Decoding', () => {

tests/lighting-decode.test.js

@@ -0,0 +1,181 @@
+const { deepEqual, throws } = require('assert');
+const { describe, it } = require('node:test');
+const { Decoders } = require('../dist/cjs');
+const goodTests = [
+  {
+    description: 'RTTrPL + Lighting Output + Universe + Spot + Single Channel Block',
+    bytes: new Uint8Array([
+      65, 84, 0x44, 0x34, 0, 2, 0, 0, 0, 1, 0, 0, 53, 18, 52, 86, 120, 1, 0x07, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01,
+      0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x01, 0x09, 0x00, 0x15, 0x12, 0x34, 0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34,
+      0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40,
+    ]),
+    expected: {
+      header: {
+        intHeader: 0x4154,
+        floatHeader: 0x4434,
+        version: 2,
+        packetID: 1,
+        packetFormat: 0,
+        size: 53,
+        context: 0x12345678,
+        subModuleCount: 1,
+        isLittleEndian: false,
+      },
+      modules: [
+        {
+          type: 0x07,
+          size: 35,
+          sequence: 1,
+          action: 1,
+          holdTime: 100,
+          numberOfUniverses: 1,
+          universes: [
+            {
+              type: 0x09,
+              size: 21,
+              id: 0x1234,
+              numberOfSpots: 1,
+              spots: [
+                {
+                  type: 0x0a,
+                  size: 14,
+                  id: 0x1234,
+                  offset: 1,
+                  numberOfChannelBlocks: 1,
+                  channelBlocks: [
+                    {
+                      offset: 0x08,
+                      fade: 0x06,
+                      value: 0x40,
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    decoder: Decoders.RTTrPL,
+  },
+  {
+    description: 'Lighting Output + Universe + Spot + Single Channel Block',
+    bytes: new Uint8Array([
+      0x07, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x01, 0x09, 0x00, 0x15, 0x12, 0x34,
+      0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40,
+    ]),
+    expected: {
+      type: 0x07,
+      size: 35,
+      sequence: 1,
+      action: 1,
+      holdTime: 100,
+      numberOfUniverses: 1,
+      universes: [
+        {
+          type: 0x09,
+          size: 21,
+          id: 0x1234,
+          numberOfSpots: 1,
+          spots: [
+            {
+              type: 0x0a,
+              size: 14,
+              id: 0x1234,
+              offset: 1,
+              numberOfChannelBlocks: 1,
+              channelBlocks: [
+                {
+                  offset: 0x08,
+                  fade: 0x06,
+                  value: 0x40,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    decoder: Decoders.LightingOutput,
+  },
+  {
+    description: 'Universe + Spot + Single Channel Block',
+    bytes: new Uint8Array([
+      0x09, 0x00, 0x15, 0x12, 0x34, 0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00,
+      0x06, 0x40,
+    ]),
+    expected: {
+      type: 0x09,
+      size: 21,
+      id: 0x1234,
+      numberOfSpots: 1,
+      spots: [
+        {
+          type: 0x0a,
+          size: 14,
+          id: 0x1234,
+          offset: 1,
+          numberOfChannelBlocks: 1,
+          channelBlocks: [
+            {
+              offset: 0x08,
+              fade: 0x06,
+              value: 0x40,
+            },
+          ],
+        },
+      ],
+    },
+    decoder: Decoders.Universe,
+  },
+  {
+    description: 'Spot + Single Channel Block',
+    bytes: new Uint8Array([0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40]),
+    expected: {
+      type: 0x0a,
+      size: 14,
+      id: 0x1234,
+      offset: 1,
+      numberOfChannelBlocks: 1,
+      channelBlocks: [
+        {
+          offset: 0x08,
+          fade: 0x06,
+          value: 0x40,
+        },
+      ],
+    },
+    decoder: Decoders.Spot,
+  },
+  {
+    description: 'Channel Block',
+    bytes: new Uint8Array([0x00, 0x08, 0x00, 0x06, 0x40]),
+    expected: {
+      offset: 0x08,
+      fade: 0x06,
+      value: 0x40,
+    },
+    decoder: Decoders.ChannelBlock,
+  },
+];
+
+describe('RTTrPL Bytes Decoding', () => {
+  goodTests.forEach((bytesTest) => {
+    it(bytesTest.description, () => {
+      const decoded = bytesTest.decoder(bytesTest.bytes);
+      deepEqual(decoded, bytesTest.expected);
+    });
+  });
+});
+
+// TODO(jwetzell): add error tests
+const badTests = [];
+describe('RTTrPL Bytes Decoding Throws', () => {
+  badTests.forEach((bytesTest) => {
+    it(bytesTest.description, () => {
+      throws(() => {
+        bytesTest.decoder(bytesTest.bytes);
+      }, bytesTest.throwsMessage);
+    });
+  });
+});