@stormstreaming/stormstreamer 0.9.0-beta.0

package/dist/types/events/StormStreamerEvent.d.ts

@@ -0,0 +1,128 @@
+import { ConfigManager } from "../config/ConfigManager";
+import { PublishState } from "../playback/enum/PublishState";
+import { StormStreamer } from "../StormStreamer";
+import { InputDevice } from "../playback/model/InputDevice";
+export interface StormStreamerEvent {
+    "streamerReady": {
+        ref: StormStreamer;
+    };
+    "serverConnectionInitiate": {
+        ref: StormStreamer;
+        serverURL: string;
+    };
+    "serverConnect": {
+        ref: StormStreamer;
+        serverURL: string;
+        sequenceNum: number;
+    };
+    "serverDisconnect": {
+        ref: StormStreamer;
+        serverURL: string;
+        restart: boolean;
+        sequenceNum: number;
+    };
+    "serverConnectionError": {
+        ref: StormStreamer;
+        serverURL: string;
+        restart: boolean;
+        sequenceNum: number;
+    };
+    "allConnectionsFailed": {
+        ref: StormStreamer;
+        mode: string;
+    };
+    "interactionRequired": {
+        ref: StormStreamer;
+        mode: string;
+    };
+    "compatibilityError": {
+        ref: StormStreamer;
+        message: string;
+    };
+    "playbackForcePause": {
+        ref: StormStreamer;
+    };
+    "playbackForceMute": {
+        ref: StormStreamer;
+    };
+    "volumeChange": {
+        ref: StormStreamer;
+        volume: number;
+        muted: boolean;
+        invokedBy: "user" | "browser";
+    };
+    "videoElementCreate": {
+        ref: StormStreamer;
+        videoElement: HTMLVideoElement;
+    };
+    "containerChange": {
+        ref: StormStreamer;
+        container: HTMLElement | null;
+    };
+    "resizeUpdate": {
+        ref: StormStreamer;
+        width: number;
+        height: number;
+    };
+    "videoUnmuted": {
+        ref: StormStreamer;
+    };
+    "SSLError": {
+        ref: StormStreamer;
+        mode: string;
+    };
+    "incompatibleProtocol": {
+        ref: StormStreamer;
+        clientProtocolVer: number;
+        serverProtocolVersion: number;
+    };
+    "authorizationError": {
+        ref: StormStreamer;
+    };
+    "authorizationComplete": {
+        ref: StormStreamer;
+    };
+    "invalidLicense": {
+        ref: StormStreamer;
+    };
+    "streamConfigChange": {
+        ref: StormStreamer;
+        newConfig: ConfigManager;
+    };
+    "fullScreenEnter": {
+        ref: StormStreamer;
+    };
+    "fullScreenExit": {
+        ref: StormStreamer;
+    };
+    "noCameraFound": {
+        ref: StormStreamer;
+    };
+    "publishStateChange": {
+        ref: StormStreamer;
+        state: PublishState;
+    };
+    "noMicrophoneFound": {
+        ref: StormStreamer;
+    };
+    "deviceListUpdate": {
+        ref: StormStreamer;
+        cameraList: InputDevice[];
+        microphoneList: InputDevice[];
+    };
+    "inputDeviceError": {
+        ref: StormStreamer;
+    };
+    "inputDeviceDenied": {
+        ref: StormStreamer;
+    };
+    "streamKeyInUse": {
+        ref: StormStreamer;
+        streamKey: string | null;
+    };
+    "soundMeter": {
+        ref: StormStreamer;
+        high: number;
+        low: number;
+    };
+}

package/dist/types/events/StormStreamerListener.d.ts

@@ -0,0 +1,2 @@
+import { StormStreamerEvent } from "./StormStreamerEvent";
+export type StormStreamerListener<K extends keyof StormStreamerEvent> = [K, (ev: StormStreamerEvent[K]) => void, boolean];

package/dist/types/index.amd.d.ts

