1062 lines
35 KiB
TypeScript
1062 lines
35 KiB
TypeScript
// Module ID: 12606
|
|
// Function ID: 96885
|
|
// Name: _createForOfIteratorHelperLoose
|
|
// Dependencies: []
|
|
|
|
// Module 12606 (_createForOfIteratorHelperLoose)
|
|
function _createForOfIteratorHelperLoose(@@iterator) {
|
|
let arg1 = Symbol_iterator;
|
|
@@iterator = "undefined" !== typeof Symbol;
|
|
if (Symbol_iterator) {
|
|
const _Symbol = Symbol;
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (!Symbol_iterator) {
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (Symbol_iterator) {
|
|
const iter = Symbol_iterator.call(Symbol_iterator);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = Symbol_iterator;
|
|
if (!Array.isArray(Symbol_iterator)) {
|
|
let tmp2;
|
|
if (Symbol_iterator) {
|
|
if ("string" === typeof Symbol_iterator) {
|
|
tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const toString = {}.toString;
|
|
const substr = toString.call(Symbol_iterator).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = Symbol_iterator.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(Symbol_iterator);
|
|
const callResult = toString.call(Symbol_iterator);
|
|
const tmp3 = "Object" === substr && Symbol_iterator.constructor;
|
|
}
|
|
}
|
|
tmp = tmp2;
|
|
if (!tmp2) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (tmp) {
|
|
arg1 = tmp;
|
|
}
|
|
let closure_1 = 0;
|
|
return () => {
|
|
if (closure_1 >= tmp.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = tmp[+closure_1];
|
|
}
|
|
return obj;
|
|
};
|
|
}
|
|
}
|
|
function _arrayLikeToArray(arg0, arg1) {
|
|
let length;
|
|
if (tmp) {
|
|
length = arg0.length;
|
|
}
|
|
const ArrayResult = Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
ArrayResult[num] = arg0[num];
|
|
}
|
|
return ArrayResult;
|
|
}
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function getDefaultWants(any) {
|
|
let obj = arg1(dependencyMap[11]);
|
|
if (obj.getBrowserInvertedWantsConfig("RTCMediaSinkWantsManager.getDefaultWants").invertWants) {
|
|
obj = {};
|
|
const merged = Object.assign(obj);
|
|
} else {
|
|
obj = { any };
|
|
}
|
|
return obj;
|
|
}
|
|
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 = importDefault(dependencyMap[6]);
|
|
const VideoToggleState = arg1(dependencyMap[7]).VideoToggleState;
|
|
const SimulcastOverrideQuality = arg1(dependencyMap[8]).SimulcastOverrideQuality;
|
|
let obj = { any: 0 };
|
|
let closure_13 = 30 * importDefault(dependencyMap[9]).Millis.SECOND;
|
|
let closure_14 = 120 * importDefault(dependencyMap[9]).Millis.SECOND;
|
|
let closure_15 = -1 !== arg1(dependencyMap[10]).getFirefoxVersion();
|
|
obj = { UserSSRCUpdate: "user-ssrc-update", Update: "update" };
|
|
const obj2 = arg1(dependencyMap[10]);
|
|
const tmp2 = (arg0) => {
|
|
class RTCMediaSinkWantsManager {
|
|
constructor(arg0, arg1, arg2) {
|
|
mediaSinkWantsLadder = arg3;
|
|
self = this;
|
|
if (arg3 === undefined) {
|
|
tmp2 = RTCMediaSinkWantsManager;
|
|
tmp3 = closure_2;
|
|
num = 12;
|
|
MediaSinkWantsLadder = RTCMediaSinkWantsManager(closure_2[12]).MediaSinkWantsLadder;
|
|
prototype = MediaSinkWantsLadder.prototype;
|
|
tmp4 = new.target;
|
|
tmp5 = new.target;
|
|
mediaSinkWantsLadder = new MediaSinkWantsLadder();
|
|
}
|
|
RTCMediaSinkWantsManager = undefined;
|
|
tmp6 = closure_4(self, RTCMediaSinkWantsManager);
|
|
obj = closure_7(RTCMediaSinkWantsManager);
|
|
tmp7 = closure_6;
|
|
if (closure_19()) {
|
|
tmp9 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp10 = closure_7;
|
|
constructResult = Reflect.construct(obj, [], closure_7(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, undefined);
|
|
}
|
|
tmp7Result = tmp7(self, constructResult);
|
|
RTCMediaSinkWantsManager = tmp7Result;
|
|
tmp7Result.userId = arg0;
|
|
tmp7Result.isStageChannel = arg1;
|
|
tmp7Result.supportsSeamless = arg2;
|
|
tmp7Result.ladder = mediaSinkWantsLadder;
|
|
tmp7Result.connection = null;
|
|
tmp7Result.audioSsrcs = {};
|
|
tmp7Result.videoSsrcs = {};
|
|
tmp7Result.remoteVideoSsrcs = {};
|
|
tmp7Result.framesReceived = {};
|
|
tmp7Result.streamIds = {};
|
|
tmp7Result.offscreenUsers = {};
|
|
tmp7Result.offscreenDisabledUsers = {};
|
|
tmp7Result.streamPixelCounts = {};
|
|
tmp7Result.latestWants = closure_20(100);
|
|
set = new Set();
|
|
tmp7Result.participants = set;
|
|
tmp7Result.selectedParticipantId = null;
|
|
tmp7Result.pipOpen = false;
|
|
map = new Map();
|
|
tmp7Result.simulcastDebugOverrides = map;
|
|
tmp7Result.videoHealthManager = null;
|
|
set1 = new Set();
|
|
tmp7Result.otherUsers = set1;
|
|
tmp7Result.delayedUpdate = () => {
|
|
const delayedCall = tmp7Result.delayedCall;
|
|
delayedCall.delay();
|
|
};
|
|
tmp7Result.addLru = (arg0, arg1, arr) => {
|
|
arr.push(arg0);
|
|
if (arr.length > 3) {
|
|
let num = 0;
|
|
let num2 = -1;
|
|
let num3 = -1;
|
|
let num4 = -1;
|
|
if (0 < arr.length) {
|
|
do {
|
|
let tmp2 = closure_0;
|
|
let diff = arg1 - closure_0.offscreenUsers[arr[num]];
|
|
if (diff > num2) {
|
|
num2 = diff;
|
|
num3 = num;
|
|
}
|
|
num = num + 1;
|
|
num4 = num3;
|
|
} while (num < arr.length);
|
|
}
|
|
tmp7Result.offscreenDisabledUsers[arr[num4]] = true;
|
|
arr.splice(num4, 1);
|
|
}
|
|
};
|
|
tmp7Result.updateOffscreenUsers = () => {
|
|
let done;
|
|
let iter3;
|
|
let tmp10;
|
|
let tmp11;
|
|
const connection = tmp7Result.connection;
|
|
if (null != connection) {
|
|
if (connection.getActiveOutputSinkTrackingEnabled()) {
|
|
const _Date = Date;
|
|
const timestamp = Date.now();
|
|
const items = [];
|
|
const tmp7 = callback3(callback(closure_2[13]).entries(tmp7Result.streamIds));
|
|
const iter = tmp7();
|
|
let iter2 = iter;
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp8 = closure_3;
|
|
let tmp9 = closure_3(iter2.value, 2);
|
|
[tmp10, tmp11] = tmp9;
|
|
if (null != tmp11) {
|
|
let tmp43 = closure_0;
|
|
let connection2 = closure_0.connection;
|
|
if (null != connection2) {
|
|
if (connection2.getHasActiveVideoOutputSink(tmp11)) {
|
|
let tmp27 = closure_0;
|
|
let offscreenUsers = closure_0.offscreenUsers;
|
|
delete r15[r16];
|
|
let tmp28 = closure_0;
|
|
let offscreenDisabledUsers = closure_0.offscreenDisabledUsers;
|
|
delete r15[r16];
|
|
let tmp29 = connection2;
|
|
}
|
|
}
|
|
let tmp12 = closure_0;
|
|
if (null == closure_0.offscreenUsers[tmp10]) {
|
|
let tmp23 = closure_0;
|
|
closure_0.offscreenUsers[tmp10] = timestamp;
|
|
let tmp24 = closure_0;
|
|
let addLruResult = closure_0.addLru(tmp10, timestamp, items);
|
|
let tmp26 = connection2;
|
|
} else {
|
|
let tmp13 = closure_0;
|
|
let tmp14 = connection2;
|
|
if (!closure_0.offscreenDisabledUsers[tmp10]) {
|
|
let tmp15 = closure_0;
|
|
let tmp17 = closure_0;
|
|
let diff = timestamp - closure_0.offscreenUsers[tmp10];
|
|
if (diff >= closure_0.getOffscreenTimeoutMs()) {
|
|
let tmp21 = closure_0;
|
|
closure_0.offscreenDisabledUsers[tmp10] = true;
|
|
let tmp22 = connection2;
|
|
} else {
|
|
let tmp18 = closure_0;
|
|
let addLruResult1 = closure_0.addLru(tmp10, timestamp, items);
|
|
let tmp20 = connection2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
iter3 = tmp7();
|
|
iter2 = iter3;
|
|
} while (!iter3.done);
|
|
}
|
|
if (items.length > 0) {
|
|
const sum = timestamp + tmp7Result.getOffscreenTimeoutMs();
|
|
const tmp35 = callback3(items);
|
|
const iter4 = tmp35();
|
|
let iter5 = iter4;
|
|
let bound = sum;
|
|
let tmp37 = sum;
|
|
if (!iter4.done) {
|
|
do {
|
|
let _Math = Math;
|
|
let tmp38 = closure_0;
|
|
let tmp39 = closure_0;
|
|
bound = Math.min(bound, closure_0.offscreenUsers[iter5.value] + closure_0.getOffscreenTimeoutMs());
|
|
let iter6 = tmp35();
|
|
iter5 = iter6;
|
|
tmp37 = bound;
|
|
done = iter6.done;
|
|
} while (!done);
|
|
}
|
|
const offscreenTimeout2 = tmp7Result.offscreenTimeout;
|
|
offscreenTimeout2.start(tmp37 - timestamp, tmp7Result.update);
|
|
} else {
|
|
const offscreenTimeout = tmp7Result.offscreenTimeout;
|
|
offscreenTimeout.stop();
|
|
}
|
|
const obj = callback(closure_2[13]);
|
|
}
|
|
}
|
|
};
|
|
tmp7Result.handleLocalVideoDisabled = () => {
|
|
tmp7Result.update();
|
|
};
|
|
tmp7Result.handleLocalMute = () => {
|
|
tmp7Result.update();
|
|
};
|
|
tmp7Result.update = () => {
|
|
let arr2;
|
|
let tmp28;
|
|
let items = arg0;
|
|
if (arg0 === undefined) {
|
|
items = [];
|
|
}
|
|
let wantsLevel = tmp7Result.getWantsLevel();
|
|
let tmp2 = callback4(wantsLevel);
|
|
let obj = tmp7Result(closure_2[11]);
|
|
let tmp3 = tmp2;
|
|
if (obj.getBrowserInvertedWantsConfig("RTCMediaSinkWantsManager.update").invertWants) {
|
|
tmp7Result.invertWants(tmp2, wantsLevel);
|
|
let tmp7 = tmp2;
|
|
if (closure_15) {
|
|
obj = {};
|
|
const merged = Object.assign(tmp2);
|
|
tmp7 = obj;
|
|
}
|
|
tmp3 = tmp7;
|
|
}
|
|
tmp7Result.updateOffscreenUsers();
|
|
let isDesktopResult = tmp7Result(closure_2[14]).isDesktop();
|
|
if (isDesktopResult) {
|
|
isDesktopResult = tmp7Result.isOneToOneCall();
|
|
}
|
|
if (isDesktopResult) {
|
|
isDesktopResult = !tmp7Result.isStageChannel;
|
|
}
|
|
const obj3 = tmp7Result(closure_2[14]);
|
|
const tmp15 = callback3(callback(closure_2[13]).entries(tmp7Result.videoSsrcs));
|
|
const iter = tmp15();
|
|
let iter2 = iter;
|
|
if (!iter.done) {
|
|
while (true) {
|
|
let tmp26 = callback2;
|
|
let tmp27 = callback2(iter2.value, 2);
|
|
[tmp28, arr2] = tmp27;
|
|
let items1 = [];
|
|
let tmp29 = tmp7Result;
|
|
let tmp30 = tmp7Result;
|
|
let tmp31 = tmp7Result.streamPixelCounts[closure_0.streamIds[tmp28]];
|
|
let num = 0;
|
|
if (null != tmp31) {
|
|
num = tmp31;
|
|
}
|
|
let tmp32 = tmp7Result;
|
|
let wantsLevel1 = tmp7Result.getWantsLevel(num);
|
|
let ssrc = arr2[0].ssrc;
|
|
let tmp34 = tmp7Result;
|
|
if (tmp7Result.shouldReceiveFromUser(tmp28)) {
|
|
let tmp47 = tmp7Result;
|
|
let tmp48 = tmp28 === tmp7Result.selectedParticipantId && tmp16;
|
|
if (tmp48) {
|
|
let tmp49 = tmp7Result;
|
|
tmp48 = !tmp7Result.pipOpen;
|
|
}
|
|
if (arr2.length > 1) {
|
|
let tmp50 = callback3;
|
|
let tmp51 = callback3(arr2);
|
|
let iter6 = tmp51();
|
|
let tmp52 = ssrc;
|
|
let iter7 = iter6;
|
|
let tmp53 = ssrc;
|
|
let tmp54 = iter6;
|
|
if (!iter6.done) {
|
|
do {
|
|
let value = iter7.value;
|
|
if (value.quality === 100) {
|
|
let ssrc3 = value.ssrc;
|
|
if (tmp48) {
|
|
tmp2[ssrc3] = 100;
|
|
let ssrc2 = value.ssrc;
|
|
} else {
|
|
tmp2[ssrc3] = 0;
|
|
ssrc2 = tmp52;
|
|
}
|
|
} else if (tmp48) {
|
|
tmp2[value.ssrc] = 0;
|
|
ssrc2 = tmp52;
|
|
} else {
|
|
if (isDesktopResult) {
|
|
tmp2[value.ssrc] = wantsLevel1;
|
|
}
|
|
ssrc2 = value.ssrc;
|
|
}
|
|
let iter8 = tmp51();
|
|
tmp52 = ssrc2;
|
|
iter7 = iter8;
|
|
tmp53 = ssrc2;
|
|
tmp54 = iter8;
|
|
let tmp20 = value;
|
|
} while (!iter8.done);
|
|
}
|
|
let tmp55 = tmp7Result;
|
|
let obj5 = items1;
|
|
let flag = false;
|
|
let tmp37 = tmp53;
|
|
let tmp38 = tmp48;
|
|
let tmp39 = tmp54;
|
|
let tmp40 = tmp51;
|
|
let tmp41 = tmp20;
|
|
let tmp42 = tmp21;
|
|
let tmp43 = tmp22;
|
|
let tmp44 = tmp23;
|
|
let tmp45 = tmp24;
|
|
let tmp46 = tmp25;
|
|
if (tmp7Result.supportsSeamless) {
|
|
let tmp56 = tmp7Result;
|
|
obj5 = items1;
|
|
flag = false;
|
|
tmp37 = tmp53;
|
|
tmp38 = tmp48;
|
|
tmp39 = tmp54;
|
|
tmp40 = tmp51;
|
|
tmp41 = tmp20;
|
|
tmp42 = tmp21;
|
|
tmp43 = tmp22;
|
|
tmp44 = tmp23;
|
|
tmp45 = tmp24;
|
|
tmp46 = tmp25;
|
|
if (!tmp7Result.framesReceived[tmp53]) {
|
|
let items2 = [tmp53];
|
|
let tmp57 = callback3;
|
|
let tmp58 = callback3(arr2);
|
|
let iter9 = tmp58();
|
|
let iter10 = iter9;
|
|
obj5 = items2;
|
|
flag = true;
|
|
tmp37 = tmp53;
|
|
tmp38 = tmp48;
|
|
tmp39 = tmp54;
|
|
tmp40 = tmp51;
|
|
tmp41 = tmp20;
|
|
tmp42 = iter9;
|
|
tmp43 = tmp58;
|
|
tmp44 = tmp23;
|
|
tmp45 = tmp24;
|
|
tmp46 = tmp25;
|
|
if (!iter9.done) {
|
|
while (true) {
|
|
value = iter10.value;
|
|
let tmp59 = value.ssrc !== tmp53;
|
|
if (tmp59) {
|
|
let tmp60 = tmp7Result;
|
|
tmp59 = tmp7Result.framesReceived[value.ssrc];
|
|
}
|
|
if (tmp59) {
|
|
break;
|
|
} else {
|
|
let iter11 = tmp58();
|
|
iter10 = iter11;
|
|
obj5 = items2;
|
|
flag = true;
|
|
tmp37 = tmp53;
|
|
tmp38 = tmp48;
|
|
tmp39 = tmp54;
|
|
tmp40 = tmp51;
|
|
tmp41 = tmp20;
|
|
tmp42 = iter11;
|
|
tmp43 = tmp58;
|
|
tmp44 = value;
|
|
tmp45 = tmp24;
|
|
tmp46 = tmp25;
|
|
continue;
|
|
}
|
|
}
|
|
if (value.quality === 100) {
|
|
tmp2[value.ssrc] = 100;
|
|
} else {
|
|
let tmp61 = wantsLevel;
|
|
if (isDesktopResult) {
|
|
tmp61 = wantsLevel1;
|
|
}
|
|
tmp2[value.ssrc] = tmp61;
|
|
}
|
|
let arr = items2.push(value.ssrc);
|
|
}
|
|
}
|
|
}
|
|
} else if (tmp48) {
|
|
tmp2[ssrc] = 100;
|
|
obj5 = items1;
|
|
flag = false;
|
|
tmp37 = ssrc;
|
|
tmp38 = tmp48;
|
|
tmp39 = tmp18;
|
|
tmp40 = tmp19;
|
|
tmp41 = tmp20;
|
|
tmp42 = tmp21;
|
|
tmp43 = tmp22;
|
|
tmp44 = tmp23;
|
|
tmp45 = tmp24;
|
|
tmp46 = tmp25;
|
|
} else {
|
|
obj5 = items1;
|
|
flag = false;
|
|
tmp37 = ssrc;
|
|
tmp38 = tmp48;
|
|
tmp39 = tmp18;
|
|
tmp40 = tmp19;
|
|
tmp41 = tmp20;
|
|
tmp42 = tmp21;
|
|
tmp43 = tmp22;
|
|
tmp44 = tmp23;
|
|
tmp45 = tmp24;
|
|
tmp46 = tmp25;
|
|
if (isDesktopResult) {
|
|
tmp2[ssrc] = wantsLevel1;
|
|
obj5 = items1;
|
|
flag = false;
|
|
tmp37 = ssrc;
|
|
tmp38 = tmp48;
|
|
tmp39 = tmp18;
|
|
tmp40 = tmp19;
|
|
tmp41 = tmp20;
|
|
tmp42 = tmp21;
|
|
tmp43 = tmp22;
|
|
tmp44 = tmp23;
|
|
tmp45 = tmp24;
|
|
tmp46 = tmp25;
|
|
}
|
|
}
|
|
} else {
|
|
let tmp35 = callback3;
|
|
let tmp36 = callback3(arr2);
|
|
let iter3 = tmp36();
|
|
let iter4 = iter3;
|
|
obj5 = items1;
|
|
flag = false;
|
|
tmp37 = ssrc;
|
|
tmp38 = tmp17;
|
|
tmp39 = tmp18;
|
|
tmp40 = tmp19;
|
|
tmp41 = tmp20;
|
|
tmp42 = tmp21;
|
|
tmp43 = tmp22;
|
|
tmp44 = tmp23;
|
|
tmp45 = iter3;
|
|
tmp46 = tmp36;
|
|
if (!iter3.done) {
|
|
tmp2[iter4.value.ssrc] = 0;
|
|
let iter5 = tmp36();
|
|
iter4 = iter5;
|
|
obj5 = items1;
|
|
flag = false;
|
|
tmp37 = ssrc;
|
|
tmp38 = tmp17;
|
|
tmp39 = tmp18;
|
|
tmp40 = tmp19;
|
|
tmp41 = tmp20;
|
|
tmp42 = tmp21;
|
|
tmp43 = tmp22;
|
|
tmp44 = tmp23;
|
|
tmp45 = iter5;
|
|
tmp46 = tmp36;
|
|
}
|
|
}
|
|
let tmp63 = tmp7Result;
|
|
let simulcastOverrideQuality = tmp7Result.getSimulcastOverrideQuality(tmp28);
|
|
let tmp65 = constants;
|
|
if (simulcastOverrideQuality === constants.HIGH) {
|
|
tmp2[tmp37] = 100;
|
|
} else {
|
|
let tmp66 = constants;
|
|
if (simulcastOverrideQuality === constants.LOW) {
|
|
tmp2[tmp37] = 50;
|
|
}
|
|
}
|
|
let tmp67 = tmp7Result;
|
|
let tmp68 = tmp7Result.supportsSeamless && flag;
|
|
if (!tmp68) {
|
|
let items3 = [tmp37];
|
|
obj5 = items3;
|
|
}
|
|
let tmp69 = callback3;
|
|
let tmp70 = callback3(arr2);
|
|
let iter12 = tmp70();
|
|
if (!iter12.done) {
|
|
do {
|
|
value = iter12.value;
|
|
if (!obj5.includes(value.ssrc)) {
|
|
let tmp71 = closure_0;
|
|
let framesReceived = closure_0.framesReceived;
|
|
let ssrc4 = value.ssrc;
|
|
delete r45[r5];
|
|
}
|
|
let iter13 = tmp70();
|
|
iter12 = iter13;
|
|
let tmp72 = value;
|
|
} while (!iter13.done);
|
|
}
|
|
let hasItem = items.includes(tmp28);
|
|
if (!hasItem) {
|
|
let tmp74 = tmp7Result;
|
|
let tmp75 = undefined !== tmp7Result.remoteVideoSsrcs[tmp28];
|
|
if (tmp75) {
|
|
let tmp76 = callback;
|
|
let tmp77 = closure_2;
|
|
let tmp78 = tmp7Result;
|
|
tmp75 = !callback(closure_2[15])(tmp7Result.remoteVideoSsrcs[tmp28], obj5);
|
|
}
|
|
hasItem = tmp75;
|
|
}
|
|
if (hasItem) {
|
|
let tmp79 = tmp7Result;
|
|
let items4 = [];
|
|
let tmp80 = items4;
|
|
let tmp81 = obj5;
|
|
let num2 = 0;
|
|
let arraySpreadResult = HermesBuiltin.arraySpread(obj5, 0);
|
|
tmp7Result.remoteVideoSsrcs[tmp28] = items4;
|
|
let tmp83 = tmp7Result;
|
|
let tmp84 = closure_16;
|
|
let tmp85 = tmp7Result;
|
|
let tmp86 = tmp7Result;
|
|
let tmp87 = tmp28;
|
|
let tmp88 = obj5;
|
|
let emitResult = tmp7Result.emit(closure_16.UserSSRCUpdate, tmp28, tmp7Result.audioSsrcs[tmp28], obj5);
|
|
}
|
|
let iter14 = tmp15();
|
|
iter2 = iter14;
|
|
let tmp17 = tmp38;
|
|
let tmp18 = tmp39;
|
|
let tmp19 = tmp40;
|
|
tmp20 = tmp41;
|
|
let tmp21 = tmp42;
|
|
let tmp22 = tmp43;
|
|
let tmp23 = tmp44;
|
|
let tmp24 = tmp45;
|
|
let tmp25 = tmp46;
|
|
}
|
|
}
|
|
if (closure_15) {
|
|
tmp2 = tmp3;
|
|
}
|
|
const entries = Object.entries(tmp7Result.audioSsrcs);
|
|
for (let num3 = 0; num3 < entries.length; num3 = num3 + 1) {
|
|
let tmp90 = callback2;
|
|
let tmp91 = callback2(entries[num3], 2);
|
|
let tmp93 = tmp7Result;
|
|
let connection = tmp7Result.connection;
|
|
let localMute = null != connection;
|
|
if (localMute) {
|
|
localMute = connection.getLocalMute(tmp92);
|
|
}
|
|
if (localMute) {
|
|
tmp2[tmp91[1]] = 0;
|
|
}
|
|
}
|
|
let isEqualResult = null == tmp7Result.connection;
|
|
if (!isEqualResult) {
|
|
isEqualResult = callback(closure_2[16]).isEqual(tmp7Result.latestWants, tmp2);
|
|
const obj6 = callback(closure_2[16]);
|
|
}
|
|
if (!isEqualResult) {
|
|
tmp7Result.latestWants = tmp2;
|
|
wantsLevel = tmp7Result;
|
|
wantsLevel = closure_16;
|
|
wantsLevel = tmp7Result.emit(closure_16.Update, tmp2);
|
|
}
|
|
return tmp2;
|
|
};
|
|
tmp7Result.incomingVideoEnabledChanged = () => {
|
|
tmp7Result.update();
|
|
};
|
|
delayedCall = new RTCMediaSinkWantsManager(closure_2[17]).DelayedCall(100, tmp7Result.update);
|
|
tmp7Result.delayedCall = delayedCall;
|
|
timeout = new RTCMediaSinkWantsManager(closure_2[17]).Timeout();
|
|
tmp7Result.offscreenTimeout = timeout;
|
|
WindowVisibilityVideoManager = RTCMediaSinkWantsManager(closure_2[18]).WindowVisibilityVideoManager;
|
|
onResult = WindowVisibilityVideoManager.on(RTCMediaSinkWantsManager(closure_2[18]).WindowVisibilityEvent.IncomingVideoEnabledChanged, tmp7Result.incomingVideoEnabledChanged);
|
|
return tmp7Result;
|
|
}
|
|
}
|
|
const arg1 = RTCMediaSinkWantsManager;
|
|
callback2(RTCMediaSinkWantsManager, arg0);
|
|
let obj = {
|
|
key: "getWantsLevel",
|
|
value() {
|
|
let num = arg0;
|
|
const self = this;
|
|
if (arg0 === undefined) {
|
|
num = 0;
|
|
}
|
|
const ladder = self.ladder;
|
|
return ladder.getMaxSinkValue(self.getVideoParticipantCount(), num);
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , , , , , , , , , , , , , , ];
|
|
obj = {
|
|
key: "userVideoDisabled",
|
|
value(arg0) {
|
|
return this.offscreenDisabledUsers[arg0];
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "isOneToOneCall",
|
|
value() {
|
|
return 1 === this.otherUsers.size;
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "updateCallUserIds",
|
|
value(items) {
|
|
this.otherUsers = new Set(items);
|
|
const otherUsers = this.otherUsers;
|
|
otherUsers.delete(id.getId());
|
|
this.update();
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "shouldReceiveFromUser",
|
|
value(arg0) {
|
|
const self = this;
|
|
const connection = this.connection;
|
|
let tmp = null != connection && connection.getLocalVideoDisabled(arg0);
|
|
if (!tmp) {
|
|
let userVideoDisabledResult = self.userVideoDisabled(arg0);
|
|
if (userVideoDisabledResult) {
|
|
const videoHealthManager = self.videoHealthManager;
|
|
let currentVideoToggleState;
|
|
if (null != videoHealthManager) {
|
|
currentVideoToggleState = videoHealthManager.getCurrentVideoToggleState(arg0);
|
|
}
|
|
userVideoDisabledResult = currentVideoToggleState !== constants.AUTO_PROBING;
|
|
}
|
|
tmp = userVideoDisabledResult;
|
|
}
|
|
const WindowVisibilityVideoManager = RTCMediaSinkWantsManager(closure_2[18]).WindowVisibilityVideoManager;
|
|
return WindowVisibilityVideoManager.isIncomingVideoEnabled() && !tmp;
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "invertWants",
|
|
value(arg0, arg1) {
|
|
let length;
|
|
let values = Object.values(this.videoSsrcs);
|
|
for (let num = 0; num < values.length; num = num + 1) {
|
|
let tmp = callback3;
|
|
let tmp2 = callback3(values[num]);
|
|
let iter = tmp2();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
let tmp3 = closure_15;
|
|
if (closure_15) {
|
|
if (value.quality !== 100) {
|
|
arg0[value.ssrc] = 100;
|
|
} else {
|
|
arg0[value.ssrc] = 0;
|
|
}
|
|
} else {
|
|
arg0[value.ssrc] = arg1;
|
|
}
|
|
let iter2 = tmp2();
|
|
iter = iter2;
|
|
let tmp4 = value;
|
|
} while (!iter2.done);
|
|
}
|
|
}
|
|
values = Object.values(this.audioSsrcs);
|
|
let num2 = 0;
|
|
if (0 < values.length) {
|
|
do {
|
|
arg0[values[num2]] = 100;
|
|
num2 = num2 + 1;
|
|
length = values.length;
|
|
} while (num2 < length);
|
|
}
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "getAudioSSRCs",
|
|
value() {
|
|
return this.audioSsrcs;
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "setConnection",
|
|
value(connection) {
|
|
let flag = arg1;
|
|
const self = this;
|
|
if (arg1 === undefined) {
|
|
flag = true;
|
|
}
|
|
connection = self.connection;
|
|
if (null != connection) {
|
|
connection.removeListener(RTCMediaSinkWantsManager(closure_2[19]).BaseConnectionEvent.LocalVideoDisabled, self.handleLocalVideoDisabled);
|
|
}
|
|
const connection2 = self.connection;
|
|
if (null != connection2) {
|
|
connection2.removeListener(RTCMediaSinkWantsManager(closure_2[19]).BaseConnectionEvent.LocalMute, self.handleLocalMute);
|
|
}
|
|
const connection3 = self.connection;
|
|
if (null != connection3) {
|
|
connection3.removeListener(RTCMediaSinkWantsManager(closure_2[19]).BaseConnectionEvent.ActiveSinksChange, self.delayedUpdate);
|
|
}
|
|
self.connection = connection;
|
|
const connection4 = self.connection;
|
|
if (null != connection4) {
|
|
connection4.addListener(RTCMediaSinkWantsManager(closure_2[19]).BaseConnectionEvent.LocalVideoDisabled, self.handleLocalVideoDisabled);
|
|
}
|
|
const connection5 = self.connection;
|
|
if (null != connection5) {
|
|
connection5.addListener(RTCMediaSinkWantsManager(closure_2[19]).BaseConnectionEvent.LocalMute, self.handleLocalMute);
|
|
}
|
|
const connection6 = self.connection;
|
|
if (null != connection6) {
|
|
connection6.addListener(RTCMediaSinkWantsManager(closure_2[19]).BaseConnectionEvent.ActiveSinksChange, self.delayedUpdate);
|
|
}
|
|
if (flag) {
|
|
self.update();
|
|
}
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "setAudioSSRC",
|
|
value(arg0, arg1) {
|
|
const self = this;
|
|
if (arg1 > 0) {
|
|
self.audioSsrcs[arg0] = arg1;
|
|
} else {
|
|
const audioSsrcs = self.audioSsrcs;
|
|
delete r0[r3];
|
|
}
|
|
return self.update();
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "setVideoSSRCs",
|
|
value(arg0, arr) {
|
|
let done;
|
|
const self = this;
|
|
const found = arr.filter((active) => {
|
|
active = active.active;
|
|
if (active) {
|
|
const ssrc = active.ssrc;
|
|
let num2 = 0;
|
|
if (null != ssrc) {
|
|
num2 = ssrc;
|
|
}
|
|
active = num2 > 0;
|
|
}
|
|
return active;
|
|
});
|
|
const mapped = found.map((quality) => {
|
|
const obj = {};
|
|
quality = quality.quality;
|
|
let num = 100;
|
|
if (null != quality) {
|
|
num = quality;
|
|
}
|
|
obj.quality = num;
|
|
obj.ssrc = quality.ssrc;
|
|
return obj;
|
|
});
|
|
if (mapped.length > 0) {
|
|
self.videoSsrcs[arg0] = mapped;
|
|
const participants2 = self.participants;
|
|
participants2.add(arg0);
|
|
} else {
|
|
if (undefined !== self.videoSsrcs[arg0]) {
|
|
const tmp2 = callback3(self.videoSsrcs[arg0]);
|
|
let iter = tmp2();
|
|
if (!iter.done) {
|
|
do {
|
|
let ssrc = iter.value.ssrc;
|
|
let framesReceived = self.framesReceived;
|
|
delete r0[r7];
|
|
let iter2 = tmp2();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
}
|
|
const remoteVideoSsrcs = self.remoteVideoSsrcs;
|
|
delete r0[r3];
|
|
const videoSsrcs = self.videoSsrcs;
|
|
delete r0[r3];
|
|
const participants = self.participants;
|
|
participants.delete(arg0);
|
|
self.emit(UserSSRCUpdate.UserSSRCUpdate, arg0, self.audioSsrcs[arg0], []);
|
|
}
|
|
return self.update(Array.from(self.participants));
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "setFirstFrameReceived",
|
|
value(arg0) {
|
|
this.framesReceived[arg0] = true;
|
|
return this.update();
|
|
}
|
|
};
|
|
items[11] = {
|
|
key: "setStreamId",
|
|
value(arg0, arg1) {
|
|
const self = this;
|
|
if (null != arg1) {
|
|
self.streamIds[arg0] = arg1;
|
|
} else {
|
|
if (arg0 in self.streamIds) {
|
|
const streamPixelCounts = self.streamPixelCounts;
|
|
delete r4[r0];
|
|
}
|
|
const streamIds = self.streamIds;
|
|
delete r0[r3];
|
|
}
|
|
return self.update();
|
|
}
|
|
};
|
|
items[12] = {
|
|
key: "destroyUser",
|
|
value(arg0) {
|
|
delete r0[r1];
|
|
delete r0[r1];
|
|
const participants = this.participants;
|
|
participants.delete(arg0);
|
|
delete r3[r0];
|
|
delete r0[r1];
|
|
return this.update(Array.from(this.participants));
|
|
}
|
|
};
|
|
items[13] = {
|
|
key: "reset",
|
|
value() {
|
|
this.setConnection(null, false);
|
|
this.audioSsrcs = {};
|
|
this.videoSsrcs = {};
|
|
this.remoteVideoSsrcs = {};
|
|
this.framesReceived = {};
|
|
this.streamIds = {};
|
|
this.streamPixelCounts = {};
|
|
this.latestWants = callback5(100);
|
|
const WindowVisibilityVideoManager = RTCMediaSinkWantsManager(closure_2[18]).WindowVisibilityVideoManager;
|
|
WindowVisibilityVideoManager.off(RTCMediaSinkWantsManager(closure_2[18]).WindowVisibilityEvent.IncomingVideoEnabledChanged, this.incomingVideoEnabledChanged);
|
|
}
|
|
};
|
|
items[14] = {
|
|
key: "setSelectedParticipant",
|
|
value(selectedParticipantId) {
|
|
const self = this;
|
|
const RTCMediaSinkWantsManager = this;
|
|
if (selectedParticipantId === this.selectedParticipantId) {
|
|
return self.latestWants;
|
|
} else {
|
|
const items = [];
|
|
if (tmp) {
|
|
items.push(self.selectedParticipantId);
|
|
}
|
|
if (null != selectedParticipantId) {
|
|
const participants = self.participants;
|
|
if (participants.has(selectedParticipantId)) {
|
|
self.selectedParticipantId = selectedParticipantId;
|
|
items.push(selectedParticipantId);
|
|
} else if (self.userId !== selectedParticipantId) {
|
|
return self.latestWants;
|
|
} else {
|
|
self.selectedParticipantId = selectedParticipantId;
|
|
}
|
|
} else {
|
|
self.selectedParticipantId = null;
|
|
}
|
|
return self.update(items.filter((arg0) => {
|
|
let length;
|
|
if (null != self.videoSsrcs[arg0]) {
|
|
length = arr.length;
|
|
}
|
|
return length > 1;
|
|
}));
|
|
}
|
|
}
|
|
};
|
|
items[15] = {
|
|
key: "setPipOpen",
|
|
value(pipOpen) {
|
|
const self = this;
|
|
this.pipOpen = pipOpen;
|
|
if (null != this.selectedParticipantId) {
|
|
const items = [self.selectedParticipantId];
|
|
let latestWants = self.update(items);
|
|
} else {
|
|
latestWants = self.latestWants;
|
|
}
|
|
return latestWants;
|
|
}
|
|
};
|
|
items[16] = {
|
|
key: "getOffscreenDisabledUsers",
|
|
value() {
|
|
return this.offscreenDisabledUsers;
|
|
}
|
|
};
|
|
items[17] = {
|
|
key: "setSimulcastDebugOverride",
|
|
value(arg0, arg1) {
|
|
const simulcastDebugOverrides = this.simulcastDebugOverrides;
|
|
const result = simulcastDebugOverrides.set(arg0, arg1);
|
|
this.update();
|
|
}
|
|
};
|
|
items[18] = {
|
|
key: "setVideoSize",
|
|
value(arg0, arg1) {
|
|
const self = this;
|
|
if (arg1 > 0) {
|
|
self.streamPixelCounts[arg0] = arg1;
|
|
} else {
|
|
const streamPixelCounts = self.streamPixelCounts;
|
|
delete r0[r3];
|
|
}
|
|
self.delayedUpdate();
|
|
}
|
|
};
|
|
items[19] = {
|
|
key: "getVideoParticipantCount",
|
|
value() {
|
|
const keys = Object.keys(this.videoSsrcs);
|
|
let num = 0;
|
|
let num2 = 0;
|
|
let num3 = 0;
|
|
if (0 < keys.length) {
|
|
do {
|
|
let connection = this.connection;
|
|
let tmp2 = null != connection && connection.getLocalVideoDisabled(tmp);
|
|
let sum = num2;
|
|
if (!tmp2) {
|
|
sum = num2 + 1;
|
|
}
|
|
num3 = num3 + 1;
|
|
num2 = sum;
|
|
num = sum;
|
|
} while (num3 < keys.length);
|
|
}
|
|
return num;
|
|
}
|
|
};
|
|
items[20] = {
|
|
key: "getOffscreenTimeoutMs",
|
|
value() {
|
|
return this.isStageChannel ? closure_14 : closure_13;
|
|
}
|
|
};
|
|
items[21] = {
|
|
key: "getSimulcastOverrideQuality",
|
|
value(arg0) {
|
|
const simulcastDebugOverrides = this.simulcastDebugOverrides;
|
|
if (simulcastDebugOverrides.has(arg0)) {
|
|
const simulcastDebugOverrides2 = this.simulcastDebugOverrides;
|
|
let NO_OVERRIDE = simulcastDebugOverrides2.get(arg0);
|
|
} else {
|
|
NO_OVERRIDE = constants2.NO_OVERRIDE;
|
|
}
|
|
return NO_OVERRIDE;
|
|
}
|
|
};
|
|
return callback(RTCMediaSinkWantsManager, items);
|
|
}(importDefault(dependencyMap[20]));
|
|
const result = arg1(dependencyMap[21]).fileFinishedImporting("lib/RTCMediaSinkWantsManager.tsx");
|
|
|
|
export default tmp2;
|
|
export const DEFAULT_WANTS_FULL = { any: 100 };
|
|
export const DEFAULT_WANTS_DISABLED = obj;
|
|
export const RTCMediaSinkWantsManagerEvent = obj;
|