@campoint/vxwebrtc 0.0.2

package/src/WebRtcOutputConnection.ts

@@ -0,0 +1,122 @@
+import adapter from 'webrtc-adapter';
+import { mungeSdpPublish } from './MungeSdp';
+import {
+  EnumMediaStreamTrackKind,
+  EnumWebSocketConnectionCommand,
+  EnumWebSocketConnectionDirection,
+  EnumWebSocketConnectionStatus,
+  MediaInfo,
+  WebSocketReply,
+} from './Types/CommonConnectionTypes';
+import WebRtcPeerConnection, { IWebRtcPeerConnectionOptions } from './WebRtcPeerConnection';
+
+export class WebRtcOutputConnection extends WebRtcPeerConnection {
+  protected connectionOptions: IWebRtcOutputConnection;
+  protected wsConnection?: WebSocket = undefined;
+  protected peerConnection?: RTCPeerConnection = undefined;
+  private peerConnectionConfig?: RTCConfiguration = undefined;
+  private videoSender?: RTCRtpSender = undefined;
+  private audioSender?: RTCRtpSender = undefined;
+
+  constructor(connectionOptions: IWebRtcOutputConnection) {
+    super(connectionOptions);
+
+    this.onError = this.onError.bind(this);
+    this.onRtcDescription = this.onRtcDescription.bind(this);
+    this.onWsOpen = this.onWsOpen.bind(this);
+    this.onWsMessage = this.onWsMessage.bind(this);
+    this.connectionOptions = connectionOptions;
+  }
+
+  protected onRtcDescription(description: RTCSessionDescriptionInit) {
+    if (!this.peerConnection) {
+      return this.onError(new Error('RTC got description, but no RTC'));
+    }
+
+    if (description.sdp && adapter.browserDetails.browser !== 'safari') {
+      description.sdp = mungeSdpPublish(
+        description.sdp ? description.sdp : '',
+        this.connectionOptions.mediaInfo
+      );
+    }
+
+    this.peerConnection
+      .setLocalDescription(description)
+      .then(() => {
+        this.sendResponse(
+          EnumWebSocketConnectionDirection.PUBLISH,
+          EnumWebSocketConnectionCommand.SEND_OFFER,
+          description
+        );
+      })
+      .catch(this.onError);
+  }
+
+  protected onWsOpen() {
+    this.peerConnection = new RTCPeerConnection(this.peerConnectionConfig);
+    this.videoSender = undefined;
+    this.audioSender = undefined;
+
+    this.peerConnection.onnegotiationneeded = () => {
+      if (this.peerConnection) {
+        this.peerConnection.createOffer().then(this.onRtcDescription, this.onError);
+      }
+    };
+
+    const localTracks = this.connectionOptions.localStream.getTracks();
+
+    for (const localTrack of localTracks) {
+      const sender = this.peerConnection.addTrack(localTrack, this.connectionOptions.localStream);
+
+      if (localTrack.kind === EnumMediaStreamTrackKind.AUDIO) {
+        this.audioSender = sender;
+      } else if (localTrack.kind === EnumMediaStreamTrackKind.VIDEO) {
+        this.videoSender = sender;
+      }
+    }
+  }
+
+  protected onWsMessage(evt: MessageEvent) {
+    const msgJson: WebSocketReply = JSON.parse(evt.data);
+    const msgStatus = parseInt(msgJson.status, 10);
+
+    if (msgStatus !== EnumWebSocketConnectionStatus.OK) {
+      return this.onError(new Error(msgJson.statusDescription));
+    }
+
+    const sdpData = msgJson.sdp;
+
+    if (sdpData && this.peerConnection) {
+      this.peerConnection
+        .setRemoteDescription(new RTCSessionDescription(sdpData))
+        .catch(this.onError);
+    }
+
+    const iceCandidates = msgJson.iceCandidates;
+
+    if (iceCandidates !== undefined && this.peerConnection) {
+      for (const iceCandidate of iceCandidates) {
+        this.peerConnection.addIceCandidate(new RTCIceCandidate(iceCandidate)).catch(this.onError);
+      }
+    }
+  }
+
+  public start() {
+    super.start();
+    if (this.wsConnection) {
+      this.wsConnection.onopen = this.onWsOpen;
+      this.wsConnection.onmessage = this.onWsMessage;
+    }
+  }
+
+  public stop() {
+    super.stop();
+    this.videoSender = undefined;
+    this.audioSender = undefined;
+  }
+}
+
+export interface IWebRtcOutputConnection extends IWebRtcPeerConnectionOptions {
+  localStream: MediaStream;
+  mediaInfo: MediaInfo;
+}

package/src/WebRtcPeerConnection.ts