@@ -0,0 +1,10 @@
+import { StormStreamer } from "./StormStreamer";
+import { StreamerConfig } from "./types/StreamerConfig";
+export { StormStreamer } from "./StormStreamer";
+export { PublishState } from "./playback/enum/PublishState";
+export type { StreamerConfig } from "./types/StreamerConfig";
+export type { StormStreamerListener } from "./events/StormStreamerListener";
+export type { StormStreamerEvent } from "./events/StormStreamerEvent";
+export type { ScalingType } from "./config/enum/ScalingType";
+export type { Logger } from "./logger/Logger";
+export declare function create(config: StreamerConfig): StormStreamer;

package/dist/types/index.cjs.d.ts

@@ -0,0 +1,10 @@
+import { StormStreamer } from "./StormStreamer";
+import { StreamerConfig } from "./types/StreamerConfig";
+export { StormStreamer } from "./StormStreamer";
+export { PublishState } from "./playback/enum/PublishState";
+export type { StreamerConfig } from "./types/StreamerConfig";
+export type { StormStreamerListener } from "./events/StormStreamerListener";
+export type { StormStreamerEvent } from "./events/StormStreamerEvent";
+export type { ScalingType } from "./config/enum/ScalingType";
+export type { Logger } from "./logger/Logger";
+export declare function create(config: StreamerConfig): StormStreamer;

package/dist/types/index.esm.d.ts

@@ -0,0 +1,10 @@
+import { StormStreamer } from "./StormStreamer";
+import { StreamerConfig } from "./types/StreamerConfig";
+export { StormStreamer } from "./StormStreamer";
+export { PublishState } from "./playback/enum/PublishState";
+export type { StreamerConfig } from "./types/StreamerConfig";
+export type { StormStreamerListener } from "./events/StormStreamerListener";
+export type { StormStreamerEvent } from "./events/StormStreamerEvent";
+export type { ScalingType } from "./config/enum/ScalingType";
+export type { Logger } from "./logger/Logger";
+export declare function create(config: StreamerConfig): StormStreamer;

package/dist/types/index.iife.d.ts

@@ -0,0 +1,3 @@
+import { StormStreamer } from "./StormStreamer";
+import { StreamerConfig } from "./types/StreamerConfig";
+export default function (config: StreamerConfig): StormStreamer;

package/dist/types/index.umd.d.ts

@@ -0,0 +1,10 @@
+import { StormStreamer } from "./StormStreamer";
+import { StreamerConfig } from "./types/StreamerConfig";
+export { StormStreamer } from "./StormStreamer";
+export { PublishState } from "./playback/enum/PublishState";
+export type { StreamerConfig } from "./types/StreamerConfig";
+export type { StormStreamerListener } from "./events/StormStreamerListener";
+export type { StormStreamerEvent } from "./events/StormStreamerEvent";
+export type { ScalingType } from "./config/enum/ScalingType";
+export type { Logger } from "./logger/Logger";
+export declare function create(config: StreamerConfig): StormStreamer;

package/dist/types/logger/Logger.d.ts

@@ -0,0 +1,25 @@
+import { DebugData } from "../config/DebugData";
+import { StormStreamer } from "../StormStreamer";
+export declare class Logger {
+    private static INFO_COLOR;
+    private static WARNING_COLOR;
+    private static ERROR_COLOR;
+    private static SUCCESS_COLOR;
+    private static TRACE_COLOR;
+    private _debugConfig;
+    private _stormStreamer;
+    private colorOrder;
+    private _monoColor;
+    private _logMemory;
+    private _streamerInstanceID;
+    constructor(config: DebugData, stormStreamer: StormStreamer);
+    info(objectName: any, message: string): void;
+    warning(objectName: any, message: string): void;
+    error(objectName: any, message: string): void;
+    success(objectName: any, message: string): void;
+    trace(objectName: any, message: string): void;
+    private logData;
+    private writeToContainer;
+    setPlayerID(playerID: number): void;
+    getAllLogs(): Array<string>;
+}

package/dist/types/model/AbstractSourceItem.d.ts

