<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/resources/testdriver.js"></script>
<script src="/resources/testdriver-vendor.js"></script>
<script src="/mediacapture-image/resources/imagecapture-helpers.js"></script>
<script>
// This test verifies that we can set some nondefault constraints, then clone a
// MediaStreamTrack and check that the cloned constraints are the same as the
// original, with a mock Mojo service implementation.
image_capture_test(async (t, imageCaptureTest) => {
await test_driver.set_permission({name: 'camera', panTiltZoom: true},
'granted');
const constraints = { advanced : [{ whiteBalanceMode : 'single-shot',
exposureMode : 'manual',
focusMode : 'single-shot',
pointsOfInterest : [{x : 0.1, y : 0.2},
{x : 0.3, y : 0.4}],
exposureCompensation : 133.77,
exposureTime : 10000,
colorTemperature : 6000,
iso : 120.0,
brightness : 3,
contrast : 4,
saturation : 5,
sharpness : 6,
focusDistance : 7,
pan : 8,
tilt : 9,
zoom : 3.141592,
torch : true
}]};
for (const [key, value] of Object.entries(constraints.advanced[0])) {
constraints[key] = {exact: value};
}
let stream = await navigator.mediaDevices.getUserMedia({video: true});
let originalVideoTrack = stream.getVideoTracks()[0];
await originalVideoTrack.applyConstraints(constraints);
let appliedConstraints = originalVideoTrack.getConstraints();
let clonedVideoTrack = originalVideoTrack.clone();
let appliedClonedConstraints = clonedVideoTrack.getConstraints();
assert_true('advanced' in appliedClonedConstraints);
assert_equals(appliedClonedConstraints.advanced.length, 1);
const appliedClonedAdvancedConstraints = appliedClonedConstraints.advanced[0];
// Check that |appliedClonedConstraints| and |appliedConstraints| are equal.
const appliedAdvancedConstraints = appliedConstraints.advanced[0];
assert_equals(appliedAdvancedConstraints.length, appliedClonedAdvancedConstraints.length);
Object.keys(appliedClonedAdvancedConstraints).forEach(key => {
assert_not_equals(appliedClonedConstraints[key], undefined, 'key ' + key);
assert_not_equals(appliedConstraints[key], undefined, 'key ' + key);
assert_not_equals(appliedConstraints[key].exact, undefined, 'key ' + key);
assert_not_equals(appliedAdvancedConstraints[key], undefined, 'key ' + key);
if (key != 'pointsOfInterest') {
assert_equals(appliedConstraints[key].exact, appliedClonedConstraints[key].exact, key);
assert_equals(appliedAdvancedConstraints[key], appliedClonedAdvancedConstraints[key], key);
} else {
assert_point2d_array_approx_equals(appliedConstraints[key].exact,
appliedClonedConstraints[key].exact, 0.01);
assert_point2d_array_approx_equals(appliedAdvancedConstraints[key],
appliedClonedAdvancedConstraints[key], 0.01);
}
});
assert_equals(appliedAdvancedConstraints.whiteBalanceMode,
appliedClonedAdvancedConstraints.whiteBalanceMode,
'whiteBalanceMode');
assert_equals(appliedAdvancedConstraints.exposureMode,
appliedClonedAdvancedConstraints.exposureMode,
'exposureMode');
assert_equals(appliedAdvancedConstraints.focusMode,
appliedClonedAdvancedConstraints.focusMode,
'focusMode');
assert_point2d_array_approx_equals(
appliedAdvancedConstraints.pointsOfInterest,
appliedClonedAdvancedConstraints.pointsOfInterest,
0.01);
assert_equals(appliedAdvancedConstraints.exposureCompensation,
appliedClonedAdvancedConstraints.exposureCompensation,
'exposureCompensation');
assert_equals(appliedAdvancedConstraints.exposureTime,
appliedClonedAdvancedConstraints.exposureTime,
'exposureTime');
assert_equals(appliedAdvancedConstraints.colorTemperature,
appliedClonedAdvancedConstraints.colorTemperature,
'colorTemperature');
assert_equals(appliedAdvancedConstraints.iso,
appliedClonedAdvancedConstraints.iso,
'iso');
assert_equals(appliedAdvancedConstraints.brightness,
appliedClonedAdvancedConstraints.brightness,
'brightness');
assert_equals(appliedAdvancedConstraints.contrast,
appliedClonedAdvancedConstraints.contrast,
'constrast');
assert_equals(appliedAdvancedConstraints.saturation,
appliedClonedAdvancedConstraints.saturation,
'saturation');
assert_equals(appliedAdvancedConstraints.sharpness,
appliedClonedAdvancedConstraints.sharpness,
'sharpness');
assert_equals(appliedAdvancedConstraints.focusDistance,
appliedClonedAdvancedConstraints.focusDistance,
'focusDistance');
assert_equals(appliedAdvancedConstraints.pan,
appliedClonedAdvancedConstraints.pan,
'pan');
assert_equals(appliedAdvancedConstraints.tilt,
appliedClonedAdvancedConstraints.tilt,
'tilt');
assert_equals(appliedAdvancedConstraints.zoom,
appliedClonedAdvancedConstraints.zoom,
'zoom');
assert_equals(appliedAdvancedConstraints.torch,
appliedClonedAdvancedConstraints.torch,
'torch');
}, 'checks MediaStreamTrack.clone() gets same applied constraints');
// This test verifies that MediaStreamTrack ImageCapture settings are copied
// when cloning a MediaStreamTrack.
image_capture_test(async (t, imageCaptureTest) => {
await test_driver.set_permission({name: 'camera', panTiltZoom: true},
'granted');
let stream = await navigator.mediaDevices.getUserMedia({video: true});
let originalVideoTrack = stream.getVideoTracks()[0];
let clonedVideoTrack = originalVideoTrack.clone();
let settings = originalVideoTrack.getSettings();
let clonedSettings = clonedVideoTrack.getSettings();
assert_equals(settings.whiteBalanceMode,
clonedSettings.whiteBalanceMode,
'whiteBalanceMode');
assert_equals(settings.exposureMode,
clonedSettings.exposureMode,
'exposureMode;');
assert_equals(settings.focusMode,
clonedSettings.focusMode,
'focusMode');
assert_point2d_array_approx_equals(
settings.pointsOfInterest,
clonedSettings.pointsOfInterest,
0.01);
assert_equals(settings.exposureCompensation,
clonedSettings.exposureCompensation,
'exposureCompensation');
assert_equals(settings.exposureTime,
clonedSettings.exposureTime,
'exposureTime');
assert_equals(settings.colorTemperature,
clonedSettings.colorTemperature,
'colorTemperature');
assert_equals(settings.iso,
clonedSettings.iso,
'iso');
assert_equals(settings.brightness,
clonedSettings.brightness,
'brightness');
assert_equals(settings.contrast,
clonedSettings.contrast,
'contrast');
assert_equals(settings.saturation,
clonedSettings.saturation,
'saturation');
assert_equals(settings.sharpness,
clonedSettings.sharpness,
'sharpness');
assert_equals(settings.focusDistance,
clonedSettings.focusDistance,
'focusDistance');
assert_equals(settings.pan,
clonedSettings.pan,
'pan');
assert_equals(settings.tilt,
clonedSettings.tilt,
'tilt');
assert_equals(settings.zoom,
clonedSettings.zoom,
'zoom');
assert_equals(settings.torch,
clonedSettings.torch,
'torch');
}, 'checks MediaStreamTrack.clone() gets same settings');
// This test verifies that MediaStreamTrack ImageCapture capabilities are copied
// when cloning a MediaStreamTrack.
image_capture_test(async (t, imageCaptureTest) => {
await test_driver.set_permission({name: 'camera', panTiltZoom: true},
'granted');
let stream = await navigator.mediaDevices.getUserMedia({video: true});
let originalVideoTrack = stream.getVideoTracks()[0];
let clonedVideoTrack = originalVideoTrack.clone();
let capabilities = originalVideoTrack.getCapabilities();
let clonedCapabilities = clonedVideoTrack.getCapabilities();
assert_equals(capabilities.whiteBalanceMode.length,
clonedCapabilities.whiteBalanceMode.length,
'whiteBalanceMode length');
for (i = 0; i < capabilities.whiteBalanceMode.length; ++i) {
assert_equals(capabilities.whiteBalanceMode[i],
clonedCapabilities.whiteBalanceMode[i],
'whiteBalanceMode');
}
assert_equals(capabilities.exposureMode.length,
clonedCapabilities.exposureMode.length,
'exposureMode length');
for (i = 0; i < capabilities.exposureMode.length; ++i) {
assert_equals(capabilities.exposureMode[i],
clonedCapabilities.exposureMode[i],
'exposureMode');
}
assert_equals(capabilities.focusMode.length,
clonedCapabilities.focusMode.length,
'focusMode length');
for (i = 0; i < capabilities.focusMode.length; ++i) {
assert_equals(capabilities.focusMode[i],
clonedCapabilities.focusMode[i],
'focusMode');
}
assert_equals(capabilities.exposureCompensation.max,
clonedCapabilities.exposureCompensation.max,
'exposureCompensation max');
assert_equals(capabilities.exposureCompensation.min,
clonedCapabilities.exposureCompensation.min,
'exposureCompensation min');
assert_equals(capabilities.exposureCompensation.step,
clonedCapabilities.exposureCompensation.step,
'exposureCompensation step');
assert_equals(capabilities.exposureTime.max,
clonedCapabilities.exposureTime.max,
'exposureTime max');
assert_equals(capabilities.exposureTime.min,
clonedCapabilities.exposureTime.min,
'exposureTime min');
assert_equals(capabilities.exposureTime.step,
clonedCapabilities.exposureTime.step,
'exposureTime step');
assert_equals(capabilities.colorTemperature.max,
clonedCapabilities.colorTemperature.max,
'colorTemperature max');
assert_equals(capabilities.colorTemperature.min,
clonedCapabilities.colorTemperature.min,
'colorTemperature min');
assert_equals(capabilities.colorTemperature.step,
clonedCapabilities.colorTemperature.step,
'colorTemperature step');
assert_equals(capabilities.iso.max,
clonedCapabilities.iso.max,
'iso max');
assert_equals(capabilities.iso.min,
clonedCapabilities.iso.min,
'iso min');
assert_equals(capabilities.iso.step,
clonedCapabilities.iso.step,
'iso step');
assert_equals(capabilities.brightness.max,
clonedCapabilities.brightness.max,
'brightness max');
assert_equals(capabilities.brightness.min,
clonedCapabilities.brightness.min,
'brightness min');
assert_equals(capabilities.brightness.step,
clonedCapabilities.brightness.step,
'brightness step');
assert_equals(capabilities.contrast.max,
clonedCapabilities.contrast.max,
'contrast max');
assert_equals(capabilities.contrast.min,
clonedCapabilities.contrast.min,
'contrast min');
assert_equals(capabilities.contrast.step,
clonedCapabilities.contrast.step,
'contrast step');
assert_equals(capabilities.saturation.max,
clonedCapabilities.saturation.max,
'saturation max');
assert_equals(capabilities.saturation.min,
clonedCapabilities.saturation.min,
'saturation min');
assert_equals(capabilities.saturation.step,
clonedCapabilities.saturation.step,
'saturation step');
assert_equals(capabilities.sharpness.max,
clonedCapabilities.sharpness.max,
'sharpness max');
assert_equals(capabilities.sharpness.min,
clonedCapabilities.sharpness.min,
'sharpness min');
assert_equals(capabilities.sharpness.step,
clonedCapabilities.sharpness.step,
'sharpness step');
assert_equals(capabilities.focusDistance.max,
clonedCapabilities.focusDistance.max,
'focusDistance max');
assert_equals(capabilities.focusDistance.min,
clonedCapabilities.focusDistance.min,
'focusDistance min');
assert_equals(capabilities.focusDistance.step,
clonedCapabilities.focusDistance.step,
'focusDistance step');
assert_equals(capabilities.pan.max,
clonedCapabilities.pan.max,
'pan max');
assert_equals(capabilities.pan.min,
clonedCapabilities.pan.min,
'pan min');
assert_equals(capabilities.pan.step,
clonedCapabilities.pan.step,
'pan step');
assert_equals(capabilities.tilt.max,
clonedCapabilities.tilt.max,
'tilt max');
assert_equals(capabilities.tilt.min,
clonedCapabilities.tilt.min,
'tilt min');
assert_equals(capabilities.tilt.step,
clonedCapabilities.tilt.step,
'tilt step');
assert_equals(capabilities.zoom.max,
clonedCapabilities.zoom.max,
'zoom max');
assert_equals(capabilities.zoom.min,
clonedCapabilities.zoom.min,
'zoom min');
assert_equals(capabilities.zoom.step,
clonedCapabilities.zoom.step,
'zoom step');
assert_equals(capabilities.torch,
clonedCapabilities.torch,
'torch');
}, 'checks MediaStreamTrack.clone() gets same capabilities');
</script>
Codebase Browser
chromium