diff options
Diffstat (limited to 'testing/web-platform/tests/webrtc/RTCRtpParameters-encodings.html')
| -rw-r--r-- | testing/web-platform/tests/webrtc/RTCRtpParameters-encodings.html | 543 |
1 files changed, 543 insertions, 0 deletions
diff --git a/testing/web-platform/tests/webrtc/RTCRtpParameters-encodings.html b/testing/web-platform/tests/webrtc/RTCRtpParameters-encodings.html new file mode 100644 index 0000000000..22abbb3718 --- /dev/null +++ b/testing/web-platform/tests/webrtc/RTCRtpParameters-encodings.html @@ -0,0 +1,543 @@ +<!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> |