RTCRtpParameters-encodings.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>

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: