1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_GL_DC_LAYER_OVERLAY_IMAGE_H_
#define UI_GL_DC_LAYER_OVERLAY_IMAGE_H_
#include <wrl/client.h>
#include "base/containers/span.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/raw_span.h"
#include "ui/gl/dcomp_surface_proxy.h"
#include "ui/gl/gl_export.h"
class ID3D11Texture2D;
class IDCompositionSurface;
class IDXGISwapChain1;
class IUnknown;
namespace gl {
enum class DCLayerOverlayType {
// Hardware decoder NV12 or P010 video texture - might be a texture array.
kD3D11Texture,
// Software decoder NV12 or P010 video Y and UV plane pixmaps.
kShMemPixmap,
// Either an IDCompositionSurface or an IDXGISwapChain1
kDCompVisualContent,
// gl::DCOMPSurfaceProxy used for MediaFoundation video renderer.
kDCompSurfaceProxy,
};
// Holds DComp content needed to update the DComp layer tree
class GL_EXPORT DCLayerOverlayImage {
public:
DCLayerOverlayImage(
const gfx::Size& size,
Microsoft::WRL::ComPtr<ID3D11Texture2D> d3d11_video_texture,
size_t array_slice = 0u);
DCLayerOverlayImage(const gfx::Size& size,
base::span<const uint8_t> shm_video_pixmap,
size_t stride);
DCLayerOverlayImage(const gfx::Size& size,
Microsoft::WRL::ComPtr<IUnknown> dcomp_visual_content,
uint64_t dcomp_surface_serial = 0u);
DCLayerOverlayImage(const gfx::Size& size,
scoped_refptr<gl::DCOMPSurfaceProxy> dcomp_surface_proxy);
DCLayerOverlayImage(DCLayerOverlayImage&&);
DCLayerOverlayImage& operator=(DCLayerOverlayImage&&);
~DCLayerOverlayImage();
DCLayerOverlayImage CloneForTesting() const { return *this; }
DCLayerOverlayType type() const { return type_; }
const gfx::Size& size() const { return size_; }
ID3D11Texture2D* d3d11_video_texture() const {
return d3d11_video_texture_.Get();
}
size_t texture_array_slice() const { return texture_array_slice_; }
base::span<const uint8_t> shm_video_pixmap() const {
return shm_video_pixmap_;
}
size_t pixmap_stride() const { return pixmap_stride_; }
IUnknown* dcomp_visual_content() const { return dcomp_visual_content_.Get(); }
uint64_t dcomp_surface_serial() const { return dcomp_surface_serial_; }
gl::DCOMPSurfaceProxy* dcomp_surface_proxy() const {
return dcomp_surface_proxy_.get();
}
bool operator==(const DCLayerOverlayImage& other) const {
auto data = shm_video_pixmap_.data();
auto other_data = other.shm_video_pixmap_.data();
return std::tie(type_, size_, d3d11_video_texture_, texture_array_slice_,
data, pixmap_stride_, dcomp_visual_content_,
dcomp_surface_serial_, dcomp_surface_proxy_) ==
std::tie(other.type_, other.size_, other.d3d11_video_texture_,
other.texture_array_slice_, other_data,
other.pixmap_stride_, other.dcomp_visual_content_,
other.dcomp_surface_serial_, other.dcomp_surface_proxy_);
}
private:
// Private copy constructors used for testing purposes for reusing overlay
// images.
DCLayerOverlayImage(const DCLayerOverlayImage& other);
DCLayerOverlayImage& operator=(const DCLayerOverlayImage& other);
// Type of overlay image.
DCLayerOverlayType type_;
// Size of overlay image.
gfx::Size size_;
// Hardware decoder NV12 or P010 video texture - can be a texture array.
Microsoft::WRL::ComPtr<ID3D11Texture2D> d3d11_video_texture_;
// Array slice/index if |d3d11_video_texture_| is a texture array.
size_t texture_array_slice_ = 0;
// Software decoder NV12 or P010 frame pixmap.
base::raw_span<const uint8_t, DanglingUntriaged> shm_video_pixmap_;
// Software video pixmap stride. Y and UV planes have the same stride in NV12.
size_t pixmap_stride_ = 0;
// Either an IDCompositionSurface or an IDXGISwapChain1
Microsoft::WRL::ComPtr<IUnknown> dcomp_visual_content_;
// This is a number that increments once for every EndDraw on a surface, and
// is used to determine when the contents have changed so Commit() needs to
// be called on the device.
uint64_t dcomp_surface_serial_ = 0;
// DCOMPSurfaceProxy used for MediaFoundation video renderer.
scoped_refptr<gl::DCOMPSurfaceProxy> dcomp_surface_proxy_;
};
} // namespace gl
#endif // UI_GL_DC_LAYER_OVERLAY_IMAGE_H_
|
