@warren-bank/fx_cast_bridge 0.3.1

package/js/src/bridge/index.js

@@ -0,0 +1,161 @@
+"use strict";
+var __awaiter =
+    (this && this.__awaiter) ||
+    function (thisArg, _arguments, P, generator) {
+        function adopt(value) {
+            return value instanceof P
+                ? value
+                : new P(function (resolve) {
+                      resolve(value);
+                  });
+        }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) {
+                try {
+                    step(generator.next(value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function rejected(value) {
+                try {
+                    step(generator["throw"](value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function step(result) {
+                result.done
+                    ? resolve(result.value)
+                    : adopt(result.value).then(fulfilled, rejected);
+            }
+            step(
+                (generator = generator.apply(thisArg, _arguments || [])).next()
+            );
+        });
+    };
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const cast_1 = require("./components/cast");
+const discovery_1 = __importDefault(require("./components/cast/discovery"));
+const remote_1 = __importDefault(require("./components/cast/remote"));
+const mediaServer_1 = require("./components/mediaServer");
+const config_json_1 = require("../../config.json");
+process.on("SIGTERM", () =>
+    __awaiter(void 0, void 0, void 0, function* () {
+        discovery === null || discovery === void 0 ? void 0 : discovery.stop();
+        try {
+            yield (0, mediaServer_1.stopMediaServer)();
+        } catch (err) {
+            console.error("Error stopping media server!", err);
+        } finally {
+            process.exit(1);
+        }
+    })
+);
+let discovery = null;
+const remotes = new Map();
+function run(messaging) {
+    messaging.on("message", message => {
+        var _a, _b;
+        switch (message.subject) {
+            case "bridge:getInfo":
+            case "bridge:/getInfo": {
+                messaging.send(config_json_1.applicationVersion);
+                break;
+            }
+            case "bridge:startDiscovery": {
+                const { shouldWatchStatus } = message.data;
+                discovery = new discovery_1.default({
+                    onDeviceFound(device) {
+                        messaging.sendMessage({
+                            subject: "main:deviceUp",
+                            data: {
+                                deviceId: device.id,
+                                deviceInfo: device
+                            }
+                        });
+                        if (shouldWatchStatus) {
+                            remotes.set(
+                                device.id,
+                                new remote_1.default(device.host, {
+                                    port: device.port,
+                                    onReceiverStatusUpdate(status) {
+                                        messaging.sendMessage({
+                                            subject:
+                                                "main:receiverDeviceStatusUpdated",
+                                            data: {
+                                                deviceId: device.id,
+                                                status
+                                            }
+                                        });
+                                    },
+                                    onMediaStatusUpdate(status) {
+                                        if (!status) return;
+                                        messaging.sendMessage({
+                                            subject:
+                                                "main:receiverDeviceMediaStatusUpdated",
+                                            data: {
+                                                deviceId: device.id,
+                                                status
+                                            }
+                                        });
+                                    }
+                                })
+                            );
+                        }
+                    },
+                    onDeviceDown(deviceId) {
+                        var _a;
+                        messaging.sendMessage({
+                            subject: "main:deviceDown",
+                            data: { deviceId }
+                        });
+                        if (shouldWatchStatus) {
+                            if (remotes.has(deviceId)) {
+                                (_a = remotes.get(deviceId)) === null ||
+                                _a === void 0
+                                    ? void 0
+                                    : _a.disconnect();
+                                remotes.delete(deviceId);
+                            }
+                        }
+                    }
+                });
+                discovery.start();
+                break;
+            }
+            case "bridge:sendReceiverMessage": {
+                const { deviceId, message: receiverMessage } = message.data;
+                (_a = remotes.get(deviceId)) === null || _a === void 0
+                    ? void 0
+                    : _a.sendReceiverMessage(receiverMessage);
+                break;
+            }
+            case "bridge:sendMediaMessage": {
+                const { deviceId, message: mediaMessage } = message.data;
+                (_b = remotes.get(deviceId)) === null || _b === void 0
+                    ? void 0
+                    : _b.sendMediaMessage(mediaMessage);
+                break;
+            }
+            case "bridge:startMediaServer": {
+                const { filePath, port } = message.data;
+                (0, mediaServer_1.startMediaServer)(messaging, filePath, port);
+                break;
+            }
+            case "bridge:stopMediaServer": {
+                (0, mediaServer_1.stopMediaServer)();
+                break;
+            }
+            default: {
+                (0, cast_1.handleCastMessage)(messaging, message);
+            }
+        }
+    });
+}

package/js/src/bridge/lib/mdns.js

@@ -0,0 +1,154 @@
+// https://github.com/futomi/node-dns-sd
+
+const mDnsSd = require('node-dns-sd')
+const ping   = require('./ping')
+
+const browsers = []
+
+mDnsSd.ondata = (packet) => {
+  const service = packet_to_service(packet)
+  if (!service) return
+
+  for (const browser of browsers) {
+    browser.handleService(service)
+  }
+}
+
+const packet_to_service = (packet) => {
+  if (!packet || !(packet instanceof Object) || !packet.address || !packet.header || !(packet.header instanceof Object) || !packet.header.answers || !Array.isArray(packet.answers)  || !(packet.header.answers === packet.answers.length) || !packet.header.additionals || !Array.isArray(packet.additionals)  || !(packet.header.additionals === packet.additionals.length))
+    return null
+
+  const service = {
+    address: packet.address
+  }
+
+  for (const answer of packet.answers) {
+    if (answer && (answer instanceof Object) && answer.name && answer.rdata) {
+      service.name     = answer.name
+      service.fullname = answer.rdata
+      break
+    }
+  }
+
+  if (!service.name)
+    return null
+
+  for (const xtra of packet.additionals) {
+    if ((xtra.name === service.fullname) && xtra.rdata && (xtra.rdata instanceof Object)) {
+      if (xtra.type === 'TXT')
+        service.txtRecord = xtra.rdata
+
+      if ((xtra.type === 'SRV') && xtra.rdata.port)
+        service.port = xtra.rdata.port
+    }
+  }
+
+  if (!service.txtRecord || !service.port)
+    return null
+
+  return service
+}
+
+class DnsSdBrowser {
+  constructor(filter, hasServiceChanged) {
+    this.filter            = filter
+    this.hasServiceChanged = (typeof hasServiceChanged === 'function') ? hasServiceChanged : null
+    this.started           = false
+    this.events            = {}
+    this.services          = []
+
+    setInterval(this.pingAllServices.bind(this), 5000)
+  }
+
+  pingAllServices() {
+    for (const service of this.services) {
+      ping(service.address, service.port, this.handlePing.bind(this))
+    }
+  }
+
+  handlePing(pingResult) {
+    if (pingResult.alive) return
+
+    for (let i=0; i < this.services.length; i++) {
+      const service = this.services[i]
+      if ((service.address === pingResult.hostname) && (service.port === pingResult.port)) {
+        this.services.splice(i, 1)
+        this.handleEvent('serviceDown', service)
+        break
+      }
+    }
+  }
+
+  on(event, callback) {
+    if (!this.events[event])
+      this.events[event] = []
+
+    this.events[event].push(callback)
+  }
+
+  handleService(newService) {
+    if (newService.name.indexOf(this.filter) >= 0) {
+      let dupl_idx = -1
+      let dupl_svc = null
+      let has_diff = false
+
+      for (let i=0; i < this.services.length; i++) {
+        const oldService = this.services[i]
+        if ((oldService.address === newService.address) && (oldService.port === newService.port)) {
+          dupl_idx = i
+          dupl_svc = oldService
+          has_diff = !!this.hasServiceChanged && this.hasServiceChanged(oldService, newService)
+          break
+        }
+      }
+      if (dupl_svc && has_diff) {
+        this.services.splice(dupl_idx, 1)
+        this.handleEvent('serviceDown', dupl_svc)
+        dupl_svc = null
+      }
+      if (!dupl_svc) {
+        this.services.push(newService)
+        this.handleEvent('serviceUp', newService)
+      }
+    }
+  }
+
+  handleEvent(event, service) {
+    if (Array.isArray(this.events[event])) {
+      for (const callback of this.events[event]) {
+        callback(service)
+      }
+    }
+  }
+
+  start() {
+    if (this.started) return
+
+    this.started = true
+
+    browsers.push(this)
+
+    mDnsSd.startMonitoring()
+  }
+
+  stop() {
+    if (!this.started) return
+
+    this.started = false
+
+    const index = browsers.indexOf(this)
+    if (index >= 0)
+      browsers.splice(index, 1)
+
+    if (!browsers.length)
+      mDnsSd.stopMonitoring()
+  }
+}
+
+const createBrowser = (filter, hasServiceChanged) => {
+  return new DnsSdBrowser(filter, hasServiceChanged)
+}
+
+module.exports = {
+  createBrowser
+}

package/js/src/bridge/lib/ping.js

@@ -0,0 +1,20 @@
+const {createConnection} = require('node:net')
+
+const ping = (hostname, port, callback, timeout = 3000) => {
+  const socket = createConnection(port, hostname)
+  const handleSuccess = () => {
+    socket.end()
+    callback({alive: true, hostname, port})
+  }
+  const handleFailure = () => {
+    socket.destroy()
+    callback({alive: false, hostname, port})
+  }
+
+  socket.setTimeout(timeout)
+  socket.on('connect', handleSuccess)
+  socket.on('timeout', handleFailure)
+  socket.on('error',   handleFailure)
+}
+
+module.exports = ping

package/js/src/bridge/lib/subtitles.js

@@ -0,0 +1,131 @@
+"use strict";
+var __awaiter =
+    (this && this.__awaiter) ||
+    function (thisArg, _arguments, P, generator) {
+        function adopt(value) {
+            return value instanceof P
+                ? value
+                : new P(function (resolve) {
+                      resolve(value);
+                  });
+        }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) {
+                try {
+                    step(generator.next(value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function rejected(value) {
+                try {
+                    step(generator["throw"](value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function step(result) {
+                result.done
+                    ? resolve(result.value)
+                    : adopt(result.value).then(fulfilled, rejected);
+            }
+            step(
+                (generator = generator.apply(thisArg, _arguments || [])).next()
+            );
+        });
+    };
+var __asyncValues =
+    (this && this.__asyncValues) ||
+    function (o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator],
+            i;
+        return m
+            ? m.call(o)
+            : ((o =
+                  typeof __values === "function"
+                      ? __values(o)
+                      : o[Symbol.iterator]()),
+              (i = {}),
+              verb("next"),
+              verb("throw"),
+              verb("return"),
+              (i[Symbol.asyncIterator] = function () {
+                  return this;
+              }),
+              i);
+        function verb(n) {
+            i[n] =
+                o[n] &&
+                function (v) {
+                    return new Promise(function (resolve, reject) {
+                        (v = o[n](v)), settle(resolve, reject, v.done, v.value);
+                    });
+                };
+        }
+        function settle(resolve, reject, d, v) {
+            Promise.resolve(v).then(function (v) {
+                resolve({ value: v, done: d });
+            }, reject);
+        }
+    };
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertSrtToVtt = convertSrtToVtt;
+const fs_1 = __importDefault(require("fs"));
+function convertSrtToVtt(srtFilePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const fileStream = fs_1.default.createReadStream(srtFilePath, {
+            encoding: "utf-8"
+        });
+        let fileContents = "";
+        try {
+            for (
+                var _d = true,
+                    fileStream_1 = __asyncValues(fileStream),
+                    fileStream_1_1;
+                (fileStream_1_1 = yield fileStream_1.next()),
+                    (_a = fileStream_1_1.done),
+                    !_a;
+                _d = true
+            ) {
+                _c = fileStream_1_1.value;
+                _d = false;
+                let chunk = _c;
+                if (!fileContents && chunk[0] === "\uFEFF") {
+                    chunk = chunk.slice(1);
+                }
+                fileContents += chunk.replace(/$\r\n/gm, "\n");
+            }
+        } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+        } finally {
+            try {
+                if (!_d && !_a && (_b = fileStream_1.return))
+                    yield _b.call(fileStream_1);
+            } finally {
+                if (e_1) throw e_1.error;
+            }
+        }
+        let vttText = "WEBVTT\n";
+        const REGEX_CAPTION =
+            /(?:(\d+)\n(\d{2}:\d{2}:\d{2},\d{3} --> \d{2}:\d{2}:\d{2},\d{3}))\n((?:.+)\n?)*/g;
+        for (const groups of fileContents.matchAll(REGEX_CAPTION)) {
+            const captionIndex = groups[1];
+            const captionTime = groups[2];
+            const captionText = groups[3];
+            vttText += `\n${captionIndex}\n`;
+            vttText += `${captionTime.replace(/,/g, ".")}\n`;
+            if (captionText) {
+                vttText += `${captionText}`;
+            }
+        }
+        return vttText;
+    });
+}

package/js/src/bridge/messaging.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketMessenger =
+    exports.StdioMessenger =
+    exports.Messenger =
+        void 0;
+const tiny_typed_emitter_1 = require("tiny-typed-emitter");
+const transforms_1 = require("../transforms");
+class Messenger extends tiny_typed_emitter_1.TypedEmitter {}
+exports.Messenger = Messenger;
+class StdioMessenger extends tiny_typed_emitter_1.TypedEmitter {
+    constructor() {
+        super();
+        this.decodeTransform = new transforms_1.DecodeTransform();
+        this.encodeTransform = new transforms_1.EncodeTransform();
+        process.stdin.pipe(this.decodeTransform);
+        this.encodeTransform.pipe(process.stdout);
+        this.decodeTransform.on("error", err =>
+            console.error("err (message decode):", err)
+        );
+        this.encodeTransform.on("error", err =>
+            console.error("err (message encode):", err)
+        );
+        this.decodeTransform.on("data", message => {
+            this.emit("message", message);
+        });
+    }
+    sendMessage(message) {
+        this.send(message);
+    }
+    send(data) {
+        this.encodeTransform.write(data);
+    }
+}
+exports.StdioMessenger = StdioMessenger;
+class WebsocketMessenger extends tiny_typed_emitter_1.TypedEmitter {
+    constructor(socket) {
+        super();
+        this.socket = socket;
+        socket.on("message", message => {
+            try {
+                const parsed = JSON.parse(message);
+                this.emit("message", parsed);
+            } catch (err) {
+                socket.close();
+            }
+        });
+    }
+    sendMessage(message) {
+        this.send(message);
+    }
+    send(data) {
+        this.socket.send(JSON.stringify(data));
+    }
+}
+exports.WebsocketMessenger = WebsocketMessenger;

package/js/src/bridge/messagingTypes.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiverDeviceCapabilities = void 0;
+var ReceiverDeviceCapabilities;
+(function (ReceiverDeviceCapabilities) {
+    ReceiverDeviceCapabilities[(ReceiverDeviceCapabilities["NONE"] = 0)] =
+        "NONE";
+    ReceiverDeviceCapabilities[(ReceiverDeviceCapabilities["VIDEO_OUT"] = 1)] =
+        "VIDEO_OUT";
+    ReceiverDeviceCapabilities[(ReceiverDeviceCapabilities["VIDEO_IN"] = 2)] =
+        "VIDEO_IN";
+    ReceiverDeviceCapabilities[(ReceiverDeviceCapabilities["AUDIO_OUT"] = 4)] =
+        "AUDIO_OUT";
+    ReceiverDeviceCapabilities[(ReceiverDeviceCapabilities["AUDIO_IN"] = 8)] =
+        "AUDIO_IN";
+    ReceiverDeviceCapabilities[
+        (ReceiverDeviceCapabilities["MULTIZONE_GROUP"] = 32)
+    ] = "MULTIZONE_GROUP";
+})(
+    ReceiverDeviceCapabilities ||
+        (exports.ReceiverDeviceCapabilities = ReceiverDeviceCapabilities = {})
+);