aes70 1.6.2 → 2.0.1

package/src/OCP1/OcaVariant.js

@@ -0,0 +1,92 @@
+import { createType } from './createType.js';
+import { OcaVariant as OcaVariantType } from '../types/OcaVariant.js';
+
+export function OcaVariant(...Types) {
+  const canEncode = function (value) {
+    if (typeof value === 'object' && value instanceof OcaVariantType) {
+      return Types[value.Index].canEncode(value.Value);
+    }
+
+    for (const type of Types) {
+      if (type.canEncode(value)) return true;
+    }
+    return false;
+  };
+  const encodeTo = function (dataView, pos, value) {
+    if (typeof value === 'object' && value instanceof OcaVariantType) {
+      dataView.setUint8(pos++, value.Index);
+      return Types[value.Index].encodeTo(dataView, pos, value.Value);
+    }
+
+    for (let i = 0; i < Types.length; i++) {
+      const type = Types[i];
+
+      if (!type.canEncode(value)) continue;
+      dataView.setUint8(pos++, i);
+      return type.encodeTo(dataView, pos, value);
+    }
+
+    throw new TypeError('Cannot encode argument.');
+  };
+  const decodeFrom = function (dataView, pos) {
+    const index = dataView.getUint8(pos++);
+    const type = Types[index];
+
+    const tmp = type.decodeFrom(dataView, pos);
+
+    tmp[1] = new OcaVariantType(index, tmp[1]);
+
+    return tmp;
+  };
+  const decodeLength = function (dataView, pos) {
+    const index = dataView.getUint8(pos);
+
+    if (index >= Types.length) {
+      throw new Error('OcaVariant index out of bounds.');
+    }
+
+    const type = Types[index];
+
+    return type.decodeLength(dataView, pos + 1) + 1;
+  };
+
+  const isConstantLength = Types.every((type) => type.isConstantLength);
+
+  if (isConstantLength) {
+    const encodedLengths = Types.map((type) => type.encodedLength());
+
+    if (encodedLengths.every((length) => length === encodedLengths[0])) {
+      return createType({
+        isConstantLength: true,
+        encodedLength: function (value) {
+          return encodedLengths[0] + 1;
+        },
+        canEncode,
+        encodeTo,
+        decodeFrom,
+        decodeLength,
+      });
+    }
+  }
+
+  return createType({
+    isConstantLength: false,
+    encodedLength: function (value) {
+      if (typeof value === 'object' && value instanceof OcaVariantType) {
+        return Types[value.Index].encodedLength(value.Value) + 1;
+      }
+
+      for (const type of Types) {
+        if (type.canEncode(value)) {
+          return 1 + type.encodedLength(value);
+        }
+      }
+
+      throw new TypeError('Cannot encode argument.');
+    },
+    canEncode,
+    encodeTo,
+    decodeFrom,
+    decodeLength,
+  });
+}

package/src/OCP1/OcaWhenPhysicalAbsolute.js

@@ -0,0 +1,16 @@
+/*
+ * This file has been generated.
+ */
+import { OcaTime } from './OcaTime.js';
+import { OcaUint32 } from './OcaUint32.js';
+import { Struct } from './Struct.js';
+
+import { OcaWhenPhysicalAbsolute as type } from '../types/OcaWhenPhysicalAbsolute.js';
+
+export const OcaWhenPhysicalAbsolute = Struct(
+  {
+    TimeRefONo: OcaUint32,
+    Value: OcaTime,
+  },
+  type
+);

package/src/OCP1/OcaWhenPhysicalRelative.js

@@ -0,0 +1,16 @@
+/*
+ * This file has been generated.
+ */
+import { OcaTime } from './OcaTime.js';
+import { OcaUint32 } from './OcaUint32.js';
+import { Struct } from './Struct.js';
+
+import { OcaWhenPhysicalRelative as type } from '../types/OcaWhenPhysicalRelative.js';
+
+export const OcaWhenPhysicalRelative = Struct(
+  {
+    TimeRefONo: OcaUint32,
+    Value: OcaTime,
+  },
+  type
+);

package/src/OCP1/RestWithOffset.js

