@signalapp/ringrtc 2.23.0

package/dist/ringrtc/VideoSupport.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+interface Ref<T> {
+    readonly current: T | null;
+}
+export declare enum VideoPixelFormatEnum {
+    I420 = 0,
+    Nv12 = 1,
+    Rgba = 2
+}
+export interface VideoFrameSource {
+    receiveVideoFrame(buffer: Buffer): [number, number] | undefined;
+}
+interface VideoFrameSender {
+    sendVideoFrame(width: number, height: number, format: VideoPixelFormatEnum, buffer: Buffer): void;
+}
+export declare class GumVideoCaptureOptions {
+    maxWidth: number;
+    maxHeight: number;
+    maxFramerate: number;
+    preferredDeviceId?: string;
+    screenShareSourceId?: string;
+}
+export declare class GumVideoCapturer {
+    private defaultCaptureOptions;
+    private localPreview?;
+    private captureOptions?;
+    private sender?;
+    private mediaStream?;
+    private spawnedSenderRunning;
+    private preferredDeviceId?;
+    private updateLocalPreviewIntervalId?;
+    constructor(defaultCaptureOptions: GumVideoCaptureOptions);
+    capturing(): boolean;
+    setLocalPreview(localPreview: Ref<HTMLVideoElement> | undefined): void;
+    enableCapture(): void;
+    enableCaptureAndSend(sender: VideoFrameSender, options?: GumVideoCaptureOptions): void;
+    disable(): void;
+    setPreferredDevice(deviceId: string): Promise<void>;
+    enumerateDevices(): Promise<MediaDeviceInfo[]>;
+    private getUserMedia;
+    private startCapturing;
+    private stopCapturing;
+    private startSending;
+    private spawnSender;
+    private stopSending;
+    private updateLocalPreviewSourceObject;
+}
+export declare const MAX_VIDEO_CAPTURE_WIDTH: number;
+export declare const MAX_VIDEO_CAPTURE_HEIGHT: number;
+export declare const MAX_VIDEO_CAPTURE_AREA: number;
+export declare const MAX_VIDEO_CAPTURE_BUFFER_SIZE: number;
+export declare class CanvasVideoRenderer {
+    private canvas?;
+    private buffer;
+    private imageData?;
+    private source?;
+    private rafId?;
+    constructor();
+    setCanvas(canvas: Ref<HTMLCanvasElement> | undefined): void;
+    enable(source: VideoFrameSource): void;
+    disable(): void;
+    private requestAnimationFrameCallback;
+    private renderBlack;
+    private renderVideoFrame;
+}
+export {};

package/dist/ringrtc/VideoSupport.js

