nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Bug 1868470 - Add new OffscreenCanvas and WebCodecs talos tests. r=perftest-reviewers,sparky

Browse source 
This patch adds new variants of the glvideo/canvas2dvideo talos tests,
but this time focused on OffscreenCanvas and WebCodecs.

There are test variants for each:
- Execution thread (main thread or DOM worker)
- Canvas type (WebGL or 2D canvas)
- Codec type (H264, VP9 or AV1)

They are included as part of the existing webgl talos job.

Differential Revision: https://phabricator.services.mozilla.com/D196465
This commit is contained in:
Andrew Osmond 2023-12-15 22:18:41 +00:00
parent d00fc5db08
commit 816b0b6da1
43 changed files with 5079 additions and 1 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

2
.prettierignore
View file

@ -1187,6 +1187,8 @@ testing/mozbase/mozprofile/tests/files/prefs_with_comments.js
testing/mozharness/configs/test/test_malformed.json
testing/talos/talos/startup_test/sessionrestore/profile/sessionstore.js
testing/talos/talos/startup_test/sessionrestore/profile-manywindows/sessionstore.js
testing/talos/talos/tests/offscreencanvas/benchmarks/video/demuxer_mp4.js
testing/talos/talos/tests/offscreencanvas/benchmarks/video/mp4box.all.min.js
# Python json.
testing/talos/talos/unittests/test_talosconfig_browser_config.json
testing/talos/talos/unittests/test_talosconfig_test_config.json

1
taskcluster/ci/test/talos.yml
View file

@ -724,6 +724,7 @@ talos-webgl-profiling:
extra-options:
- --suite=webgl
- --gecko-profile
- --setpref=dom.media.webcodecs.enabled=true
talos-xperf:
description: Talos xperf

3552
testing/perfdocs/generated/talos.rst
View file

File diff suppressed because it is too large Load diff

3
testing/talos/moz.build
View file

@ -29,6 +29,9 @@ with Files("talos/tests/dromaeo/**"):
with Files("talos/tests/kraken/**"):
BUG_COMPONENT = ("Core", "JavaScript Engine")
with Files("talos/tests/offscreencanvas/**"):
BUG_COMPONENT = ("Core", "Graphics: Canvas2D")
with Files("talos/tests/scroll/**"):
BUG_COMPONENT = ("Core", "Graphics")

216
testing/talos/perfdocs/config.yml
View file