@@ -0,0 +1,9 @@
+import { ProtocolType } from "../config/enum/ProtocolType";
+import { StreamInfo } from "./StreamInfo";
+export declare class AbstractSourceItem {
+    protected type: ProtocolType;
+    protected streamInfo: StreamInfo;
+    constructor(type: ProtocolType, info: StreamInfo);
+    getType(): ProtocolType;
+    getStreamInfo(): StreamInfo;
+}

package/dist/types/model/ClientUser.d.ts

@@ -0,0 +1,6 @@
+export declare class ClientUser {
+    private bandwidthCapabilities;
+    constructor();
+    setBandwidthCapabilities(newCapabilities: number): void;
+    getBandwidthCapabilities(): number;
+}

package/dist/types/model/GatewayServerItem.d.ts

@@ -0,0 +1,17 @@
+import { IServerItem } from "./IServerItem";
+export declare class GatewayServerItem implements IServerItem {
+    private host;
+    private application;
+    private port;
+    private isSSL;
+    private hasFaild;
+    constructor(host: string, application: string, port?: number, isSSL?: boolean);
+    getHost(): string;
+    getPort(): number;
+    getIfSSL(): boolean;
+    getIfFaild(): boolean;
+    setAsFaild(value: boolean): void;
+    getApplication(): string;
+    getData(): any;
+    toString(): string;
+}

package/dist/types/model/IServerItem.d.ts

@@ -0,0 +1,9 @@
+export interface IServerItem {
+    getHost(): string;
+    getApplication(): string;
+    getPort(): number;
+    getIfSSL(): boolean;
+    getIfFaild(): boolean;
+    setAsFaild(value: boolean): void;
+    toString(): string;
+}

package/dist/types/model/ISourceItem.d.ts

@@ -0,0 +1,8 @@
+import { ProtocolType } from "../config/enum/ProtocolType";
+import { StreamInfo } from "./StreamInfo";
+export interface ISourceItem {
+    getType(): ProtocolType;
+    getStreamInfo(): StreamInfo;
+    getStreamKey(): string;
+    toString(): string;
+}

package/dist/types/model/IStreamItem.d.ts

@@ -0,0 +1,8 @@
+import { ProtocolType } from "../config/enum/ProtocolType";
+export interface IStreamItem {
+    getType(): ProtocolType;
+    getStreamName(): string;
+    getHost(): string;
+    getApplicationName(): string;
+    toString(): string;
+}

package/dist/types/model/QualityItem.d.ts

@@ -0,0 +1,17 @@
+export declare class QualityItem {
+    private _id;
+    private _label;
+    private _monogram;
+    private _isSelected;
+    private _isAuto;
+    constructor(id: number, label: string, monogram: string);
+    getIfSelected(): boolean;
+    setIfSelected(newValue: boolean): void;
+    getLabel(): string;
+    setLabel(newValue: string): void;
+    getID(): number;
+    getMonogram(): string;
+    setMonogram(newValue: string): void;
+    getIfAuto(): boolean;
+    setIfAuto(newValue: boolean): void;
+}

package/dist/types/model/RTMPSourceItem.d.ts

@@ -0,0 +1,17 @@
+import { AbstractSourceItem } from "./AbstractSourceItem";
+import { ISourceItem } from "./ISourceItem";
+import { StreamInfo } from "./StreamInfo";
+export declare class RTMPSourceItem extends AbstractSourceItem implements ISourceItem {
+    private host;
+    private application;
+    private streamKey;
+    private port;
+    private defaultSource;
+    constructor(host: string, application: string, streamKey: string, port: number, streamInfo: StreamInfo, defaultSource: boolean);
+    getHost(): string;
+    getPort(): number;
+    getApplicationName(): string;
+    getStreamKey(): string;
+    isDefaultSource(): boolean;
+    toString(): string;
+}

package/dist/types/model/RTSPSourceItem.d.ts

