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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#ifndef mozilla_layers_SurfacePoolWayland_h
#define mozilla_layers_SurfacePoolWayland_h
#include <wayland-egl.h>
#include "GLContext.h"
#include "MozFramebuffer.h"
#include "mozilla/layers/SurfacePool.h"
#include "mozilla/widget/WaylandBuffer.h"
#include <unordered_map>
namespace mozilla::layers {
class SurfacePoolWayland final : public SurfacePool {
public:
// Get a handle for a new window. aGL can be nullptr.
RefPtr<SurfacePoolHandle> GetHandleForGL(gl::GLContext* aGL) override;
// Destroy all GL resources associated with aGL managed by this pool.
void DestroyGLResourcesForContext(gl::GLContext* aGL) override;
private:
friend class SurfacePoolHandleWayland;
friend RefPtr<SurfacePool> SurfacePool::Create(size_t aPoolSizeLimit);
explicit SurfacePoolWayland(size_t aPoolSizeLimit);
RefPtr<widget::WaylandBuffer> ObtainBufferFromPool(
const widget::WaylandSurfaceLock& aWaylandSurfaceLock,
const gfx::IntSize& aSize, gl::GLContext* aGL,
RefPtr<widget::DRMFormat> aFormat);
void ReturnBufferToPool(const widget::WaylandSurfaceLock& aWaylandSurfaceLock,
const RefPtr<widget::WaylandBuffer>& aBuffer);
void EnforcePoolSizeLimit();
void CollectPendingSurfaces();
Maybe<GLuint> GetFramebufferForBuffer(
const RefPtr<widget::WaylandBuffer>& aBuffer, gl::GLContext* aGL,
bool aNeedsDepthBuffer);
struct GLResourcesForBuffer final {
RefPtr<gl::GLContext> mGL; // non-null
UniquePtr<gl::MozFramebuffer> mFramebuffer; // non-null
};
// Keep mWaylandSurface / mWaylandBuffer in pair as we don't share
// mWaylandBuffer among WaylandSurfaces.
struct SurfacePoolEntry final {
const gfx::IntSize mSize;
const RefPtr<widget::WaylandSurface> mWaylandSurface; // non-null
const RefPtr<widget::WaylandBuffer> mWaylandBuffer; // non-null
Maybe<GLResourcesForBuffer> mGLResources;
};
bool CanRecycleSurfaceForRequest(
const MutexAutoLock& aProofOfLock, const SurfacePoolEntry& aEntry,
const widget::WaylandSurfaceLock& aWaylandSurfaceLock,
const gfx::IntSize& aSize, gl::GLContext* aGL);
RefPtr<gl::DepthAndStencilBuffer> GetDepthBufferForSharing(
const MutexAutoLock& aProofOfLock, gl::GLContext* aGL,
const gfx::IntSize& aSize);
UniquePtr<gl::MozFramebuffer> CreateFramebufferForTexture(
const MutexAutoLock& aProofOfLock, gl::GLContext* aGL,
const gfx::IntSize& aSize, GLuint aTexture, bool aNeedsDepthBuffer);
Mutex mMutex MOZ_UNANNOTATED;
// Stores the entries for surfaces that are in use by NativeLayerWayland, i.e.
// an entry is inside mInUseEntries between calls to ObtainSurfaceFromPool()
// and ReturnSurfaceToPool().
std::unordered_map<widget::WaylandBuffer*, SurfacePoolEntry> mInUseEntries;
// Stores entries which are no longer in use by NativeLayerWayland but are
// still in use by the window server, i.e. for which
// WaylandBuffer::IsAttached() still returns true.
// These entries are checked once per frame inside
// CollectPendingSurfaces(), and returned to mAvailableEntries once the
// window server is done.
nsTArray<SurfacePoolEntry> mPendingEntries;
// Stores entries which are available for recycling. These entries are not
// in use by a NativeLayerWayland or by the window server.
nsTArray<SurfacePoolEntry> mAvailableEntries;
size_t mPoolSizeLimit;
template <typename F>
void ForEachEntry(F aFn);
struct DepthBufferEntry final {
RefPtr<gl::GLContext> mGL;
gfx::IntSize mSize;
WeakPtr<gl::DepthAndStencilBuffer> mBuffer;
};
nsTArray<DepthBufferEntry> mDepthBuffers;
};
// A surface pool handle that is stored on NativeLayerWayland and keeps the
// SurfacePool alive.
class SurfacePoolHandleWayland final : public SurfacePoolHandle {
public:
SurfacePoolHandleWayland* AsSurfacePoolHandleWayland() override {
return this;
}
RefPtr<widget::WaylandBuffer> ObtainBufferFromPool(
const widget::WaylandSurfaceLock& aWaylandSurfaceLock,
const gfx::IntSize& aSize, RefPtr<widget::DRMFormat> aFormat);
void ReturnBufferToPool(const widget::WaylandSurfaceLock& aWaylandSurfaceLock,
const RefPtr<widget::WaylandBuffer>& aBuffer);
Maybe<GLuint> GetFramebufferForBuffer(
const RefPtr<widget::WaylandBuffer>& aBuffer, bool aNeedsDepthBuffer);
const auto& gl() { return mGL; }
RefPtr<SurfacePool> Pool() override { return mPool; }
void OnBeginFrame() override;
void OnEndFrame() override;
private:
friend class SurfacePoolWayland;
SurfacePoolHandleWayland(RefPtr<SurfacePoolWayland> aPool,
gl::GLContext* aGL);
const RefPtr<SurfacePoolWayland> mPool;
const RefPtr<gl::GLContext> mGL;
};
} // namespace mozilla::layers
#endif
|
