Status Update
No update yet.
Comments
an...@google.com
Hi test team, this appears to be a regression, making it a good candidate for bisection to quickly identify the root cause. Please remove 'Needs-Bisect' hotlist and provide a rationale if bisection isn't applicable; this feedback will improve the automated system.
ka...@google.com
Tried to reproduce the issue as per
Opened the linkwww.canalplus.com and seen unable to stream the video as it need subscription to watch the videos
Reporter@ Could you please provide alternate sample URL which use HW secure decryption that reproduce issue for futher bisecting
Looping Vikram Pasupathy@ as per suspect mentioned inhttps://chromium.googlesource.com/chromium/src/+/1cade20afb7d56a237dce9199e29cd2054ab4fd3 " for further inputs on the issue
Thanks..!!
Opened the link
Reporter@ Could you please provide alternate sample URL which use HW secure decryption that reproduce issue for futher bisecting
Looping Vikram Pasupathy@ as per suspect mentioned in
Thanks..!!
sp...@gmail.com
You don't need to test on any streaming services
you just have to head to edge://media-internals in the CDMs tab, and check the playready section and then you'll see the status. If it's disabled because of "Bad GPU or driver". Then you successfully reproduced the problem.
Not being able to watch FHD content on for example canalplus is a consequence of that drm being disabled.
you just have to head to edge://media-internals in the CDMs tab, and check the playready section and then you'll see the status. If it's disabled because of "Bad GPU or driver". Then you successfully reproduced the problem.
Not being able to watch FHD content on for example canalplus is a consequence of that drm being disabled.
sa...@gmail.com
@ sp...@gmail.com Yes, I could have not put it better myself. Sorry for the confusion, the root of the problem is indeed having Playready hardware secure disabled. You can also check it in edge://gpu where "PlayReady Hardware DRM disabled" is set to "true".
This web application is supposed to allow testing multiple DRMs including Playready2 :https://refapp.hbbtv.org/staging/catalogue/ . Go to Playready2 (with key arrows) and try to play a SL3000 stream. Unfortunately, it does not work even on devices it is supposed to work.
I also found this:https://testweb.playready.microsoft.com/ . But no idea on how to use it.
This web application is supposed to allow testing multiple DRMs including Playready2 :
I also found this:
pe...@google.com
Thank you for providing more feedback. Adding the requester to the CC list.
sa...@gmail.com
I've accidentally removed myself from the CC list, sorry about that.
va...@google.com
Tried to reproduce the issue on chrome version #134.0.6998.178 using Win 11 as per
Steps to reproduce:
---------------------------
1.Launched the Chrome browser.
2.Opened given link:http://www.canalplus.com/
3. Opened chrome://media-internals >> CDMs tab
4. Didnt observe playready section
5. In Edge browser go to >> edge://media-internals >> CDMs tab >> and observe playready section and status: Enabled
Reporter@ Could you please review the attached screencast to confirm if there’s anything missed in the process.also please help us with actual and expected behaviour which helps us in further triaging the issue.
**Note: Requesting you to copy-paste the entire content of "chrome://version/?show-variations-cmd" details to a .txt file format and attach it.
Thanks..!!
Steps to reproduce:
---------------------------
1.Launched the Chrome browser.
2.Opened given link:
3. Opened chrome://media-internals >> CDMs tab
4. Didnt observe playready section
5. In Edge browser go to >> edge://media-internals >> CDMs tab >> and observe playready section and status: Enabled
Reporter@ Could you please review the attached screencast to confirm if there’s anything missed in the process.also please help us with actual and expected behaviour which helps us in further triaging the issue.
**Note: Requesting you to copy-paste the entire content of "chrome://version/?show-variations-cmd" details to a .txt file format and attach it.
Thanks..!!
sa...@gmail.com
Please read the whole issue, it is mentionned in the first step that only a few AMD GPUs are concerned. Having one these GPUs and going to edge://media-internals, CDMs tab as per
pe...@google.com
Thank you for providing more feedback. Adding the requester to the CC list.
va...@google.com
As per
Thanks..!!
Thanks..!!
eg...@gmail.com
I have the same problem as the OP with an AMD Radeon RX 7900 XTX.
Steps to reproduce:
1. Launch Edge Browser
2. Opened edge://media-internals >> CDMs tab
3. observe playready hardware secure status: Disabled via GPU feature (e.g. bad GPU or driver)
Steps to reproduce:
1. Launch Edge Browser
2. Opened edge://media-internals >> CDMs tab
3. observe playready hardware secure status: Disabled via GPU feature (e.g. bad GPU or driver)
nm...@google.com
Hi,
As per C#11 and C#12, i am requesting DEV to look into this issue for more inputs on triaging the issue further.
Thanks for the help!
As per C#11 and C#12, i am requesting DEV to look into this issue for more inputs on triaging the issue further.
Thanks for the help!
vp...@chromium.org
This is an edge issue, and there is a work around in Chromium for this issue:
--enable-features=EnableFaultyGPUForMediaFoundation
If this does not work in Edge, it is because there are Edge specific behaviors preventing this, and there is nothing Chromium can do.
--enable-features=EnableFaultyGPUForMediaFoundation
If this does not work in Edge, it is because there are Edge specific behaviors preventing this, and there is nothing Chromium can do.
eg...@gmail.com
How to test if "--enable-features=EnableFaultyGPUForMediaFoundation" works in Edge?
Where do I need to input that command?
Where do I need to input that command?
sh...@gmail.com
I have the same issue with an AMD Radeon RX 6800
eg...@gmail.com
Assigned to vp...@chromium.org
Well your "Intended Behavior" breaks Netflix 4K/HDR on PC for many AMD GPU owners.
Please fix.
Well your "Intended Behavior" breaks Netflix 4K/HDR on PC for many AMD GPU owners.
Please fix.
th...@gmail.com
"This is an edge issue"
How could you even say that? This is started by the supposed "fix" that is supposed to "improve the error rate for hw secure playback on Windows". Instead it broke DRM hd playback on all AMD windows devices. Do you understand that it not only broke Edge playback but also official Netflix, Prime and other DRM supported windows apps? How are we supposed to use the flag with all those apps even if its somehow possible on Edge?
How could you even say that? This is started by the supposed "fix" that is supposed to "improve the error rate for hw secure playback on Windows". Instead it broke DRM hd playback on all AMD windows devices. Do you understand that it not only broke Edge playback but also official Netflix, Prime and other DRM supported windows apps? How are we supposed to use the flag with all those apps even if its somehow possible on Edge?
sa...@gmail.com
Could it be possible to mention the two reviewers who validated the modification? One of them literally said that she didn't know what it was all about but still said "LGTM" (
vp...@chromium.org
Hey Nic, assigning this to Edge media to triage why this CL (below) wasn't downstreamed to Edge:
https://chromium-review.googlesource.com/c/chromium/src/+/5743268
Also, not sure how it breaks DRM supported windows apps, unless Edge does a specific windowing for apps by making them based on Edge.
Also, not sure how it breaks DRM supported windows apps, unless Edge does a specific windowing for apps by making them based on Edge.
ch...@microsoft.com
We're digging into why that code differs for Edge. Early indication is that the flag should be fixed. Regardless, feels like that flag is a workaround and exposes the underlying issues that led to the original GPU disablement and should only be used for testing?
@vp...@chromium.org is there a plan for seeing if these AMD driver issues get resolved and then re-enabling support for these GPUs?
This issue affects Netflix and other apps because they are built on Edge WebView2, which shares the same code as the browser. This should also affect Chrome for cases where HWDRM is used on Windows, as the original GPU disablement came from failure telemetry in Chrome. This affects Edge-only in cases where content providers are only using HWDRM in Edge, like Canal+.
This issue affects Netflix and other apps because they are built on Edge WebView2, which shares the same code as the browser. This should also affect Chrome for cases where HWDRM is used on Windows, as the original GPU disablement came from failure telemetry in Chrome. This affects Edge-only in cases where content providers are only using HWDRM in Edge, like Canal+.
vp...@chromium.org
There is ongoing dialogue with AMD, and we're committed to reviewing these GPUs periodically in context of the previously collected stats and how they've changed since then.
Chrome telemetry did in fact guide us, as we've identified these GPUs as poor performing and failing at certain parts of the HWDRM pipeline.
We have the flag for technical users to be able to bypass these block-lists and as part of our testing experience to evaluate HW Secure playback on Windows.
Guidance for Edge users to be able to use this flag would be great so that they can get hwdrm on their devices.
Also, separately, these CLs were not chained, but having Edge downstream the entirety of the CLs might give a better experience and prevent situations like this. What's your guidance for making sure CLs get downstreamed to Edge?
Chrome telemetry did in fact guide us, as we've identified these GPUs as poor performing and failing at certain parts of the HWDRM pipeline.
We have the flag for technical users to be able to bypass these block-lists and as part of our testing experience to evaluate HW Secure playback on Windows.
Guidance for Edge users to be able to use this flag would be great so that they can get hwdrm on their devices.
Also, separately, these CLs were not chained, but having Edge downstream the entirety of the CLs might give a better experience and prevent situations like this. What's your guidance for making sure CLs get downstreamed to Edge?
ch...@microsoft.com
Glad to hear about the process, and thanks for confirming!
The lack of CL chaining wasn't the issue, and Edge generally downstreams the entirety of the CLs as they come. But there is some divergence between Chromium and Edge code, which requires a process to make sure CLs integrate downstream cleanly. In this case the flag happened to get added into a section of code that had already been disabled in Edge. We're working to re-enable the flag in Edge.
For anyone running into this issue, you might also try running Edge with the "--disable-gpu-driver-bug-workarounds" flag. We only recommend this flag for testing, as it might expose driver bugs that lead to an unstable browsing experience.
The lack of CL chaining wasn't the issue, and Edge generally downstreams the entirety of the CLs as they come. But there is some divergence between Chromium and Edge code, which requires a process to make sure CLs integrate downstream cleanly. In this case the flag happened to get added into a section of code that had already been disabled in Edge. We're working to re-enable the flag in Edge.
For anyone running into this issue, you might also try running Edge with the "--disable-gpu-driver-bug-workarounds" flag. We only recommend this flag for testing, as it might expose driver bugs that lead to an unstable browsing experience.
vp...@chromium.org
Awesome yes, verified that
"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --disable-gpu-driver-bug-workarounds works as intended in regards to edge://media-internals. Thanks for chiming in!
dx...@google.com
Project: chromium/src
Branch: main
Author: Vikram Pasupathy
Link:
cdm: Clean up flag usage in MediaFoundationHardwareSecurity code
Expand for full commit details
There are already existing flags that govern the GPU blocklist. Removing
the media switch that exists just for MediaFoundation.
Now, behavior is as follows. On my AMD GPU that is currently disabled
via the BlockList, passing in --disable-gpu-driver-bug-workarounds
enables MediaFoundation HW security
Bug: 406357270
Change-Id: I04eb6a0d9f776db27c3b0bb38ac33fbd2360f542
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6439190
Reviewed-by: Maggie Chen <magchen@chromium.org>
Reviewed-by: John Rummell <jrummell@chromium.org>
Auto-Submit: Vikram Pasupathy <vpasupathy@chromium.org>
Commit-Queue: John Rummell <jrummell@chromium.org>
Reviewed-by: Sangbaek Park <sangbaekpark@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1444941}
Files:
- M
content/browser/media/cdm_registry_impl.cc - M
media/base/media_switches.cc - M
media/base/media_switches.h
Hash: 683217cfeba9ba977c1973493ea7d2f03ccaf60b
Date: Wed Apr 9 21:19:07 2025
Re...@gmx.de
Just want to chime in, because this issue is an "insanity". It suddenly and completely broke 4K Netflix streaming with no prior warning for months now on ALL (I believe) discrete AMD GPUs of at least the RX 6000 and RX 7000 series. I own a RX 6650 XT and RX 7900 XT and I have not been able to conveniently stream Netflix 4K for 2 months now. I complained to Netflix 1 1/2 months ago, the customer service had absolutely no idea what was going on. They did not know how to fix it or even what the issue could be. I HAD to explain it to them, that likely due to a block list/driver listing incompatibility AMD GPUs were now suddenly restricted from using Play ready DRM, since it was now disabled in the media foundation. I even had to provide the workaround myself which at the time was to manually uninstalling MS Edge and then manually installing the last MS Edge version that enabled PlayReady DRM due to hardware decoding which was version 132.XXXX. Since then nothing at all happened officially. I pay 20$ equivalent per month for 4K netflix and I cannot use it properly because someone decided to "fix" something which was not broken (for me). Do you know how bad Netflix streaming quality gets on a 4K device without PlayReady DRM?
Honestly to take such steps without informing end users is utterly inappropriate. To not provide public info how to work around it really lets me question if anybody thinks about the consequences of such changes beforehand... . Really, this completely breaks quality streaming for anyone who does not know quite a bit about how edge works internally and how to even get manual edge installations or how to actively fight Windows so that it does not update edge to the broken version again all the time. A huge NO as to how this affair was handled.
It is good to see that things are moving now somewhat, but this is really not how it should go in the first place.
Btw. "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --disable-gpu-driver-bug-workarounds works mostly, but is almost as inconvenient as always installing a working MS Edge version. It also only seems to work if no instance of edge is already running which again means fighting Windows... . I really am frustrated about this. For now fighting Windows and installing old MS Edge versions when needed. Please, JUST make an official roleback on this. It would be the easiest solution and I never had any issues with 4K streaming or any streaming in context with the AMD GPUs and this seems to be the case for MOST AMD GPU users. It is just ridiculous that this is considered a "fix" or "better" in any way... .
Honestly to take such steps without informing end users is utterly inappropriate. To not provide public info how to work around it really lets me question if anybody thinks about the consequences of such changes beforehand... . Really, this completely breaks quality streaming for anyone who does not know quite a bit about how edge works internally and how to even get manual edge installations or how to actively fight Windows so that it does not update edge to the broken version again all the time. A huge NO as to how this affair was handled.
It is good to see that things are moving now somewhat, but this is really not how it should go in the first place.
Btw. "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --disable-gpu-driver-bug-workarounds works mostly, but is almost as inconvenient as always installing a working MS Edge version. It also only seems to work if no instance of edge is already running which again means fighting Windows... . I really am frustrated about this. For now fighting Windows and installing old MS Edge versions when needed. Please, JUST make an official roleback on this. It would be the easiest solution and I never had any issues with 4K streaming or any streaming in context with the AMD GPUs and this seems to be the case for MOST AMD GPU users. It is just ridiculous that this is considered a "fix" or "better" in any way... .
ch...@google.com
M136 merge request created. Please update crbug/411210730 to have this merge reviewed.
dx...@google.com
Project: chromium/src
Branch: main
Author: Vikram Pasupathy
Link:
gpu: Reenable AMD GPUs for MediaFoundation HW security
Expand for full commit details
The AMD GPUs were disabled for MediaFoundation playback based on metrics
that no longer apply, and we don't see any metrics since they are
disabled.
We should reenable them to collect data via the new metrics
now that Chromium is going to use PlayReady directly.
Bug: 406357270
Change-Id: I8b23f6270dbf3600cce846f07cd3b5ae6d967487
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6461748
Reviewed-by: Sangbaek Park <sangbaekpark@chromium.org>
Commit-Queue: Vikram Pasupathy <vpasupathy@chromium.org>
Reviewed-by: Maggie Chen <magchen@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1448075}
Files:
- M
gpu/config/gpu_driver_bug_list.json
Hash: abab5b7d58934dfd4fe0787f004180e125efa727
Date: Wed Apr 16 23:36:42 2025
Description
Steps to reproduce the problem
Problem Description
"Bugfix" that led to disable these specific GPUs (for some reason, link to the analysis is broken):https://chromium.googlesource.com/chromium/src/+/1cade20afb7d56a237dce9199e29cd2054ab4fd3
In the bugfix description, it is said “disabling the AMD gpus specified below will improve the error rate for hw secure playback on Windows.“ which means the goal is to improve the error rate the hardware secure playback on Windows. But strangely enough, in the file called gpu_driver_bug_list.json, it is said: “Disable hardware secure decryption on AMD GPUs with higher error rates to achieve better playback results” in which the goal is now to disable hardware secure decryption and not reducing the error rate to improve it.
Reddit thread with several people having the same problem:https://www.reddit.com/r/MicrosoftEdge/comments/1ixxt8a/help_with_playready/
A command line flag was created to bypass this block list but it can't be used with Microsoft Edge:https://chromium-review.googlesource.com/c/chromium/src/+/5743268
Why Edge instead of Chromium? In my case, because MyCanal only supports 1080p/4k with Edge.
Summary
Some AMD GPUs are restricted from HD Streaming content because of disabled HW secure decryption
Custom Questions
Does this work in other browsers?
Yes - This is just a Chromium problem
Contents of chrome://gpu:
Graphics Feature Status
Version Information
Data exported : 2025-03-26T11:10:19.923Z Chrome version : Edg/134.0.3124.85 Operating system : Windows NT 10.0.26100 Software rendering list URL:https://chromium.googlesource.com/chromium/src/+/0b26d3a1ee1e44572492002c2e52ffcd13ac701b/gpu/config/software_rendering_list.json
Driver bug list URL : https://chromium.googlesource.com/chromium/src/+/0b26d3a1ee1e44572492002c2e52ffcd13ac701b/gpu/config/gpu_driver_bug_list.json
ANGLE commit id : 3b7e0c13e1a0
2D graphics backend : Skia/134 aefbd9403c1b3032ad4cd0281ef312ed262c7125
Command Line : "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --flag-switches-begin --ignore-gpu-blocklist --enable-features=msPlayReadyWin10 --disable-features=HardwareSecureDecryptionFallback,msWidevinePlatform --flag-switches-end
Driver Information
Initialization time : 178 In-process GPU : false Passthrough Command Decoder : true Sandboxed : true GPU0 : VENDOR= 0x1002, DEVICE=0x744c, SUBSYS=0x471e1da2, REV=204, LUID={0,7023121}, DRIVER_VENDOR=AMD, DRIVER_VERSION=32.0.13031.3015 ACTIVE GPU1 : VENDOR= 0x1414, DEVICE=0x008c, LUID={0,98767}, DRIVER_VERSION=10.0.26100.3323 Optimus : false AMD switchable : false Desktop compositing : Aero Glass Direct composition : true Supports overlays : false YUY2 overlay support : NONE NV12 overlay support : NONE BGRA8 overlay support : NONE RGB10A2 overlay support : NONE P010 overlay support : NONE DirectML feature level : 5.0 Driver D3D12 feature level : D3D 12.2 Driver Vulkan API version : Vulkan API 1.3.0 Pixel shader version : 5.0 Vertex shader version : 5.0 Max. MSAA samples : 8 Machine model name : Machine model version : GL implementation parts : (gl=egl-angle,angle=d3d11) Display type : ANGLE_D3D11 GL_VENDOR : Google Inc. (AMD) GL_RENDERER : ANGLE (AMD, AMD Radeon RX 7900 XT (0x0000744C) Direct3D11 vs_5_0 ps_5_0, D3D11-32.0.13031.3015) GL_VERSION : OpenGL ES 2.0.0 (ANGLE 2.1.40144 git hash: 3b7e0c13e1a0) GL_EXTENSIONS : GL_AMD_performance_monitor GL_ANGLE_base_vertex_base_instance_shader_builtin GL_ANGLE_blob_cache GL_ANGLE_client_arrays GL_ANGLE_depth_texture GL_ANGLE_framebuffer_blit GL_ANGLE_framebuffer_multisample GL_ANGLE_get_serialized_context_string GL_ANGLE_get_tex_level_parameter GL_ANGLE_instanced_arrays GL_ANGLE_lossy_etc_decode GL_ANGLE_memory_size GL_ANGLE_pack_reverse_row_order GL_ANGLE_polygon_mode GL_ANGLE_program_binary_readiness_query GL_ANGLE_program_cache_control GL_ANGLE_provoking_vertex GL_ANGLE_request_extension GL_ANGLE_robust_client_memory GL_ANGLE_texture_compression_dxt3 GL_ANGLE_texture_compression_dxt5 GL_ANGLE_texture_usage GL_ANGLE_translated_shader_source GL_APPLE_clip_distance GL_ARM_rgba8 GL_CHROMIUM_bind_generates_resource GL_CHROMIUM_bind_uniform_location GL_CHROMIUM_color_buffer_float_rgb GL_CHROMIUM_color_buffer_float_rgba GL_CHROMIUM_copy_compressed_texture GL_CHROMIUM_copy_texture GL_CHROMIUM_lose_context GL_CHROMIUM_sync_query GL_EXT_EGL_image_external_wrap_modes GL_EXT_blend_func_extended GL_EXT_blend_minmax GL_EXT_clip_control GL_EXT_color_buffer_half_float GL_EXT_debug_label GL_EXT_debug_marker GL_EXT_depth_clamp GL_EXT_discard_framebuffer GL_EXT_disjoint_timer_query GL_EXT_draw_buffers GL_EXT_draw_elements_base_vertex GL_EXT_float_blend GL_EXT_frag_depth GL_EXT_instanced_arrays GL_EXT_map_buffer_range GL_EXT_multisampled_render_to_texture GL_EXT_occlusion_query_boolean GL_EXT_polygon_offset_clamp GL_EXT_read_format_bgra GL_EXT_robustness GL_EXT_sRGB GL_EXT_shader_texture_lod GL_EXT_texture_border_clamp GL_EXT_texture_compression_bptc GL_EXT_texture_compression_dxt1 GL_EXT_texture_compression_rgtc GL_EXT_texture_compression_s3tc_srgb GL_EXT_texture_filter_anisotropic GL_EXT_texture_format_BGRA8888 GL_EXT_texture_mirror_clamp_to_edge GL_EXT_texture_norm16 GL_EXT_texture_rg GL_EXT_texture_storage GL_EXT_texture_type_2_10_10_10_REV GL_EXT_unpack_subimage GL_KHR_debug GL_KHR_parallel_shader_compile GL_KHR_robustness GL_NV_EGL_stream_consumer_external GL_NV_fence GL_NV_framebuffer_blit GL_NV_pack_subimage GL_NV_pixel_buffer_object GL_OES_EGL_image GL_OES_EGL_image_external GL_OES_compressed_EAC_R11_signed_texture GL_OES_compressed_EAC_R11_unsigned_texture GL_OES_compressed_EAC_RG11_signed_texture GL_OES_compressed_EAC_RG11_unsigned_texture GL_OES_compressed_ETC2_RGB8_texture GL_OES_compressed_ETC2_RGBA8_texture GL_OES_compressed_ETC2_punchthroughA_RGBA8_texture GL_OES_compressed_ETC2_punchthroughA_sRGB8_alpha_texture GL_OES_compressed_ETC2_sRGB8_alpha8_texture GL_OES_compressed_ETC2_sRGB8_texture GL_OES_depth24 GL_OES_depth32 GL_OES_draw_elements_base_vertex GL_OES_element_index_uint GL_OES_fbo_render_mipmap GL_OES_get_program_binary GL_OES_mapbuffer GL_OES_packed_depth_stencil GL_OES_required_internalformat GL_OES_rgb8_rgba8 GL_OES_standard_derivatives GL_OES_surfaceless_context GL_OES_texture_border_clamp GL_OES_texture_float GL_OES_texture_float_linear GL_OES_texture_half_float GL_OES_texture_half_float_linear GL_OES_texture_npot GL_OES_vertex_array_object GL_WEBGL_video_texture Disabled Extensions : GL_KHR_blend_equation_advanced GL_KHR_blend_equation_advanced_coherent Disabled WebGL Extensions : Window system binding vendor : Google Inc. (AMD) Window system binding version : 1.5 (ANGLE 2.1.40144 git hash: 3b7e0c13e1a0) Window system binding extensions: EGL_EXT_create_context_robustness EGL_ANGLE_d3d_share_handle_client_buffer EGL_ANGLE_d3d_texture_client_buffer EGL_ANGLE_surface_d3d_texture_2d_share_handle EGL_ANGLE_query_surface_pointer EGL_ANGLE_window_fixed_size EGL_ANGLE_keyed_mutex EGL_ANGLE_surface_orientation EGL_ANGLE_direct_composition EGL_NV_post_sub_buffer EGL_KHR_create_context EGL_KHR_image EGL_KHR_image_base EGL_KHR_gl_texture_2D_image EGL_KHR_gl_texture_cubemap_image EGL_KHR_gl_renderbuffer_image EGL_KHR_get_all_proc_addresses EGL_KHR_stream EGL_KHR_stream_consumer_gltexture EGL_NV_stream_consumer_gltexture_yuv EGL_ANGLE_stream_producer_d3d_texture EGL_ANGLE_create_context_webgl_compatibility EGL_CHROMIUM_create_context_bind_generates_resource EGL_CHROMIUM_sync_control EGL_EXT_pixel_format_float EGL_KHR_surfaceless_context EGL_ANGLE_display_texture_share_group EGL_ANGLE_display_semaphore_share_group EGL_ANGLE_create_context_client_arrays EGL_ANGLE_program_cache_control EGL_ANGLE_robust_resource_initialization EGL_ANGLE_create_context_extensions_enabled EGL_ANDROID_blob_cache EGL_ANDROID_recordable EGL_ANGLE_image_d3d11_texture EGL_ANGLE_create_context_backwards_compatible EGL_KHR_no_config_context EGL_KHR_create_context_no_error EGL_KHR_reusable_sync EGL_ANGLE_memory_usage_report Direct rendering version : unknown Reset notification strategy : 0x8252 GPU process crash count : 0 gfx::BufferFormats supported for allocation and texturing: R_8: not supported, R_16: not supported, RG_88: not supported, RG_1616: not supported, BGR_565: not supported, RGBA_4444: not supported, RGBX_8888: not supported, RGBA_8888: not supported, BGRX_8888: not supported, BGRA_1010102: not supported, RGBA_1010102: not supported, BGRA_8888: not supported, RGBA_F16: not supported, YVU_420: not supported, YUV_420_BIPLANAR: not supported, YUVA_420_TRIPLANAR: not supported, P010: not supported
Driver Bug Workarounds
Problems Detected
Some drivers are unable to reset the D3D device in the GPU process sandbox Applied Workarounds: exit_on_context_lost
Disable KHR_blend_equation_advanced until cc shaders are updated: (http://crbug.com/661715 )
Applied Workarounds: disable(GL_KHR_blend_equation_advanced),
disable(GL_KHR_blend_equation_advanced_coherent)
Expose WebGL's disjoint_timer_query extensions on platforms with site isolation: (http://crbug.com/808744 ), (http://crbug.com/870491 )
Applied Workarounds: enable_webgl_timer_query_extensions
dynamic textures fail to work on AMD GPUs: (http://crbug.com/1029855 ), (http://crbug.com/1050666 )
Applied Workarounds: disable_nv12_dynamic_textures
Limit D3D11VideoDecoder to 11.0 due to crashes on AMD: (http://crbug.com/1012464 )
Applied Workarounds: limit_d3d11_video_decoder_to_11_0
Software overlays fail to work reliably on AMD devices: (http://crbug.com/1161215 ), (http://crbug.com/1160217 )
Applied Workarounds: disable_direct_composition_sw_video_overlays
Only enable video processor super resolution on Intel Gen10+ GPUs and NVIDIA GPUs with 530+ drivers: (http://crbug.com/1318380 )
Applied Workarounds: disable_vp_super_resolution
Only enable video processor auto HDR on NVIDIA GPUs with 550.50+ driver: (http://crbug.com/1445741 )
Applied Workarounds: disable_vp_auto_hdr
Disable VP9 k-SVC video decoding on non-Intel GPUs: (http://crbug.com/1508379 )
Applied Workarounds: disable_d3d11_vp9_ksvc_decoding
Block all NPU drivers except Intel driver versions >= 32.0.100.3053 for WebNN: (http://crbug.com/341327464 )
Applied Workarounds: disable_webnn_for_npu
Disable overlay promotion for clear video quads when their MPO quads would move: (http://crbug.com/40677119 )
Applied Workarounds: disable_video_overlay_if_moving
Disable hardware secure decryption on AMD GPUs with higher error rates to achieve better playback results.: (http://crbug.com/315860185 )
Applied Workarounds: disable_media_foundation_hardware_security
VP9 resilient mode causes corruptions with AMD VCN HW decoders, using DXVA: (http://crbug.com/1087422 )
Applied Workarounds: disallow_vp9_resilient_dxva_decoding
Disable WebGPU Model for AMD GPUs Applied Workarounds: disable_ms_webgpu_on_device_model
ANGLE Features
allowCompressedFormats (Frontend workarounds): Enabled
alwaysEnableEmulatedMultidrawExtensions (Frontend workarounds): Disabled
alwaysRunLinkSubJobsThreaded (Frontend features): Disabled
cacheCompiledShader (Frontend features): Disabled
compileJobIsThreadSafe (Frontend features): Enabled
disableAnisotropicFiltering (Frontend workarounds): Disabled
disableDrawBuffersIndexed (Frontend features): Disabled
disableProgramBinary (Frontend features): Disabled
disableProgramCaching (Frontend features): Disabled
disableProgramCachingForTransformFeedback (Frontend workarounds): Disabled
dumpShaderSource (Frontend features): Disabled
dumpTranslatedShaders (Frontend features): Disabled
emulatePixelLocalStorage (Frontend features): Enabled
enableCaptureLimits (Frontend features): Disabled
enableProgramBinaryForCapture (Frontend features): Disabled
enableShaderSubstitution (Frontend workarounds): Disabled
enableTranslatedShaderSubstitution (Frontend workarounds): Disabled
forceDepthAttachmentInitOnClear (Frontend workarounds): Enabled
forceFlushAfterDrawcallUsingShadowmap (Frontend workarounds): Disabled
forceGlErrorChecking (Frontend features): Disabled
forceInitShaderVariables (Frontend features): Disabled
forceMinimumMaxVertexAttributes (Frontend features): Disabled
forceRobustResourceInit (Frontend features): Disabled
linkJobIsThreadSafe (Frontend features): Enabled
loseContextOnOutOfMemory (Frontend workarounds): Enabled
rejectWebglShadersWithUndefinedBehavior (Frontend workarounds): Enabled
singleThreadedTextureDecompression (Frontend workarounds): Disabled
uncurrentEglSurfaceUponSurfaceDestroy (Frontend workarounds): Disabled
addMockTextureNoRenderTarget (D3D workarounds): Disabled
allowClearForRobustResourceInit (D3D workarounds): Enabled
allowES3OnFL100 (D3D workarounds): Disabled
allowTranslateUniformBlockToStructuredBuffer (D3D workarounds): Enabled
borderColorSrgb (D3D workarounds): Disabled
callClearTwice (D3D workarounds): Disabled
depthStencilBlitExtraCopy (D3D workarounds): Disabled
disableB5G6R5Support (D3D workarounds): Enabled
disableRasterizerOrderViews (D3D workarounds): Disabled
emulateIsnanFloat (D3D workarounds): Disabled
emulateTinyStencilTextures (D3D workarounds): Enabled
enableTimestampQueries (D3D workarounds): Disabled
expandIntegerPowExpressions (D3D workarounds): Enabled
flushAfterEndingTransformFeedback (D3D workarounds): Disabled
forceAtomicValueResolution (D3D workarounds): Disabled
getDimensionsIgnoresBaseLevel (D3D workarounds): Disabled
mrtPerfWorkaround (D3D workarounds): Enabled
preAddTexelFetchOffsets (D3D workarounds): Disabled
rewriteUnaryMinusOperator (D3D workarounds): Disabled
selectViewInGeometryShader (D3D workarounds): Disabled
setDataFasterThanImageUpload (D3D workarounds): Enabled
skipVSConstantRegisterZero (D3D workarounds): Disabled
supportsNonConstantLoopIndexing (D3D workarounds): Enabled
useSystemMemoryForConstantBuffers (D3D workarounds): Disabled
zeroMaxLodWorkaround (D3D workarounds): Disabled
Dawn Info
<Unknown GPU> OpenGLES backend - ANGLE (AMD, AMD Radeon RX 7900 XT (0x0000744C) Direct3D11 vs_5_0 ps_5_0, D3D11-32.0.13031.3015) (Compatibility Mode)
[WebGPU Status]
[Adapter Supported Features]
[Enabled Toggle Names]
lazy_clear_resource_on_first_use: (https://crbug.com/dawn/145 ):
Clears resource to zero on first usage. This initializes the resource so
that no dirty bits from recycled memory is present in the new resource.
disable_indexed_draw_buffers: (https://crbug.com/dawn/582 ):
Disables the use of indexed draw buffer state which is unsupported on some
platforms.
flush_before_client_wait_sync: (https://crbug.com/dawn/633 ):
Call glFlush before glClientWaitSync to work around bugs in the latter
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
use_placeholder_fragment_in_vertex_only_pipeline: (https://crbug.com/dawn/136 ):
Use a placeholder empty fragment shader in vertex only render pipeline.
This toggle must be enabled for OpenGL ES backend, the Vulkan Backend, and
serves as a workaround by default enabled on some Metal devices with Intel
GPU to ensure the depth result is correct.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
use_blit_for_buffer_to_stencil_texture_copy: (https://crbug.com/dawn/1389 ):
Use a blit instead of a copy command to copy buffer data to the stencil
aspect of a texture. Works around an issue where stencil writes by copy
commands are not visible to a render or compute pass.
use_blit_for_depth16unorm_texture_to_buffer_copy: (https://crbug.com/dawn/1782 ):
Use a blit instead of a copy command to copy depth aspect of a texture to
a buffer.Workaround for OpenGL and OpenGLES.
use_blit_for_depth32float_texture_to_buffer_copy: (https://crbug.com/dawn/1782 ):
Use a blit instead of a copy command to copy depth aspect of a texture to
a buffer.Workaround for OpenGLES.
use_blit_for_stencil_texture_to_buffer_copy: (https://crbug.com/dawn/1782 ):
Use a blit instead of a copy command to copy stencil aspect of a texture
to a buffer.Workaround for OpenGLES.
use_blit_for_snorm_texture_to_buffer_copy: (https://crbug.com/dawn/1781 ):
Use a blit instead of a copy command to copy snorm texture to a
buffer.Workaround for OpenGLES.
use_blit_for_rgb9e5ufloat_texture_copy: (https://crbug.com/381214487 ):
Use a blit instead of a copy command to copy rg11b10ufloat texture to a
texture or a buffer.Workaround for OpenGLES.
use_t2b2t_for_srgb_texture_copy: (https://crbug.com/dawn/2362 ):
Use T2B and B2T copies to emulate a T2T copy between sRGB and non-sRGB
textures.Workaround for OpenGLES.
[WebGPU Required Toggles - enabled]
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
<Discrete GPU> Vulkan backend - AMD Radeon RX 7900 XT
[WebGPU Status]
[Adapter Supported Features]
[Enabled Toggle Names]
lazy_clear_resource_on_first_use: (https://crbug.com/dawn/145 ):
Clears resource to zero on first usage. This initializes the resource so
that no dirty bits from recycled memory is present in the new resource.
use_temporary_buffer_in_texture_to_texture_copy: (https://crbug.com/dawn/42 ):
Split texture-to-texture copy into two copies: copy from source texture
into a temporary buffer, and copy from the temporary buffer into the
destination texture when copying between compressed textures that don't
have block-aligned sizes. This workaround is enabled by default on all
Vulkan drivers to solve an issue in the Vulkan SPEC about the
texture-to-texture copies with compressed formats. See #1005
(https://github.com/KhronosGroup/Vulkan-Docs/issues/1005 ) for more
details.
vulkan_use_d32s8: (https://crbug.com/dawn/286 ):
Vulkan mandates support of either D32_FLOAT_S8 or D24_UNORM_S8. When
available the backend will use D32S8 (toggle to on) but setting the toggle
to off will make it use the D24S8 format when possible.
vulkan_use_s8: (https://crbug.com/dawn/666 ):
Vulkan has a pure stencil8 format but it is not universally available.
When this toggle is on, the backend will use S8 for the stencil8 format,
otherwise it will fallback to D32S8 or D24S8.
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
vulkan_use_demote_to_helper_invocation_extension: (https://crbug.com/42250787 ):
Sets the use of the vulkan demote to helper extension
use_placeholder_fragment_in_vertex_only_pipeline: (https://crbug.com/dawn/136 ):
Use a placeholder empty fragment shader in vertex only render pipeline.
This toggle must be enabled for OpenGL ES backend, the Vulkan Backend, and
serves as a workaround by default enabled on some Metal devices with Intel
GPU to ensure the depth result is correct.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
use_vulkan_zero_initialize_workgroup_memory_extension: (https://crbug.com/dawn/1302 ):
Initialize workgroup memory with OpConstantNull on Vulkan when the Vulkan
extension VK_KHR_zero_initialize_workgroup_memory is supported.
vulkan_use_image_robust_access_2: (https://crbug.com/tint/1890 ):
Disable Tint robustness transform on textures when VK_EXT_robustness2 is
supported and robustImageAccess2 == VK_TRUE.
vulkan_use_buffer_robust_access_2: (https://crbug.com/tint/1890 ):
Disable index clamping on the runtime-sized arrays on buffers in Tint
robustness transform when VK_EXT_robustness2 is supported and
robustBufferAccess2 == VK_TRUE.
vulkan_use_storage_input_output_16: (https://crbug.com/tint/2161 ):
Use the StorageInputOutput16 SPIR-V capability for f16 shader IO types
when the device supports it.
[WebGPU Required Toggles - enabled]
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
<Discrete GPU> D3D11 backend - AMD Radeon RX 7900 XT
[WebGPU Status]
[Adapter Supported Features]
[Enabled Toggle Names]
lazy_clear_resource_on_first_use: (https://crbug.com/dawn/145 ):
Clears resource to zero on first usage. This initializes the resource so
that no dirty bits from recycled memory is present in the new resource.
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
apply_clear_big_integer_color_value_with_draw: (https://crbug.com/dawn/537 ):
Apply the clear value of the color attachment with a draw call when load
op is 'clear'. This toggle is enabled by default on D3D12 backends when we
set large integer values (> 2^24 or < -2^24 for signed integer formats) as
the clear value of a color attachment with 32-bit integer or unsigned
integer formats because D3D12 APIs only support using float numbers as
clear values, while a float number cannot always precisely represent an
integer that is greater than 2^24 or smaller than -2^24). This toggle is
also enabled on Intel GPUs on Metal backend due to a driver issue on Intel
Metal driver.
use_blit_for_buffer_to_stencil_texture_copy: (https://crbug.com/dawn/1389 ):
Use a blit instead of a copy command to copy buffer data to the stencil
aspect of a texture. Works around an issue where stencil writes by copy
commands are not visible to a render or compute pass.
use_blit_for_t2b: (https://crbug.com/dawn/348654098 ):
Use a compute based blit instead of a copy command to copy texture with
supported format to a buffer.
[WebGPU Required Toggles - enabled]
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
<CPU> Vulkan backend - SwiftShader Device (Subzero)
[WebGPU Status]
[Adapter Supported Features]
[Enabled Toggle Names]
lazy_clear_resource_on_first_use: (https://crbug.com/dawn/145 ):
Clears resource to zero on first usage. This initializes the resource so
that no dirty bits from recycled memory is present in the new resource.
use_temporary_buffer_in_texture_to_texture_copy: (https://crbug.com/dawn/42 ):
Split texture-to-texture copy into two copies: copy from source texture
into a temporary buffer, and copy from the temporary buffer into the
destination texture when copying between compressed textures that don't
have block-aligned sizes. This workaround is enabled by default on all
Vulkan drivers to solve an issue in the Vulkan SPEC about the
texture-to-texture copies with compressed formats. See #1005
(https://github.com/KhronosGroup/Vulkan-Docs/issues/1005 ) for more
details.
vulkan_use_d32s8: (https://crbug.com/dawn/286 ):
Vulkan mandates support of either D32_FLOAT_S8 or D24_UNORM_S8. When
available the backend will use D32S8 (toggle to on) but setting the toggle
to off will make it use the D24S8 format when possible.
vulkan_use_s8: (https://crbug.com/dawn/666 ):
Vulkan has a pure stencil8 format but it is not universally available.
When this toggle is on, the backend will use S8 for the stencil8 format,
otherwise it will fallback to D32S8 or D24S8.
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
vulkan_use_demote_to_helper_invocation_extension: (https://crbug.com/42250787 ):
Sets the use of the vulkan demote to helper extension
use_placeholder_fragment_in_vertex_only_pipeline: (https://crbug.com/dawn/136 ):
Use a placeholder empty fragment shader in vertex only render pipeline.
This toggle must be enabled for OpenGL ES backend, the Vulkan Backend, and
serves as a workaround by default enabled on some Metal devices with Intel
GPU to ensure the depth result is correct.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
use_vulkan_zero_initialize_workgroup_memory_extension: (https://crbug.com/dawn/1302 ):
Initialize workgroup memory with OpConstantNull on Vulkan when the Vulkan
extension VK_KHR_zero_initialize_workgroup_memory is supported.
[WebGPU Required Toggles - enabled]
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
<CPU> D3D11 backend - Microsoft Basic Render Driver
[WebGPU Status]
[Adapter Supported Features]
[Enabled Toggle Names]
lazy_clear_resource_on_first_use: (https://crbug.com/dawn/145 ):
Clears resource to zero on first usage. This initializes the resource so
that no dirty bits from recycled memory is present in the new resource.
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
apply_clear_big_integer_color_value_with_draw: (https://crbug.com/dawn/537 ):
Apply the clear value of the color attachment with a draw call when load
op is 'clear'. This toggle is enabled by default on D3D12 backends when we
set large integer values (> 2^24 or < -2^24 for signed integer formats) as
the clear value of a color attachment with 32-bit integer or unsigned
integer formats because D3D12 APIs only support using float numbers as
clear values, while a float number cannot always precisely represent an
integer that is greater than 2^24 or smaller than -2^24). This toggle is
also enabled on Intel GPUs on Metal backend due to a driver issue on Intel
Metal driver.
use_blit_for_buffer_to_stencil_texture_copy: (https://crbug.com/dawn/1389 ):
Use a blit instead of a copy command to copy buffer data to the stencil
aspect of a texture. Works around an issue where stencil writes by copy
commands are not visible to a render or compute pass.
use_blit_for_t2b: (https://crbug.com/dawn/348654098 ):
Use a compute based blit instead of a copy command to copy texture with
supported format to a buffer.
[WebGPU Required Toggles - enabled]
disallow_spirv: (https://crbug.com/1214923 ):
Disallow usage of SPIR-V completely so that only WGSL is used for shader
modules. This is useful to prevent a Chromium renderer process from
successfully sending SPIR-V code to be compiled in the GPU process.
timestamp_quantization: (https://crbug.com/dawn/1800 ):
Enable timestamp queries quantization to reduce the precision of timers
that can be created with timestamp queries.
Compositor Information
Tile Update Mode: One-copy Partial Raster : Enabled
GpuMemoryBuffers Status
R_8 : Software only R_16 : Software only RG_88 : Software only RG_1616 : Software only BGR_565 : Software only RGBA_4444 : Software only RGBX_8888 : GPU_READ, SCANOUT RGBA_8888 : GPU_READ, SCANOUT BGRX_8888 : GPU_READ, SCANOUT BGRA_1010102 : Software only RGBA_1010102 : Software only BGRA_8888 : GPU_READ, SCANOUT RGBA_F16 : Software only YVU_420 : Software only YUV_420_BIPLANAR : Software only YUVA_420_TRIPLANAR: Software only P010 : Software only
Media Foundation Rendering Capabilities
PlayReady Hardware DRM disabled: true Direct Composition : true Dolby Atmos support : false AV1 installed : true AV1 activable : true AV1 version : AV1:1.3.4.0 HEVC installed : true HEVC activable : true HEVC version : HEVC:2.2.33.0 Display: : Scaled: [-1920,-150 1920x1080] Scale: 1.00 Actual: [-1920,-150 1920x1080] GPU Index : GPU0 HEVC - Dolby Vision support : false HEVC - HDR10 support : false HDCP 2.2 support : false HEVC - 4K support : true Display: : Scaled: [0,0 2560x1440] Scale: 1.00 Actual: [0,0 2560x1440] GPU Index : GPU0 HEVC - Dolby Vision support : false HEVC - HDR10 support : false HDCP 2.2 support : false HEVC - 4K support : true
Display(s) Information
Info : Display[4053669451] bounds=[-1920,-150 1920x1080], workarea=[-1920,-150 1920x1032], scale=1, rotation=0, panel_rotation=0 external detected Color space (all) : {r:[0.6311, 0.3271], g:[0.2882, 0.6328], b:[0.1462, 0.0506], w:[0.3127, 0.3290]}, transfer:SRGB, matrix:RGB, range:FULL} Buffer format (all) : BGRA_8888 Color volume : {r:[0.6311, 0.3271], g:[0.2882, 0.6328], b:[0.1462, 0.0506], w:[0.3127, 0.3290]} SDR white level in nits : 203 HDR relative maximum luminance: 1 Bits per color component : 8 Bits per pixel : 24 Refresh Rate in Hz : 144 Info : Display[80957078] bounds=[0,0 2560x1440], workarea=[0,0 2560x1392], scale=1, rotation=0, panel_rotation=0 external detected Color space (all) : {r:[0.6799, 0.3097], g:[0.2537, 0.6504], b:[0.1411, 0.0567], w:[0.3127, 0.3290]}, transfer:SRGB, matrix:RGB, range:FULL} Buffer format (all) : BGRA_8888 Color volume : {r:[0.6799, 0.3097], g:[0.2537, 0.6504], b:[0.1411, 0.0567], w:[0.3127, 0.3290]} SDR white level in nits : 203 HDR relative maximum luminance: 1 Bits per color component : 8 Bits per pixel : 24 Refresh Rate in Hz : 165
Video Acceleration Information
Decoding : Decode h264 baseline : 64x64 to 4096x4096 pixels Decode h264 main : 64x64 to 4096x4096 pixels Decode h264 high : 64x64 to 4096x4096 pixels Decode vp9 profile0 : 64x64 to 8192x4320 pixels Decode vp9 profile2 : 64x64 to 8192x4320 pixels Decode av1 profile main : 64x64 to 8192x4320 pixels Decode hevc main : 48x48 to 8192x8192 pixels Decode hevc main 10 : 48x48 to 8192x8192 pixels Decode hevc main still-picture: 48x48 to 8192x8192 pixels Encoding : Encode h264 baseline : 128x128 to 1920x1080 pixels, and/or 172.000 fps. Encode h264 baseline : 128x128 to 1080x1920 pixels, and/or 172.000 fps. Encode h264 main : 128x128 to 1920x1080 pixels, and/or 172.000 fps. Encode h264 main : 128x128 to 1080x1920 pixels, and/or 172.000 fps. Encode h264 high : 128x128 to 1920x1080 pixels, and/or 172.000 fps. Encode h264 high : 128x128 to 1080x1920 pixels, and/or 172.000 fps. Encode h264 baseline : 128x128 to 3840x2160 pixels, and/or 60.000 fps. Encode h264 baseline : 128x128 to 2160x3840 pixels, and/or 60.000 fps. Encode h264 main : 128x128 to 3840x2160 pixels, and/or 60.000 fps. Encode h264 main : 128x128 to 2160x3840 pixels, and/or 60.000 fps. Encode h264 high : 128x128 to 3840x2160 pixels, and/or 60.000 fps. Encode h264 high : 128x128 to 2160x3840 pixels, and/or 60.000 fps.
Vulkan Information
Device Performance Information
Total Physical Memory (Gb): 31 Total Disk Space (Gb) : 1862 Hardware Concurrency : 16 System Commit Limit (Gb) : 33 D3D11 Feature Level : 12_1 Has Discrete GPU : yes Software Rendering : No
Log Messages
[14044:15152:0326/121014.631:WARNING:viz_main_impl.cc(85)] : VizNullHypothesis is disabled (not a warning) [14044:22628:0326/121015.741:WARNING:angle_platform_impl.cc(54)] : HLSLCompiler.cpp:250 (rx::HLSLCompiler::compileToBinary): C:\fakepath(137,3-70): warning X3557: loop only executes for 1 iteration(s), forcing loop to unroll
[14044:22628:0326/121015.989:WARNING:angle_platform_impl.cc(54)] : HLSLCompiler.cpp:250 (rx::HLSLCompiler::compileToBinary): C:\fakepath(137,3-70): warning X3557: loop only executes for 1 iteration(s), forcing loop to unroll
[14044:12784:0326/121017.231:ERROR:mf_video_encoder_util.cc(573)] : Set output type failed, Paramètre incorrect. (0x80070057) GpuProcessHost: The info collection GPU process exited normally. Everything is okay.
Additional Data
Category: Audio / Video
Chrome Channel: Not sure
Regression: Yes