@@ -0,0 +1,17 @@
+import { AbstractSourceItem } from "./AbstractSourceItem";
+import { ISourceItem } from "./ISourceItem";
+import { StreamInfo } from "./StreamInfo";
+export declare class RTSPSourceItem extends AbstractSourceItem implements ISourceItem {
+    private host;
+    private application;
+    private streamKey;
+    private port;
+    private defaultSource;
+    constructor(host: string, application: string, streamKey: string, port: number, streamInfo: StreamInfo, defaultSource: boolean);
+    getHost(): string;
+    getPort(): number;
+    getApplicationName(): string;
+    getStreamKey(): string;
+    isDefaultSource(): boolean;
+    toString(): string;
+}

package/dist/types/model/StormMetaDataItem.d.ts

@@ -0,0 +1,44 @@
+export declare class StormMetaDataItem {
+    private videoWidth;
+    private videoHeight;
+    private videoTimeScale;
+    private constantFrameRate;
+    private videoDataRate;
+    private frameRate;
+    private encoder;
+    private audioCodec;
+    private videoCodec;
+    private audioChannels;
+    private audioSampleRate;
+    private audioSampleSize;
+    private audioDataRate;
+    MetaDataItem(): void;
+    setVideoWidth(width: number): void;
+    setVideoHeight(height: number): void;
+    setIfConstantFrameRate(constantFrameRate: boolean): void;
+    setEncoder(encoder: string): void;
+    setAudioCodec(audioCodec: string): void;
+    setVideoDataRate(videoDataRate: number): void;
+    setAudioCodecID(audioCodecID: number): void;
+    setVideoCodec(videoCodec: string): void;
+    setVideoCodecID(videoCodecID: number): void;
+    setAudioChannels(audioChannels: number): void;
+    setAudioSampleRate(audioSampleRate: number): void;
+    setAudioSampleSize(audioSampleSize: number): void;
+    setAudioDataRate(audioDataRate: number): void;
+    setVideoTimeScale(videoTimeScale: number): void;
+    setFrameRate(fps: number): void;
+    getVideoWidth(): number;
+    getVideoHeight(): number;
+    isVariableFPS(): boolean;
+    getNominalFPS(): number;
+    getEncoder(): string;
+    getAudioCodec(): string;
+    getVideoCodec(): string;
+    getAudioChannels(): number;
+    getAudioSampleRate(): number;
+    getAudioSampleSize(): number;
+    getAudioDataRate(): number;
+    getVideoTimeScale(): number;
+    toString(): string;
+}

package/dist/types/model/StormServerItem.d.ts

@@ -0,0 +1,17 @@
+import { IServerItem } from "./IServerItem";
+export declare class StormServerItem implements IServerItem {
+    private host;
+    private application;
+    private port;
+    private isSSL;
+    private hasFaild;
+    constructor(host: string, application: string, port?: number, isSSL?: boolean);
+    getHost(): string;
+    getApplication(): string;
+    getPort(): number;
+    getIfSSL(): boolean;
+    getIfFaild(): boolean;
+    setAsFaild(value: boolean): void;
+    getData(): any;
+    toString(): string;
+}

package/dist/types/model/StormSourceItem.d.ts

@@ -0,0 +1,11 @@
+import { AbstractSourceItem } from "./AbstractSourceItem";
+import { ISourceItem } from "./ISourceItem";
+import { StreamInfo } from "./StreamInfo";
+export declare class StormSourceItem extends AbstractSourceItem implements ISourceItem {
+    private streamKey;
+    private defaultSource;
+    constructor(streamKey: string, streamInfo: StreamInfo, defaultSource: boolean);
+    getStreamKey(): string;
+    isDefaultSource(): boolean;
+    toString(): string;
+}

package/dist/types/model/StreamInfo.d.ts

@@ -0,0 +1,17 @@
+export declare class StreamInfo {
+    private label;
+    private monogram;
+    private width;
+    private height;
+    private fps;
+    private bitrate;
+    constructor(config: any);
+    assignMonogram(): void;
+    getLabel(): string;
+    getMonogram(): string;
+    getWidth(): number;
+    getHeight(): number;
+    getFPS(): number;
+    getBitrate(): number;
+    toString(): string;
+}

package/dist/types/network/AbstractSocket.d.ts

