@livedigital/client 3.50.0 → 3.51.0

package/dist/inversify.tokens.d.ts

@@ -10,7 +10,12 @@ export declare enum TOKEN {
     ChannelAudioObserverMissingProducerRestorer = "ChannelAudioObserverMissingProducerRestorer",
     ChannelStateSynchronizer = "ChannelStateSynchronizer",
     ChannelStateSyncEventHandler = "ChannelStateSyncEventHandler",
+    CompositeStatsParser = "CompositeStatsParser",
+    PeriodicStatsReporter = "PeriodicStatsReporter",
+    WIDIgnoreSsrcList = "WIDIgnoreSsrcList",
     WebRTCIssueDetector = "WebRTCIssueDetector",
+    WIDStatsAdapter = "WIDStatsAdapter",
+    ScoresCalculator = "ScoresCalculator",
     LoggerFactory = "LoggerFactory",
     MediaStreamTrackManager = "MediaStreamTrackManager",
     EventsQueue = "EventsQueue",

package/dist/qoe/ScoresCalculator.d.ts

@@ -0,0 +1,11 @@
+import type { AudioStreamStats, VideoStreamStats, ScoresCalculatorConfig, DeviceType } from './types';
+export declare class ScoresCalculator {
+    private readonly config;
+    constructor(config?: ScoresCalculatorConfig);
+    calculateAudioMOS(stats: Partial<AudioStreamStats>): number;
+    calculateVideoMOS(stats: Partial<VideoStreamStats>): number;
+    calculateAVCompositeMOS(Qa: number, Qv: number, deviceType?: DeviceType): number;
+    private mergeConfig;
+    private normalizeAudioStats;
+    private normalizeVideoStats;
+}

package/dist/qoe/WIDStatsAdapter.d.ts

@@ -0,0 +1,10 @@
+import type { AdaptInboundAudioStatsPayload, AdaptInboundVideoStatsPayload, AdaptOutboundAudioStatsPayload, AdaptOutboundVideoStatsPayload, AudioStreamStats, VideoStreamStats } from './types';
+export declare class WIDStatsAdapter {
+    adaptInboundAudioStats(payload: AdaptInboundAudioStatsPayload): AudioStreamStats;
+    adaptInboundVideoStats(payload: AdaptInboundVideoStatsPayload): VideoStreamStats;
+    adaptOutboundAudioStats(payload: AdaptOutboundAudioStatsPayload): AudioStreamStats;
+    adaptOutboundVideoStats(payload: AdaptOutboundVideoStatsPayload): VideoStreamStats;
+    private calculateDeltaPacketLoss;
+    private calculateDeltaAverageQP;
+    private calculateJitterBufferDelay;
+}

package/dist/qoe/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SCORE_PRECISION = 2;
+export declare const MOS_MIN_VAL = 1;
+export declare const MOS_MAX_VAL = 5;
+export declare const MS_IN_SEC = 1000;
+export declare const INBOUND_Q_PERCENTILE = 0.5;

package/dist/qoe/helpers.d.ts

@@ -0,0 +1,7 @@
+export declare function findStatsBySsrc<T extends {
+    ssrc: number;
+}>(ssrc: number, statsItems: T[]): T | undefined;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function toPrecision(num: number, precision?: number): number;
+export declare function prepareScore(score: number): number;
+export declare function linearPercentile(sorted: number[], percentile: number): number;

package/dist/qoe/types.d.ts

@@ -0,0 +1,112 @@
+import type { ParsedConnectionStats, ParsedInboundAudioStreamStats, ParsedInboundVideoStreamStats, ParsedOutboundAudioStreamStats, ParsedOutboundVideoStreamStats, ParsedRemoteInboundStreamStats } from 'webrtc-issue-detector';
+export interface AudioStreamStats {
+    ssrc: number;
+    packetLoss: number;
+    bitrate: number;
+    roundTripTime: number;
+    bufferDelay: number;
+    fec: boolean;
+    dtx: boolean;
+}
+export interface VideoStreamStats {
+    ssrc: number;
+    packetLoss: number;
+    bitrate: number;
+    roundTripTime: number;
+    bufferDelay: number;
+    codec?: string;
+    width: number;
+    height: number;
+    expectedWidth: number;
+    expectedHeight: number;
+    frameRate: number;
+    expectedFrameRate: number;
+    decreaseOutboundPenalty?: boolean;
+    isStaticContent?: boolean;
+    averageQP?: number;
+    qualityLimitationReason?: 'none' | 'bandwidth' | 'cpu' | 'other';
+}
+export interface AdaptedWIDStats {
+    inbound: {
+        audio: AudioStreamStats[];
+        video: VideoStreamStats[];
+    };
+    outbound: {
+        audio: AudioStreamStats[];
+        video: VideoStreamStats[];
+    };
+}
+export interface CodecFactors {
+    vp9?: number;
+    vp8?: number;
+    h264?: number;
+    [codec: string]: number | undefined;
+}
+export interface VideoCalculatorConfig {
+    codecFactors?: CodecFactors;
+}
+export interface ScoresCalculatorConfig {
+    video?: VideoCalculatorConfig;
+}
+export interface BaseCalculatorConfig {
+    video: Required<VideoCalculatorConfig>;
+    defaults: Required<{
+        audio: AudioStreamStats;
+        video: VideoStreamStats;
+    }>;
+}
+export type DeviceType = 'mobile' | 'pc' | 'tv';
+export interface MOSScores {
+    Qa?: number;
+    Qv?: number;
+}
+export interface ExpectedVideoParams {
+    width?: number;
+    height?: number;
+    maxFramerate?: number;
+}
+export interface PacketLossStats {
+    packetsLost: number;
+    packetsReceivedOrSent: number;
+}
+type RemoteInboundStats = Pick<ParsedRemoteInboundStreamStats, 'packetsLost' | 'jitter' | 'roundTripTime'>;
+interface OutboundPrevStats {
+    outbound: {
+        packetsSent: number;
+        qpSum?: number;
+        framesEncoded?: number;
+    };
+    remoteInbound: {
+        packetsLost: number;
+    };
+}
+export interface AdaptInboundAudioStatsPayload {
+    stats: ParsedInboundAudioStreamStats;
+    connectionStats: ParsedConnectionStats;
+    fec: boolean;
+    dtx: boolean;
+    prevStats?: ParsedInboundAudioStreamStats;
+}
+export interface AdaptInboundVideoStatsPayload {
+    stats: ParsedInboundVideoStreamStats;
+    connectionStats: ParsedConnectionStats;
+    prevStats?: ParsedInboundVideoStreamStats;
+    expectedWidth?: number;
+    expectedHeight?: number;
+    expectedFrameRate?: number;
+    isStaticContent?: boolean;
+}
+export interface AdaptOutboundAudioStatsPayload {
+    stats: ParsedOutboundAudioStreamStats;
+    remoteInboundStats?: RemoteInboundStats;
+    fec: boolean;
+    dtx: boolean;
+    prevStats?: OutboundPrevStats;
+}
+export interface AdaptOutboundVideoStatsPayload {
+    stats: ParsedOutboundVideoStreamStats;
+    remoteInboundStats?: RemoteInboundStats;
+    prevStats?: OutboundPrevStats;
+    isStaticContent?: boolean;
+}
+export {};

package/dist/types/media.d.ts

@@ -13,6 +13,9 @@ import type Network from '../engine/network';
 import type StatsHandler from '../engine/WebRTCStats/StatsHandler';
 import type ProducerCloseManager from '../engine/media/producer/ProducerCloseManager';
 import type EnhancedEventEmitter from '../EnhancedEventEmitter';
+import type { MOSScores } from '../qoe/types';
+import type { WIDStatsAdapter } from '../qoe/WIDStatsAdapter';
+import type { ScoresCalculator } from '../qoe/ScoresCalculator';
 import type { BaseTrackInfo, EncoderConfig, TrackLabel, TrackOutboundStats, TrackProduceParams, TrackTransformParams } from './common';
 import type { InternalObserverEvents } from './engine';
 export interface BaseTrackDependenciesParams {
@@ -25,6 +28,8 @@ export interface BaseTrackDependenciesParams {
     producerCloseManager: ProducerCloseManager;
     mutex: LocalMutex;
     statsHandler: StatsHandler;
+    widStatsAdapter: WIDStatsAdapter;
+    scoresCalculator: ScoresCalculator;
 }
 export interface BaseTrackParams {
     loggerNamespace: string;
@@ -42,6 +47,7 @@ export interface BaseTrack {
     producerId?: string;
     videoWebRTCStats?: ParsedOutboundVideoStreamStats;
     audioWebRTCStats?: ParsedOutboundAudioStreamStats;
+    connectionScores: MOSScores;
     getLabel: () => TrackLabel;
     setLabel: (label: TrackLabel) => void;
     setEncoderConfig: (encoderConfig: EncoderConfig) => void;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.50.0",
+  "version": "3.51.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -56,7 +56,7 @@
     "qs": "^6.11.0",
     "reflect-metadata": "^0.2.2",
     "serialize-error": "^7.0.1",
-    "webrtc-issue-detector": "^1.17.1"
+    "webrtc-issue-detector": "^1.17.2"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^19.0.0",

package/dist/engine/WebRTCStats/OutboudTrackStatsManager.d.ts

@@ -1,16 +0,0 @@
-import type { ParsedOutboundVideoStreamStats, ParsedOutboundAudioStreamStats } from 'webrtc-issue-detector';
-import type StatsHandler from './StatsHandler';
-interface OutboundTrackStatsManagerParams {
-    track: MediaStreamTrack;
-    statsHandler: StatsHandler;
-}
-export default class OutboundTrackStatsManager {
-    #private;
-    constructor({ track, statsHandler }: OutboundTrackStatsManagerParams);
-    get videoWebRTCStats(): ParsedOutboundVideoStreamStats | undefined;
-    get audioWebRTCStats(): ParsedOutboundAudioStreamStats | undefined;
-    private handleWebRTCStats;
-    private setVideoWebRTCStats;
-    private setAudioWebRTCStats;
-}
-export {};