@@ -0,0 +1,91 @@
+import {
+  OnErrorCallback,
+  OnStopCallback,
+  StreamInfo,
+  EnumWebSocketConnectionCommand,
+  EnumWebSocketConnectionDirection,
+} from './Types/CommonConnectionTypes';
+
+abstract class WebRtcPeerConnection {
+  protected wsConnection?: WebSocket = undefined;
+  protected peerConnection?: RTCPeerConnection = undefined;
+
+  protected abstract onRtcDescription(description: RTCSessionDescriptionInit): void;
+  protected abstract onWsOpen(): void;
+  protected abstract onWsMessage(evt: MessageEvent): void;
+
+  protected constructor(protected connectionOptions: IWebRtcPeerConnectionOptions) {
+    this.connectionOptions = connectionOptions;
+    this.connectToWebSocket = this.connectToWebSocket.bind(this);
+    this.onError = this.onError.bind(this);
+  }
+
+  protected sendResponse(
+    direction: EnumWebSocketConnectionDirection,
+    command: EnumWebSocketConnectionCommand,
+    description?: RTCSessionDescriptionInit
+  ) {
+    if (this.wsConnection) {
+      let json = {
+        direction: direction,
+        command: command,
+        streamInfo: this.connectionOptions.streamInfo,
+        userData: this.connectionOptions.userData,
+      };
+
+      if (description !== undefined) {
+        json = { ...json, ...{ sdp: description } };
+      }
+
+      this.wsConnection.send(JSON.stringify(json));
+    }
+  }
+
+  protected connectToWebSocket() {
+    this.wsConnection = new WebSocket(this.connectionOptions.wsUrl);
+    this.wsConnection.binaryType = 'arraybuffer';
+    this.wsConnection.onerror = () => this.onError(new Error('WsConnection failed'));
+  }
+
+  protected onError(error: Error) {
+    this.stop();
+    this.connectionOptions.onError(error);
+  }
+
+  public start() {
+    if (!this.peerConnection) {
+      if (this.wsConnection) {
+        this.wsConnection.close();
+        this.wsConnection = undefined;
+      }
+
+      this.connectToWebSocket();
+    }
+  }
+
+  public stop() {
+    if (this.peerConnection) {
+      this.peerConnection.close();
+    }
+
+    this.peerConnection = undefined;
+
+    if (this.wsConnection) {
+      this.wsConnection.close();
+    }
+
+    this.wsConnection = undefined;
+
+    this.connectionOptions.onStop();
+  }
+}
+
+export interface IWebRtcPeerConnectionOptions {
+  wsUrl: string;
+  streamInfo: StreamInfo;
+  userData?: object;
+  onStop: OnStopCallback;
+  onError: OnErrorCallback;
+}
+
+export default WebRtcPeerConnection;

package/src/browserSupportedAudioCodec.ts

@@ -0,0 +1,49 @@
+import adapter from 'webrtc-adapter';
+import { EnumCodecContentType } from './Types/EnumCodecContentType';
+import { supportsCodec } from './utils';
+
+export enum EnumAudioCodecs {
+  OPUS = 'opus',
+  VORBIS = 'vorbis',
+  PCMU = 'pcmu',
+  PCMA = 'pcma',
+}
+
+/** @see CanPlayTypeResult */
+export enum EnumMediaCodecSupported {
+  UNKNOWN = '',
+  PROBABLY = 'probably',
+  MAYBE = 'maybe',
+}
+
+export const browserSupportedAudioCodec = (codecs: string[]) => {
+  const isSafari = adapter.browserDetails.browser === 'safari';
+
+  for (let i = 0; i < codecs.length; i++) {
+    const codec = codecs[i];
+
+    switch (codec) {
+      case EnumAudioCodecs.OPUS:
+        if (
+          isSafari ||
+          supportsCodec(EnumCodecContentType.OPUS) === EnumMediaCodecSupported.PROBABLY
+        ) {
+          return EnumAudioCodecs.OPUS;
+        }
+        break;
+
+      case EnumAudioCodecs.VORBIS:
+        if (supportsCodec(EnumCodecContentType.VORBIS) === EnumMediaCodecSupported.PROBABLY) {
+          return EnumAudioCodecs.VORBIS;
+        }
+        break;
+
+      // could not find a way to check the support of this codec in the browser
+      case EnumAudioCodecs.PCMU:
+      case EnumAudioCodecs.PCMA:
+        break;
+    }
+  }
+
+  return '';
+};

package/src/browserSupportedVideoCodec.ts

@@ -0,0 +1,39 @@
+import * as _ from 'lodash';
+import { EnumCodecContentType } from './Types/EnumCodecContentType';
+import { EnumVideoCodec } from './Types/CommonConnectionTypes';
+import { supportsCodec } from './utils';
+
+export enum EnumVideoCodecs {
+  H264 = 'h264',
+  VP9 = 'VP9',
+  VP8 = 'VP8',
+}
+
+export const browserSupportedVideoCodec = (codecs: string[]) => {
+  for (let i = 0; i < codecs.length; i++) {
+    const codec = codecs[i];
+
+    switch (codec) {
+      case EnumVideoCodecs.H264:
+        /** @note codec is re-named here on purpose to make Wowza server happy */
+        if (!_.isEmpty(supportsCodec(EnumCodecContentType.H264))) {
+          return EnumVideoCodec.H264;
+        }
+        break;
+
+      case EnumVideoCodecs.VP9:
+        if (!_.isEmpty(supportsCodec(EnumCodecContentType.VP9))) {
+          return EnumVideoCodecs.VP9;
+        }
+        break;
+
+      case EnumVideoCodecs.VP8:
+        if (!_.isEmpty(supportsCodec(EnumCodecContentType.VP8))) {
+          return EnumVideoCodecs.VP8;
+        }
+        break;
+    }
+  }
+
+  return '';
+};

