855 lines
36 KiB
JavaScript
855 lines
36 KiB
JavaScript
// Module ID: 6974
|
|
// Function ID: 55739
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: []
|
|
|
|
// Module 6974 (_isNativeReflectConstruct)
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function parseEncoder(key10013) {
|
|
if (null == key10013) {
|
|
return obj.UNKNOWN;
|
|
} else {
|
|
const _Object = Object;
|
|
const keys = Object.keys(closure_16);
|
|
let num = 0;
|
|
if (0 < keys.length) {
|
|
const formatted = key10013.toLowerCase();
|
|
while (!formatted.includes(keys[num])) {
|
|
num = num + 1;
|
|
}
|
|
return closure_16[keys[num]];
|
|
}
|
|
return obj.UNCATEGORIZED;
|
|
}
|
|
}
|
|
function parseDecoder(prop1) {
|
|
if (null == prop1) {
|
|
return obj.UNKNOWN;
|
|
} else {
|
|
const _Object = Object;
|
|
const keys = Object.keys(closure_17);
|
|
let num = 0;
|
|
if (0 < keys.length) {
|
|
const formatted = prop1.toLowerCase();
|
|
while (!formatted.includes(keys[num])) {
|
|
num = num + 1;
|
|
}
|
|
return closure_17[keys[num]];
|
|
}
|
|
return obj.UNCATEGORIZED;
|
|
}
|
|
}
|
|
function parseCodecType(name) {
|
|
if (null == name) {
|
|
let AV1 = obj.UNKNOWN;
|
|
} else {
|
|
const formatted = name.toUpperCase();
|
|
if ("H264" === formatted) {
|
|
AV1 = obj.H264;
|
|
} else if ("H265" === formatted) {
|
|
AV1 = obj.H265;
|
|
} else if ("VP8" === formatted) {
|
|
AV1 = obj.VP8;
|
|
} else if ("VP9" === formatted) {
|
|
AV1 = obj.VP9;
|
|
} else {
|
|
if ("AV1" !== formatted) {
|
|
if ("AV1X" !== formatted) {
|
|
AV1 = obj.UNKNOWN;
|
|
}
|
|
}
|
|
AV1 = obj.AV1;
|
|
}
|
|
}
|
|
return AV1;
|
|
}
|
|
let closure_3 = importDefault(dependencyMap[0]);
|
|
let closure_4 = importDefault(dependencyMap[1]);
|
|
let closure_5 = importDefault(dependencyMap[2]);
|
|
let closure_6 = importDefault(dependencyMap[3]);
|
|
let closure_7 = importDefault(dependencyMap[4]);
|
|
let closure_8 = importDefault(dependencyMap[5]);
|
|
let closure_9 = ["PotionSpotIllustration", "EMOJI_IN_ANIMATION_SIZE", "construct", "isArray", "DEFAULT_ENABLE_BLUR_KEYBOARD_ON_GESTURE", "numOfGoreAttachments", "invokeCallbackAndReturnFlushedQueue", "thumbTintColor", "getCtaLink", "addBit", "multiMerge"];
|
|
let closure_10 = [-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000010150041648849781, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001535392741234323, -127319024029445520000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 80298925201347620000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002403180811794, -0.000000000000000000000000000010854726055866047, 873989989186783300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055171890578, -0.0000000000000000000000000015251038636174268, -0.0000000000000000000000000015251148384329003, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009097163991622018, -0.00000000000000000000000000000000000000000000000000000000000000000053887346968165155, -0.0000000000000000000000000000000000000000000000000000000000000000005388734697429711];
|
|
let closure_11 = [];
|
|
let closure_12 = [];
|
|
let obj = { H264: "H264", H265: "H265", VP8: "VP8", VP9: "VP9", AV1: "AV1", UNKNOWN: "UNKNOWN" };
|
|
obj = { NVIDIA_CUDA: "nvidia_cuda", NVIDIA_DIRECT_3D: "nvidia_direct_3d", NVIDIA_VULKAN: "nvidia_vulkan", OPENH264: "openh264", VIDEOTOOLBOX: "videotoolbox", AMD_DIRECT_3D: "amd_direct_3d", AMD_VAAPI: "amd_vaapi", INTEL: "intel", INTEL_DIRECT_3D: "intel_direct_3d", INTEL_VAAPI: "intel_vaapi", VP8_LIBVPX: "vp8_libvpx", EXYNOS: "exynos", QUALCOMM: "qualcomm", MEDIATEK: "mediatek", WMF_SW: "wmf_sw", WMF_HW: "wmf_hw", WMF_DIRECT_3D: "wmf_direct_3d", WMF_DIRECT_3D_INTEL: "wmf_direct_3d_intel", WMF_DIRECT_3D_NVIDIA: "wmf_direct_3d_nvidia", WMF_DIRECT_3D_AMD: "wmf_direct_3d_amd", WMF_CHROME: "wmf_chrome", UNCATEGORIZED: "uncategorized", UNKNOWN: "unknown" };
|
|
obj = { VIDEOTOOLBOX: "videotoolbox", VP8_LIBVPX: "vp8_libvpx", ELECTRON: "electron", FFMPEG: "ffmpeg", DAV1D: "dav1d", WEBRTC: "WebRTC", EXYNOS: "exynos", QUALCOMM: "qualcomm", MEDIATEK: "mediatek", UNCATEGORIZED: "uncategorized", D3D11VIDEODECODER: "d3d11videodecoder", ANDROID: "android", UNKNOWN: "unknown" };
|
|
let closure_16 = Object.freeze({ mediafoundation direct3d intel: obj.WMF_DIRECT_3D_INTEL, mediafoundation direct3d nvidia: obj.WMF_DIRECT_3D_NVIDIA, mediafoundation direct3d amd: obj.WMF_DIRECT_3D_AMD, mediafoundationvideoencodeaccelerator: obj.WMF_CHROME, nvidia: cuda: obj.NVIDIA_CUDA, nvidia: direct3d: obj.NVIDIA_DIRECT_3D, nvidia: vulkan: obj.NVIDIA_VULKAN, amd: direct3d: obj.AMD_DIRECT_3D, amd: vaapi: obj.AMD_VAAPI, intel: direct3d: obj.INTEL_DIRECT_3D, intel: vaapi: obj.INTEL_VAAPI, intel: obj.INTEL, videotoolbox: obj.VIDEOTOOLBOX, openh264: obj.OPENH264, libvpx: obj.VP8_LIBVPX, c2.exynos: obj.EXYNOS, omx.exynos: obj.EXYNOS, c2.qti: obj.QUALCOMM, omx.qcom: obj.QUALCOMM, c2.mtk: obj.MEDIATEK, omx.mtk: obj.MEDIATEK, mediafoundation sw: obj.WMF_SW, mediafoundation hw: obj.WMF_HW, mediafoundation direct3d: obj.WMF_DIRECT_3D });
|
|
let closure_17 = Object.freeze({ videotoolbox: obj.VIDEOTOOLBOX, libvpx: obj.VP8_LIBVPX, electron: obj.ELECTRON, ffmpeg: obj.FFMPEG, dav1d: obj.DAV1D, webrtc: obj.WEBRTC, c2.exynos: obj.EXYNOS, omx.exynos: obj.EXYNOS, c2.qti: obj.QUALCOMM, omx.qcom: obj.QUALCOMM, c2.mtk: obj.MEDIATEK, omx.mtk: obj.MEDIATEK, d3d11videodecoder: obj.D3D11VIDEODECODER, c2.android: obj.ANDROID, omx.google: obj.ANDROID });
|
|
const obj3 = { None: 0, [0]: "None", ClientSideDisableVideo: 1, [1]: "ClientSideDisableVideo", SenderStopped: 2, [2]: "SenderStopped" };
|
|
const tmp3 = () => {
|
|
class InboundStats {
|
|
constructor(arg0) {
|
|
InboundStats = this;
|
|
tmp = closure_7(this, InboundStats);
|
|
values = Object.values(closure_15);
|
|
this.decoderBuckets = Object.fromEntries(values.map((arg0) => {
|
|
const items = [arg0, 0];
|
|
return items;
|
|
}));
|
|
this.codecBuckets = {};
|
|
this.statsWindow = [];
|
|
histogram = new InboundStats(closure_2[6]).Histogram();
|
|
this.fpsHistogram = histogram;
|
|
histogram1 = new InboundStats(closure_2[6]).Histogram();
|
|
this.bitrateHistogram = histogram1;
|
|
histogram2 = new InboundStats(closure_2[6]).Histogram();
|
|
this.inboundBitrateEstimateHistogram = histogram2;
|
|
histogram3 = new InboundStats(closure_2[6]).Histogram();
|
|
this.resolutionHistogram = histogram3;
|
|
histogram4 = new InboundStats(closure_2[6]).Histogram();
|
|
this.localWantHistogram = histogram4;
|
|
tmp7 = closure_1(closure_2[7]);
|
|
tmp7 = new tmp7();
|
|
this.systemResources = tmp7;
|
|
this.decoderCodec = closure_13.UNKNOWN;
|
|
this.aggregatedProperties = {};
|
|
this.aggregationDuration = 0;
|
|
this.bitrateBuckets = {};
|
|
this.fpsBuckets = {};
|
|
this.resolutionBuckets = {};
|
|
this.resolutionTotal = 0;
|
|
this.minorResolutionTotal = 0;
|
|
this.majorResolutionTotal = 0;
|
|
this.intervalTotal = 0;
|
|
this.cryptorMaxAttempts = 0;
|
|
this.minWidth = null;
|
|
this.minHeight = null;
|
|
this.maxConsecutiveStaticColorFrames = 0;
|
|
this.videoStoppedReason = closure_18.None;
|
|
this.startTime = arg0.now();
|
|
stopWatch = new InboundStats(closure_2[8]).StopWatch(arg0);
|
|
this.videoStoppedWatch = stopWatch;
|
|
item = closure_9.forEach((arg0) => {
|
|
self.bitrateBuckets[arg0] = 0;
|
|
});
|
|
item1 = closure_10.forEach((arg0) => {
|
|
self.fpsBuckets[arg0] = 0;
|
|
});
|
|
item2 = closure_11.forEach((arg0) => {
|
|
self.resolutionBuckets[arg0] = 0;
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = InboundStats;
|
|
let obj = {
|
|
key: "isVideoStopped",
|
|
get() {
|
|
return this.videoStoppedReason !== closure_18.None;
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , ];
|
|
obj = {
|
|
key: "videoStoppedDuration",
|
|
get() {
|
|
const videoStoppedWatch = this.videoStoppedWatch;
|
|
return videoStoppedWatch.elapsed();
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "collectAggregationStats",
|
|
value(timestamp, timestamp2) {
|
|
const self = this;
|
|
let num = 0;
|
|
if (0 < length.length) {
|
|
do {
|
|
let tmp = arr[num];
|
|
let tmp2 = timestamp[tmp];
|
|
if (null !== tmp2) {
|
|
let tmp3 = timestamp2[tmp];
|
|
let num2 = 0;
|
|
if (null != tmp3) {
|
|
num2 = tmp3;
|
|
}
|
|
let aggregatedProperties = self.aggregatedProperties;
|
|
let diff = tmp2;
|
|
if (num2 <= tmp2) {
|
|
diff = tmp2 - num2;
|
|
}
|
|
aggregatedProperties[tmp] = aggregatedProperties[tmp] + diff;
|
|
let tmp5 = tmp3;
|
|
let tmp6 = num2;
|
|
}
|
|
num = num + 1;
|
|
} while (num < arr.length);
|
|
}
|
|
self.aggregationDuration = self.aggregationDuration + (timestamp.timestamp - timestamp2.timestamp);
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "setVideoStopped",
|
|
value(arg0, arg1) {
|
|
const self = this;
|
|
const videoStoppedReason = this.videoStoppedReason;
|
|
if (arg0) {
|
|
self.videoStoppedReason = videoStoppedReason | arg1;
|
|
const videoStoppedWatch2 = self.videoStoppedWatch;
|
|
videoStoppedWatch2.start();
|
|
} else {
|
|
self.videoStoppedReason = videoStoppedReason & ~arg1;
|
|
if (self.videoStoppedReason === closure_18.None) {
|
|
const statsWindow = self.statsWindow;
|
|
statsWindow.splice(0);
|
|
const videoStoppedWatch = self.videoStoppedWatch;
|
|
videoStoppedWatch.stop();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "appendAndIncrementStats",
|
|
value(cryptorSuccessCount) {
|
|
let bytes;
|
|
let bytes2;
|
|
let codecType;
|
|
let decoder;
|
|
let encoder;
|
|
let framesCodec;
|
|
let framesCodec2;
|
|
let localWant;
|
|
let resolution;
|
|
let timestamp;
|
|
let timestamp2;
|
|
const self = this;
|
|
const InboundStats = this;
|
|
if (!this.isVideoStopped) {
|
|
const statsWindow = self.statsWindow;
|
|
statsWindow.push(cryptorSuccessCount);
|
|
if (self.statsWindow.length >= 2) {
|
|
const result = self.collectAggregationStats(tmp13, tmp14);
|
|
if (null == self.cryptorFailureBeforeSuccessCount) {
|
|
if (cryptorSuccessCount.cryptorSuccessCount > 0) {
|
|
const cryptorFailureCount = self.aggregatedProperties.cryptorFailureCount;
|
|
let num3 = 0;
|
|
if (null != cryptorFailureCount) {
|
|
num3 = cryptorFailureCount;
|
|
}
|
|
self.cryptorFailureBeforeSuccessCount = num3;
|
|
}
|
|
}
|
|
({ timestamp, resolution } = self.statsWindow[self.statsWindow.length - 1]);
|
|
({ encoder, decoder, codecType } = self.statsWindow[self.statsWindow.length - 1]);
|
|
const result1 = (timestamp - tmp14.timestamp) / 1000;
|
|
self.intervalTotal = self.intervalTotal + result1;
|
|
self.resolutionTotal = self.resolutionTotal + resolution * result1;
|
|
self.minorResolutionTotal = self.minorResolutionTotal + self.statsWindow[self.statsWindow.length - 1].minorResolution * result1;
|
|
self.majorResolutionTotal = self.majorResolutionTotal + self.statsWindow[self.statsWindow.length - 1].majorResolution * result1;
|
|
const _Math = Math;
|
|
({ bytes, framesCodec, localWant } = self.statsWindow[self.statsWindow.length - 1]);
|
|
self.cryptorMaxAttempts = Math.max(self.cryptorMaxAttempts, self.statsWindow[self.statsWindow.length - 1].cryptorMaxAttempts);
|
|
if (null != encoder) {
|
|
if (null != codecType) {
|
|
if ("encoderBuckets" in self) {
|
|
const encoderBuckets = self.encoderBuckets;
|
|
encoderBuckets[encoder] = encoderBuckets[encoder] + result1;
|
|
const codecBuckets = self.codecBuckets;
|
|
codecBuckets[codecType] = codecBuckets[codecType] + result1;
|
|
let tmp4 = null != tmp13.codecType;
|
|
if (tmp4) {
|
|
tmp4 = tmp13.codecType !== constants.UNKNOWN;
|
|
}
|
|
if (tmp4) {
|
|
self.encoderCodec = tmp13.codecType;
|
|
}
|
|
let tmp6 = null != cryptorSuccessCount.vmafScore;
|
|
if (tmp6) {
|
|
tmp6 = cryptorSuccessCount.vmafScore >= 0;
|
|
}
|
|
if (tmp6) {
|
|
self.vmafScoreNum = self.vmafScoreNum + 1;
|
|
self.vmafScoreSum = self.vmafScoreSum + cryptorSuccessCount.vmafScore;
|
|
const vmafHistogram = self.vmafHistogram;
|
|
vmafHistogram.addSample(cryptorSuccessCount.vmafScore);
|
|
}
|
|
let tmp8 = null != cryptorSuccessCount.psnrDb;
|
|
if (tmp8) {
|
|
tmp8 = cryptorSuccessCount.psnrDb >= 0;
|
|
}
|
|
if (tmp8) {
|
|
self.psnrDbNum = self.psnrDbNum + 1;
|
|
self.psnrDbSum = self.psnrDbSum + cryptorSuccessCount.psnrDb;
|
|
const psnrHistogram = self.psnrHistogram;
|
|
psnrHistogram.addSample(cryptorSuccessCount.psnrDb);
|
|
}
|
|
let tmp10 = null != cryptorSuccessCount.outboundSinkWant;
|
|
if (tmp10) {
|
|
tmp10 = 0 !== cryptorSuccessCount.outboundSinkWant;
|
|
}
|
|
if (tmp10) {
|
|
self.outboundSinkWantNum = self.outboundSinkWantNum + 1;
|
|
self.outboundSinkWantSum = self.outboundSinkWantSum + cryptorSuccessCount.outboundSinkWant;
|
|
}
|
|
const _Math2 = Math;
|
|
self.consecutiveStaticColorFramesMax = Math.max(self.consecutiveStaticColorFramesMax, cryptorSuccessCount.consecutiveStaticColorFrames);
|
|
}
|
|
}
|
|
}
|
|
if (null != decoder) {
|
|
if (null != codecType) {
|
|
if ("decoderBuckets" in self) {
|
|
const decoderBuckets = self.decoderBuckets;
|
|
decoderBuckets[decoder] = decoderBuckets[decoder] + result1;
|
|
const codecBuckets2 = self.codecBuckets;
|
|
codecBuckets2[codecType] = codecBuckets2[codecType] + result1;
|
|
let tmp11 = null != tmp13.codecType;
|
|
if (tmp11) {
|
|
tmp11 = tmp13.codecType !== constants.UNKNOWN;
|
|
}
|
|
if (tmp11) {
|
|
self.decoderCodec = tmp13.codecType;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (self.statsWindow.length >= 6) {
|
|
({ bytes: bytes2, framesCodec: framesCodec2, timestamp: timestamp2 } = self.statsWindow[self.statsWindow.length - 3]);
|
|
const item = closure_11.forEach((arg0) => {
|
|
if (resolution <= arg0) {
|
|
const resolutionBuckets = self.resolutionBuckets;
|
|
resolutionBuckets[arg0] = resolutionBuckets[arg0] + result1;
|
|
}
|
|
});
|
|
const result2 = (timestamp - timestamp2) / 1000;
|
|
const result3 = 8 * (bytes - bytes2) / result2;
|
|
const result4 = (framesCodec - framesCodec2) / result2;
|
|
const item1 = closure_9.forEach((arg0) => {
|
|
if (result3 <= arg0) {
|
|
const bitrateBuckets = self.bitrateBuckets;
|
|
bitrateBuckets[arg0] = bitrateBuckets[arg0] + result1;
|
|
}
|
|
});
|
|
const item2 = closure_10.forEach((arg0) => {
|
|
if (result4 <= arg0) {
|
|
const fpsBuckets = self.fpsBuckets;
|
|
fpsBuckets[arg0] = fpsBuckets[arg0] + result1;
|
|
}
|
|
});
|
|
const resolutionHistogram = self.resolutionHistogram;
|
|
resolutionHistogram.addSample(resolution);
|
|
const bitrateHistogram = self.bitrateHistogram;
|
|
bitrateHistogram.addSample(result3);
|
|
const fpsHistogram = self.fpsHistogram;
|
|
fpsHistogram.addSample(result4);
|
|
const localWantHistogram = self.localWantHistogram;
|
|
localWantHistogram.addSample(localWant);
|
|
const statsWindow1 = self.statsWindow;
|
|
statsWindow1.shift();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "addSystemResources",
|
|
value() {
|
|
const systemResources = this.systemResources;
|
|
systemResources.takeSample();
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "appendTransportStats",
|
|
value(inboundBitrateEstimate) {
|
|
if (null != inboundBitrateEstimate.inboundBitrateEstimate) {
|
|
const self = this;
|
|
const inboundBitrateEstimateHistogram = this.inboundBitrateEstimateHistogram;
|
|
inboundBitrateEstimateHistogram.addSample(inboundBitrateEstimate.inboundBitrateEstimate);
|
|
}
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "getCodecsUsed",
|
|
value() {
|
|
const set = new Set();
|
|
const entries = Object.entries(this.codecBuckets);
|
|
for (let num = 0; num < entries.length; num = num + 1) {
|
|
let tmp = callback2;
|
|
let tmp2 = callback2(entries[num], 2);
|
|
if (tmp2[1] > 0) {
|
|
let addResult = set.add(tmp3);
|
|
}
|
|
}
|
|
return set;
|
|
}
|
|
};
|
|
return callback2(InboundStats, items);
|
|
}();
|
|
const obj1 = { mediafoundation direct3d intel: obj.WMF_DIRECT_3D_INTEL, mediafoundation direct3d nvidia: obj.WMF_DIRECT_3D_NVIDIA, mediafoundation direct3d amd: obj.WMF_DIRECT_3D_AMD, mediafoundationvideoencodeaccelerator: obj.WMF_CHROME, nvidia: cuda: obj.NVIDIA_CUDA, nvidia: direct3d: obj.NVIDIA_DIRECT_3D, nvidia: vulkan: obj.NVIDIA_VULKAN, amd: direct3d: obj.AMD_DIRECT_3D, amd: vaapi: obj.AMD_VAAPI, intel: direct3d: obj.INTEL_DIRECT_3D, intel: vaapi: obj.INTEL_VAAPI, intel: obj.INTEL, videotoolbox: obj.VIDEOTOOLBOX, openh264: obj.OPENH264, libvpx: obj.VP8_LIBVPX, c2.exynos: obj.EXYNOS, omx.exynos: obj.EXYNOS, c2.qti: obj.QUALCOMM, omx.qcom: obj.QUALCOMM, c2.mtk: obj.MEDIATEK, omx.mtk: obj.MEDIATEK, mediafoundation sw: obj.WMF_SW, mediafoundation hw: obj.WMF_HW, mediafoundation direct3d: obj.WMF_DIRECT_3D };
|
|
const obj2 = { videotoolbox: obj.VIDEOTOOLBOX, libvpx: obj.VP8_LIBVPX, electron: obj.ELECTRON, ffmpeg: obj.FFMPEG, dav1d: obj.DAV1D, webrtc: obj.WEBRTC, c2.exynos: obj.EXYNOS, omx.exynos: obj.EXYNOS, c2.qti: obj.QUALCOMM, omx.qcom: obj.QUALCOMM, c2.mtk: obj.MEDIATEK, omx.mtk: obj.MEDIATEK, d3d11videodecoder: obj.D3D11VIDEODECODER, c2.android: obj.ANDROID, omx.google: obj.ANDROID };
|
|
const tmp2 = () => {
|
|
class RawVideoStats {
|
|
constructor() {
|
|
tmp = closure_7(this, RawVideoStats);
|
|
this.bytes = 0;
|
|
this.framesCodec = 0;
|
|
this.framesCodecError = null;
|
|
this.framesNetwork = 0;
|
|
this.resolution = 0;
|
|
this.minorResolution = 0;
|
|
this.majorResolution = 0;
|
|
this.timestamp = 0;
|
|
this.packets = 0;
|
|
this.packetsLost = 0;
|
|
this.framesDropped = 0;
|
|
this.nackCount = 0;
|
|
this.pliCount = 0;
|
|
this.encoder = null;
|
|
this.decoder = null;
|
|
this.codecType = null;
|
|
this.qpSum = 0;
|
|
this.freezeCount = 0;
|
|
this.pauseCount = 0;
|
|
this.totalFreezesDuration = 0;
|
|
this.totalPausesDuration = 0;
|
|
this.totalFramesDuration = 0;
|
|
this.totalDecodeTime = 0;
|
|
this.vmafScore = null;
|
|
this.psnrDb = null;
|
|
this.outboundSinkWant = null;
|
|
this.keyframes = null;
|
|
this.framesDroppedRateLimiter = null;
|
|
this.framesDroppedEncoderQueue = null;
|
|
this.framesDroppedCongestionWindow = null;
|
|
this.framesDroppedEncoder = null;
|
|
this.passthroughCount = 0;
|
|
this.cryptorSuccessCount = 0;
|
|
this.cryptorFailureCount = 0;
|
|
this.cryptorDuration = 0;
|
|
this.cryptorAttempts = 0;
|
|
this.cryptorMaxAttempts = 0;
|
|
this.cryptorMissingKeyCount = 0;
|
|
this.cryptorInvalidNonceCount = 0;
|
|
this.qualityDecodeErrors = 0;
|
|
this.qualityDecoderReboots = 0;
|
|
this.qualityScoreErrors = 0;
|
|
this.qualityFrameDrops = 0;
|
|
this.qualitySizeMismatches = 0;
|
|
this.localWant = 0;
|
|
this.consecutiveStaticColorFrames = 0;
|
|
this.screenshareFramesUnique = 0;
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = RawVideoStats;
|
|
let obj = {
|
|
key: "parseInboundStats",
|
|
value(resolution, timestamp) {
|
|
let framesDecodeErrors;
|
|
let totalDecodeTime;
|
|
const tmp = new RawVideoStats();
|
|
if (null != resolution) {
|
|
({ bytesReceived: tmp.bytes, framesDecoded: tmp.framesCodec, framesDecodeErrors } = resolution);
|
|
let tmp2 = null;
|
|
if (null != framesDecodeErrors) {
|
|
tmp2 = framesDecodeErrors;
|
|
}
|
|
tmp.framesCodecError = tmp2;
|
|
({ framesReceived: tmp.framesNetwork, packetsReceived: tmp.packets, packetsLost: tmp.packetsLost, framesDropped: tmp.framesDropped } = resolution);
|
|
let num2 = 0;
|
|
if (null != resolution.resolution) {
|
|
num2 = resolution.resolution.height;
|
|
}
|
|
tmp.resolution = num2;
|
|
let num3 = 0;
|
|
if (null != resolution.resolution) {
|
|
const _Math = Math;
|
|
num3 = Math.min(resolution.resolution.height, resolution.resolution.width);
|
|
}
|
|
tmp.minorResolution = num3;
|
|
let num4 = 0;
|
|
if (null != resolution.resolution) {
|
|
const _Math2 = Math;
|
|
num4 = Math.max(resolution.resolution.height, resolution.resolution.width);
|
|
}
|
|
tmp.majorResolution = num4;
|
|
tmp.timestamp = timestamp;
|
|
({ nackCount: tmp.nackCount, pliCount: tmp.pliCount } = resolution);
|
|
tmp.decoder = callback3(resolution.decoderImplementationName);
|
|
tmp.codecType = callback4(resolution.codec.name);
|
|
tmp.qpSum = 0;
|
|
({ freezeCount: tmp.freezeCount, pauseCount: tmp.pauseCount, totalFreezesDuration: tmp.totalFreezesDuration, totalPausesDuration: tmp.totalPausesDuration, totalFramesDuration: tmp.totalFramesDuration, totalDecodeTime } = resolution);
|
|
let num5 = 0;
|
|
if (null != totalDecodeTime) {
|
|
num5 = totalDecodeTime;
|
|
}
|
|
tmp.totalDecodeTime = num5;
|
|
const keyFramesDecoded = resolution.keyFramesDecoded;
|
|
let tmp8 = null;
|
|
if (null != keyFramesDecoded) {
|
|
tmp8 = keyFramesDecoded;
|
|
}
|
|
tmp.keyframes = tmp8;
|
|
const passthroughCount = resolution.passthroughCount;
|
|
let num6 = 0;
|
|
if (null != passthroughCount) {
|
|
num6 = passthroughCount;
|
|
}
|
|
tmp.passthroughCount = num6;
|
|
const decryptSuccessCount = resolution.decryptSuccessCount;
|
|
let num7 = 0;
|
|
if (null != decryptSuccessCount) {
|
|
num7 = decryptSuccessCount;
|
|
}
|
|
tmp.cryptorSuccessCount = num7;
|
|
const decryptFailureCount = resolution.decryptFailureCount;
|
|
let num8 = 0;
|
|
if (null != decryptFailureCount) {
|
|
num8 = decryptFailureCount;
|
|
}
|
|
tmp.cryptorFailureCount = num8;
|
|
const decryptDuration = resolution.decryptDuration;
|
|
let num9 = 0;
|
|
if (null != decryptDuration) {
|
|
num9 = decryptDuration;
|
|
}
|
|
tmp.cryptorDuration = num9;
|
|
const decryptAttempts = resolution.decryptAttempts;
|
|
let num10 = 0;
|
|
if (null != decryptAttempts) {
|
|
num10 = decryptAttempts;
|
|
}
|
|
tmp.cryptorAttempts = num10;
|
|
const decryptMissingKeyCount = resolution.decryptMissingKeyCount;
|
|
let num11 = 0;
|
|
if (null != decryptMissingKeyCount) {
|
|
num11 = decryptMissingKeyCount;
|
|
}
|
|
tmp.cryptorMissingKeyCount = num11;
|
|
const decryptInvalidNonceCount = resolution.decryptInvalidNonceCount;
|
|
let num12 = 0;
|
|
if (null != decryptInvalidNonceCount) {
|
|
num12 = decryptInvalidNonceCount;
|
|
}
|
|
tmp.cryptorInvalidNonceCount = num12;
|
|
const sinkWantLocalAsInt = resolution.sinkWantLocalAsInt;
|
|
let num13 = 0;
|
|
if (null != sinkWantLocalAsInt) {
|
|
num13 = sinkWantLocalAsInt;
|
|
}
|
|
tmp.localWant = num13;
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
const items = [obj, ];
|
|
obj = {
|
|
key: "parseOutboundStats",
|
|
value(framesSent, timestamp) {
|
|
let freezeCount;
|
|
let packetsLost;
|
|
let tmp = new RawVideoStats();
|
|
if (null != framesSent) {
|
|
const obj = {};
|
|
({ bytesSent: obj.bytes, framesEncoded: obj.framesCodec } = framesSent);
|
|
obj.framesCodecError = null;
|
|
framesSent = framesSent.framesSent;
|
|
let num = 0;
|
|
if (null != framesSent) {
|
|
num = framesSent;
|
|
}
|
|
obj.framesNetwork = num;
|
|
({ packetsSent: obj.packets, packetsLost } = framesSent);
|
|
let num2 = 0;
|
|
if (null != packetsLost) {
|
|
num2 = packetsLost;
|
|
}
|
|
obj.packetsLost = num2;
|
|
obj.framesDropped = 0;
|
|
let num3 = 0;
|
|
if (null != framesSent.resolution) {
|
|
num3 = framesSent.resolution.height;
|
|
}
|
|
obj.resolution = num3;
|
|
let num4 = 0;
|
|
if (null != framesSent.resolution) {
|
|
const _Math = Math;
|
|
num4 = Math.min(framesSent.resolution.height, framesSent.resolution.width);
|
|
}
|
|
obj.minorResolution = num4;
|
|
let num5 = 0;
|
|
if (null != framesSent.resolution) {
|
|
const _Math2 = Math;
|
|
num5 = Math.max(framesSent.resolution.height, framesSent.resolution.width);
|
|
}
|
|
obj.majorResolution = num5;
|
|
obj.timestamp = timestamp;
|
|
obj.encoder = callback2(framesSent.encoderImplementationName);
|
|
obj.decoder = null;
|
|
obj.codecType = callback4(framesSent.codec.name);
|
|
({ nackCount: obj.nackCount, pliCount: obj.pliCount, qpSum: obj.qpSum, freezeCount } = framesSent);
|
|
let num6 = 0;
|
|
if (null != freezeCount) {
|
|
num6 = freezeCount;
|
|
}
|
|
obj.freezeCount = num6;
|
|
obj.pauseCount = 0;
|
|
const totalFreezesDuration = framesSent.totalFreezesDuration;
|
|
let num7 = 0;
|
|
if (null != totalFreezesDuration) {
|
|
num7 = totalFreezesDuration;
|
|
}
|
|
obj.totalFreezesDuration = num7;
|
|
obj.totalPausesDuration = 0;
|
|
const totalFramesDuration = framesSent.totalFramesDuration;
|
|
let num8 = 0;
|
|
if (null != totalFramesDuration) {
|
|
num8 = totalFramesDuration;
|
|
}
|
|
obj.totalFramesDuration = num8;
|
|
obj.totalDecodeTime = 0;
|
|
const sinkWantAsInt = framesSent.sinkWantAsInt;
|
|
let tmp7 = null;
|
|
if (null != sinkWantAsInt) {
|
|
tmp7 = sinkWantAsInt;
|
|
}
|
|
obj.outboundSinkWant = tmp7;
|
|
const encoderQualityVmaf = framesSent.encoderQualityVmaf;
|
|
let tmp8 = null;
|
|
if (null != encoderQualityVmaf) {
|
|
tmp8 = encoderQualityVmaf;
|
|
}
|
|
obj.vmafScore = tmp8;
|
|
const qualityDecodeErrors = framesSent.qualityDecodeErrors;
|
|
let num9 = 0;
|
|
if (null != qualityDecodeErrors) {
|
|
num9 = qualityDecodeErrors;
|
|
}
|
|
obj.qualityDecodeErrors = num9;
|
|
const qualityDecoderReboots = framesSent.qualityDecoderReboots;
|
|
let num10 = 0;
|
|
if (null != qualityDecoderReboots) {
|
|
num10 = qualityDecoderReboots;
|
|
}
|
|
obj.qualityDecoderReboots = num10;
|
|
const qualityScoreErrors = framesSent.qualityScoreErrors;
|
|
let num11 = 0;
|
|
if (null != qualityScoreErrors) {
|
|
num11 = qualityScoreErrors;
|
|
}
|
|
obj.qualityScoreErrors = num11;
|
|
const qualityFrameDrops = framesSent.qualityFrameDrops;
|
|
let num12 = 0;
|
|
if (null != qualityFrameDrops) {
|
|
num12 = qualityFrameDrops;
|
|
}
|
|
obj.qualityFrameDrops = num12;
|
|
const qualitySizeMismatches = framesSent.qualitySizeMismatches;
|
|
let num13 = 0;
|
|
if (null != qualitySizeMismatches) {
|
|
num13 = qualitySizeMismatches;
|
|
}
|
|
obj.qualitySizeMismatches = num13;
|
|
const encoderQualityPsnr = framesSent.encoderQualityPsnr;
|
|
let tmp9 = null;
|
|
if (null != encoderQualityPsnr) {
|
|
tmp9 = encoderQualityPsnr;
|
|
}
|
|
obj.psnrDb = tmp9;
|
|
const keyFramesEncoded = framesSent.keyFramesEncoded;
|
|
let tmp10 = null;
|
|
if (null != keyFramesEncoded) {
|
|
tmp10 = keyFramesEncoded;
|
|
}
|
|
obj.keyframes = tmp10;
|
|
const framesDroppedRateLimiter = framesSent.framesDroppedRateLimiter;
|
|
let tmp11 = null;
|
|
if (null != framesDroppedRateLimiter) {
|
|
tmp11 = framesDroppedRateLimiter;
|
|
}
|
|
obj.framesDroppedRateLimiter = tmp11;
|
|
const framesDroppedEncoderQueue = framesSent.framesDroppedEncoderQueue;
|
|
let tmp12 = null;
|
|
if (null != framesDroppedEncoderQueue) {
|
|
tmp12 = framesDroppedEncoderQueue;
|
|
}
|
|
obj.framesDroppedEncoderQueue = tmp12;
|
|
const framesDroppedCongestionWindow = framesSent.framesDroppedCongestionWindow;
|
|
let tmp13 = null;
|
|
if (null != framesDroppedCongestionWindow) {
|
|
tmp13 = framesDroppedCongestionWindow;
|
|
}
|
|
obj.framesDroppedCongestionWindow = tmp13;
|
|
const framesDroppedEncoder = framesSent.framesDroppedEncoder;
|
|
let tmp14 = null;
|
|
if (null != framesDroppedEncoder) {
|
|
tmp14 = framesDroppedEncoder;
|
|
}
|
|
obj.framesDroppedEncoder = tmp14;
|
|
const passthroughCount = framesSent.passthroughCount;
|
|
let num14 = 0;
|
|
if (null != passthroughCount) {
|
|
num14 = passthroughCount;
|
|
}
|
|
obj.passthroughCount = num14;
|
|
const encryptSuccessCount = framesSent.encryptSuccessCount;
|
|
let num15 = 0;
|
|
if (null != encryptSuccessCount) {
|
|
num15 = encryptSuccessCount;
|
|
}
|
|
obj.cryptorSuccessCount = num15;
|
|
const encryptFailureCount = framesSent.encryptFailureCount;
|
|
let num16 = 0;
|
|
if (null != encryptFailureCount) {
|
|
num16 = encryptFailureCount;
|
|
}
|
|
obj.cryptorFailureCount = num16;
|
|
const encryptDuration = framesSent.encryptDuration;
|
|
let num17 = 0;
|
|
if (null != encryptDuration) {
|
|
num17 = encryptDuration;
|
|
}
|
|
obj.cryptorDuration = num17;
|
|
const encryptAttempts = framesSent.encryptAttempts;
|
|
let num18 = 0;
|
|
if (null != encryptAttempts) {
|
|
num18 = encryptAttempts;
|
|
}
|
|
obj.cryptorAttempts = num18;
|
|
const encryptMaxAttempts = framesSent.encryptMaxAttempts;
|
|
let num19 = 0;
|
|
if (null != encryptMaxAttempts) {
|
|
num19 = encryptMaxAttempts;
|
|
}
|
|
obj.cryptorMaxAttempts = num19;
|
|
const encryptMissingKeyCount = framesSent.encryptMissingKeyCount;
|
|
let num20 = 0;
|
|
if (null != encryptMissingKeyCount) {
|
|
num20 = encryptMissingKeyCount;
|
|
}
|
|
obj.cryptorMissingKeyCount = num20;
|
|
obj.cryptorInvalidNonceCount = 0;
|
|
obj.localWant = 0;
|
|
const consecutiveStaticColorFrames = framesSent.consecutiveStaticColorFrames;
|
|
let num21 = 0;
|
|
if (null != consecutiveStaticColorFrames) {
|
|
num21 = consecutiveStaticColorFrames;
|
|
}
|
|
obj.consecutiveStaticColorFrames = num21;
|
|
obj.screenshareFramesUnique = 0;
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
return callback2(RawVideoStats, null, items);
|
|
}();
|
|
const tmp4 = (arg0) => {
|
|
class OutboundStats {
|
|
constructor(arg0) {
|
|
self = this;
|
|
items = [...arguments];
|
|
tmp = closure_7(this, OutboundStats);
|
|
items1 = [...items];
|
|
obj = closure_4(OutboundStats);
|
|
tmp2 = closure_3;
|
|
if (closure_19()) {
|
|
tmp4 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp5 = closure_4;
|
|
constructResult = Reflect.construct(obj, items1, closure_4(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items1);
|
|
}
|
|
tmp2Result = tmp2(self, constructResult);
|
|
values = Object.values(closure_14);
|
|
tmp2Result.encoderBuckets = Object.fromEntries(values.map((arg0) => {
|
|
const items = [arg0, 0];
|
|
return items;
|
|
}));
|
|
tmp2Result.encoderCodec = closure_13.UNKNOWN;
|
|
tmp2Result.targetFrames = 0;
|
|
tmp2Result.targetBytesMax = 0;
|
|
tmp2Result.targetBytesNetwork = 0;
|
|
histogram = new OutboundStats(closure_2[6]).Histogram();
|
|
tmp2Result.targetBitrateHistogram = histogram;
|
|
tmp2Result.outboundBytesAvailable = 0;
|
|
histogram1 = new OutboundStats(closure_2[6]).Histogram();
|
|
tmp2Result.outboundBandwidthSurplus = histogram1;
|
|
tmp2Result.averageEncodeTime = 0;
|
|
tmp2Result.vmafScoreSum = 0;
|
|
tmp2Result.vmafScoreNum = 0;
|
|
histogram2 = new OutboundStats(closure_2[6]).Histogram();
|
|
tmp2Result.vmafHistogram = histogram2;
|
|
tmp2Result.psnrDbSum = 0;
|
|
tmp2Result.psnrDbNum = 0;
|
|
histogram3 = new OutboundStats(closure_2[6]).Histogram();
|
|
tmp2Result.psnrHistogram = histogram3;
|
|
tmp2Result.qualityDecodeErrors = 0;
|
|
tmp2Result.qualityDecoderReboots = 0;
|
|
tmp2Result.qualityScoreErrors = 0;
|
|
tmp2Result.qualityFrameDrops = 0;
|
|
tmp2Result.qualitySizeMismatches = 0;
|
|
tmp2Result.outboundSinkWantSum = 0;
|
|
tmp2Result.outboundSinkWantNum = 0;
|
|
tmp2Result.framesDroppedRateLimiter = null;
|
|
tmp2Result.framesDroppedEncoderQueue = null;
|
|
tmp2Result.framesDroppedCongestionWindow = null;
|
|
tmp2Result.framesDroppedEncoder = null;
|
|
tmp2Result.consecutiveStaticColorFramesMax = 0;
|
|
return tmp2Result;
|
|
}
|
|
}
|
|
const arg1 = OutboundStats;
|
|
callback(OutboundStats, arg0);
|
|
const items = [
|
|
{
|
|
key: "appendTargetRates",
|
|
value(arg0, arg1, arg2, arg3) {
|
|
const self = this;
|
|
if (this.statsWindow.length >= 2) {
|
|
let num = 0;
|
|
if (null != arg0) {
|
|
num = arg0;
|
|
}
|
|
let num2 = 0;
|
|
if (null != arg1) {
|
|
num2 = arg1;
|
|
}
|
|
let num3 = 0;
|
|
if (null != arg2) {
|
|
num3 = arg2;
|
|
}
|
|
let num4 = 0;
|
|
if (null != arg3) {
|
|
num4 = arg3;
|
|
}
|
|
const result = (self.statsWindow[self.statsWindow.length - 1].timestamp - self.statsWindow[self.statsWindow.length - 2].timestamp) / 1000;
|
|
self.targetFrames = self.targetFrames + num * result;
|
|
self.targetBytesNetwork = self.targetBytesNetwork + num2 / 8 * result;
|
|
self.targetBytesMax = self.targetBytesMax + num3 / 8 * result;
|
|
self.outboundBytesAvailable = self.outboundBytesAvailable + num4 / 8 * result;
|
|
const targetBitrateHistogram = self.targetBitrateHistogram;
|
|
targetBitrateHistogram.addSample(num2);
|
|
const outboundBandwidthSurplus = self.outboundBandwidthSurplus;
|
|
outboundBandwidthSurplus.addSample(num4 - num2);
|
|
}
|
|
}
|
|
}
|
|
];
|
|
return callback2(OutboundStats, items);
|
|
}(tmp3);
|
|
const result = arg1(dependencyMap[9]).fileFinishedImporting("lib/VideoQualityStats.tsx");
|
|
|
|
export const CodecTypes = obj;
|
|
export const Encoders = obj;
|
|
export const Decoders = obj;
|
|
export const VideoStoppedReasons = obj3;
|
|
export { parseEncoder };
|
|
export { parseDecoder };
|
|
export { parseCodecType };
|
|
export const RawVideoStats = tmp2;
|
|
export const InboundStats = tmp3;
|
|
export const OutboundStats = tmp4;
|