Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 320 insertions, 0 deletions

diff --git a/testing/web-platform/tests/webcodecs/video-encoder.https.any.js b/testing/web-platform/tests/webcodecs/video-encoder.https.any.js
new file mode 100644
index 0000000000..b5c511d406
--- /dev/null
+++ b/testing/web-platform/tests/webcodecs/video-encoder.https.any.js
@@ -0,0 +1,320 @@
+// META: global=window,dedicatedworker
+// META: script=/common/media.js
+// META: script=/webcodecs/utils.js
+// META: script=/webcodecs/video-encoder-utils.js
+
+const defaultConfig = {
+  codec: 'vp8',
+  width: 640,
+  height: 480
+};
+
+promise_test(t => {
+  // VideoEncoderInit lacks required fields.
+  assert_throws_js(TypeError, () => { new VideoEncoder({}); });
+
+  // VideoEncoderInit has required fields.
+  let encoder = new VideoEncoder(getDefaultCodecInit(t));
+
+  assert_equals(encoder.state, "unconfigured");
+
+  encoder.close();
+
+  return endAfterEventLoopTurn();
+}, 'Test VideoEncoder construction');
+
+promise_test(t => {
+  let encoder = new VideoEncoder(getDefaultCodecInit(t));
+
+  let badCodecsList = [
+    '',                         // Empty codec
+    'bogus',                    // Non exsitent codec
+    'vorbis',                   // Audio codec
+    'vp9',                      // Ambiguous codec
+    'video/webm; codecs="vp9"'  // Codec with mime type
+  ]
+
+  testConfigurations(encoder, defaultConfig, badCodecsList);
+
+  return endAfterEventLoopTurn();
+}, 'Test VideoEncoder.configure()');
+
+promise_test(async t => {
+  let output_chunks = [];
+  let codecInit = getDefaultCodecInit(t);
+  let decoderConfig = null;
+  let encoderConfig = {
+    codec: 'vp8',
+    width: 640,
+    height: 480,
+    displayWidth: 800,
+    displayHeight: 600,
+  };
+
+  codecInit.output = (chunk, metadata) => {
+    assert_not_equals(metadata, null);
+    if (metadata.decoderConfig)
+      decoderConfig = metadata.decoderConfig;
+    output_chunks.push(chunk);
+  }
+
+  let encoder = new VideoEncoder(codecInit);
+  encoder.configure(encoderConfig);
+
+  let frame1 = createFrame(640, 480, 0);
+  let frame2 = createFrame(640, 480, 33333);
+  t.add_cleanup(() => {
+    frame1.close();
+    frame2.close();
+  });
+
+  encoder.encode(frame1);
+  encoder.encode(frame2);
+
+  await encoder.flush();
+
+  // Decoder config should be given with the first chunk
+  assert_not_equals(decoderConfig, null);
+  assert_equals(decoderConfig.codec, encoderConfig.codec);
+  assert_greater_than_equal(decoderConfig.codedHeight, encoderConfig.height);
+  assert_greater_than_equal(decoderConfig.codedWidth, encoderConfig.width);
+  assert_equals(decoderConfig.displayAspectHeight, encoderConfig.displayHeight);
+  assert_equals(decoderConfig.displayAspectWidth, encoderConfig.displayWidth);
+  assert_not_equals(decoderConfig.colorSpace.primaries, null);
+  assert_not_equals(decoderConfig.colorSpace.transfer, null);
+  assert_not_equals(decoderConfig.colorSpace.matrix, null);
+  assert_not_equals(decoderConfig.colorSpace.fullRange, null);
+
+  assert_equals(output_chunks.length, 2);
+  assert_equals(output_chunks[0].timestamp, frame1.timestamp);
+  assert_equals(output_chunks[0].duration, frame1.duration);
+  assert_equals(output_chunks[1].timestamp, frame2.timestamp);
+  assert_equals(output_chunks[1].duration, frame2.duration);
+}, 'Test successful configure(), encode(), and flush()');
+
+promise_test(async t => {
+  let codecInit = getDefaultCodecInit(t);
+  let encoderConfig = {
+    codec: 'vp8',
+    width: 320,
+    height: 200
+  };
+
+  codecInit.output = (chunk, metadata) => {}
+
+  let encoder = new VideoEncoder(codecInit);
+
+  // No encodes yet.
+  assert_equals(encoder.encodeQueueSize, 0);
+
+  encoder.configure(encoderConfig);
+
+  // Still no encodes.
+  assert_equals(encoder.encodeQueueSize, 0);
+
+  const frames_count = 100;
+  let frames = [];
+  for (let i = 0; i < frames_count; i++) {
+    let frame = createFrame(320, 200, i * 16000);
+    frames.push(frame);
+  }
+
+  let lastDequeueSize = Infinity;
+  encoder.ondequeue = () => {
+    assert_greater_than(lastDequeueSize, 0, "Dequeue event after queue empty");
+    assert_greater_than(lastDequeueSize, encoder.encodeQueueSize,
+                        "Dequeue event without decreased queue size");
+    lastDequeueSize = encoder.encodeQueueSize;
+  };
+
+  for (let frame of frames)
+    encoder.encode(frame);
+
+  assert_greater_than_equal(encoder.encodeQueueSize, 0);
+  assert_less_than_equal(encoder.encodeQueueSize, frames_count);
+
+  await encoder.flush();
+  // We can guarantee that all encodes are processed after a flush.
+  assert_equals(encoder.encodeQueueSize, 0);
+  // Last dequeue event should fire when the queue is empty.
+  assert_equals(lastDequeueSize, 0);
+
+  // Reset this to Infinity to track the decline of queue size for this next
+  // batch of encodes.
+  lastDequeueSize = Infinity;
+
+  for (let frame of frames) {
+    encoder.encode(frame);
+    frame.close();
+  }
+
+  assert_greater_than_equal(encoder.encodeQueueSize, 0);
+  encoder.reset();
+  assert_equals(encoder.encodeQueueSize, 0);
+}, 'encodeQueueSize test');
+
+
+promise_test(async t => {
+  let timestamp = 0;
+  let callbacks_before_reset = 0;
+  let callbacks_after_reset = 0;
+  const timestamp_step = 40000;
+  const expected_callbacks_before_reset = 3;
+  let codecInit = getDefaultCodecInit(t);
+  let original = createFrame(320, 200, 0);
+  let encoder = null;
+  let reset_completed = false;
+  codecInit.output = (chunk, metadata) => {
+    if (chunk.timestamp % 2 == 0) {
+      // pre-reset frames have even timestamp
+      callbacks_before_reset++;
+      if (callbacks_before_reset == expected_callbacks_before_reset) {
+        encoder.reset();
+        reset_completed = true;
+      }
+    } else {
+      // after-reset frames have odd timestamp
+      callbacks_after_reset++;
+    }
+  }
+
+  encoder = new VideoEncoder(codecInit);
+  encoder.configure(defaultConfig);
+  await encoder.flush();
+
+  // Send 10x frames to the encoder, call reset() on it after x outputs,
+  // and make sure no more chunks are emitted afterwards.
+  let encodes_before_reset = expected_callbacks_before_reset * 10;
+  for (let i = 0; i < encodes_before_reset; i++) {
+    let frame = new VideoFrame(original, { timestamp: timestamp });
+    timestamp += timestamp_step;
+    encoder.encode(frame);
+    frame.close();
+  }
+
+  await t.step_wait(() => reset_completed,
+    "Reset() should be called by output callback", 10000, 1);
+
+  assert_equals(callbacks_before_reset, expected_callbacks_before_reset);
+  assert_true(reset_completed);
+  assert_equals(encoder.encodeQueueSize, 0);
+
+  let newConfig = { ...defaultConfig };
+  newConfig.width = 800;
+  newConfig.height = 600;
+  encoder.configure(newConfig);
+
+  const frames_after_reset = 5;
+  for (let i = 0; i < frames_after_reset; i++) {
+    let frame = createFrame(800, 600, timestamp + 1);
+    timestamp += timestamp_step;
+    encoder.encode(frame);
+    frame.close();
+  }
+  await encoder.flush();
+
+  assert_equals(callbacks_after_reset, frames_after_reset,
+    "not all after-reset() outputs have been emitted");
+  assert_equals(callbacks_before_reset, expected_callbacks_before_reset,
+    "pre-reset() outputs were emitter after reset() and flush()");
+  assert_equals(encoder.encodeQueueSize, 0);
+}, 'Test successful reset() and re-confiugre()');
+
+promise_test(async t => {
+  let output_chunks = [];
+  let codecInit = getDefaultCodecInit(t);
+  codecInit.output = chunk => output_chunks.push(chunk);
+
+  let encoder = new VideoEncoder(codecInit);
+
+  // No encodes yet.
+  assert_equals(encoder.encodeQueueSize, 0);
+
+  let config = defaultConfig;
+
+  encoder.configure(config);
+
+  let frame1 = createFrame(640, 480, 0);
+  let frame2 = createFrame(640, 480, 33333);
+
+  encoder.encode(frame1);
+  encoder.configure(config);
+
+  encoder.encode(frame2);
+
+  await encoder.flush();
+
+  // We can guarantee that all encodes are processed after a flush.
+  assert_equals(encoder.encodeQueueSize, 0, "queue size after encode");
+
+  assert_equals(output_chunks.length, 2, "number of chunks");
+  assert_equals(output_chunks[0].timestamp, frame1.timestamp);
+  assert_equals(output_chunks[1].timestamp, frame2.timestamp);
+
+  output_chunks = [];
+
+  let frame3 = createFrame(640, 480, 66666);
+  let frame4 = createFrame(640, 480, 100000);
+
+  encoder.encode(frame3);
+
+  // Verify that a failed call to configure does not change the encoder's state.
+  let badConfig = { ...defaultConfig };
+  badConfig.codec = 'bogus';
+  assert_throws_js(TypeError, () => encoder.configure(badConfig));
+
+  encoder.encode(frame4);
+
+  await encoder.flush();
+
+  assert_equals(output_chunks[0].timestamp, frame3.timestamp);
+  assert_equals(output_chunks[1].timestamp, frame4.timestamp);
+}, 'Test successful encode() after re-configure().');
+
+promise_test(async t => {
+  let encoder = new VideoEncoder(getDefaultCodecInit(t));
+
+  let frame = createFrame(640, 480, 0);
+
+  return testClosedCodec(t, encoder, defaultConfig, frame);
+}, 'Verify closed VideoEncoder operations');
+
+promise_test(async t => {
+  let encoder = new VideoEncoder(getDefaultCodecInit(t));
+
+  let frame = createFrame(640, 480, 0);
+
+  return testUnconfiguredCodec(t, encoder, frame);
+}, 'Verify unconfigured VideoEncoder operations');
+
+promise_test(async t => {
+  let encoder = new VideoEncoder(getDefaultCodecInit(t));
+
+  let frame = createFrame(640, 480, 0);
+  frame.close();
+
+  encoder.configure(defaultConfig);
+
+  assert_throws_dom("OperationError", () => {
+    encoder.encode(frame);
+  });
+}, 'Verify encoding closed frames throws.');
+
+promise_test(async t => {
+  let output_chunks = [];
+  let codecInit = getDefaultCodecInit(t);
+  codecInit.output = chunk => output_chunks.push(chunk);
+
+  let encoder = new VideoEncoder(codecInit);
+  let config = defaultConfig;
+  encoder.configure(config);
+
+  let frame = createFrame(640, 480, -10000);
+  encoder.encode(frame);
+  frame.close();
+  await encoder.flush();
+  encoder.close();
+  assert_equals(output_chunks.length, 1);
+  assert_equals(output_chunks[0].timestamp, -10000, "first chunk timestamp");
+  assert_greater_than(output_chunks[0].byteLength, 0);
+}, 'Encode video with negative timestamp');