@@ -0,0 +1,421 @@
+"use strict";
+//
+// Copyright 2019-2021 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasVideoRenderer = exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE = exports.MAX_VIDEO_CAPTURE_AREA = exports.MAX_VIDEO_CAPTURE_HEIGHT = exports.MAX_VIDEO_CAPTURE_WIDTH = exports.GumVideoCapturer = exports.GumVideoCaptureOptions = exports.VideoPixelFormatEnum = void 0;
+const index_1 = require("../index");
+// Given a weird name to not conflict with WebCodec's VideoPixelFormat
+var VideoPixelFormatEnum;
+(function (VideoPixelFormatEnum) {
+    VideoPixelFormatEnum[VideoPixelFormatEnum["I420"] = 0] = "I420";
+    VideoPixelFormatEnum[VideoPixelFormatEnum["Nv12"] = 1] = "Nv12";
+    VideoPixelFormatEnum[VideoPixelFormatEnum["Rgba"] = 2] = "Rgba";
+})(VideoPixelFormatEnum = exports.VideoPixelFormatEnum || (exports.VideoPixelFormatEnum = {}));
+function videoPixelFormatFromEnum(format) {
+    switch (format) {
+        case VideoPixelFormatEnum.I420: {
+            return 'I420';
+        }
+        case VideoPixelFormatEnum.Nv12: {
+            return 'NV12';
+        }
+        case VideoPixelFormatEnum.Rgba: {
+            return 'RGBA';
+        }
+    }
+}
+function videoPixelFormatToEnum(format) {
+    switch (format) {
+        case 'I420': {
+            return VideoPixelFormatEnum.I420;
+        }
+        case 'NV12': {
+            return VideoPixelFormatEnum.Nv12;
+        }
+        case 'RGBA': {
+            return VideoPixelFormatEnum.Rgba;
+        }
+    }
+}
+class GumVideoCaptureOptions {
+    constructor() {
+        this.maxWidth = 640;
+        this.maxHeight = 480;
+        this.maxFramerate = 30;
+    }
+}
+exports.GumVideoCaptureOptions = GumVideoCaptureOptions;
+class GumVideoCapturer {
+    constructor(defaultCaptureOptions) {
+        this.spawnedSenderRunning = false;
+        this.defaultCaptureOptions = defaultCaptureOptions;
+    }
+    capturing() {
+        return this.captureOptions != undefined;
+    }
+    setLocalPreview(localPreview) {
+        var _a;
+        const oldLocalPreview = (_a = this.localPreview) === null || _a === void 0 ? void 0 : _a.current;
+        if (oldLocalPreview) {
+            oldLocalPreview.srcObject = null;
+        }
+        this.localPreview = localPreview;
+        this.updateLocalPreviewSourceObject();
+        // This is a dumb hack around the fact that sometimes the
+        // this.localPreview.current is updated without a call
+        // to setLocalPreview, in which case the local preview
+        // won't be rendered.
+        if (this.updateLocalPreviewIntervalId != undefined) {
+            clearInterval(this.updateLocalPreviewIntervalId);
+        }
+        this.updateLocalPreviewIntervalId = setInterval(this.updateLocalPreviewSourceObject.bind(this), 1000);
+    }
+    enableCapture() {
+        // tslint:disable no-floating-promises
+        this.startCapturing(this.defaultCaptureOptions);
+    }
+    enableCaptureAndSend(sender, options) {
+        // tslint:disable no-floating-promises
+        this.startCapturing(options !== null && options !== void 0 ? options : this.defaultCaptureOptions);
+        this.startSending(sender);
+    }
+    disable() {
+        this.stopCapturing();
+        this.stopSending();
+        if (this.updateLocalPreviewIntervalId != undefined) {
+            clearInterval(this.updateLocalPreviewIntervalId);
+        }
+        this.updateLocalPreviewIntervalId = undefined;
+    }
+    setPreferredDevice(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.preferredDeviceId = deviceId;
+            if (this.captureOptions) {
+                const captureOptions = this.captureOptions;
+                const sender = this.sender;
+                this.disable();
+                this.startCapturing(captureOptions);
+                if (sender) {
+                    this.startSending(sender);
+                }
+            }
+        });
+    }
+    enumerateDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield window.navigator.mediaDevices.enumerateDevices();
+            const cameras = devices.filter(d => d.kind == 'videoinput');
+            return cameras;
+        });
+    }
+    getUserMedia(options) {
+        var _a;
+        // TODO: Figure out a better way to make typescript accept "mandatory".
+        let constraints = {
+            audio: false,
+            video: {
+                deviceId: (_a = options.preferredDeviceId) !== null && _a !== void 0 ? _a : this.preferredDeviceId,
+                width: {
+                    max: options.maxWidth,
+                },
+                height: {
+                    max: options.maxHeight,
+                },
+                frameRate: {
+                    max: options.maxFramerate,
+                },
+            },
+        };
+        if (options.screenShareSourceId != undefined) {
+            constraints.video = {
+                mandatory: {
+                    chromeMediaSource: 'desktop',
+                    chromeMediaSourceId: options.screenShareSourceId,
+                    maxWidth: options.maxWidth,
+                    maxHeight: options.maxHeight,
+                    maxFrameRate: options.maxFramerate,
+                },
+            };
+        }
+        return window.navigator.mediaDevices.getUserMedia(constraints);
+    }
+    startCapturing(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.capturing()) {
+                index_1.RingRTC.logWarn('startCapturing(): already capturing');
+                return;
+            }
+            index_1.RingRTC.logInfo(`startCapturing(): ${options.maxWidth}x${options.maxHeight}@${options.maxFramerate}`);
+            this.captureOptions = options;
+            try {
+                // If we start/stop/start, we may have concurrent calls to getUserMedia,
+                // which is what we want if we're switching from camera to screenshare.
+                // But we need to make sure we deal with the fact that things might be
+                // different after the await here.
+                const mediaStream = yield this.getUserMedia(options);
+                // It's possible video was disabled, switched to screenshare, or
+                // switched to a different camera while awaiting a response, in
+                // which case we need to disable the camera we just accessed.
+                if (this.captureOptions != options) {
+                    index_1.RingRTC.logWarn('startCapturing(): different state after getUserMedia()');
+                    for (const track of mediaStream.getVideoTracks()) {
+                        // Make the light turn off faster
+                        track.stop();
+                    }
+                    return;
+                }
+                this.mediaStream = mediaStream;
+                if (!this.spawnedSenderRunning &&
+                    this.mediaStream != undefined &&
+                    this.sender != undefined) {
+                    this.spawnSender(this.mediaStream, this.sender);
+                }
+                this.updateLocalPreviewSourceObject();
+            }
+            catch (e) {
+                index_1.RingRTC.logError(`startCapturing(): ${e}`);
+                // It's possible video was disabled, switched to screenshare, or
+                // switched to a different camera while awaiting a response, in
+                // which case we should reset the captureOptions if we set them.
+                if (this.captureOptions == options) {
+                    // We couldn't open the camera.  Oh well.
+                    this.captureOptions = undefined;
+                }
+            }
+        });
+    }
+    stopCapturing() {
+        if (!this.capturing()) {
+            index_1.RingRTC.logWarn('stopCapturing(): not capturing');
+            return;
+        }
+        index_1.RingRTC.logInfo('stopCapturing()');
+        this.captureOptions = undefined;
+        if (!!this.mediaStream) {
+            for (const track of this.mediaStream.getVideoTracks()) {
+                // Make the light turn off faster
+                track.stop();
+            }
+            this.mediaStream = undefined;
+        }
+        this.updateLocalPreviewSourceObject();
+    }
+    startSending(sender) {
+        if (this.sender === sender) {
+            return;
+        }
+        if (!!this.sender) {
+            // If we're replacing an existing sender, make sure we stop the
+            // current setInterval loop before starting another one.
+            this.stopSending();
+        }
+        this.sender = sender;
+        if (!this.spawnedSenderRunning && this.mediaStream != undefined) {
+            this.spawnSender(this.mediaStream, this.sender);
+        }
+    }
+    spawnSender(mediaStream, sender) {
+        const track = mediaStream.getVideoTracks()[0];
+        if (track == undefined || this.spawnedSenderRunning) {
+            return;
+        }
+        if (track.readyState === "ended") {
+            this.stopCapturing();
+            index_1.RingRTC.logError(`spawnSender(): Video track ended before spawning sender`);
+            return;
+        }
+        const reader = new MediaStreamTrackProcessor({
+            track,
+        }).readable.getReader();
+        const buffer = Buffer.alloc(exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE);
+        this.spawnedSenderRunning = true;
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                while (sender === this.sender && mediaStream == this.mediaStream) {
+                    const { done, value: frame } = yield reader.read();
+                    if (done) {
+                        break;
+                    }
+                    if (!frame) {
+                        continue;
+                    }
+                    try {
+                        const format = videoPixelFormatToEnum((_a = frame.format) !== null && _a !== void 0 ? _a : 'I420');
+                        if (format == undefined) {
+                            index_1.RingRTC.logWarn(`Unsupported video frame format: ${frame.format}`);
+                            break;
+                        }
+                        frame.copyTo(buffer);
+                        sender.sendVideoFrame(frame.codedWidth, frame.codedHeight, format, buffer);
+                    }
+                    catch (e) {
+                        index_1.RingRTC.logError(`sendVideoFrame(): ${e}`);
+                    }
+                    finally {
+                        // This must be called for more frames to come.
+                        frame.close();
+                    }
+                }
+            }
+            catch (e) {
+                index_1.RingRTC.logError(`spawnSender(): ${e}`);
+            }
+            finally {
+                reader.releaseLock();
+            }
+            this.spawnedSenderRunning = false;
+        }))();
+    }
+    stopSending() {
+        // The spawned sender should stop
+        this.sender = undefined;
+    }
+    updateLocalPreviewSourceObject() {
+        if (!this.localPreview) {
+            return;
+        }
+        const localPreview = this.localPreview.current;
+        if (!localPreview) {
+            return;
+        }
+        const { mediaStream = null } = this;
+        if (localPreview.srcObject === mediaStream) {
+            return;
+        }
+        if (mediaStream) {
+            localPreview.srcObject = mediaStream;
+            if (localPreview.width === 0) {
+                localPreview.width = this.captureOptions.maxWidth;
+            }
+            if (localPreview.height === 0) {
+                localPreview.height = this.captureOptions.maxHeight;
+            }
+        }
+        else {
+            localPreview.srcObject = null;
+        }
+    }
+}
+exports.GumVideoCapturer = GumVideoCapturer;
+// We add 10% in each dimension to allow for things that are slightly wider or taller than 1080p.
+const MAX_VIDEO_CAPTURE_MULTIPLIER = 1.0;
+exports.MAX_VIDEO_CAPTURE_WIDTH = 1920 * MAX_VIDEO_CAPTURE_MULTIPLIER;
+exports.MAX_VIDEO_CAPTURE_HEIGHT = 1080 * MAX_VIDEO_CAPTURE_MULTIPLIER;
+exports.MAX_VIDEO_CAPTURE_AREA = exports.MAX_VIDEO_CAPTURE_WIDTH * exports.MAX_VIDEO_CAPTURE_HEIGHT;
+exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE = exports.MAX_VIDEO_CAPTURE_AREA * 4;
+class CanvasVideoRenderer {
+    constructor() {
+        this.buffer = Buffer.alloc(exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE);
+    }
+    setCanvas(canvas) {
+        this.canvas = canvas;
+    }
+    enable(source) {
+        if (this.source === source) {
+            return;
+        }
+        if (!!this.source) {
+            // If we're replacing an existing source, make sure we stop the
+            // current rAF loop before starting another one.
+            if (this.rafId) {
+                window.cancelAnimationFrame(this.rafId);
+            }
+        }
+        this.source = source;
+        this.requestAnimationFrameCallback();
+    }
+    disable() {
+        this.renderBlack();
+        this.source = undefined;
+        if (this.rafId) {
+            window.cancelAnimationFrame(this.rafId);
+        }
+    }
+    requestAnimationFrameCallback() {
+        this.renderVideoFrame();
+        this.rafId = window.requestAnimationFrame(this.requestAnimationFrameCallback.bind(this));
+    }
+    renderBlack() {
+        if (!this.canvas) {
+            return;
+        }
+        const canvas = this.canvas.current;
+        if (!canvas) {
+            return;
+        }
+        const context = canvas.getContext('2d');
+        if (!context) {
+            return;
+        }
+        context.fillStyle = 'black';
+        context.fillRect(0, 0, canvas.width, canvas.height);
+    }
+    renderVideoFrame() {
+        var _a, _b;
+        if (!this.source || !this.canvas) {
+            return;
+        }
+        const canvas = this.canvas.current;
+        if (!canvas) {
+            return;
+        }
+        const context = canvas.getContext('2d');
+        if (!context) {
+            return;
+        }
+        const frame = this.source.receiveVideoFrame(this.buffer);
+        if (!frame) {
+            return;
+        }
+        const [width, height] = frame;
+        if (canvas.clientWidth <= 0 ||
+            width <= 0 ||
+            canvas.clientHeight <= 0 ||
+            height <= 0) {
+            return;
+        }
+        const frameAspectRatio = width / height;
+        const canvasAspectRatio = canvas.clientWidth / canvas.clientHeight;
+        let dx = 0;
+        let dy = 0;
+        if (frameAspectRatio > canvasAspectRatio) {
+            // Frame wider than view: We need bars at the top and bottom
+            canvas.width = width;
+            canvas.height = width / canvasAspectRatio;
+            dy = (canvas.height - height) / 2;
+        }
+        else if (frameAspectRatio < canvasAspectRatio) {
+            // Frame narrower than view: We need pillars on the sides
+            canvas.width = height * canvasAspectRatio;
+            canvas.height = height;
+            dx = (canvas.width - width) / 2;
+        }
+        else {
+            // Will stretch perfectly with no bars
+            canvas.width = width;
+            canvas.height = height;
+        }
+        if (dx > 0 || dy > 0) {
+            context.fillStyle = 'black';
+            context.fillRect(0, 0, canvas.width, canvas.height);
+        }
+        if (((_a = this.imageData) === null || _a === void 0 ? void 0 : _a.width) !== width || ((_b = this.imageData) === null || _b === void 0 ? void 0 : _b.height) !== height) {
+            this.imageData = new ImageData(width, height);
+        }
+        this.imageData.data.set(this.buffer.subarray(0, width * height * 4));
+        context.putImageData(this.imageData, dx, dy);
+    }
+}
+exports.CanvasVideoRenderer = CanvasVideoRenderer;