@@ -0,0 +1,26 @@
+import { ConnectionState } from "../playback/enum/ConnectionState";
+import { Logger } from "../logger/Logger";
+export declare class AbstractSocket {
+    protected readonly CONNECTION_TIMEOUT: number;
+    protected _logger: Logger;
+    protected socket: WebSocket;
+    protected socketURL: string;
+    protected isBinary: boolean;
+    protected _connectionState: ConnectionState;
+    protected _messageCount: number;
+    protected _connectionTimeout: any;
+    protected _disconnectedByUser: boolean;
+    protected _isConnected: boolean;
+    protected _sequenceNumber: number;
+    startConnection(): void;
+    protected onSocketOpen(event: Event): void;
+    protected onSocketClose(event: CloseEvent): void;
+    protected onSocketMessage(event: MessageEvent): void;
+    protected onSocketError(event: Event): void;
+    protected onError(error: string): void;
+    sendData(data: any): void;
+    getConnectionState(): ConnectionState;
+    disconnect(byUser?: boolean): void;
+    protected destroy(): void;
+    getSocketURL(): string;
+}

package/dist/types/network/NetworkController.d.ts

@@ -0,0 +1,20 @@
+import { WowzaConnection } from "./WowzaConnection";
+import { Logger } from "../logger/Logger";
+import { StormStreamer } from "../StormStreamer";
+export declare class NetworkController {
+    private readonly _main;
+    private _connection;
+    protected _logger: Logger;
+    private _currentStreamKey;
+    private _lastState;
+    constructor(main: StormStreamer);
+    initialize(): void;
+    start(): void;
+    stop(): void;
+    private onServerConnect;
+    private onServerDisconnect;
+    onMessage: (event: MessageEvent) => void;
+    sendMessage(message: String): void;
+    getConnection(): WowzaConnection;
+    getCurrentStreamKey(): string;
+}

package/dist/types/network/StormPacket.d.ts

@@ -0,0 +1,93 @@
+export interface ServerHandshakePacket {
+    branch: string;
+    group: string;
+    license: string;
+    name: string;
+    protocolVer: number;
+    serverTime: number;
+    version: string;
+}
+export interface AppDataPacket {
+    name: string;
+    tokenRequired: boolean;
+    dvrEnabled: boolean;
+    type: string;
+}
+export interface AppAuthPacket {
+    command: string;
+    token: boolean;
+    userAgent: boolean;
+    uniq: string;
+    domain: string;
+}
+export interface AuthResultPacket {
+    answer: string;
+    reason?: string;
+}
+export interface PlayRequestPacket {
+    protocol: string;
+    streamKey: string;
+    subscriptionKey: string;
+    extApplication?: string;
+    extPort?: number;
+    extHost?: string;
+    startTime: number;
+    packetizer: string;
+}
+export interface PlayResultPacket {
+    reason?: string;
+    status: string;
+    streamState?: string;
+    streamKey: string;
+}
+export interface PlaybackMetadataPacket {
+    audioCodecID: number;
+    audioDataRate: number;
+    audioSampleRate: number;
+    audioSampleSize: number;
+    encoder: string;
+    frameRate?: number;
+    constFrameRate: boolean;
+    videoHeight: number;
+    videoWidth: number;
+    videoCodecID: number;
+    videoDataRate: number;
+    width: number;
+    audioChannels: number;
+}
+export interface PlaybackStopPacket {
+    newState: string;
+}
+export interface PlaybackLinkingPacket {
+    path: string;
+}
+export interface SubscribeRequestPacket {
+    streamKey: string;
+}
+export interface UnsubscribeRequestPacket {
+    streamKey: string;
+}
+export interface LatencyReportPacket {
+    streamKey: string;
+    latency: number;
+}
+export interface SubscriptionResultPacket {
+    reason?: string;
+    status: string;
+    streamState: string;
+    optParameters: any;
+    streamList?: any;
+    streamKey: string;
+}
+export interface SubscriptionUpdatePacket {
+    streamKey: string;
+    streamState: string;
+    streamList?: any;
+}
+export interface PlaybackProgressPacket {
+    streamDuration: number;
+    streamStartTime: number;
+    playbackStartTime: number;
+    playbackDuration: number;
+    dvrCacheSize: number;
+}