package/src/utils.ts

@@ -0,0 +1,18 @@
+import * as _ from 'lodash';
+import { EnumCodecContentType } from './Types/EnumCodecContentType';
+
+export enum EnumSupportedMediaType {
+  VIDEO = 'video',
+  AUDIO = 'audio',
+}
+
+export const supportsCodec = (codecType: EnumCodecContentType): CanPlayTypeResult => {
+  const mediaType = codecType.split('/');
+
+  if (!_.includes(Object.values(EnumSupportedMediaType), mediaType[0])) {
+    return '';
+  }
+
+  const v = window.document.createElement(mediaType[0]) as HTMLMediaElement;
+  return v.canPlayType(codecType);
+};

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '__VERSION__';

package/src/vxwebrtc.ts

@@ -0,0 +1,8 @@
+export { WebRtcInputConnection, IWebRtcInputConnection } from './WebRtcInputConnection';
+export { WebRtcOutputConnection, IWebRtcOutputConnection } from './WebRtcOutputConnection';
+
+export { TWebRtcH264CodecOptions, TWebRtcVP9CodecOptions } from './Types/CodecsOptions';
+export { TConstrainULongRange } from './Types/WebRTCStreamConfig';
+
+export {browserSupportedAudioCodec} from './browserSupportedAudioCodec'
+export {browserSupportedVideoCodec} from './browserSupportedVideoCodec'

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "lib": ["dom", "es5", "scripthost", "ES2015", "es2016.array.include"],
+        "target": "es5",
+        "moduleResolution": "node",
+        "sourceMap": true,
+        "declaration": true,
+        "newLine": "LF",
+        "outDir": "./dist",
+        "rootDirs": ["src"],
+        "allowJs": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "**/*.spec.ts"]
+}

package/tslint.json

@@ -0,0 +1,18 @@
+{
+    "defaultSeverity": "warning",
+    "extends": [
+        "tslint:recommended"
+    ],
+    "jsRules": {},
+    "rules": {
+        "interface-name": [false],
+        "max-line-length": [false],
+        "no-empty": [false],
+        "object-literal-shorthand": [false],
+        "object-literal-sort-keys": [true, "match-declaration-order"],
+        "quotemark": [true, "single", "avoid-escape", "avoid-template"],
+        "trailing-comma": [true, {"multiline": "never", "singleline": "never"}],
+        "variable-name": { "options": [ "check-format", "allow-leading-underscore", "allow-pascal-case", "ban-keywords" ] }
+    },
+    "rulesDirectory": []
+}

package/webpack.common.js

@@ -0,0 +1,43 @@
+const path = require('path');
+const { CleanWebpackPlugin } = require('clean-webpack-plugin');
+const DuplicatePackageCheckerPlugin = require('duplicate-package-checker-webpack-plugin');
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+
+module.exports = {
+    entry: {
+        'vxwebrtc': './src/vxwebrtc.ts',
+    },
+    plugins: [
+        new CleanWebpackPlugin(),
+        new DuplicatePackageCheckerPlugin(),
+        new BundleAnalyzerPlugin({
+            analyzerMode: 'disabled',
+            generateStatsFile: true,
+        }),
+    ],
+    module: {
+        rules: [
+            {
+                test: /version.ts$/,
+                loader: 'string-replace-loader',
+                options: {
+                    search: '__VERSION__',
+                    replace: require('./package.json').version,
+                },
+            },
+            {
+                test: /\.tsx?$/,
+                use: 'ts-loader',
+                exclude: /node_modules/,
+            },
+        ],
+    },
+    resolve: {
+        extensions: ['.tsx', '.ts', '.js'],
+    },
+    output: {
+        filename: '[name].js',
+        library: 'webRTC',
+        path: path.resolve(__dirname, 'dist'),
+    }
+};

package/webpack.dev.js

@@ -0,0 +1,7 @@
+const { merge } = require('webpack-merge');
+const common = require('./webpack.common.js');
+
+module.exports = merge(common, {
+    mode: 'development',
+    devtool: 'inline-source-map'
+});

package/webpack.prod.js

@@ -0,0 +1,7 @@
+const { merge } = require('webpack-merge');
+const common = require('./webpack.common.js');
+
+module.exports = merge(common, {
+    mode: 'production',
+    devtool: 'source-map'
+});