package/dist/test/RingRTC-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/RingRTC-test.js

@@ -0,0 +1,71 @@
+"use strict";
+//
+// Copyright 2019-2021 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const chaiAsPromised = require("chai-as-promised");
+const index_1 = require("../index");
+(0, chai_1.use)(chaiAsPromised);
+describe('RingRTC', () => {
+    it('testsInitialization', () => {
+        chai_1.assert.isNotNull(index_1.RingRTC, "RingRTC didn't initialize!");
+    });
+    it('reports an age for expired offers', () => __awaiter(void 0, void 0, void 0, function* () {
+        const offer = {
+            offer: {
+                callId: { high: 0, low: 123 },
+                type: index_1.OfferType.AudioCall,
+                opaque: Buffer.from([]),
+            },
+            supportsMultiRing: true,
+        };
+        const age = 60 * 60;
+        try {
+            const { reason, ageSec: reportedAge } = yield new Promise((resolve, _reject) => {
+                index_1.RingRTC.handleAutoEndedIncomingCallRequest = (_callId, _remoteUserId, reason, ageSec) => {
+                    resolve({ reason, ageSec });
+                };
+                index_1.RingRTC.handleCallingMessage('remote', null, 4, 2, age, 1, offer, Buffer.from([]), Buffer.from([]));
+            });
+            chai_1.assert.equal(reason, index_1.CallEndedReason.ReceivedOfferExpired);
+            chai_1.assert.equal(reportedAge, age);
+        }
+        finally {
+            index_1.RingRTC.handleAutoEndedIncomingCallRequest = null;
+        }
+    }));
+    it('reports 0 as the age of other auto-ended offers', () => __awaiter(void 0, void 0, void 0, function* () {
+        const offer = {
+            offer: {
+                callId: { high: 0, low: 123 },
+                type: index_1.OfferType.AudioCall,
+                opaque: Buffer.from([]),
+            },
+            supportsMultiRing: true,
+        };
+        try {
+            const { reason, ageSec: reportedAge } = yield new Promise((resolve, _reject) => {
+                index_1.RingRTC.handleAutoEndedIncomingCallRequest = (_callId, _remoteUserId, reason, ageSec) => {
+                    resolve({ reason, ageSec });
+                };
+                index_1.RingRTC.handleCallingMessage('remote', null, 4, 2, 10, 2, offer, Buffer.from([]), Buffer.from([]));
+            });
+            chai_1.assert.equal(reason, index_1.CallEndedReason.Declined); // because we didn't set handleIncomingCall.
+            chai_1.assert.equal(reportedAge, 0);
+        }
+        finally {
+            index_1.RingRTC.handleAutoEndedIncomingCallRequest = null;
+        }
+    }));
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@signalapp/ringrtc",
+  "version": "2.23.0",
+  "description": "Signal Messenger voice and video calling library.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/*",
+    "scripts/fetch-prebuild.js"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "test": "electron-mocha --recursive dist/test",
+    "eslint": "eslint --cache .",
+    "lint": "yarn format --list-different && yarn eslint",
+    "format": "prettier --write \"*.{css,js,json,md,scss,ts,tsx}\" \"./**/*.{css,js,json,md,scss,ts,tsx}\"",
+    "install": "node scripts/fetch-prebuild.js",
+    "prepublishOnly": "node scripts/prepublish.js"
+  },
+  "config": {
+    "prebuildUrl": "https://build-artifacts.signal.org/libraries/ringrtc-desktop-build-v${npm_package_version}.tar.gz",
+    "prebuildChecksum": "92f2a82a2acc5b853855a17b57f31354166783ec938f2452563f07e32e263c78"
+  },
+  "author": "",
+  "license": "AGPL-3.0-only",
+  "dependencies": {
+    "tar": "^6.1.0"
+  },
+  "devDependencies": {
+    "@types/chai": "4.2.18",
+    "@types/chai-as-promised": "^7.1.3",
+    "@types/dom-mediacapture-transform": "0.1.2",
+    "@types/mocha": "5.2.7",
+    "@types/node": "14.14.37",
+    "@types/offscreencanvas": "^2019.6.4",
+    "@types/react": "16.8.5",
+    "chai": "4.3.5",
+    "chai-as-promised": "^7.1.1",
+    "electron": "15.3.2",
+    "electron-mocha": "11.0.2",
+    "eslint": "7.32.0",
+    "eslint-config-airbnb-typescript-prettier": "4.2.0",
+    "eslint-config-prettier": "6.15.0",
+    "eslint-plugin-import": "2.25.4",
+    "eslint-plugin-mocha": "9.0.0",
+    "eslint-plugin-more": "1.0.5",
+    "eslint-plugin-react": "7.28.0",
+    "mocha": "9.2.0",
+    "prettier": "^2.5.1",
+    "rimraf": "3.0.2",
+    "typescript": "4.5.2",
+    "yarn-audit-fix": "^9.2.2"
+  }
+}