@ -135,6 +135,222 @@ suites:
ticks to measure how much time it will spend for a video texture upload
to be a Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore
the first found. Lower results are better.
offscreencanvas_webcodecs_main_webgl_h264: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_main_webgl_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p H264 video on the main thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a H264 video file using WebCodecs and ask WebGL to draw video
frames as WebGL textures for 100 frames on the main thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_main_webgl_vp9: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_main_webgl_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p VP9 video on the main thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a VP9 video file using WebCodecs and ask WebGL to draw video
frames as WebGL textures for 100 frames on the main thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_main_webgl_av1: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_main_webgl_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p AV1 video on the main thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a AV1 video file using WebCodecs and ask WebGL to draw video
frames as WebGL textures for 100 frames on the main thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_worker_webgl_h264: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_worker_webgl_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p H264 video on a DOM worker thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a H264 video file using WebCodecs and ask WebGL to draw video
frames as WebGL textures for 100 frames on a DOM worker. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_worker_webgl_vp9: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_worker_webgl_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p VP9 video on a DOM worker thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a VP9 video file using WebCodecs and ask WebGL to draw video
frames as WebGL textures for 100 frames on a DOM worker. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_worker_webgl_av1: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_worker_webgl_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p AV1 video on a DOM worker thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a AV1 video file using WebCodecs and ask WebGL to draw video
frames as WebGL textures for 100 frames on a DOM worker. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_main_2d_h264: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_main_2d_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p H264 video on the main thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a H264 video file using WebCodecs and ask Canvas2D to draw video
frames as Canvas2D textures for 100 frames on the main thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_main_2d_vp9: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_main_2d_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p VP9 video on the main thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l819>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a VP9 video file using WebCodecs and ask Canvas2D to draw video
frames as Canvas2D textures for 100 frames on the main thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_main_2d_av1: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_main_2d_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p AV1 video on the main thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l843>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a AV1 video file using WebCodecs and ask Canvas2D to draw video
frames as Canvas2D textures for 100 frames on the main thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_worker_2d_h264: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_worker_2d_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p H264 video on a DOM worker thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a H264 video file using WebCodecs and ask Canvas2D to draw video
frames as Canvas2D textures for 100 frames on a DOM worker thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_worker_2d_vp9: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_worker_2d_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p VP9 video on a DOM worker thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a VP9 video file using WebCodecs and ask Canvas2D to draw video
frames as Canvas2D textures for 100 frames on a DOM worker thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
results are better.
offscreencanvas_webcodecs_worker_2d_av1: >
- contact: :aosmond and gfx
- source: `offscreencanvas_webcodecs_worker_2d_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
- type: `Page load`_
- data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
- summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p AV1 video on a DOM worker thread. Measures mean frame time across 100 frames.
* subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
* suite: `geometric mean`_ of the 4 subtest results.
- **Lower is better**
- **Example Data**
* 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
- description:
| This test extracts frames from a AV1 video file using WebCodecs and ask Canvas2D to draw video
frames as Canvas2D textures for 100 frames on a DOM worker thread. It collects the mean frame time
across 100 frames to measure how much time it will spend for a video texture upload to be a
Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
results are better.
cpstartup: >
- contact: :mconley, Firefox Desktop Front-end team, Gijs, fqueze, and dthayer
- measuring: Time from opening a new tab (which creates a new content process) to having that new content process be ready to load URLs.

19
testing/talos/talos.json
View file

@ -88,7 +88,24 @@
"pagesets_name": "tp5n.zip"
},
"webgl": {
"tests": ["canvas2dvideo", "glterrain", "glvideo", "motionmark_webgl"]
"tests": [
"canvas2dvideo",
"glterrain",
"glvideo",
"motionmark_webgl",
"offscreencanvas_webcodecs_main_webgl_h264",
"offscreencanvas_webcodecs_main_webgl_vp9",
"offscreencanvas_webcodecs_main_webgl_av1",
"offscreencanvas_webcodecs_worker_webgl_h264",
"offscreencanvas_webcodecs_worker_webgl_vp9",
"offscreencanvas_webcodecs_worker_webgl_av1",
"offscreencanvas_webcodecs_main_2d_h264",
"offscreencanvas_webcodecs_main_2d_vp9",
"offscreencanvas_webcodecs_main_2d_av1",
"offscreencanvas_webcodecs_worker_2d_h264",
"offscreencanvas_webcodecs_worker_2d_vp9",
"offscreencanvas_webcodecs_worker_2d_av1"
]
},
"xperf": {
"tests": ["tp5n"],

324
testing/talos/talos/test.py
View file

@ -659,6 +659,330 @@ class canvas2dvideo(PageloaderTest):
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_main_webgl_h264(PageloaderTest):
"""
OffscreenCanvas WebGL video texture update on the main thread with WebCodecs and 1080p H264 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs texImage2D(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_h264.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "CanvasRenderer,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_main_webgl_vp9(PageloaderTest):
"""
OffscreenCanvas WebGL video texture update on the main thread with WebCodecs and 1080p VP9 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs texImage2D(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_vp9.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "CanvasRenderer,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_main_webgl_av1(PageloaderTest):
"""
OffscreenCanvas WebGL video texture update on the main thread with WebCodecs and 1080p AV1 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs texImage2D(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_av1.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "CanvasRenderer,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_worker_webgl_h264(PageloaderTest):
"""
OffscreenCanvas WebGL video texture update on a DOM worker thread with WebCodecs and 1080p H264 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs texImage2D(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_h264.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "DOM Worker,CanvasRenderer,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_worker_webgl_vp9(PageloaderTest):
"""
OffscreenCanvas WebGL video texture update on a DOM worker thread with WebCodecs and 1080p VP9 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs texImage2D(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_vp9.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "DOM Worker,CanvasRenderer,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_worker_webgl_av1(PageloaderTest):
"""
OffscreenCanvas WebGL video texture update on a DOM worker thread with WebCodecs and 1080p AV1 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs texImage2D(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_av1.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "DOM Worker,CanvasRenderer,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_main_2d_h264(PageloaderTest):
"""
OffscreenCanvas 2D video texture update on the main thread with WebCodecs and 1080p H264 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs drawImage(<videoFrame>))
"""
tpmanifest = (
"${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_h264.manifest"
)
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "CanvasRenderer,CanvasWorker,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_main_2d_vp9(PageloaderTest):
"""
OffscreenCanvas 2D video texture update on the main thread with WebCodecs and 1080p VP9 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs drawImage(<videoFrame>))
"""
tpmanifest = (
"${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_vp9.manifest"
)
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "CanvasRenderer,CanvasWorker,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_main_2d_av1(PageloaderTest):
"""
OffscreenCanvas 2D video texture update on the main thread with WebCodecs and 1080p AV1 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs drawImage(<videoFrame>))
"""
tpmanifest = (
"${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_av1.manifest"
)
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = "CanvasRenderer,CanvasWorker,MediaSupervisor"
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_worker_2d_h264(PageloaderTest):
"""
OffscreenCanvas 2D video texture update on a DOM worker thread with WebCodecs and 1080p H264 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs drawImage(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_h264.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = (
"DOM Worker,CanvasRenderer,CanvasWorker,MediaSupervisor"
)
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_worker_2d_vp9(PageloaderTest):
"""
OffscreenCanvas 2D video texture update on a DOM worker thread with WebCodecs and 1080p VP9 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs drawImage(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_vp9.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = (
"DOM Worker,CanvasRenderer,CanvasWorker,MediaSupervisor"
)
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class offscreencanvas_webcodecs_worker_2d_av1(PageloaderTest):
"""
OffscreenCanvas 2D video texture update on a DOM worker thread with WebCodecs and 1080p AV1 video.
Measures mean frame time across 100 frames.
(decodes each frame and performs drawImage(<videoFrame>))
"""
tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_av1.manifest"
tpcycles = 1
tppagecycles = 5
tploadnocache = True
tpmozafterpaint = False
tpchrome = False
timeout = 600
gecko_profile_interval = 2
gecko_profile_extra_threads = (
"DOM Worker,CanvasRenderer,CanvasWorker,MediaSupervisor"
)
win_counters = w7_counters = linux_counters = mac_counters = None
preferences = {
"dom.media.webcodecs.enabled": True,
"dom.media.webcodecs.force-osx-h264-enabled": True,
}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = "ms"
@register_test()
class tp5n(PageloaderTest):
"""

22
testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_av1_main.html Normal file
View file

@ -0,0 +1,22 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="mp4box.all.min.js" type="text/javascript"></script>
<script src="demuxer_mp4.js" type="text/javascript"></script>
<script src="shared.js" type="text/javascript"></script>
<script src="helper_main.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
runTest("offscreencanvas_webcodecs_main_2d_av1", "2d", videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

20
testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_av1_worker.html Normal file
View file

@ -0,0 +1,20 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="helper_worker.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
const worker = new Worker("worker.js");
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
runTest("offscreencanvas_webcodecs_worker_2d_av1", "2d", worker, videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

22
testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_h264_main.html Normal file
View file

@ -0,0 +1,22 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="mp4box.all.min.js" type="text/javascript"></script>
<script src="demuxer_mp4.js" type="text/javascript"></script>
<script src="shared.js" type="text/javascript"></script>
<script src="helper_main.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
runTest("offscreencanvas_webcodecs_main_2d_h264", "2d", videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

20
testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_h264_worker.html Normal file
View file

@ -0,0 +1,20 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="helper_worker.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
const worker = new Worker("worker.js");
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
runTest("offscreencanvas_webcodecs_worker_2d_h264", "2d", worker, videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

22
testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_vp9_main.html Normal file
View file

@ -0,0 +1,22 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="mp4box.all.min.js" type="text/javascript"></script>
<script src="demuxer_mp4.js" type="text/javascript"></script>
<script src="shared.js" type="text/javascript"></script>
<script src="helper_main.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
runTest("offscreencanvas_webcodecs_main_2d_vp9", "2d", videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

20
testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_vp9_worker.html Normal file
View file

@ -0,0 +1,20 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="helper_worker.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
const worker = new Worker("worker.js");
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
runTest("offscreencanvas_webcodecs_worker_2d_vp9", "2d", worker, videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

113
testing/talos/talos/tests/offscreencanvas/benchmarks/video/demuxer_mp4.js Normal file
View file

@ -0,0 +1,113 @@
/**
* This software or document includes material copied from or derived from:
* https://github.com/w3c/webcodecs/blob/main/samples/video-decode-display/demuxer_mp4.js
*
* Copyright (c) 2022-2023 World Wide Web Consortium.
* https://www.w3.org/copyright/software-license-2023/
*/
// Wraps an MP4Box File as a WritableStream underlying sink.
class MP4FileSink {
#setStatus = null;
#file = null;
#offset = 0;
constructor(file, setStatus) {
this.#file = file;
this.#setStatus = setStatus;
}
write(chunk) {
// MP4Box.js requires buffers to be ArrayBuffers, but we have a Uint8Array.
const buffer = new ArrayBuffer(chunk.byteLength);
new Uint8Array(buffer).set(chunk);
// Inform MP4Box where in the file this chunk is from.
buffer.fileStart = this.#offset;
this.#offset += buffer.byteLength;
// Append chunk.
this.#setStatus("fetch", (this.#offset / (1024 ** 2)).toFixed(1) + " MiB");
this.#file.appendBuffer(buffer);
}
close() {
this.#setStatus("fetch", "Done");
this.#file.flush();
}
}
// Demuxes the first video track of an MP4 file using MP4Box, calling
// `onConfig()` and `onChunk()` with appropriate WebCodecs objects.
class MP4Demuxer {
#onConfig = null;
#onChunk = null;
#setStatus = null;
#file = null;
constructor(uri, {onConfig, onChunk, setStatus}) {
this.#onConfig = onConfig;
this.#onChunk = onChunk;
this.#setStatus = setStatus;
// Configure an MP4Box File for demuxing.
this.#file = MP4Box.createFile();
this.#file.onError = error => setStatus("demux", error);
this.#file.onReady = this.#onReady.bind(this);
this.#file.onSamples = this.#onSamples.bind(this);
// Fetch the file and pipe the data through.
const fileSink = new MP4FileSink(this.#file, setStatus);
fetch(uri).then(response => {
// highWaterMark should be large enough for smooth streaming, but lower is
// better for memory usage.
response.body.pipeTo(new WritableStream(fileSink, {highWaterMark: 2}));
});
}
// Get the appropriate `description` for a specific track. Assumes that the
// track is H.264, H.265, VP8, VP9, or AV1.
#description(track) {
const trak = this.#file.getTrackById(track.id);
for (const entry of trak.mdia.minf.stbl.stsd.entries) {
const box = entry.avcC || entry.hvcC || entry.vpcC || entry.av1C;
if (box) {
const stream = new DataStream(undefined, 0, DataStream.BIG_ENDIAN);
box.write(stream);
return new Uint8Array(stream.buffer, 8); // Remove the box header.
}
}
throw new Error("avcC, hvcC, vpcC, or av1C box not found");
}
#onReady(info) {
this.#setStatus("demux", "Ready");
const track = info.videoTracks[0];
// Generate and emit an appropriate VideoDecoderConfig.
this.#onConfig({
// Browser doesn't support parsing full vp8 codec (eg: `vp08.00.41.08`),
// they only support `vp8`.
codec: track.codec.startsWith('vp08') ? 'vp8' : track.codec,
codedHeight: track.video.height,
codedWidth: track.video.width,
description: this.#description(track),
});
// Start demuxing.
this.#file.setExtractionOptions(track.id);
this.#file.start();
}
#onSamples(track_id, ref, samples) {
// Generate and emit an EncodedVideoChunk for each demuxed sample.
for (const sample of samples) {
this.#onChunk(new EncodedVideoChunk({
type: sample.is_sync ? "key" : "delta",
timestamp: 1e6 * sample.cts / sample.timescale,
duration: 1e6 * sample.duration / sample.timescale,
data: sample.data
}));
}
}
}

57
testing/talos/talos/tests/offscreencanvas/benchmarks/video/helper_main.js Normal file
View file

@ -0,0 +1,57 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
/*global runTestInternal b:true*/
function runTest(testName, canvasType, videoUri) {
const canvas = document.createElement("canvas");
canvas.width = 1920;
canvas.height = 1080;
document.body.appendChild(canvas);
const offscreenCanvas = canvas.transferControlToOffscreen();
return new Promise((resolve, reject) => {
try {
runTestInternal(
testName,
canvasType,
offscreenCanvas,
/* isWorker */ false,
videoUri,
resolve,
reject
);
} catch (e) {
reject(e);
}
})
.then(result => {
let name =
result.testName +
" Mean time across " +
result.totalFrames +
" frames: ";
let value = result.elapsed / result.totalFrames;
let msg = name + value + "\n";
dump("[talos offscreen-canvas-webcodecs result] " + msg);
if (window.tpRecordTime) {
// Within talos - report the results
tpRecordTime(value, 0, name);
} else {
alert(msg);
}
})
.catch(e => {
let msg = "caught error " + e;
dump("[talos offscreen-canvas-webcodecs result] " + msg);
if (window.tpRecordTime) {
// Within talos - report the results
tpRecordTime("", 0, "");
} else {
alert(msg);
}
});
}

53
testing/talos/talos/tests/offscreencanvas/benchmarks/video/helper_worker.js Normal file
View file

@ -0,0 +1,53 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
function runTest(testName, canvasType, worker, videoUri) {
const canvas = document.createElement("canvas");
canvas.width = 1920;
canvas.height = 1080;
document.body.appendChild(canvas);
const offscreenCanvas = canvas.transferControlToOffscreen();
return new Promise((resolve, reject) => {
worker.onmessage = e => {
if (e.data.errorMessage) {
reject(e.data.errorMessage);
} else {
resolve(e.data);
}
};
worker.postMessage({ offscreenCanvas, testName, canvasType, videoUri }, [
offscreenCanvas,
]);
})
.then(result => {
let name =
result.testName +
" Mean time across " +
result.totalFrames +
" frames: ";
let value = result.elapsed / result.totalFrames;
let msg = name + value + "\n";
dump("[talos offscreen-canvas-webcodecs result] " + msg);
if (window.tpRecordTime) {
// Within talos - report the results
tpRecordTime(value, 0, name);
} else {
alert(msg);
}
})
.catch(e => {
let msg = "caught error " + e;
dump("[talos offscreen-canvas-webcodecs result] " + msg);
if (window.tpRecordTime) {
// Within talos - report the results
tpRecordTime("", 0, "");
} else {
alert(msg);
}
});
}

4
testing/talos/talos/tests/offscreencanvas/benchmarks/video/mp4box.all.min.js vendored Normal file
View file

File diff suppressed because one or more lines are too long

24
testing/talos/talos/tests/offscreencanvas/benchmarks/video/mp4box.js-LICENSE Normal file
View file

@ -0,0 +1,24 @@
Copyright (c) 2012. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

128
testing/talos/talos/tests/offscreencanvas/benchmarks/video/shared.js Normal file
View file

@ -0,0 +1,128 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
/*global MP4Demuxer b:true*/
const kTotalFrames = 100;
let start;
let frameCount;
function runTestInternal(
testName,
canvasType,
canvas,
isWorker,
videoUri,
resolve,
reject
) {
const runContext = isWorker ? "worker" : "main";
dump(
"[" +
canvasType +
" webcodecs " +
runContext +
"] load video '" +
videoUri +
"'\n"
);
let drawImage;
if (canvasType == "2d") {
const ctx = canvas.getContext("2d");
drawImage = function (frame) {
ctx.drawImage(frame, 0, 0);
};
} else if (canvasType == "webgl") {
const gl = canvas.getContext("webgl");
gl.bindTexture(gl.TEXTURE_2D, gl.createTexture());
drawImage = function (frame) {
gl.texImage2D(
gl.TEXTURE_2D,
0,
gl.RGBA,
gl.RGBA,
gl.UNSIGNED_BYTE,
frame
);
};
} else {
dump("[" + canvasType + " webcodecs " + runContext + "] unknown type\n");
reject("unknown type " + canvasType);
return;
}
frameCount = 0;
const decoder = new VideoDecoder({
output(frame) {
if (frameCount == 0) {
start = performance.now();
}
++frameCount;
dump(
"[" +
canvasType +
" webcodecs " +
runContext +
"] draw frame " +
frameCount +
"\n"
);
drawImage(frame);
frame.close();
if (frameCount == kTotalFrames) {
var elapsed = performance.now() - start;
setTimeout(() => {
resolve({ testName, elapsed, totalFrames: kTotalFrames });
}, 0);
dump(
"[" + canvasType + " webcodecs " + runContext + "] close decoder\n"
);
decoder.close();
}
},
error(e) {
dump(
"[" +
canvasType +
" webcodecs " +
runContext +
"] decoder error " +
e +
"\n"
);
decoder.close();
reject(e);
},
});
new MP4Demuxer(videoUri, {
onConfig(config) {
dump(
"[" + canvasType + " webcodecs " + runContext + "] demuxer config\n"
);
decoder.configure(config);
},
onChunk(chunk) {
dump("[" + canvasType + " webcodecs " + runContext + "] demuxer chunk\n");
decoder.decode(chunk);
},
setStatus(msg) {
dump(
"[" +
canvasType +
" webcodecs " +
runContext +
"] demuxer status - " +
msg +
"\n"
);
},
});
}

22
testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_av1_main.html Normal file
View file

@ -0,0 +1,22 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="mp4box.all.min.js" type="text/javascript"></script>
<script src="demuxer_mp4.js" type="text/javascript"></script>
<script src="shared.js" type="text/javascript"></script>
<script src="helper_main.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
runTest("offscreencanvas_webcodecs_main_av1_webgl", "webgl", videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

20
testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_av1_worker.html Normal file
View file

@ -0,0 +1,20 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="helper_worker.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
const worker = new Worker("worker.js");
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
runTest("offscreencanvas_webcodecs_worker_webgl_av1", "webgl", worker, videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

22
testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_h264_main.html Normal file
View file

@ -0,0 +1,22 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="mp4box.all.min.js" type="text/javascript"></script>
<script src="demuxer_mp4.js" type="text/javascript"></script>
<script src="shared.js" type="text/javascript"></script>
<script src="helper_main.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
runTest("offscreencanvas_webcodecs_main_webgl_h264", "webgl", videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

20
testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_h264_worker.html Normal file
View file

@ -0,0 +1,20 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="helper_worker.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
const worker = new Worker("worker.js");
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
runTest("offscreencanvas_webcodecs_worker_webgl_h264", "webgl", worker, videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

22
testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_vp9_main.html Normal file
View file

@ -0,0 +1,22 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="mp4box.all.min.js" type="text/javascript"></script>
<script src="demuxer_mp4.js" type="text/javascript"></script>
<script src="shared.js" type="text/javascript"></script>
<script src="helper_main.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
runTest("offscreencanvas_webcodecs_main_webgl_vp9", "webgl", videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

20
testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_vp9_worker.html Normal file
View file

@ -0,0 +1,20 @@
<!-- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this file,
- You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html>
<head>
<script src="helper_worker.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
const worker = new Worker("worker.js");
function init() {
const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
runTest("offscreencanvas_webcodecs_worker_webgl_vp9", "webgl", worker, videoUri);
}
</script>
</head>
<body id="body" onload="init();">
</body>
</html>

30
testing/talos/talos/tests/offscreencanvas/benchmarks/video/worker.js Normal file
View file

@ -0,0 +1,30 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
importScripts("mp4box.all.min.js");
importScripts("demuxer_mp4.js");
importScripts("shared.js");
self.onmessage = e => {
const resolve = result => {
self.postMessage(result);
};
const reject = errorMessage => {
self.postMessage({ errorMessage });
};
try {
runTestInternal(
e.data.testName,
e.data.canvasType,
e.data.offscreenCanvas,
/* isWorker */ true,
e.data.videoUri,
resolve,
reject
);
} catch (e) {
reject(e);
}
};

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_av1.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/2d_av1_main.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_h264.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/2d_h264_main.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_vp9.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/2d_vp9_main.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_av1.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_av1_main.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_h264.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_h264_main.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_vp9.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_vp9_main.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_av1.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/2d_av1_worker.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_h264.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/2d_h264_worker.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_vp9.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/2d_vp9_worker.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_av1.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_av1_worker.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_h264.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_h264_worker.html

1
testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_vp9.manifest Normal file
View file

@ -0,0 +1 @@
% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_vp9_worker.html

BIN
testing/talos/talos/tests/video/clips/testsrc.1080p.60fps.av1.short.mp4 Normal file
View file

Binary file not shown.

BIN
testing/talos/talos/tests/video/clips/testsrc.1080p.60fps.h264.short.mp4 Normal file
View file

Binary file not shown.

BIN
testing/talos/talos/tests/video/clips/testsrc.1080p.60fps.vp9.short.mp4 Normal file
View file

Binary file not shown.

288
testing/talos/talos/unittests/test_config.py
View file

@ -273,6 +273,18 @@ class Test_get_config(object):
cls.argv_canvas2dvideo = (
"--activeTests canvas2dvideo -e /some/random/path".split()
)
cls.argv_offscreencanvas_webcodecs_main_webgl_h264 = "--activeTests offscreencanvas_webcodecs_main_webgl_h264 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_main_webgl_vp9 = "--activeTests offscreencanvas_webcodecs_main_webgl_vp9 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_main_webgl_av1 = "--activeTests offscreencanvas_webcodecs_main_webgl_av1 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_worker_webgl_h264 = "--activeTests offscreencanvas_webcodecs_worker_webgl_h264 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_worker_webgl_vp9 = "--activeTests offscreencanvas_webcodecs_worker_webgl_vp9 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_worker_webgl_av1 = "--activeTests offscreencanvas_webcodecs_worker_webgl_av1 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_main_2d_h264 = "--activeTests offscreencanvas_webcodecs_main_2d_h264 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_main_2d_vp9 = "--activeTests offscreencanvas_webcodecs_main_2d_vp9 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_main_2d_av1 = "--activeTests offscreencanvas_webcodecs_main_2d_av1 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_worker_2d_h264 = "--activeTests offscreencanvas_webcodecs_worker_2d_h264 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_worker_2d_vp9 = "--activeTests offscreencanvas_webcodecs_worker_2d_vp9 -e /some/random/path".split()
cls.argv_offscreencanvas_webcodecs_worker_2d_av1 = "--activeTests offscreencanvas_webcodecs_worker_2d_av1 -e /some/random/path".split()
cls.argv_tp5n = "--activeTests tp5n -e /some/random/path".split()
cls.argv_tp5o = "--activeTests tp5o -e /some/random/path".split()
cls.argv_tp5o_webext = "--activeTests tp5o_webext -e /some/random/path".split()
@ -641,6 +653,282 @@ class Test_get_config(object):
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_main_webgl_h264_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_main_webgl_h264)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_main_webgl_h264"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_h264.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_main_webgl_vp9_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_main_webgl_vp9)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_main_webgl_vp9"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_vp9.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_main_webgl_av1_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_main_webgl_av1)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_main_webgl_av1"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_av1.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_worker_webgl_h264_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_worker_webgl_h264)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_worker_webgl_h264"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_h264.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_worker_webgl_vp9_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_worker_webgl_vp9)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_worker_webgl_vp9"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_vp9.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_worker_webgl_av1_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_worker_webgl_av1)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_worker_webgl_av1"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_av1.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_main_2d_h264_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_main_2d_h264)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_main_2d_h264"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_h264.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_main_2d_vp9_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_main_2d_vp9)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_main_2d_vp9"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_vp9.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_main_2d_av1_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_main_2d_av1)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_main_2d_av1"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_av1.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_worker_2d_h264_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_worker_2d_h264)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_worker_2d_h264"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_h264.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_worker_2d_vp9_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_worker_2d_vp9)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_worker_2d_vp9"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_vp9.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
def test_offscreencanvas_webcodecs_worker_2d_av1_has_expected_attributes(self):
config = get_config(self.argv_offscreencanvas_webcodecs_worker_2d_av1)
test_config = config["tests"][0]
assert test_config["name"] == "offscreencanvas_webcodecs_worker_2d_av1"
assert (
test_config["tpmanifest"]
!= "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_av1.manifest"
)
assert test_config["tpcycles"] == 1
assert test_config["tppagecycles"] == 5
assert test_config["tploadnocache"] is True
assert test_config["tpmozafterpaint"] is False
assert test_config["tpchrome"] is False
assert test_config["gecko_profile_interval"] == 2
assert test_config["gecko_profile_entries"] == 2000000
assert "win_counters" not in test_config
assert "w7_counters" not in test_config
assert "linux_counters" not in test_config
assert "mac_counters" not in test_config
assert test_config["filters"] is not None
assert test_config["unit"] == "ms"
@mock.patch("talos.config.build_manifest", conftest.patched_build_manifest)
def test_tp5n_has_expected_attributes(self):
config = get_config(self.argv_tp5n)

2
tools/rewriting/ThirdPartyPaths.txt
View file

@ -165,6 +165,8 @@ testing/mozbase/mozproxy/mozproxy/backends/mitm/scripts/catapult/
testing/talos/talos/tests/devtools/addon/content/pages/
testing/talos/talos/tests/dromaeo/
testing/talos/talos/tests/kraken/
testing/talos/talos/tests/offscreencanvas/benchmarks/video/demuxer_mp4.js
testing/talos/talos/tests/offscreencanvas/benchmarks/video/mp4box.all.min.js
testing/talos/talos/tests/v8_7/
testing/web-platform/tests/resources/webidl2/
testing/web-platform/tests/tools/third_party/