| <!DOCTYPE html> |
| <meta charset="utf-8"> |
| <title>RTCRtpEncodingParameters scaleResolutionDownTo attribute</title> |
| <meta name="timeout" content="long"> |
| <script src="/resources/testharness.js"></script> |
| <script src="/resources/testharnessreport.js"></script> |
| <script src="../webrtc/simulcast/simulcast.js"></script> |
| <script src="../webrtc/third_party/sdp/sdp.js"></script> |
| <script> |
| 'use strict'; |
| |
| // Creates a track that can be resized with `track.resize(w,h)`. |
| function createResizableTrack(width, height) { |
| // Draw to a canvas with a 30 fps interval. |
| const canvas = Object.assign( |
| document.createElement('canvas'), {width, height}); |
| const ctx = canvas.getContext('2d'); |
| ctx.fillStyle = 'rgb(255,0,0)'; |
| const interval = setInterval(() => { |
| ctx.fillRect(0, 0, canvas.width, canvas.height); |
| }, 1000 / 30); |
| // Capture the canvas and add/modify reize() and stop() methods. |
| const stream = canvas.captureStream(); |
| const [track] = stream.getTracks(); |
| track.resize = (w, h) => { |
| canvas.width = w; |
| canvas.height = h; |
| }; |
| const nativeStop = track.stop; |
| track.stop = () => { |
| clearInterval(interval); |
| nativeStop.apply(track); |
| }; |
| return track; |
| } |
| |
| async function getLastEncodedResolution(pc, rid = null) { |
| const report = await pc.getStats(); |
| for (const stats of report.values()) { |
| if (stats.type != 'outbound-rtp') { |
| continue; |
| } |
| if (rid && stats.rid != rid) { |
| continue; |
| } |
| if (!stats.frameWidth || !stats.frameWidth) { |
| // The resolution is missing until the first frame has been encoded. |
| break; |
| } |
| return { width: stats.frameWidth, height: stats.frameHeight }; |
| } |
| return { width: null, height: null }; |
| } |
| |
| async function waitForFrameWithResolution(t, pc, width, height, rid = null) { |
| let resolution; |
| do { |
| resolution = await getLastEncodedResolution(pc, rid); |
| await new Promise(r => t.step_timeout(r, 50)); |
| } while (resolution.width != width || resolution.height != height); |
| } |
| |
| promise_test(async t => { |
| const pc = new RTCPeerConnection(); |
| t.add_cleanup(() => pc.close()); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| assert_throws_dom('OperationError', () => { |
| pc.addTransceiver(track, { |
| sendEncodings:[{ |
| scaleResolutionDownTo: { maxWidth: 0, maxHeight: 0 } |
| }] |
| }); |
| }); |
| }, `addTransceiver: Invalid scaling throws`); |
| |
| promise_test(async t => { |
| const pc = new RTCPeerConnection(); |
| t.add_cleanup(() => pc.close()); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc.addTransceiver(track, {sendEncodings:[{}]}); |
| |
| const params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 0, maxHeight: 0 }; |
| const p = sender.setParameters(params); |
| |
| promise_rejects_dom(t, 'InvalidModificationError', p); |
| }, `setParameters: Invalid scaling throws`); |
| |
| promise_test(async t => { |
| const pc = new RTCPeerConnection(); |
| t.add_cleanup(() => pc.close()); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| assert_throws_dom('OperationError', () => { |
| pc.addTransceiver(track, { |
| sendEncodings:[{ |
| scaleResolutionDownTo: undefined, |
| }, { |
| scaleResolutionDownTo: { maxWidth: 120, maxHeight: 60 } |
| }] |
| }); |
| }); |
| }, `addTransceiver: Specifying scaling on a subset of active encodings throws`); |
| |
| promise_test(async t => { |
| const pc = new RTCPeerConnection(); |
| t.add_cleanup(() => pc.close()); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| pc.addTransceiver(track, { |
| sendEncodings:[{ |
| active: true, |
| scaleResolutionDownTo: { maxWidth: 120, maxHeight: 60 }, |
| }, { |
| active: false, |
| scaleResolutionDownTo: undefined |
| }] |
| }); |
| }, `addTransceiver: Specifying scaling on inactive encodings is optional`); |
| |
| promise_test(async t => { |
| const pc = new RTCPeerConnection(); |
| t.add_cleanup(() => pc.close()); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc.addTransceiver(track, {sendEncodings:[{},{}]}); |
| |
| const params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = undefined; |
| params.encodings[1].scaleResolutionDownTo = { maxWidth: 120, maxHeight: 60 }; |
| const p = sender.setParameters(params); |
| |
| promise_rejects_dom(t, 'InvalidModificationError', p); |
| }, `setParameters: Specifying scaling on a subset of active encodings throws`); |
| |
| promise_test(async t => { |
| const pc = new RTCPeerConnection(); |
| t.add_cleanup(() => pc.close()); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc.addTransceiver(track, {sendEncodings:[{},{}]}); |
| |
| const params = sender.getParameters(); |
| params.encodings[0].active = true; |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 120, maxHeight: 60 }; |
| params.encodings[1].active = false; |
| params.encodings[1].scaleResolutionDownTo = undefined; |
| await sender.setParameters(params); |
| }, `setParameters: Specifying scaling on inactive encodings is optional`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| |
| let {sender} = pc1.addTransceiver(track, { |
| sendEncodings:[{ |
| scaleResolutionDownTo: { maxWidth: 120, maxHeight: 60 } |
| }] |
| }); |
| |
| // Get the initial value set. |
| let params = sender.getParameters(); |
| assert_equals(params.encodings[0].scaleResolutionDownTo?.maxWidth, 120); |
| assert_equals(params.encodings[0].scaleResolutionDownTo?.maxHeight, 60); |
| // Set parameters and get the result. |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 60, maxHeight: 30 }; |
| await sender.setParameters(params); |
| params = sender.getParameters(); |
| assert_equals(params.encodings[0].scaleResolutionDownTo?.maxWidth, 60); |
| assert_equals(params.encodings[0].scaleResolutionDownTo?.maxHeight, 30); |
| }, `getParameters reflect the current scaleResolutionDownTo`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| |
| pc1.addTransceiver(track, { |
| sendEncodings:[{ |
| scaleResolutionDownBy: 2.0, |
| scaleResolutionDownTo: { maxWidth: 120, maxHeight: 60 } |
| }] |
| }); |
| |
| await pc1.setLocalDescription(); |
| await pc2.setRemoteDescription(pc1.localDescription); |
| await pc2.setLocalDescription(); |
| await pc1.setRemoteDescription(pc2.localDescription); |
| |
| await waitForFrameWithResolution(t, pc1, 120, 60); |
| }, `addTransceiver: scaleResolutionDownBy is ignored when ` + |
| `scaleResolutionDownTo is specified`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc1.addTransceiver(track); |
| |
| const params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownBy = 2.0; |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 120, maxHeight: 60 }; |
| const p = sender.setParameters(params); |
| |
| await pc1.setLocalDescription(); |
| await pc2.setRemoteDescription(pc1.localDescription); |
| await pc2.setLocalDescription(); |
| await pc1.setRemoteDescription(pc2.localDescription); |
| |
| await waitForFrameWithResolution(t, pc1, 120, 60); |
| }, `setParameters: scaleResolutionDownBy is ignored when ` + |
| `scaleResolutionDownTo is specified`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc1.addTransceiver(track, { |
| sendEncodings: [{ |
| scaleResolutionDownTo: { maxWidth: 60, maxHeight: 30 } |
| }] |
| }); |
| |
| await pc1.setLocalDescription(); |
| await pc2.setRemoteDescription(pc1.localDescription); |
| await pc2.setLocalDescription(); |
| await pc1.setRemoteDescription(pc2.localDescription); |
| |
| await waitForFrameWithResolution(t, pc1, 60, 30); |
| }, `addTransceiver: scaleResolutionDownTo with half resolution`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc1.addTransceiver(track); |
| |
| await pc1.setLocalDescription(); |
| await pc2.setRemoteDescription(pc1.localDescription); |
| await pc2.setLocalDescription(); |
| await pc1.setRemoteDescription(pc2.localDescription); |
| |
| // Request full resolution. |
| let params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 120, maxHeight: 60 }; |
| await sender.setParameters(params); |
| await waitForFrameWithResolution(t, pc1, 120, 60); |
| |
| // Request half resolution. |
| params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 60, maxHeight: 30 }; |
| await sender.setParameters(params); |
| await waitForFrameWithResolution(t, pc1, 60, 30); |
| |
| // Request full resolution again. |
| params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 120, maxHeight: 60 }; |
| await sender.setParameters(params); |
| await waitForFrameWithResolution(t, pc1, 120, 60); |
| }, `setParameters: Modify scaleResolutionDownTo while sending`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(80, 40); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc1.addTransceiver(track); |
| |
| await pc1.setLocalDescription(); |
| await pc2.setRemoteDescription(pc1.localDescription); |
| await pc2.setLocalDescription(); |
| await pc1.setRemoteDescription(pc2.localDescription); |
| |
| // scaleTo is portrait, track is landscape, but no scaling should happen due |
| // to orientation agnosticism. |
| let params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 40, maxHeight: 80 }; |
| await sender.setParameters(params); |
| await waitForFrameWithResolution(t, pc1, 80, 40); |
| |
| // Change orientation of the track: still no downscale, but encoder begins to |
| // produce the new orientation. |
| track.resize(40, 80); |
| await waitForFrameWithResolution(t, pc1, 40, 80); |
| |
| // scaleTo in landscape, reducing to half size. Verify track, which is |
| // portrait, is scaled down by 2. |
| params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 40, maxHeight: 20 }; |
| await sender.setParameters(params); |
| await waitForFrameWithResolution(t, pc1, 20, 40); |
| }, `scaleResolutionDownTo is orientation agnostic`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(120, 60); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc1.addTransceiver(track); |
| |
| await pc1.setLocalDescription(); |
| await pc2.setRemoteDescription(pc1.localDescription); |
| await pc2.setLocalDescription(); |
| await pc1.setRemoteDescription(pc2.localDescription); |
| |
| // Restrict to 60x60. This results in 60x30 due to maintaining aspect ratio. |
| let params = sender.getParameters(); |
| params.encodings[0].scaleResolutionDownTo = { maxWidth: 60, maxHeight: 60 }; |
| await sender.setParameters(params); |
| await waitForFrameWithResolution(t, pc1, 60, 30); |
| }, `scaleResolutionDownTo does not change aspect ratio`); |
| |
| promise_test(async t => { |
| const pc1 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc1.close()); |
| const pc2 = new RTCPeerConnection(); |
| t.add_cleanup(() => pc2.close()); |
| pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate); |
| pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate); |
| |
| const track = createResizableTrack(160, 80); |
| t.add_cleanup(() => track.stop()); |
| const {sender} = pc1.addTransceiver(track, { |
| sendEncodings: [{ |
| rid: '0', |
| scaleResolutionDownTo: { maxWidth: 40, maxHeight: 20 } |
| }, { |
| rid: '1', |
| scaleResolutionDownTo: { maxWidth: 80, maxHeight: 40 } |
| }, { |
| rid: '2', |
| scaleResolutionDownTo: { maxWidth: 160, maxHeight: 80 } |
| }] |
| }); |
| |
| // Negotiate with simulcast tweaks. |
| await doOfferToSendSimulcastAndAnswer(pc1, pc2, ['0', '1', '2']); |
| |
| await waitForFrameWithResolution(t, pc1, 40, 20, '0'); |
| await waitForFrameWithResolution(t, pc1, 80, 40, '1'); |
| await waitForFrameWithResolution(t, pc1, 160, 80, '2'); |
| }, `scaleResolutionDownTo with simulcast`); |
| </script> |
