Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test has a WPT meta file that expects 4 subtest issues.
- This WPT test may be referenced by the following Test IDs:
- /webrtc/RTCRtpParameters-codecs.html - WPT Dashboard Interop Dashboard
<!doctype html>
<meta charset=utf-8>
<meta name="timeout" content="long">
<title>RTCRtpParameters codecs</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 src="RTCPeerConnection-helper.js"></script>
<script src="./third_party/sdp/sdp.js"></script>
<script>
'use strict';
// Test is based on the following editor draft:
// The following helper functions are called from RTCRtpParameters-helper.js:
// doOfferAnswerExchange
// validateSenderRtpParameters
/*
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 RTCRtpCodecParameters {
[readonly]
unsigned short payloadType;
[readonly]
DOMString mimeType;
[readonly]
unsigned long clockRate;
[readonly]
unsigned short channels;
[readonly]
DOMString sdpFmtpLine;
};
getParameters
- The codecs sequence is populated based on the codecs that have been negotiated
for sending, and which the user agent is currently capable of sending.
If setParameters has removed or reordered codecs, getParameters MUST return
the shortened/reordered list. However, every time codecs are renegotiated by
a new offer/answer exchange, the list of codecs MUST be restored to the full
negotiated set, in the priority order indicated by the remote description,
in effect discarding the effects of setParameters.
codecs
- When using the setParameters method, the codecs sequence from the corresponding
call to getParameters can be reordered and entries can be removed, but entries
cannot be added, and the RTCRtpCodecParameters dictionary members cannot be modified.
*/
// Get the first codec from param.codecs.
// Assert that param.codecs has at least one element
function getFirstCodec(param) {
const { codecs } = param;
assert_greater_than(codecs.length, 0);
return codecs[0];
}
function compareCodecParam(observed, expected) {
assert_equals(observed.payloadType, expected.payloadType);
assert_equals(observed.clockRate, expected.clockRate);
assert_equals(observed.channels, expected.channels);
// Comparisons of mime-type are case-insensitive (see
assert_equals(observed.mimeType.toLowerCase(), expected.mimeType.toLowerCase());
// This is not ideal; Firefox does not store fmtp verbatim, it stores a
// reserialiaztion of the parsed form. We would like to be able to test
// the other fields without tripping over that. So, we only test
// sdpFmtpLine if it is a property of |expected|.
if (expected.hasOwnProperty('sdpFmtpLine')) {
assert_equals(observed.sdpFmtpLine, expected.sdpFmtpLine);
}
}
function compareCodecParams(observed, expected) {
assert_equals(observed.length, expected.length);
for (let i = 0; i < observed.length; ++i) {
compareCodecParam(observed[i], expected[i]);
}
}
// Does not support disregarding unsupported codecs in the SDP, so is not
// suitable for all test-cases.
function checkCodecsAgainstSDP(codecs, msection) {
const rtpParameters = SDPUtils.parseRtpParameters(msection);
const {kind} = SDPUtils.parseMLine(msection);
assert_not_equals(codecs.length, 0);
assert_equals(codecs.length, rtpParameters.codecs.length);
for (let i = 0; i < codecs.length; ++i) {
const observed = codecs[i];
const fromSdp = rtpParameters.codecs[i];
const expected = {
payloadType: fromSdp.payloadType,
clockRate: fromSdp.clockRate,
mimeType: `${kind}/${fromSdp.name}`,
};
if (kind == 'audio') {
expected.channels = fromSdp.channels;
}
const fmtps = SDPUtils.matchPrefixAndTrim(msection, `a=fmtp:${fromSdp.payloadType}`);
if (fmtps.length == 1) {
expected.sdpFmtpLine = fmtps[0];
} else {
// compareCodecParam will check if observed.sdpFmtpLine is undefined if we
// set this, but will not perform any checks if we do not.
expected.sdpFmtpLine = undefined;
}
compareCodecParam(observed, expected);
}
}
['audio', 'video'].forEach(kind => {
/*
5.2. setParameters
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(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const codec = getFirstCodec(param);
if(codec.payloadType === undefined) {
codec.payloadType = 8;
} else {
codec.payloadType += 1;
}
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codec.payloadType modified should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const codec = getFirstCodec(param);
if(codec.mimeType === undefined) {
codec.mimeType = `${kind}/piedpiper`;
} else {
codec.mimeType = `${codec.mimeType}-modified`;
}
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codec.mimeType modified should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const codec = getFirstCodec(param);
if(codec.clockRate === undefined) {
codec.clockRate = 8000;
} else {
codec.clockRate += 1;
}
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codec.clockRate modified should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const codec = getFirstCodec(param);
if(codec.channels === undefined) {
codec.channels = 6;
} else {
codec.channels += 1;
}
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codec.channels modified should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const codec = getFirstCodec(param);
if(codec.sdpFmtpLine === undefined) {
codec.sdpFmtpLine = 'a=fmtp:98 0-15';
} else {
codec.sdpFmtpLine = `${codec.sdpFmtpLine};foo=1`;
}
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codec.sdpFmtpLine modified should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const { codecs } = param;
codecs.push({
payloadType: 2,
mimeType: `${kind}/piedpiper`,
clockRate: 1000,
channels: 2
});
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with new codecs inserted should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const { codecs } = param;
codecs.pop();
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codecs removed should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
const { codecs } = param;
codecs.reverse();
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codecs reordered should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const param = sender.getParameters();
validateSenderRtpParameters(param);
delete param.codecs;
return promise_rejects_dom(t, 'InvalidModificationError',
sender.setParameters(param));
}, `setParameters() with codecs undefined should reject with InvalidModificationError (${kind})`);
promise_test(async t => {
const pc1 = new RTCPeerConnection();
t.add_cleanup(() => pc1.close());
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc2.close());
const sender1 = pc1.addTransceiver(kind).sender;
let param = sender1.getParameters();
assert_array_equals(param.codecs, [], 'No sender codecs in initial stable state');
const offer = await pc1.createOffer();
param = sender1.getParameters();
assert_array_equals(param.codecs, [], 'No sender codecs in initial stable state (after createOffer)');
await pc1.setLocalDescription(offer);
param = sender1.getParameters();
assert_array_equals(param.codecs, [], 'No sender codecs in initial have-local-offer');
await pc2.setRemoteDescription(offer);
const [sender2] = pc2.getSenders();
param = sender2.getParameters();
assert_array_equals(param.codecs, [], 'No sender codecs in initial have-remote-offer');
const answer = await pc2.createAnswer();
param = sender2.getParameters();
assert_array_equals(param.codecs, [], 'No sender codecs in initial have-remote-offer (after createAnswer)');
}, `RTCRtpSender.getParameters() should not have codecs before SDP negotiation completes (${kind})`);
promise_test(async t => {
const pc1 = new RTCPeerConnection();
t.add_cleanup(() => pc1.close());
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc2.close());
const receiver1 = pc1.addTransceiver(kind).receiver;
let param = receiver1.getParameters();
assert_array_equals(param.codecs, [], 'No receiver codecs in initial stable state');
const offer = await pc1.createOffer();
param = receiver1.getParameters();
assert_array_equals(param.codecs, [], 'No receiver codecs in initial stable state (after createOffer)');
await pc1.setLocalDescription(offer);
param = receiver1.getParameters();
assert_array_equals(param.codecs, [], 'No receiver codecs in initial have-local-offer');
await pc2.setRemoteDescription(offer);
const [receiver2] = pc2.getReceivers();
param = receiver2.getParameters();
assert_array_equals(param.codecs, [], 'No receiver codecs in initial have-remote-offer');
const answer = await pc2.createAnswer();
param = receiver2.getParameters();
assert_array_equals(param.codecs, [], 'No receiver codecs in initial have-remote-offer (after createAnswer)');
}, `RTCRtpReceiver.getParameters() should not have codecs before SDP negotiation completes (${kind})`);
promise_test(async t => {
const pc1 = new RTCPeerConnection();
t.add_cleanup(() => pc1.close());
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc2.close());
const sender1 = pc1.addTransceiver(kind).sender;
await exchangeOfferAnswer(pc1, pc2);
const [sender2] = pc2.getSenders();
let param = sender1.getParameters();
assert_array_field(param, 'codecs');
assert_not_equals(param.codecs.length, 0);
for (const codec of param.codecs) {
validateCodecParameters(codec);
}
param = sender2.getParameters();
assert_array_field(param, 'codecs');
assert_not_equals(param.codecs.length, 0);
for (const codec of param.codecs) {
validateCodecParameters(codec);
}
}, `RTCRtpSender.getParameters() should have codecs after negotiation (${kind})`);
promise_test(async t => {
const pc1 = new RTCPeerConnection();
t.add_cleanup(() => pc1.close());
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc2.close());
const receiver1 = pc1.addTransceiver(kind).receiver;
await exchangeOfferAnswer(pc1, pc2);
const [receiver2] = pc2.getReceivers();
let param = receiver1.getParameters();
assert_array_field(param, 'codecs');
assert_not_equals(param.codecs.length, 0);
for (const codec of param.codecs) {
validateCodecParameters(codec);
}
param = receiver2.getParameters();
assert_array_field(param, 'codecs');
assert_not_equals(param.codecs.length, 0);
for (const codec of param.codecs) {
validateCodecParameters(codec);
}
}, `RTCRtpReceiver.getParameters() should have codecs after negotiation (${kind})`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const { sender } = pc.addTransceiver(kind);
await doOfferAnswerExchange(t, pc);
const {codecs} = pc.getReceivers()[0].getParameters();
const sections = SDPUtils.splitSections(pc.localDescription.sdp);
checkCodecsAgainstSDP(codecs, sections[1]);
}, `RTCRtpReceiver.getParameters() codecs should match local SDP (${kind}, offerer)`);
promise_test(async t => {
const pc1 = new RTCPeerConnection();
t.add_cleanup(() => pc1.close());
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc2.close());
pc1.addTransceiver(kind);
await exchangeOfferAnswer(pc1, pc2);
const {codecs} = pc2.getReceivers()[0].getParameters();
const sections = SDPUtils.splitSections(pc2.localDescription.sdp);
checkCodecsAgainstSDP(codecs, sections[1]);
}, `RTCRtpReceiver.getParameters() codecs should match local SDP (${kind}, answerer)`);
});
// SDP with unusual payload types and fmtp, and an unknown codec
const audioSdp = `v=0
o=- 166855176514521964 2 IN IP4 127.0.0.1
s=-
t=0 0
m=audio 9 UDP/TLS/RTP/SAVPF 121 111 0 101
c=IN IP4 0.0.0.0
a=rtcp:9 IN IP4 0.0.0.0
a=ice-ufrag:foobarba
a=ice-pwd:foobarba
a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
a=setup:passive
a=mid:mid1
a=sendrecv
a=rtcp-rsize
a=rtpmap:101 telephone-event/8000/1
a=rtpmap:121 flarglblurp/8000/2
a=rtpmap:111 opus/48000/2
a=fmtp:111 maxaveragebitrate=20001;unknownparam=foo
`;
// SDP with unusual payload types and fmtp, and an unknown codec
const videoSdp = `v=0
o=- 1878890426675213188 2 IN IP4 127.0.0.1
s=-
t=0 0
m=video 9 UDP/TLS/RTP/SAVPF 116 117 120 124 119 123 122 121 118
c=IN IP4 0.0.0.0
a=sendrecv
a=fmtp:117 apt=116
a=fmtp:120 max-fs=12277;max-fr=50;unknownparam=foo
a=fmtp:124 apt=120
a=fmtp:119 max-fs=12266;max-fr=40
a=fmtp:123 apt=119
a=fmtp:118 apt=121
a=ice-pwd:60840251a559417c253d68478b0020fb
a=ice-ufrag:741347dd
a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
a=setup:passive
a=mid:mid1
a=rtcp-mux
a=rtcp-rsize
a=rtpmap:116 flarglblurp/90000
a=rtpmap:117 rtx/90000
a=rtpmap:120 VP9/90000
a=rtpmap:124 rtx/90000
a=rtpmap:119 VP8/90000
a=rtpmap:123 rtx/90000
a=rtpmap:122 ulpfec/90000
a=rtpmap:121 red/90000
a=rtpmap:118 rtx/90000
`;
const remoteSdpParamsTests = [
{
description: 'audio, no fmtp checks',
kind: 'audio',
sdp: audioSdp,
expectedCodecs: [
{payloadType: 111, clockRate: 48000, channels: 2, mimeType: 'audio/opus'},
{payloadType: 0, clockRate: 8000, channels: 1, mimeType: 'audio/pcmu'},
{payloadType: 101, clockRate: 8000, channels: 1, mimeType: 'audio/telephone-event'},
]
},
{
description: 'audio, with fmtp checks',
kind: 'audio',
sdp: audioSdp,
expectedCodecs: [
{payloadType: 111, clockRate: 48000, channels: 2, mimeType: 'audio/opus', sdpFmtpLine: 'maxaveragebitrate=20001;unknownparam=foo'},
{payloadType: 0, clockRate: 8000, channels: 1, mimeType: 'audio/pcmu', sdpFmtpLine: undefined},
{payloadType: 101, clockRate: 8000, channels: 1, mimeType: 'audio/telephone-event', sdpFmtpLine: undefined},
]
},
{
description: 'video, minimal fmtp checks',
kind: 'video',
sdp: videoSdp,
expectedCodecs: [
{payloadType: 120, clockRate: 90000, mimeType: 'video/vp9'},
{payloadType: 124, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=120'},
{payloadType: 119, clockRate: 90000, mimeType: 'video/vp8'},
{payloadType: 123, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=119'},
{payloadType: 122, clockRate: 90000, mimeType: 'video/ulpfec'},
{payloadType: 121, clockRate: 90000, mimeType: 'video/red'},
{payloadType: 118, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=121'},
]
},
{
description: 'video, with fmtp checks',
kind: 'video',
sdp: videoSdp,
expectedCodecs: [
{payloadType: 120, clockRate: 90000, mimeType: 'video/vp9', sdpFmtpLine: 'max-fs=12277;max-fr=50;unknownparam=foo'},
{payloadType: 124, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=120'},
{payloadType: 119, clockRate: 90000, mimeType: 'video/vp8', sdpFmtpLine: 'max-fs=12266;max-fr=40'},
{payloadType: 123, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=119'},
{payloadType: 122, clockRate: 90000, mimeType: 'video/ulpfec', sdpFmtpLine: undefined},
{payloadType: 121, clockRate: 90000, mimeType: 'video/red', sdpFmtpLine: undefined},
{payloadType: 118, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=121'},
]
},
];
remoteSdpParamsTests.forEach(test => {
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
pc.addTransceiver(test.kind, { direction: 'sendrecv'});
await pc.setLocalDescription();
const {sender, mid} = pc.getTransceivers()[0];
await pc.setRemoteDescription({sdp: test.sdp.replace('mid1', mid), type: 'answer'});
const {codecs} = sender.getParameters();
compareCodecParams(codecs, test.expectedCodecs);
}, `RTCRtpSender.getParameters() codecs should match remote SDP (${test.description}, offerer)`);
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
await pc.setRemoteDescription({sdp: test.sdp, type: 'offer'});
await pc.setLocalDescription();
const {codecs} = pc.getSenders()[0].getParameters();
compareCodecParams(codecs, test.expectedCodecs);
}, `RTCRtpSender.getParameters() codecs should match remote SDP (${test.description}, answerer)`);
});
</script>