mozilla-central/testing/web-platform/tests/webcodecs/videoFrame-construction.any.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

// META: global=window,dedicatedworker
// META: script=/webcodecs/utils.js
// META: script=/webcodecs/videoFrame-utils.js
test(t => {
let image = makeImageBitmap(32, 16);
let frame = new VideoFrame(image, {timestamp: 10});
assert_equals(frame.timestamp, 10, 'timestamp');
assert_equals(frame.duration, null, 'duration');
assert_equals(frame.visibleRect.width, 32, 'visibleRect.width');
assert_equals(frame.visibleRect.height, 16, 'visibleRect.height');
assert_equals(frame.displayWidth, 32, 'displayWidth');
assert_equals(frame.displayHeight, 16, 'displayHeight');
frame.close();
}, 'Test we can construct a VideoFrame.');
test(t => {
let image = makeImageBitmap(32, 16);
let frame = new VideoFrame(image, {timestamp: 10, duration: 15});
frame.close();
assert_equals(frame.format, null, 'format')
assert_equals(frame.timestamp, 10, 'timestamp');
assert_equals(frame.duration, 15, 'duration');
assert_equals(frame.codedWidth, 0, 'codedWidth');
assert_equals(frame.codedHeight, 0, 'codedHeight');
assert_equals(frame.visibleRect, null, 'visibleRect');
assert_equals(frame.displayWidth, 0, 'displayWidth');
assert_equals(frame.displayHeight, 0, 'displayHeight');
assert_equals(frame.colorSpace.primaries, null, 'colorSpace.primaries');
assert_equals(frame.colorSpace.transfer, null, 'colorSpace.transfer');
assert_equals(frame.colorSpace.matrix, null, 'colorSpace.matrix');
assert_equals(frame.colorSpace.fullRange, null, 'colorSpace.fullRange');
assert_true(isFrameClosed(frame));
assert_throws_dom('InvalidStateError', () => frame.clone());
}, 'Test closed VideoFrame.');
test(t => {
let image = makeImageBitmap(32, 16);
let frame = new VideoFrame(image, {timestamp: -10});
assert_equals(frame.timestamp, -10, 'timestamp');
frame.close();
}, 'Test we can construct a VideoFrame with a negative timestamp.');
promise_test(async t => {
verifyTimestampRequiredToConstructFrame(makeImageBitmap(1, 1));
}, 'Test that timestamp is required when constructing VideoFrame from ImageBitmap');
promise_test(async t => {
verifyTimestampRequiredToConstructFrame(makeOffscreenCanvas(16, 16));
}, 'Test that timestamp is required when constructing VideoFrame from OffscreenCanvas');
promise_test(async t => {
let init = {
format: 'I420',
timestamp: 1234,
codedWidth: 4,
codedHeight: 2
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
let i420Frame = new VideoFrame(data, init);
let validFrame = new VideoFrame(i420Frame);
validFrame.close();
}, 'Test that timestamp is NOT required when constructing VideoFrame from another VideoFrame');
test(t => {
let image = makeImageBitmap(1, 1);
let frame = new VideoFrame(image, {timestamp: 10});
assert_equals(frame.visibleRect.width, 1, 'visibleRect.width');
assert_equals(frame.visibleRect.height, 1, 'visibleRect.height');
assert_equals(frame.displayWidth, 1, 'displayWidth');
assert_equals(frame.displayHeight, 1, 'displayHeight');
frame.close();
}, 'Test we can construct an odd-sized VideoFrame.');
test(t => {
// Test only valid for Window contexts.
if (!('document' in self))
return;
let video = document.createElement('video');
assert_throws_dom('InvalidStateError', () => {
let frame = new VideoFrame(video, {timestamp: 10});
})
}, 'Test constructing w/ unusable image argument throws: HAVE_NOTHING <video>.');
promise_test(async t => {
// Test only valid for Window contexts.
if (!('document' in self))
return;
let video = document.createElement('video');
video.src = 'vp9.mp4';
video.autoplay = true;
video.controls = false;
video.muted = false;
document.body.appendChild(video);
const loadVideo = new Promise((resolve) => {
if (video.requestVideoFrameCallback) {
video.requestVideoFrameCallback(resolve);
return;
}
video.onloadeddata = () => resolve();
});
await loadVideo;
let frame = new VideoFrame(video, {timestamp: 10});
assert_equals(frame.codedWidth, 320, 'codedWidth');
assert_equals(frame.codedHeight, 240, 'codedHeight');
assert_equals(frame.timestamp, 10, 'timestamp');
frame.close();
}, 'Test we can construct a VideoFrame from a <video>.');
test(t => {
let canvas = new OffscreenCanvas(0, 0);
assert_throws_dom('InvalidStateError', () => {
let frame = new VideoFrame(canvas, {timestamp: 10});
})
}, 'Test constructing w/ unusable image argument throws: emtpy Canvas.');
test(t => {
let image = makeImageBitmap(32, 16);
image.close();
assert_throws_dom('InvalidStateError', () => {
let frame = new VideoFrame(image, {timestamp: 10});
})
}, 'Test constructing w/ unusable image argument throws: closed ImageBitmap.');
test(t => {
let image = makeImageBitmap(32, 16);
let frame = new VideoFrame(image, {timestamp: 10});
frame.close();
assert_throws_dom('InvalidStateError', () => {
let newFrame = new VideoFrame(frame);
})
}, 'Test constructing w/ unusable image argument throws: closed VideoFrame.');
test(t => {
let init = {
format: 'I420',
timestamp: 1234,
codedWidth: 4,
codedHeight: 2
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
let i420Frame = new VideoFrame(data, init);
let image = makeImageBitmap(32, 16);
assert_throws_js(
TypeError,
() => new VideoFrame(
image,
{timestamp: 10, visibleRect: {x: -1, y: 0, width: 10, height: 10}}),
'negative visibleRect x');
assert_throws_js(
TypeError,
() => new VideoFrame(
image,
{timestamp: 10, visibleRect: {x: 0, y: 0, width: -10, height: 10}}),
'negative visibleRect width');
assert_throws_js(
TypeError,
() => new VideoFrame(
image,
{timestamp: 10, visibleRect: {x: 0, y: 0, width: 10, height: 0}}),
'zero visibleRect height');
assert_throws_js(
TypeError, () => new VideoFrame(image, {
timestamp: 10,
visibleRect: {x: 0, y: Infinity, width: 10, height: 10}
}),
'non finite visibleRect y');
assert_throws_js(
TypeError, () => new VideoFrame(image, {
timestamp: 10,
visibleRect: {x: 0, y: 0, width: 10, height: Infinity}
}),
'non finite visibleRect height');
assert_throws_js(
TypeError,
() => new VideoFrame(
image,
{timestamp: 10, visibleRect: {x: 0, y: 0, width: 33, height: 17}}),
'visibleRect area exceeds coded size');
assert_throws_js(
TypeError,
() => new VideoFrame(
image,
{timestamp: 10, visibleRect: {x: 2, y: 2, width: 32, height: 16}}),
'visibleRect outside coded size');
assert_throws_js(
TypeError,
() => new VideoFrame(image, {timestamp: 10, displayHeight: 10}),
'displayHeight provided without displayWidth');
assert_throws_js(
TypeError, () => new VideoFrame(image, {timestamp: 10, displayWidth: 10}),
'displayWidth provided without displayHeight');
assert_throws_js(
TypeError,
() => new VideoFrame(
image, {timestamp: 10, displayWidth: 0, displayHeight: 10}),
'displayWidth is zero');
assert_throws_js(
TypeError,
() => new VideoFrame(
image, {timestamp: 10, displayWidth: 10, displayHeight: 0}),
'displayHeight is zero');
assert_throws_js(
TypeError,
() => new VideoFrame(
i420Frame, {visibleRect: {x: 1, y: 0, width: 2, height: 2}}),
'visibleRect x is not sample aligned');
assert_throws_js(
TypeError,
() => new VideoFrame(
i420Frame, {visibleRect: {x: 0, y: 1, width: 2, height: 2}}),
'visibleRect y is not sample aligned');
}, 'Test invalid CanvasImageSource constructed VideoFrames');
test(t => {
let init = {
format: 'I420',
timestamp: 1234,
codedWidth: 4,
codedHeight: 2
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
let origFrame = new VideoFrame(data, init);
let cropLeftHalf = new VideoFrame(
origFrame, {visibleRect: {x: 0, y: 0, width: 2, height: 2}});
assert_equals(cropLeftHalf.codedWidth, origFrame.codedWidth);
assert_equals(cropLeftHalf.codedHeight, origFrame.codedHeight);
assert_equals(cropLeftHalf.visibleRect.x, 0);
assert_equals(cropLeftHalf.visibleRect.y, 0);
assert_equals(cropLeftHalf.visibleRect.width, 2);
assert_equals(cropLeftHalf.visibleRect.height, 2);
assert_equals(cropLeftHalf.displayWidth, 2);
assert_equals(cropLeftHalf.displayHeight, 2);
}, 'Test visibleRect metadata override where source display size = visible size');
test(t => {
let init = {
format: 'I420',
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
displayWidth: 8,
displayHeight: 2
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
let anamorphicFrame = new VideoFrame(data, init);
let cropRightFrame = new VideoFrame(
anamorphicFrame, {visibleRect: {x: 2, y: 0, width: 2, height: 2}});
assert_equals(cropRightFrame.codedWidth, anamorphicFrame.codedWidth);
assert_equals(cropRightFrame.codedHeight, anamorphicFrame.codedHeight);
assert_equals(cropRightFrame.visibleRect.x, 2);
assert_equals(cropRightFrame.visibleRect.y, 0);
assert_equals(cropRightFrame.visibleRect.width, 2);
assert_equals(cropRightFrame.visibleRect.height, 2);
assert_equals(cropRightFrame.displayWidth, 4, 'cropRightFrame.displayWidth');
assert_equals(cropRightFrame.displayHeight, 2, 'cropRightFrame.displayHeight');
}, 'Test visibleRect metadata override where source display width = 2 * visible width (anamorphic)');
test(t => {
let init = {
format: 'I420',
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
displayWidth: 8,
displayHeight: 4
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
let scaledFrame = new VideoFrame(data, init);
let cropRightFrame = new VideoFrame(
scaledFrame, {visibleRect: {x: 2, y: 0, width: 2, height: 2}});
assert_equals(cropRightFrame.codedWidth, scaledFrame.codedWidth);
assert_equals(cropRightFrame.codedHeight, scaledFrame.codedHeight);
assert_equals(cropRightFrame.visibleRect.x, 2);
assert_equals(cropRightFrame.visibleRect.y, 0);
assert_equals(cropRightFrame.visibleRect.width, 2);
assert_equals(cropRightFrame.visibleRect.height, 2);
assert_equals(cropRightFrame.displayWidth, 4, 'cropRightFrame.displayWidth');
assert_equals(cropRightFrame.displayHeight, 4, 'cropRightFrame.displayHeight');
}, 'Test visibleRect metadata override where source display size = 2 * visible size for both width and height');
test(t => {
let image = makeImageBitmap(32, 16);
let scaledFrame = new VideoFrame(image, {
visibleRect: {x: 0, y: 0, width: 2, height: 2},
displayWidth: 10,
displayHeight: 20,
timestamp: 0
});
assert_equals(scaledFrame.codedWidth, 32);
assert_equals(scaledFrame.codedHeight, 16);
assert_equals(scaledFrame.visibleRect.x, 0);
assert_equals(scaledFrame.visibleRect.y, 0);
assert_equals(scaledFrame.visibleRect.width, 2);
assert_equals(scaledFrame.visibleRect.height, 2);
assert_equals(scaledFrame.displayWidth, 10, 'scaledFrame.displayWidth');
assert_equals(scaledFrame.displayHeight, 20, 'scaledFrame.displayHeight');
}, 'Test visibleRect + display size metadata override');
test(t => {
let image = makeImageBitmap(32, 16);
let scaledFrame = new VideoFrame(image,
{
displayWidth: 10, displayHeight: 20,
timestamp: 0
});
assert_equals(scaledFrame.codedWidth, 32);
assert_equals(scaledFrame.codedHeight, 16);
assert_equals(scaledFrame.visibleRect.x, 0);
assert_equals(scaledFrame.visibleRect.y, 0);
assert_equals(scaledFrame.visibleRect.width, 32);
assert_equals(scaledFrame.visibleRect.height, 16);
assert_equals(scaledFrame.displayWidth, 10, 'scaledFrame.displayWidth');
assert_equals(scaledFrame.displayHeight, 20, 'scaledFrame.displayHeight');
}, 'Test display size metadata override');
test(t => {
assert_throws_js(
TypeError,
() => new VideoFrame(
new Uint8Array(1),
{format: 'ABCD', timestamp: 1234, codedWidth: 4, codedHeight: 2}),
'invalid pixel format');
assert_throws_js(
TypeError,
() =>
new VideoFrame(new Uint32Array(1), {format: 'RGBA', timestamp: 1234}),
'missing coded size');
function constructFrame(init) {
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
return new VideoFrame(data, {...init, format: 'I420'});
}
assert_throws_js(
TypeError, () => constructFrame({
timestamp: 1234,
codedWidth: Math.pow(2, 32) - 1,
codedHeight: Math.pow(2, 32) - 1,
}),
'invalid coded size');
assert_throws_js(
TypeError,
() => constructFrame({timestamp: 1234, codedWidth: 4, codedHeight: 0}),
'invalid coded height');
assert_throws_js(
TypeError,
() => constructFrame({timestamp: 1234, codedWidth: 0, codedHeight: 4}),
'invalid coded width');
assert_throws_js(
TypeError, () => constructFrame({
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
visibleRect: {x: 100, y: 100, width: 1, height: 1}
}),
'invalid visible left/right');
assert_throws_js(
TypeError, () => constructFrame({
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
visibleRect: {x: 0, y: 0, width: 0, height: 2}
}),
'invalid visible width');
assert_throws_js(
TypeError, () => constructFrame({
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
visibleRect: {x: 0, y: 0, width: 2, height: 0}
}),
'invalid visible height');
assert_throws_js(
TypeError, () => constructFrame({
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
visibleRect: {x: 0, y: 0, width: -100, height: -100}
}),
'invalid negative visible size');
assert_throws_js(
TypeError, () => constructFrame({
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
displayWidth: Math.pow(2, 32),
}),
'invalid display width');
assert_throws_js(
TypeError, () => constructFrame({
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
displayWidth: Math.pow(2, 32) - 1,
displayHeight: Math.pow(2, 32)
}),
'invalid display height');
}, 'Test invalid buffer constructed VideoFrames');
test(t => {
testBufferConstructedI420Frame('Uint8Array(ArrayBuffer)');
}, 'Test Uint8Array(ArrayBuffer) constructed I420 VideoFrame');
test(t => {
testBufferConstructedI420Frame('ArrayBuffer');
}, 'Test ArrayBuffer constructed I420 VideoFrame');
test(t => {
let fmt = 'I420';
let vfInit = {
format: fmt,
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
colorSpace: {
primaries: 'smpte170m',
matrix: 'bt470bg',
},
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
let frame = new VideoFrame(data, vfInit);
assert_equals(frame.colorSpace.primaries, 'smpte170m', 'color primaries');
assert_true(frame.colorSpace.transfer == null, 'color transfer');
assert_equals(frame.colorSpace.matrix, 'bt470bg', 'color matrix');
assert_true(frame.colorSpace.fullRange == null, 'color range');
}, 'Test planar constructed I420 VideoFrame with colorSpace');
test(t => {
let fmt = 'I420';
let vfInit = {
format: fmt,
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
colorSpace: {
primaries: null,
transfer: null,
matrix: null,
fullRange: null,
},
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
]);
let frame = new VideoFrame(data, vfInit);
assert_true(frame.colorSpace.primaries !== undefined, 'color primaries');
assert_true(frame.colorSpace.transfer !== undefined, 'color transfer');
assert_true(frame.colorSpace.matrix !== undefined, 'color matrix');
assert_true(frame.colorSpace.fullRange !== undefined, 'color range');
}, 'Test planar can construct I420 VideoFrame with null colorSpace values');
test(t => {
let fmt = 'I420A';
let vfInit = {format: fmt, timestamp: 1234, codedWidth: 4, codedHeight: 2};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
8, 7, 6, 5, 4, 3, 2, 1, // a
]);
let frame = new VideoFrame(data, vfInit);
assert_equals(frame.format, fmt, 'plane format');
assert_equals(frame.colorSpace.primaries, 'bt709', 'color primaries');
assert_equals(frame.colorSpace.transfer, 'bt709', 'color transfer');
assert_equals(frame.colorSpace.matrix, 'bt709', 'color matrix');
assert_false(frame.colorSpace.fullRange, 'color range');
frame.close();
// Most constraints are tested as part of I420 above.
let y = {offset: 0, stride: 4};
let u = {offset: 8, stride: 2};
let v = {offset: 10, stride: 2};
let a = {offset: 12, stride: 4};
assert_throws_js(TypeError, () => {
let a = {offset: 12, stride: 1};
let frame = new VideoFrame(data, {...vfInit, layout: [y, u, v, a]});
}, 'a stride too small');
assert_throws_js(TypeError, () => {
let frame = new VideoFrame(data.slice(0, 12), vfInit);
}, 'data too small');
}, 'Test buffer constructed I420+Alpha VideoFrame');
test(t => {
let fmt = 'NV12';
let vfInit = {format: fmt, timestamp: 1234, codedWidth: 4, codedHeight: 2};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, 3, 4, // uv
]);
let frame = new VideoFrame(data, vfInit);
assert_equals(frame.format, fmt, 'plane format');
assert_equals(frame.colorSpace.primaries, 'bt709', 'color primaries');
assert_equals(frame.colorSpace.transfer, 'bt709', 'color transfer');
assert_equals(frame.colorSpace.matrix, 'bt709', 'color matrix');
assert_false(frame.colorSpace.fullRange, 'color range');
frame.close();
let y = {offset: 0, stride: 4};
let uv = {offset: 8, stride: 4};
assert_throws_js(TypeError, () => {
let y = {offset: 0, stride: 1};
let frame = new VideoFrame(data, {...vfInit, layout: [y, uv]});
}, 'y stride too small');
assert_throws_js(TypeError, () => {
let uv = {offset: 8, stride: 1};
let frame = new VideoFrame(data, {...vfInit, layout: [y, uv]});
}, 'uv stride too small');
assert_throws_js(TypeError, () => {
let frame = new VideoFrame(data.slice(0, 8), vfInit);
}, 'data too small');
}, 'Test buffer constructed NV12 VideoFrame');
test(t => {
let vfInit = {timestamp: 1234, codedWidth: 4, codedHeight: 2};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
]);
let frame = new VideoFrame(data, {...vfInit, format: 'RGBA'});
assert_equals(frame.format, 'RGBA', 'plane format');
assert_equals(frame.colorSpace.primaries, 'bt709', 'color primaries');
assert_equals(frame.colorSpace.transfer, 'iec61966-2-1', 'color transfer');
assert_equals(frame.colorSpace.matrix, 'rgb', 'color matrix');
assert_true(frame.colorSpace.fullRange, 'color range');
frame.close();
frame = new VideoFrame(data, {...vfInit, format: 'RGBX'});
assert_equals(frame.format, 'RGBX', 'plane format');
assert_equals(frame.colorSpace.primaries, 'bt709', 'color primaries');
assert_equals(frame.colorSpace.transfer, 'iec61966-2-1', 'color transfer');
assert_equals(frame.colorSpace.matrix, 'rgb', 'color matrix');
assert_true(frame.colorSpace.fullRange, 'color range');
frame.close();
frame = new VideoFrame(data, {...vfInit, format: 'BGRA'});
assert_equals(frame.format, 'BGRA', 'plane format');
assert_equals(frame.colorSpace.primaries, 'bt709', 'color primaries');
assert_equals(frame.colorSpace.transfer, 'iec61966-2-1', 'color transfer');
assert_equals(frame.colorSpace.matrix, 'rgb', 'color matrix');
assert_true(frame.colorSpace.fullRange, 'color range');
frame.close();
frame = new VideoFrame(data, {...vfInit, format: 'BGRX'});
assert_equals(frame.format, 'BGRX', 'plane format');
assert_equals(frame.colorSpace.primaries, 'bt709', 'color primaries');
assert_equals(frame.colorSpace.transfer, 'iec61966-2-1', 'color transfer');
assert_equals(frame.colorSpace.matrix, 'rgb', 'color matrix');
assert_true(frame.colorSpace.fullRange, 'color range');
frame.close();
}, 'Test buffer constructed RGB VideoFrames');
test(t => {
let image = makeImageBitmap(32, 16);
let frame = new VideoFrame(image, {timestamp: 0});
assert_true(!!frame);
frame_copy = new VideoFrame(frame);
assert_equals(frame.format, frame_copy.format);
assert_equals(frame.timestamp, frame_copy.timestamp);
assert_equals(frame.codedWidth, frame_copy.codedWidth);
assert_equals(frame.codedHeight, frame_copy.codedHeight);
assert_equals(frame.displayWidth, frame_copy.displayWidth);
assert_equals(frame.displayHeight, frame_copy.displayHeight);
assert_equals(frame.duration, frame_copy.duration);
frame_copy.close();
frame_copy = new VideoFrame(frame, {duration: 1234});
assert_equals(frame.timestamp, frame_copy.timestamp);
assert_equals(frame_copy.duration, 1234);
frame_copy.close();
frame_copy = new VideoFrame(frame, {timestamp: 1234, duration: 456});
assert_equals(frame_copy.timestamp, 1234);
assert_equals(frame_copy.duration, 456);
frame_copy.close();
frame.close();
}, 'Test VideoFrame constructed VideoFrame');
test(t => {
let canvas = makeOffscreenCanvas(16, 16);
let frame = new VideoFrame(canvas, {timestamp: 0});
assert_equals(frame.displayWidth, 16);
assert_equals(frame.displayHeight, 16);
frame.close();
}, 'Test we can construct a VideoFrame from an offscreen canvas.');
test(t => {
let fmt = 'I420';
let vfInit = {
format: fmt,
timestamp: 1234,
codedWidth: 4,
codedHeight: 2,
visibleRect: {x: 0, y: 0, width: 1, height: 1},
};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
8, 7, 6, 5, 4, 3, 2, 1, // a
]);
let frame = new VideoFrame(data, vfInit);
assert_equals(frame.format, fmt, 'format');
assert_equals(frame.visibleRect.x, 0, 'visibleRect.x');
assert_equals(frame.visibleRect.y, 0, 'visibleRect.y');
assert_equals(frame.visibleRect.width, 1, 'visibleRect.width');
assert_equals(frame.visibleRect.height, 1, 'visibleRect.height');
frame.close();
}, 'Test I420 VideoFrame with odd visible size');
test(t => {
let fmt = 'I420A';
let vfInit = {format: fmt, timestamp: 1234, codedWidth: 4, codedHeight: 2};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, // y
1, 2, // u
1, 2, // v
8, 7, 6, 5, 4, 3, 2, 1, // a
]);
let frame = new VideoFrame(data, vfInit);
assert_equals(frame.format, fmt, 'plane format');
let alpha_frame_copy = new VideoFrame(frame, {alpha: 'keep'});
assert_equals(alpha_frame_copy.format, 'I420A', 'plane format');
let opaque_frame_copy = new VideoFrame(frame, {alpha: 'discard'});
assert_equals(opaque_frame_copy.format, 'I420', 'plane format');
frame.close();
alpha_frame_copy.close();
opaque_frame_copy.close();
}, 'Test I420A VideoFrame and alpha={keep,discard}');
test(t => {
let vfInit = {timestamp: 1234, codedWidth: 4, codedHeight: 2};
let data = new Uint8Array([
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
]);
let frame = new VideoFrame(data, {...vfInit, format: 'RGBA'});
assert_equals(frame.format, 'RGBA', 'plane format');
let alpha_frame_copy = new VideoFrame(frame, {alpha: 'keep'});
assert_equals(alpha_frame_copy.format, 'RGBA', 'plane format');
let opaque_frame_copy = new VideoFrame(frame, {alpha: 'discard'});
assert_equals(opaque_frame_copy.format, 'RGBX', 'plane format');
alpha_frame_copy.close();
opaque_frame_copy.close();
frame.close();
frame = new VideoFrame(data, {...vfInit, format: 'BGRA'});
assert_equals(frame.format, 'BGRA', 'plane format');
alpha_frame_copy = new VideoFrame(frame, {alpha: 'keep'});
assert_equals(alpha_frame_copy.format, 'BGRA', 'plane format');
opaque_frame_copy = new VideoFrame(frame, {alpha: 'discard'});
assert_equals(opaque_frame_copy.format, 'BGRX', 'plane format');
alpha_frame_copy.close();
opaque_frame_copy.close();
frame.close();
}, 'Test RGBA, BGRA VideoFrames with alpha={keep,discard}');
test(t => {
let canvas = makeOffscreenCanvas(16, 16, {alpha: true});
let frame = new VideoFrame(canvas, {timestamp: 0});
assert_true(
frame.format == 'RGBA' || frame.format == 'BGRA' ||
frame.format == 'I420A',
'plane format should have alpha: ' + frame.format);
frame.close();
frame = new VideoFrame(canvas, {alpha: 'discard', timestamp: 0});
assert_true(
frame.format == 'RGBX' || frame.format == 'BGRX' ||
frame.format == 'I420',
'plane format should not have alpha: ' + frame.format);
frame.close();
}, 'Test a VideoFrame constructed from canvas can drop the alpha channel.');