package/dist/types/network/WowzaConnection.d.ts

@@ -0,0 +1,22 @@
+import { AbstractSocket } from "./AbstractSocket";
+import { StormServerItem } from "../model/StormServerItem";
+import { NetworkController } from "./NetworkController";
+import { StormStreamer } from "../StormStreamer";
+export declare class WowzaConnection extends AbstractSocket {
+    private readonly _main;
+    private readonly _networkController;
+    private _currServer;
+    private _reconnectTimer;
+    constructor(main: StormStreamer, networkController: NetworkController);
+    initialize(): void;
+    protected onSocketOpen(event: Event): void;
+    protected onSocketError(event: Event): void;
+    protected onSocketClose(event: CloseEvent): void;
+    protected onSocketMessage(event: MessageEvent): void;
+    private createURL;
+    private initiateReconnect;
+    private pickServerFromList;
+    isConnectionActive(): boolean;
+    getCurrentServer(): StormServerItem | null;
+    destroy(): void;
+}

package/dist/types/playback/CooldownMonitor.d.ts

@@ -0,0 +1,9 @@
+export declare class CooldownMonitor {
+    private cooldownDuration;
+    private lastCooldownTime;
+    constructor(cooldownDuration?: number);
+    triggerCooldown(): void;
+    setCooldownDuration(newTime: number): void;
+    isCooling(): boolean;
+    reset(): void;
+}

package/dist/types/playback/PlaybackController.d.ts

@@ -0,0 +1,54 @@
+import { Logger } from "../logger/Logger";
+import { IPlayer } from "./player/IPlayer";
+import { StormStreamer } from "../StormStreamer";
+import { InputDevice } from "./model/InputDevice";
+import { PublishState } from "./enum/PublishState";
+export declare class PlaybackController {
+    private readonly _main;
+    protected _logger: Logger;
+    private _selectedPlayer;
+    private _isWindowActive;
+    private _peerConnection;
+    private _peerConnectionConfig;
+    private _mungeSDP;
+    private _selectedCamera;
+    private _selectedMicrophone;
+    private _isMicrophoneMuted;
+    private _cameraList;
+    private _microphoneList;
+    private _stream;
+    private _soundMeter;
+    private _constraints;
+    protected _publishState: PublishState;
+    constructor(main: StormStreamer);
+    initialize(): void;
+    private startWebRTC;
+    publish(streamKey: string): void;
+    unpublish(): void;
+    private onUserMediaSuccess;
+    onUserMediaError(error: any): void;
+    onSocketMessage(data: any): void;
+    private onConnectionStateChange;
+    private onServerDisconnect;
+    grabDevices(): void;
+    selectCamera(cameraID: string): void;
+    selectMicrophone(micID: string): void;
+    private pickCamera;
+    private pickMicrophone;
+    muteMicrophone(microphoneState: boolean): void;
+    private onServerConnect;
+    private onDescriptionError;
+    private onDescriptionSuccess;
+    private onIceCandidate;
+    private closeStream;
+    private visibilityChange;
+    private onWindowBlur;
+    private onWindowFocus;
+    getCurrentCamera(): InputDevice | null;
+    getCurrentMicrophone(): InputDevice | null;
+    setPublishState(newState: PublishState): void;
+    getCameraList(): InputDevice[];
+    getMicrophoneList(): InputDevice[];
+    getPlayer(): IPlayer | null;
+    destroy(): void;
+}

package/dist/types/playback/SoundMeter.d.ts

@@ -0,0 +1,17 @@
+import { StormStreamer } from "../StormStreamer";
+export declare class SoundMeter {
+    private _main;
+    private _stream;
+    private _instant;
+    private _slow;
+    private clip;
+    private audioContext;
+    private script;
+    private microphone;
+    private processor;
+    constructor(main: StormStreamer);
+    attach(stream: MediaStream): void;
+    detach(): void;
+    private clear;
+    onAudioProcess(event: any): void;
+}