@campoint/vxwebrtc 0.0.6 → 0.0.7

package/src/WebRtcInputConnection.ts

@@ -1,152 +0,0 @@
-import {
-  EnumWebSocketConnectionCommand,
-  EnumWebSocketConnectionDirection,
-  WebSocketReply,
-  EnumWebSocketConnectionStatus,
-} from './Types/CommonConnectionTypes';
-import WebRtcPeerConnection, { IWebRtcPeerConnectionOptions } from './WebRtcPeerConnection';
-
-const REPEATER_RETRY_COUNTER = 10;
-
-export class WebRtcInputConnection extends WebRtcPeerConnection {
-  protected connectionOptions: IWebRtcInputConnection;
-  private _peerConnectionConfig?: RTCConfiguration = undefined;
-  private _repeaterRetryCount = 0;
-  private _stream: MediaStream | undefined;
-
-  constructor(connectionOptions: IWebRtcInputConnection) {
-    super(connectionOptions);
-
-    this.connectionOptions = connectionOptions;
-    this.onRtcDescription = this.onRtcDescription.bind(this);
-    this.onWsOpen = this.onWsOpen.bind(this);
-    this.onWsMessage = this.onWsMessage.bind(this);
-    this.onError = this.onError.bind(this);
-    this.onRemoteTrack = this.onRemoteTrack.bind(this);
-  }
-
-  protected onRtcDescription(description: RTCSessionDescriptionInit) {
-    if (!this.peerConnection) {
-      return this.onError(new Error('RTC got description, but no RTC'));
-    }
-    this.peerConnection
-      .setLocalDescription(description)
-      .then(() =>
-        this.sendResponse(
-          EnumWebSocketConnectionDirection.PLAY,
-          EnumWebSocketConnectionCommand.SEND_RESPONSE,
-          description
-        )
-      )
-      .catch(this.onError);
-  }
-
-  protected onRemoteTrack(event: RTCTrackEvent): void {
-    try {
-      this._stream = event.streams[0];
-      this.connectionOptions.onTrack!(event.track.kind);
-      if (this.connectionOptions.videoElement) {
-        this.connectionOptions.videoElement.srcObject = event.streams[0];
-      }
-    } catch (error) {
-      this.onError(new Error(JSON.stringify(error ? error : '')));
-    }
-  }
-
-  protected onWsOpen(): void {
-    this.peerConnection = new RTCPeerConnection(this._peerConnectionConfig);
-    this.peerConnection.ontrack = this.onRemoteTrack;
-
-    this.sendResponse(
-      EnumWebSocketConnectionDirection.PLAY,
-      EnumWebSocketConnectionCommand.GET_OFFER
-    );
-  }
-
-  protected onWsMessage(evt: MessageEvent) {
-    const msgJson: WebSocketReply = JSON.parse(evt.data);
-    const msgStatus = parseInt(msgJson.status, 10);
-
-    if (msgStatus !== EnumWebSocketConnectionStatus.OK) {
-      this._repeaterRetryCount++;
-
-      if (this._repeaterRetryCount < REPEATER_RETRY_COUNTER) {
-        setTimeout(
-          () =>
-            this.sendResponse(
-              EnumWebSocketConnectionDirection.PLAY,
-              EnumWebSocketConnectionCommand.GET_OFFER
-            ),
-          this.connectionOptions.debounceTime
-        );
-      } else {
-        this.onError(
-          new Error('Live stream repeater timeout: ' + this.connectionOptions.streamInfo.streamName)
-        );
-        this.stop();
-      }
-    } else {
-      const sdpData = msgJson.sdp;
-      const streamInfoResponse = msgJson.streamInfo;
-
-      if (streamInfoResponse !== undefined) {
-        this.connectionOptions.streamInfo.sessionId = streamInfoResponse.sessionId;
-      }
-
-      if (sdpData && this.peerConnection) {
-        this.peerConnection
-          .setRemoteDescription(new RTCSessionDescription(sdpData))
-          .then(() => {
-            if (this.peerConnection !== undefined) {
-              return this.peerConnection
-                .createAnswer()
-                .then((description: RTCSessionDescriptionInit) =>
-                  this.onRtcDescription(description)
-                )
-                .catch(this.onError);
-            }
-          })
-          .catch(this.onError);
-      }
-
-      const iceCandidates: RTCIceCandidateInit[] = msgJson.iceCandidates;
-
-      if (iceCandidates?.length > 0 && this.peerConnection) {
-        for (const iceCandidate of iceCandidates) {
-          this.peerConnection
-            .addIceCandidate(new RTCIceCandidate(iceCandidate))
-            .catch(this.onError);
-        }
-      }
-    }
-
-    if (this.wsConnection && 'sendResponse'.localeCompare(msgJson.command) === 0) {
-      if (this.wsConnection !== null) {
-        this.wsConnection.close();
-      }
-
-      this.wsConnection = undefined;
-    }
-  }
-
-  public getStream(): MediaStream {
-    return this._stream;
-  }
-
-  public start(): void {
-    super.start();
-
-    this._repeaterRetryCount = 0;
-
-    if (this.wsConnection) {
-      this.wsConnection.onopen = this.onWsOpen;
-      this.wsConnection.onmessage = this.onWsMessage;
-    }
-  }
-}
-
-export interface IWebRtcInputConnection extends IWebRtcPeerConnectionOptions {
-  videoElement?: HTMLVideoElement;
-  onTrack?: (string) => void;
-  debounceTime: number;
-}

package/src/WebRtcOutputConnection.ts

@@ -1,153 +0,0 @@
-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 changeTrack(newTrack: MediaStreamTrack): Promise<void> {
-    if (!this.wsConnection) {
-      throw new Error('No connection open');
-    }
-
-    switch (newTrack.kind) {
-      case EnumMediaStreamTrackKind.VIDEO: {
-        if (!this.videoSender) {
-          throw new Error('No video sender available');
-        }
-
-        return this.videoSender.replaceTrack(newTrack);
-      }
-
-      case EnumMediaStreamTrackKind.AUDIO: {
-        if (!this.videoSender) {
-          throw new Error('No audio sender available');
-        }
-
-        return this.audioSender.replaceTrack(newTrack);
-      }
-
-      default: {
-        const supported = [EnumMediaStreamTrackKind.VIDEO, EnumMediaStreamTrackKind.AUDIO];
-        throw new Error(
-          `Unknown media track kind ${newTrack.kind}. Supported: ${supported.join(',')}'`
-        );
-      }
-    }
-  }
-
-  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

@@ -1,91 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-    "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

@@ -1,18 +0,0 @@
-{
-    "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

@@ -1,44 +0,0 @@
-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: 'vxWebRTC',
-        libraryTarget: 'umd',
-        path: path.resolve(__dirname, 'dist')
-    }
-};

package/webpack.dev.js

@@ -1,7 +0,0 @@
-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

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