@@ -3,6 +3,9 @@ import { createType } from './createType.js';
 export function RestWithOffset(offset) {
   return createType({
     isConstantLength: false,
+    canEncode: function (value) {
+      return typeof value === 'object' && value instanceof DataView;
+    },
     encodedLength: function (value) {
       if (!(typeof value === 'object' && value instanceof DataView))
         throw new TypeError('Expected DataView.');

package/src/OCP1/String16.js

@@ -2,6 +2,9 @@ import { createType } from './createType.js';
 
 export const String16 = createType({
   isConstantLength: false,
+  canEncode: function (value) {
+    return typeof value === 'string';
+  },
   encodedLength: function (value) {
     // TODO: we could support more than strings
     if (typeof value !== 'string') throw new TypeError('Expected string.');

package/src/OCP1/Struct.js

@@ -28,6 +28,18 @@ export function Struct(Types, DataType) {
   return createType({
     type: DataType,
     isConstantLength: false,
+    canEncode: function (value) {
+      if (typeof value !== 'object') return false;
+
+      for (const name in Types) {
+        if (!Object.prototype.hasOwnProperty.call(Types, name)) continue;
+        const Type = Types[name];
+
+        if (!Type.canEncode(value[name])) return false;
+      }
+
+      return true;
+    },
     encodedLength: function (value) {
       let result = 0;
 

package/src/OCP1/Tuple.js

@@ -6,6 +6,9 @@ export function Tuple(...Types) {
 
   return createType({
     isConstantLength: false,
+    canEncode: function (value) {
+      return Array.isArray(value) || isTypedArray(value);
+    },
     encodedLength: function (value) {
       if (!(Array.isArray(value) || isTypedArray(value)))
         throw new TypeError('Expected array.');

package/src/OCP1/createBlobType.js

@@ -0,0 +1,58 @@
+import { createType } from './createType.js';
+import { getLengthEncoder } from './getLengthEncoder.js';
+
+export function createBlobType(byteLength) {
+  const { setLength, getLength, maxLength } = getLengthEncoder(byteLength);
+
+  return createType({
+    isConstantLength: false,
+    canEncode: function (value) {
+      if (typeof value !== 'object') return false;
+
+      return (
+        value instanceof ArrayBuffer ||
+        value instanceof Uint8Array ||
+        Array.isArray(value)
+      );
+    },
+    encodedLength: function (value) {
+      if (value instanceof ArrayBuffer) value = new Uint8Array(value);
+      if (!Array.isArray(value) && !(value instanceof Uint8Array))
+        throw new TypeError('Expected Array or Uint8Array');
+
+      const length = value.length;
+
+      if (length > maxLength)
+        throw new Error('Array too long for OCP.1 encoding.');
+
+      return byteLength + length;
+    },
+    encodeTo: function (dataView, pos, value) {
+      if (value instanceof ArrayBuffer) value = new Uint8Array(value);
+
+      const length = value.length;
+
+      setLength(dataView, pos, length);
+      pos += byteLength;
+
+      const u8 = new Uint8Array(dataView.buffer, dataView.byteOffset);
+      u8.set(value, pos);
+      return pos + length;
+    },
+    decodeFrom: function (dataView, pos) {
+      const length = getLength(dataView, pos);
+
+      pos += byteLength;
+
+      return [
+        pos + length,
+        new Uint8Array(dataView.buffer, dataView.byteOffset + pos, length),
+      ];
+    },
+    decodeLength: function (dataView, pos) {
+      const length = getLength(dataView, pos);
+
+      return pos + byteLength + length;
+    },
+  });
+}

package/src/OCP1/createListType.js

@@ -0,0 +1,137 @@
+import { createType } from './createType.js';
+import { isTypedArray } from './is_typed_array.js';
+import { getLengthEncoder } from './getLengthEncoder.js';
+
+function canEncode(value) {
+  return Array.isArray(value) || isTypedArray(value);
+}
+
+function OcaListConstantLength(Type, byteLength) {
+  const encodedLength = Type.encodedLength(void 0);
+  const encodeTo = Type.encodeTo;
+  const decode = Type.decode;
+  const { setLength, getLength, maxLength } = getLengthEncoder(byteLength);
+
+  return createType({
+    isConstantLength: false,
+    canEncode,
+    encodedLength: function (value) {
+      if (!canEncode(value)) throw new TypeError('Expected array.');
+
+      const length = value.length;
+
+      if (length > maxLength)
+        throw new Error('Array too long for OcaList OCP.1 encoding');
+
+      return byteLength + length * encodedLength;
+    },
+    encodeTo: function (dataView, pos, value) {
+      const length = value.length;
+
+      setLength(dataView, pos, length);
+      pos += byteLength;
+
+      for (let i = 0; i < length; i++) {
+        pos = encodeTo(dataView, pos, value[i]);
+      }
+
+      return pos;
+    },
+    decodeFrom: function (dataView, pos) {
+      const length = getLength(dataView, pos);
+
+      pos += byteLength;
+
+      const value = new Array(length);
+
+      for (let i = 0; i < length; i++) {
+        value[i] = decode(dataView, pos);
+        pos += encodedLength;
+      }
+
+      return [pos, value];
+    },
+    decodeLength: function (dataView, pos) {
+      const length = getLength(dataView, pos);
+
+      pos += byteLength + length * encodedLength;
+
+      return pos;
+    },
+  });
+}
+
+function OcaListDynamicLength(Type, byteLength) {
+  const encodedLength = Type.encodedLength;
+  const encodeTo = Type.encodeTo;
+  const decodeFrom = Type.decodeFrom;
+  const decodeLength = Type.decodeLength;
+  const { setLength, getLength, maxLength } = getLengthEncoder(byteLength);
+
+  return createType({
+    isConstantLength: false,
+    canEncode,
+    encodedLength: function (value) {
+      if (!canEncode(value)) throw new TypeError('Expected array.');
+
+      const length = value.length;
+
+      if (length > maxLength)
+        throw new Error('Array too long for OcaList OCP.1 encoding');
+
+      let result = byteLength;
+      for (let i = 0; i < length; i++) {
+        result += encodedLength(value[i]);
+      }
+      return result;
+    },
+    encodeTo: function (dataView, pos, value) {
+      const length = value.length;
+
+      setLength(dataView, pos, length);
+      pos += byteLength;
+
+      for (let i = 0; i < length; i++) {
+        pos = encodeTo(dataView, pos, value[i]);
+      }
+
+      return pos;
+    },
+    decodeFrom: function (dataView, pos) {
+      const length = getLength(dataView, pos);
+
+      pos += byteLength;
+
+      const value = new Array(length);
+
+      for (let i = 0; i < length; i++) {
+        let tmp;
+
+        [pos, tmp] = decodeFrom(dataView, pos);
+
+        value[i] = tmp;
+      }
+
+      return [pos, value];
+    },
+    decodeLength: function (dataView, pos) {
+      const length = getLength(dataView, pos);
+
+      pos += byteLength;
+
+      for (let i = 0; i < length; i++) {
+        pos = decodeLength(dataView, pos);
+      }
+
+      return pos;
+    },
+  });
+}
+
+export function createListType(byteLength) {
+  return function (Type) {
+    return Type.isConstantLength
+      ? OcaListConstantLength(Type, byteLength)
+      : OcaListDynamicLength(Type, byteLength);
+  };
+}

package/src/OCP1/createType.js

@@ -4,17 +4,21 @@ export function createType(Type) {
   const encodedLength = Type.encodedLength();
   const decode = Type.decode;
   const encodeTo = Type.encodeTo;
+  const decodeFrom = Type.decodeFrom;
 
   return {
     isConstantLength: true,
+    canEncode: Type.canEncode,
     encodedLength: Type.encodedLength,
     encodeTo: encodeTo,
     decode: decode,
-    decodeFrom: function (dataView, pos) {
-      const result = decode(dataView, pos);
+    decodeFrom: decode
+      ? function (dataView, pos) {
+          const result = decode(dataView, pos);
 
-      return [pos + encodedLength, result];
-    },
+          return [pos + encodedLength, result];
+        }
+      : decodeFrom,
     decodeLength: function (dataView, pos) {
       return pos + encodedLength;
     },

package/src/OCP1/decode_message.js

@@ -3,8 +3,16 @@ import { CommandRrq } from './commandrrq.js';
 import { Notification } from './notification.js';
 import { Response } from './response.js';
 import { KeepAlive } from './keepalive.js';
-
-const PDUTypes = [Command, CommandRrq, Notification, Response, KeepAlive];
+import { Notification2 } from './notification2.js';
+
+const PDUTypes = [
+  Command,
+  CommandRrq,
+  Notification,
+  Response,
+  KeepAlive,
+  Notification2,
+];
 
 export function decodeMessage(data, pos, ret) {
   if (data.byteLength < data.byteOffset + pos + 10) return -1;

package/src/OCP1/encode_message.js

@@ -1,3 +1,5 @@
+import { PROTOCOL_VERSION_2024 } from './protocol_version.js';
+
 export const messageHeaderSize = 10;
 
 function calculateMessageLength(pdus) {
@@ -14,6 +16,8 @@ function calculateMessageLength(pdus) {
   return len;
 }
 
+export const currentProtocolVersion = PROTOCOL_VERSION_2024;
+
 export function encodeMessageTo(dst, pos, pdus, offset, end) {
   if (!offset) offset = 0;
 
@@ -28,7 +32,7 @@ export function encodeMessageTo(dst, pos, pdus, offset, end) {
 
   const startPos = pos;
 
-  dst.setUint16(pos, 1);
+  dst.setUint16(pos, currentProtocolVersion);
   pos += 2;
   const lenPos = pos;
   pos += 4;

package/src/OCP1/getLengthEncoder.js

@@ -0,0 +1,23 @@
+export function getLengthEncoder(byteLength) {
+  let setLength, getLength, maxLength;
+
+  if (byteLength === 2) {
+    setLength = function (dataView, pos, length) {
+      return dataView.setUint16(pos, length);
+    };
+    getLength = function (dataView, pos, length) {
+      return dataView.getUint16(pos);
+    };
+    maxLength = 0xffff;
+  } else if (byteLength === 4) {
+    setLength = function (dataView, pos, length) {
+      return dataView.setUint32(pos, length);
+    };
+    getLength = function (dataView, pos, length) {
+      return dataView.getUint32(pos);
+    };
+    maxLength = 0xffffffff;
+  } else throw new TypeError('Unsupported length size.');
+
+  return { getLength, setLength, maxLength };
+}

package/src/OCP1/notification2.js

@@ -0,0 +1,70 @@
+import { PDU } from './pdu.js';
+import { OcaEvent } from './OcaEvent.js';
+import { EncodedArguments } from './encoded_arguments.js';
+
+/**
+ * Notification packet.
+ */
+export class Notification2 extends PDU {
+  constructor(event, exception, data) {
+    super();
+    this.event = event;
+    this.exception = !!exception;
+    this.parameters = data || null;
+  }
+
+  static get messageType() {
+    return 5;
+  }
+
+  encode_to(dst, pos) {
+    dst.setUint32(pos, this.encoded_length());
+    pos += 4;
+    dst.setUint32(pos, this.event.EmitterONo);
+    pos += 4;
+    dst.setUint16(pos, this.event.EventID.DefLevel);
+    pos += 2;
+    dst.setUint16(pos, this.event.EventID.EventIndex);
+    pos += 2;
+    dst.setUint8(pos, this.exception ? 1 : 0);
+    pos += 1;
+    if (this.parameters) {
+      if (this.parameters instanceof EncodedArguments) {
+        pos = this.parameters.encodeTo(dst, pos);
+      } else {
+        new Uint8Array(dst.buffer).set(
+          new Uint8Array(this.parameters),
+          dst.byteOffset + pos
+        );
+        pos += this.parameters.byteLength;
+      }
+    }
+    return pos;
+  }
+
+  encoded_length() {
+    return 13 + (this.parameters ? this.parameters.byteLength : 0);
+  }
+
+  decode_from(data, pos, data_len) {
+    let len = data.getUint32(pos);
+    pos += 4;
+
+    let event;
+
+    [pos, event] = OcaEvent.decodeFrom(data, pos);
+
+    this.event = event;
+    this.exception = data.getUint8(pos++) ? true : false;
+    len -= 13;
+    if (len < 0) throw new Error('Bad Notification Length.');
+    if (len > 0) {
+      this.parameters = data.buffer.slice(
+        data.byteOffset + pos,
+        data.byteOffset + pos + len
+      );
+      pos += len;
+    }
+    return pos;
+  }
+}

package/src/OCP1/protocol_version.js

@@ -0,0 +1,4 @@
+export const PROTOCOL_VERSION_2015 = 1;
+export const PROTOCOL_VERSION_2018 = 2;
+export const PROTOCOL_VERSION_2023 = 3;
+export const PROTOCOL_VERSION_2024 = 4;

package/src/close_error.d.ts

@@ -0,0 +1,4 @@
+export declare class CloseError extends Error {
+  error?: Error;
+  constructor(error?: Error);
+}

package/src/close_error.js

@@ -0,0 +1,13 @@
+/**
+ * Error class raised when a connection is closed.
+ *
+ * @property {Error} [error] - The actual failure reason. May be undefined,
+ *   for instance if the connection was closed using close().
+ */
+export class CloseError extends Error {
+  constructor(error) {
+    super(`Connection has been closed.`);
+    this.name = 'aes70.CloseError';
+    this.error = error;
+  }
+}

package/src/connection.js

@@ -10,6 +10,8 @@ import { MessageGenerator } from './OCP1/message_generator.js';
  *   no parameters.
  * - ``error`` is emitted when this connection has been closed with an error.
  *   This event emits the error object as a single parameter.
+ * - ``send`` is emitted with each pdu that is sent.
+ * - ``receive`` is emitted with each pdu that is received.
  *
  * @param {object} options
  *      The options.
@@ -39,13 +41,18 @@ export class Connection extends Events {
     this.tx_bytes = 0;
     this.keepalive_interval = -1;
     this._keepalive_interval_id = null;
-    const cleanup = () => {
-      this.removeEventListener('close', cleanup);
-      this.removeEventListener('error', cleanup);
+    this._closed = false;
+    this.on('close', () => {
+      if (this._closed) return;
+      this._closed = true;
       this.cleanup();
-    };
-    this.on('close', cleanup);
-    this.on('error', cleanup);
+    });
+    this.on('error', (e) => {
+      if (this._closed) return;
+      this._closed = true;
+      this.emit('close');
+      this.cleanup(e);
+    });
   }
 
   get is_reliable() {
@@ -54,6 +61,7 @@ export class Connection extends Events {
 
   send(pdu) {
     if (this.is_closed()) throw new Error('Connection is closed.');
+    this.emit('send', pdu);
     this._message_generator.add(pdu);
   }
 
@@ -135,7 +143,7 @@ export class Connection extends Events {
     this.emit('error', err);
   }
 
-  cleanup() {
+  cleanup(error) {
     if (this.is_closed()) throw new Error('cleanup() called twice.');
 
     // disable keepalive
@@ -152,7 +160,7 @@ export class Connection extends Events {
 
     if (this.rx_idle_time() > t * 3) {
       this.emit('timeout');
-      this.error(new Error('Keepalive timeout.'));
+      this.error(new TimeoutError());
     } else if (this.tx_idle_time() > t * 0.75) {
       /* Try to flush buffers before actually sending out anything. */
       this.flush();

package/src/controller/ControlClasses/OcaActuator.d.ts

@@ -2,9 +2,9 @@ import { RemoteDevice } from '../remote_device';
 import { OcaWorker } from './OcaWorker';
 
 /**
- * Abstract base class for all actuators (i.e. devices that affect the routing
- * and/or content of the audio signal, or provide ancillary functions such as
- * power).
+ * Abstract base class for all actuators (i.e. classes) that affect the routing
+ * and/or content of the audio signal, or provide ancillary control functions
+ * such as power).
  * @extends OcaWorker
  * @class OcaActuator
  */

package/src/controller/ControlClasses/OcaActuator.js

@@ -2,9 +2,9 @@ import { make_control_class } from '../make_control_class.js';
 import { OcaWorker } from './OcaWorker.js';
 
 /**
- * Abstract base class for all actuators (i.e. devices that affect the routing
- * and/or content of the audio signal, or provide ancillary functions such as
- * power).
+ * Abstract base class for all actuators (i.e. classes) that affect the routing
+ * and/or content of the audio signal, or provide ancillary control functions
+ * such as power).
  * @extends OcaWorker
  * @class OcaActuator
  */
@@ -12,7 +12,7 @@ export const OcaActuator = make_control_class(
   'OcaActuator',
   3,
   '\u0001\u0001\u0001',
-  2,
+  3,
   OcaWorker,
   [],
   [],