543 lines
22 KiB
HTML
543 lines
22 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<title>RTCRtpParameters encodings</title>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="dictionary-helper.js"></script>
|
|
<script src="RTCRtpParameters-helper.js"></script>
|
|
<script>
|
|
'use strict';
|
|
|
|
// Test is based on the following editor draft:
|
|
// https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
|
|
|
|
// The following helper functions are called from RTCRtpParameters-helper.js:
|
|
// validateSenderRtpParameters
|
|
|
|
/*
|
|
5.1. RTCPeerConnection Interface Extensions
|
|
partial interface RTCPeerConnection {
|
|
RTCRtpTransceiver addTransceiver((MediaStreamTrack or DOMString) trackOrKind,
|
|
optional RTCRtpTransceiverInit init);
|
|
...
|
|
};
|
|
|
|
dictionary RTCRtpTransceiverInit {
|
|
RTCRtpTransceiverDirection direction = "sendrecv";
|
|
sequence<MediaStream> streams;
|
|
sequence<RTCRtpEncodingParameters> sendEncodings;
|
|
};
|
|
|
|
5.2. RTCRtpSender Interface
|
|
interface RTCRtpSender {
|
|
Promise<void> setParameters(optional RTCRtpParameters parameters);
|
|
RTCRtpParameters getParameters();
|
|
};
|
|
|
|
dictionary RTCRtpParameters {
|
|
DOMString transactionId;
|
|
sequence<RTCRtpEncodingParameters> encodings;
|
|
sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
|
|
RTCRtcpParameters rtcp;
|
|
sequence<RTCRtpCodecParameters> codecs;
|
|
};
|
|
|
|
dictionary RTCRtpEncodingParameters {
|
|
boolean active;
|
|
unsigned long maxBitrate;
|
|
|
|
[readonly]
|
|
DOMString rid;
|
|
|
|
double scaleResolutionDownBy;
|
|
};
|
|
|
|
getParameters
|
|
- encodings is set to the value of the [[send encodings]] internal slot.
|
|
*/
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('video');
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
assert_equals(param.encodings.length, 1);
|
|
// Do not call this in every test; it does not make sense to disable all of
|
|
// the tests below for an implementation that is missing support for
|
|
// fields that are not related to the test.
|
|
validateSenderRtpParameters(param);
|
|
}, `getParameters should return RTCRtpEncodingParameters with all required fields`);
|
|
|
|
/*
|
|
5.1. addTransceiver
|
|
7. Create an RTCRtpSender with track, streams and sendEncodings and let sender
|
|
be the result.
|
|
|
|
5.2. create an RTCRtpSender
|
|
5. Let sender have a [[send encodings]] internal slot, representing a list
|
|
of RTCRtpEncodingParameters dictionaries.
|
|
6. If sendEncodings is given as input to this algorithm, and is non-empty,
|
|
set the [[send encodings]] slot to sendEncodings.
|
|
|
|
Otherwise, set it to a list containing a single RTCRtpEncodingParameters
|
|
with active set to true.
|
|
*/
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('audio');
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 1);
|
|
const encoding = param.encodings[0];
|
|
|
|
assert_equals(encoding.active, true);
|
|
assert_not_own_property(encoding, "maxBitrate");
|
|
assert_not_own_property(encoding, "rid");
|
|
assert_not_own_property(encoding, "scaleResolutionDownBy");
|
|
// We do not check props from extension specifications here; those checks
|
|
// need to go in a test-case for that extension specification.
|
|
}, 'addTransceiver(audio) with undefined sendEncodings should have default encoding parameter with active set to true');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('video');
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 1);
|
|
const encoding = param.encodings[0];
|
|
|
|
assert_equals(encoding.active, true);
|
|
// spec says to return an encoding without a scaleResolutionDownBy value
|
|
// when addTransceiver does not pass any encodings, however spec also says
|
|
// to throw if setParameters is missing a scaleResolutionDownBy. One of
|
|
// these two requirements needs to be removed, but it is unclear right now
|
|
// which will be removed. For now, allow scaleResolutionDownBy, but don't
|
|
// require it.
|
|
// https://github.com/w3c/webrtc-pc/issues/2730
|
|
assert_not_own_property(encoding, "maxBitrate");
|
|
assert_not_own_property(encoding, "rid");
|
|
assert_equals(encoding.scaleResolutionDownBy, 1.0);
|
|
// We do not check props from extension specifications here; those checks
|
|
// need to go in a test-case for that extension specification.
|
|
}, 'addTransceiver(video) with undefined sendEncodings should have default encoding parameter with active set to true and scaleResolutionDownBy set to 1');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('audio', { sendEncodings: [] });
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 1);
|
|
const encoding = param.encodings[0];
|
|
|
|
assert_equals(encoding.active, true);
|
|
assert_not_own_property(encoding, "maxBitrate");
|
|
assert_not_own_property(encoding, "rid");
|
|
assert_not_own_property(encoding, "scaleResolutionDownBy");
|
|
// We do not check props from extension specifications here; those checks
|
|
// need to go in a test-case for that extension specification.
|
|
}, 'addTransceiver(audio) with empty list sendEncodings should have default encoding parameter with active set to true');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('video', { sendEncodings: [] });
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 1);
|
|
const encoding = param.encodings[0];
|
|
|
|
assert_equals(encoding.active, true);
|
|
assert_not_own_property(encoding, "maxBitrate");
|
|
assert_not_own_property(encoding, "rid");
|
|
assert_equals(encoding.scaleResolutionDownBy, 1.0);
|
|
// We do not check props from extension specifications here; those checks
|
|
// need to go in a test-case for that extension specification.
|
|
}, 'addTransceiver(video) with empty list sendEncodings should have default encoding parameter with active set to true and scaleResolutionDownBy set to 1');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('video', {sendEncodings: [{rid: "foo"}, {rid: "bar", scaleResolutionDownBy: 3.0}]});
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 2);
|
|
assert_equals(encodings[0].scaleResolutionDownBy, 1.0);
|
|
assert_equals(encodings[1].scaleResolutionDownBy, 3.0);
|
|
}, `addTransceiver(video) should auto-set scaleResolutionDownBy to 1 when some encodings have it, but not all`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('video', {sendEncodings: [{rid: "foo"}, {rid: "bar"}]});
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 2);
|
|
assert_equals(encodings[0].scaleResolutionDownBy, 2.0);
|
|
assert_equals(encodings[1].scaleResolutionDownBy, 1.0);
|
|
}, `addTransceiver should auto-set scaleResolutionDownBy to powers of 2 (descending) when absent`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const sendEncodings = [];
|
|
for (let i = 0; i < 1000; i++) {
|
|
sendEncodings.push({rid: i});
|
|
}
|
|
const transceiver = pc.addTransceiver('video', {sendEncodings});
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_less_than(encodings.length, 1000, `1000 encodings is clearly too many`);
|
|
}, `addTransceiver with a ridiculous number of encodings should truncate the list`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const transceiver = pc.addTransceiver('audio', {sendEncodings: [{rid: "foo"}, {rid: "bar"}]});
|
|
|
|
const param = transceiver.sender.getParameters();
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 1);
|
|
assert_not_own_property(encodings[0], "maxBitrate");
|
|
assert_not_own_property(encodings[0], "rid");
|
|
assert_not_own_property(encodings[0], "scaleResolutionDownBy");
|
|
// We do not check props from extension specifications here; those checks
|
|
// need to go in a test-case for that extension specification.
|
|
}, `addTransceiver(audio) with multiple encodings should result in one encoding with no properties other than active`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const {sender} = pc.addTransceiver('audio', {sendEncodings: [{rid: "foo", scaleResolutionDownBy: 2.0}]});
|
|
const {encodings} = sender.getParameters();
|
|
assert_equals(encodings.length, 1);
|
|
assert_not_own_property(encodings[0], "scaleResolutionDownBy");
|
|
}, `addTransceiver(audio) should remove valid scaleResolutionDownBy`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const {sender} = pc.addTransceiver('audio', {sendEncodings: [{rid: "foo", scaleResolutionDownBy: -1.0}]});
|
|
const {encodings} = sender.getParameters();
|
|
assert_equals(encodings.length, 1);
|
|
assert_not_own_property(encodings[0], "scaleResolutionDownBy");
|
|
}, `addTransceiver(audio) should remove invalid scaleResolutionDownBy`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const {sender} = pc.addTransceiver('audio');
|
|
let params = sender.getParameters();
|
|
assert_equals(params.encodings.length, 1);
|
|
params.encodings[0].scaleResolutionDownBy = 2;
|
|
await sender.setParameters(params);
|
|
const {encodings} = sender.getParameters();
|
|
assert_equals(encodings.length, 1);
|
|
assert_not_own_property(encodings[0], "scaleResolutionDownBy");
|
|
}, `setParameters with scaleResolutionDownBy on an audio sender should succeed, but remove the scaleResolutionDownBy`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const {sender} = pc.addTransceiver('audio');
|
|
let params = sender.getParameters();
|
|
assert_equals(params.encodings.length, 1);
|
|
params.encodings[0].scaleResolutionDownBy = -1;
|
|
await sender.setParameters(params);
|
|
const {encodings} = sender.getParameters();
|
|
assert_equals(encodings.length, 1);
|
|
assert_not_own_property(encodings[0], "scaleResolutionDownBy");
|
|
}, `setParameters with an invalid scaleResolutionDownBy on an audio sender should succeed, but remove the scaleResolutionDownBy`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: "foo"}, {rid: "foo"}] }));
|
|
}, 'addTransceiver with duplicate rid and multiple encodings throws TypeError');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: "foo"}, {}] }));
|
|
}, 'addTransceiver with missing rid and multiple encodings throws TypeError');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: ""}] }));
|
|
}, 'addTransceiver with empty rid throws TypeError');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: "!?"}] }));
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: "(╯°□°)╯︵ ┻━┻"}] }));
|
|
// RFC 8851 says '-' and '_' are allowed, but RFC 8852 says they are not.
|
|
// RFC 8852 needs to be adhered to, otherwise we can't put the rid in RTP
|
|
// https://github.com/w3c/webrtc-pc/issues/2732
|
|
// https://www.rfc-editor.org/errata/eid7132
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: "foo-bar"}] }));
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: "foo_bar"}] }));
|
|
}, 'addTransceiver with invalid rid characters throws TypeError');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
// https://github.com/w3c/webrtc-pc/issues/2732
|
|
assert_throws_js(TypeError, () => pc.addTransceiver('video', { sendEncodings: [{rid: 'a'.repeat(256)}] }));
|
|
}, 'addTransceiver with rid longer than 255 characters throws TypeError');
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
assert_throws_js(RangeError, () => pc.addTransceiver('video', { sendEncodings: [{scaleResolutionDownBy: -1}] }));
|
|
assert_throws_js(RangeError, () => pc.addTransceiver('video', { sendEncodings: [{scaleResolutionDownBy: 0}] }));
|
|
assert_throws_js(RangeError, () => pc.addTransceiver('video', { sendEncodings: [{scaleResolutionDownBy: 0.5}] }));
|
|
}, `addTransceiver with scaleResolutionDownBy < 1 throws RangeError`);
|
|
|
|
/*
|
|
5.2. create an RTCRtpSender
|
|
To create an RTCRtpSender with a MediaStreamTrack , track, a list of MediaStream
|
|
objects, streams, and optionally a list of RTCRtpEncodingParameters objects,
|
|
sendEncodings, run the following steps:
|
|
5. Let sender have a [[send encodings]] internal slot, representing a list
|
|
of RTCRtpEncodingParameters dictionaries.
|
|
|
|
6. If sendEncodings is given as input to this algorithm, and is non-empty,
|
|
set the [[send encodings]] slot to sendEncodings.
|
|
|
|
5.2. getParameters
|
|
- encodings is set to the value of the [[send encodings]] internal slot.
|
|
*/
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video', {
|
|
sendEncodings: [{
|
|
active: false,
|
|
maxBitrate: 8,
|
|
rid: 'foo'
|
|
}]
|
|
});
|
|
|
|
const param = sender.getParameters();
|
|
const encoding = param.encodings[0];
|
|
|
|
assert_equals(encoding.active, false);
|
|
assert_equals(encoding.maxBitrate, 8);
|
|
assert_not_own_property(encoding, "rid", "rid should be removed with a single encoding");
|
|
|
|
}, `sender.getParameters() should return sendEncodings set by addTransceiver()`);
|
|
|
|
/*
|
|
5.2. setParameters
|
|
3. Let N be the number of RTCRtpEncodingParameters stored in sender's internal
|
|
[[send encodings]] slot.
|
|
7. If parameters.encodings.length is different from N, or if any parameter
|
|
in the parameters argument, marked as a Read-only parameter, has a value
|
|
that is different from the corresponding parameter value returned from
|
|
sender.getParameters(), abort these steps and return a promise rejected
|
|
with a newly created InvalidModificationError. Note that this also applies
|
|
to transactionId.
|
|
*/
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video');
|
|
|
|
const param = sender.getParameters();
|
|
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 1);
|
|
|
|
// While {} is valid RTCRtpEncodingParameters because all fields are
|
|
// optional, it is still invalid to be missing a rid when there are multiple
|
|
// encodings. Only trigger one kind of error here.
|
|
encodings.push({ rid: "foo" });
|
|
assert_equals(param.encodings.length, 2);
|
|
|
|
return promise_rejects_dom(t, 'InvalidModificationError',
|
|
sender.setParameters(param));
|
|
}, `sender.setParameters() with added encodings should reject with InvalidModificationError`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video', {sendEncodings: [{rid: "foo"}, {rid: "bar"}]});
|
|
|
|
const param = sender.getParameters();
|
|
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 2);
|
|
|
|
encodings.pop();
|
|
assert_equals(param.encodings.length, 1);
|
|
|
|
return promise_rejects_dom(t, 'InvalidModificationError',
|
|
sender.setParameters(param));
|
|
}, `sender.setParameters() with removed encodings should reject with InvalidModificationError`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video', {sendEncodings: [{rid: "foo"}, {rid: "bar"}]});
|
|
|
|
const param = sender.getParameters();
|
|
|
|
const { encodings } = param;
|
|
assert_equals(encodings.length, 2);
|
|
encodings.push(encodings.shift());
|
|
assert_equals(param.encodings.length, 2);
|
|
|
|
return promise_rejects_dom(t, 'InvalidModificationError',
|
|
sender.setParameters(param));
|
|
}, `sender.setParameters() with reordered encodings should reject with InvalidModificationError`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video');
|
|
|
|
const param = sender.getParameters();
|
|
|
|
delete param.encodings;
|
|
|
|
return promise_rejects_js(t, TypeError,
|
|
sender.setParameters(param));
|
|
}, `sender.setParameters() with encodings unset should reject with TypeError`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video');
|
|
|
|
const param = sender.getParameters();
|
|
|
|
param.encodings = [];
|
|
|
|
return promise_rejects_dom(t, 'InvalidModificationError',
|
|
sender.setParameters(param));
|
|
}, `sender.setParameters() with empty encodings should reject with InvalidModificationError (video)`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('audio');
|
|
|
|
const param = sender.getParameters();
|
|
|
|
param.encodings = [];
|
|
|
|
return promise_rejects_dom(t, 'InvalidModificationError',
|
|
sender.setParameters(param));
|
|
}, `sender.setParameters() with empty encodings should reject with InvalidModificationError (audio)`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video', {
|
|
sendEncodings: [{ rid: 'foo' }, { rid: 'baz' }],
|
|
});
|
|
|
|
const param = sender.getParameters();
|
|
const encoding = param.encodings[0];
|
|
|
|
assert_equals(encoding.rid, 'foo');
|
|
|
|
encoding.rid = 'bar';
|
|
return promise_rejects_dom(t, 'InvalidModificationError',
|
|
sender.setParameters(param));
|
|
}, `setParameters() with modified encoding.rid field should reject with InvalidModificationError`);
|
|
|
|
/*
|
|
5.2. setParameters
|
|
8. If the scaleResolutionDownBy parameter in the parameters argument has a
|
|
value less than 1.0, abort these steps and return a promise rejected with
|
|
a newly created RangeError.
|
|
*/
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video');
|
|
|
|
const param = sender.getParameters();
|
|
const encoding = param.encodings[0];
|
|
|
|
encoding.scaleResolutionDownBy = 0.5;
|
|
await promise_rejects_js(t, RangeError, sender.setParameters(param));
|
|
encoding.scaleResolutionDownBy = 0;
|
|
await promise_rejects_js(t, RangeError, sender.setParameters(param));
|
|
encoding.scaleResolutionDownBy = -1;
|
|
await promise_rejects_js(t, RangeError, sender.setParameters(param));
|
|
}, `setParameters() with encoding.scaleResolutionDownBy field set to less than 1.0 should reject with RangeError`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video');
|
|
|
|
let param = sender.getParameters();
|
|
const encoding = param.encodings[0];
|
|
|
|
delete encoding.scaleResolutionDownBy;
|
|
await sender.setParameters(param);
|
|
param = sender.getParameters();
|
|
assert_equals(param.encodings[0].scaleResolutionDownBy, 1.0);
|
|
}, `setParameters() with missing encoding.scaleResolutionDownBy field should succeed, and set the value back to 1`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
const { sender } = pc.addTransceiver('video');
|
|
|
|
const param = sender.getParameters();
|
|
const encoding = param.encodings[0];
|
|
|
|
encoding.scaleResolutionDownBy = 1.5;
|
|
return sender.setParameters(param)
|
|
.then(() => {
|
|
const param = sender.getParameters();
|
|
const encoding = param.encodings[0];
|
|
|
|
assert_approx_equals(encoding.scaleResolutionDownBy, 1.5, 0.01);
|
|
});
|
|
}, `setParameters() with encoding.scaleResolutionDownBy field set to greater than 1.0 should succeed`);
|
|
|
|
test_modified_encoding('video', 'active', false, true,
|
|
'setParameters() with encoding.active false->true should succeed (video)');
|
|
|
|
test_modified_encoding('video', 'active', true, false,
|
|
'setParameters() with encoding.active true->false should succeed (video)');
|
|
|
|
test_modified_encoding('video', 'maxBitrate', 10000, 20000,
|
|
'setParameters() with modified encoding.maxBitrate should succeed (video)');
|
|
|
|
test_modified_encoding('audio', 'active', false, true,
|
|
'setParameters() with encoding.active false->true should succeed (audio)');
|
|
|
|
test_modified_encoding('audio', 'active', true, false,
|
|
'setParameters() with encoding.active true->false should succeed (audio)');
|
|
|
|
test_modified_encoding('audio', 'maxBitrate', 10000, 20000,
|
|
'setParameters() with modified encoding.maxBitrate should succeed (audio)');
|
|
|
|
test_modified_encoding('video', 'scaleResolutionDownBy', 2, 4,
|
|
'setParameters() with modified encoding.scaleResolutionDownBy should succeed');
|
|
|
|
</script>
|