217 lines
6.5 KiB
HTML
217 lines
6.5 KiB
HTML
<!DOCTYPE html>
|
|
<title>MediaCapabilities.decodingInfo() for webrtc</title>
|
|
<script src=/resources/testharness.js></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script>
|
|
|
|
// Minimal VideoConfiguration that will be allowed per spec. All optional
|
|
// properties are missing.
|
|
const minimalVideoConfiguration = {
|
|
contentType: 'video/VP9; profile-level="0"',
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: 24,
|
|
};
|
|
|
|
// Minimal AudioConfiguration that will be allowed per spec. All optional
|
|
// properties are missing.
|
|
const minimalAudioConfiguration = {
|
|
contentType: 'audio/opus',
|
|
};
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
}));
|
|
}, "Test that decodingInfo rejects if the configuration doesn't have an audio or video field");
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: {
|
|
contentType: 'video/VP9',
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: -1,
|
|
},
|
|
}));
|
|
}, "Test that decodingInfo rejects if the video configuration has a negative framerate");
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: {
|
|
contentType: 'video/VP9"',
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: 0,
|
|
},
|
|
}));
|
|
}, "Test that decodingInfo rejects if the video configuration has a framerate set to 0");
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: {
|
|
contentType: 'video/VP9"',
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: Infinity,
|
|
},
|
|
}));
|
|
}, "Test that decodingInfo rejects if the video configuration has a framerate set to Infinity");
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: {
|
|
contentType: 'fgeoa',
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: 24,
|
|
},
|
|
}));
|
|
}, "Test that decodingInfo rejects if the video configuration contentType doesn't parse");
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: {
|
|
contentType: 'audio/fgeoa',
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: 24,
|
|
},
|
|
}));
|
|
}, "Test that decodingInfo rejects if the video configuration contentType isn't of type video");
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
audio: { contentType: 'fgeoa' },
|
|
}));
|
|
}, "Test that decodingInfo rejects if the audio configuration contentType doesn't parse");
|
|
|
|
promise_test(t => {
|
|
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
audio: { contentType: 'video/fgeoa' },
|
|
}));
|
|
}, "Test that decodingInfo rejects if the audio configuration contentType isn't of type audio");
|
|
|
|
promise_test(t => {
|
|
return navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: minimalVideoConfiguration,
|
|
audio: minimalAudioConfiguration,
|
|
}).then(ability => {
|
|
assert_equals(typeof ability.supported, "boolean");
|
|
assert_equals(typeof ability.smooth, "boolean");
|
|
assert_equals(typeof ability.powerEfficient, "boolean");
|
|
});
|
|
}, "Test that decodingInfo returns a valid MediaCapabilitiesInfo objects");
|
|
|
|
promise_test(t => {
|
|
return navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: {
|
|
contentType: 'video/webm; codecs="vp09.00.10.08"',
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: 24,
|
|
},
|
|
audio: minimalAudioConfiguration,
|
|
}).then(ability => {
|
|
assert_false(ability.supported);
|
|
assert_false(ability.smooth);
|
|
assert_false(ability.powerEfficient);
|
|
});
|
|
}, "Test that decodingInfo returns supported, smooth, and powerEfficient set to false for non-webrtc video content type.");
|
|
|
|
promise_test(t => {
|
|
return navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: minimalVideoConfiguration,
|
|
audio: {
|
|
contentType: 'audio/webm; codecs="opus"',
|
|
},
|
|
}).then(ability => {
|
|
assert_false(ability.supported);
|
|
assert_false(ability.smooth);
|
|
assert_false(ability.powerEfficient);
|
|
});
|
|
}, "Test that decodingInfo returns supported, smooth, and powerEfficient set to false for non-webrtc audio content type.");
|
|
|
|
const validAudioCodecs = (() => {
|
|
// Some codecs that are returned by getCapabilities() are not real codecs,
|
|
// exclude these from the test.
|
|
const excludeList = [ 'audio/CN', 'audio/telephone-event', 'audio/red' ];
|
|
const audioCodecs = [];
|
|
RTCRtpReceiver.getCapabilities("audio")['codecs'].forEach(codec => {
|
|
if (excludeList.indexOf(codec.mimeType) < 0 &&
|
|
audioCodecs.indexOf(codec.mimeType) < 0) {
|
|
audioCodecs.push(codec.mimeType);
|
|
}
|
|
});
|
|
return audioCodecs;
|
|
})();
|
|
|
|
validAudioCodecs.forEach(codec => {
|
|
promise_test(t => {
|
|
return navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
audio: {
|
|
contentType: codec
|
|
}
|
|
}).then(ability => {
|
|
assert_true(ability.supported);
|
|
});
|
|
}, "Test that decodingInfo returns supported true for the codec " + codec + " returned by RTCRtpReceiver.getCapabilities()")}
|
|
);
|
|
|
|
const validVideoCodecs = (() => {
|
|
// Some codecs that are returned by getCapabilities() are not real codecs but
|
|
// only used for error correction, exclude these from the test.
|
|
const excludeList = [ 'video/rtx', 'video/red', 'video/ulpfec',
|
|
'video/flexfec-03' ];
|
|
const videoCodecs = [];
|
|
|
|
RTCRtpReceiver.getCapabilities("video")['codecs'].forEach(codec => {
|
|
if (excludeList.indexOf(codec.mimeType) < 0) {
|
|
let mimeType = codec.mimeType;
|
|
if ('sdpFmtpLine' in codec) {
|
|
mimeType += "; " + codec.sdpFmtpLine;
|
|
}
|
|
if (!(mimeType in videoCodecs)) {
|
|
videoCodecs.push(mimeType);
|
|
}
|
|
}
|
|
});
|
|
return videoCodecs;
|
|
})();
|
|
|
|
validVideoCodecs.forEach(codec => {
|
|
promise_test(t => {
|
|
return navigator.mediaCapabilities.decodingInfo({
|
|
type: 'webrtc',
|
|
video: {
|
|
contentType: codec,
|
|
width: 800,
|
|
height: 600,
|
|
bitrate: 3000,
|
|
framerate: 24,
|
|
}
|
|
}).then(ability => {
|
|
assert_true(ability.supported);
|
|
});
|
|
}, "Test that decodingInfo returns supported true for the codec " + codec + " returned by RTCRtpReceiver.getCapabilities()")}
|
|
);
|
|
|
|
</script>
|