blob: 7101c53771cb80f81f5ddec49ee1e1a95d8152b4 (
plain)
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
137
138
139
|
/* -*- Mode: C++; tab-width: 4; 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_WIDGET_GTK_WAYLAND_BUFFER_H
#define _MOZILLA_WIDGET_GTK_WAYLAND_BUFFER_H
#include "DMABufSurface.h"
#include "GLContext.h"
#include "MozFramebuffer.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/Mutex.h"
#include "nsTArray.h"
#include "nsWaylandDisplay.h"
namespace mozilla::widget {
// Allocates and owns shared memory for Wayland drawing surface
class WaylandShmPool {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WaylandShmPool);
static RefPtr<WaylandShmPool> Create(
const RefPtr<nsWaylandDisplay>& aWaylandDisplay, int aSize);
wl_shm_pool* GetShmPool() { return mShmPool; };
void* GetImageData() { return mImageData; };
private:
explicit WaylandShmPool(int aSize);
~WaylandShmPool();
wl_shm_pool* mShmPool;
int mShmPoolFd;
int mAllocatedSize;
void* mImageData;
};
class WaylandBuffer {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WaylandBuffer);
void AttachAndCommit(wl_surface* aSurface);
virtual wl_buffer* GetWlBuffer() = 0;
virtual already_AddRefed<gfx::DrawTarget> Lock() { return nullptr; };
virtual void* GetImageData() { return nullptr; }
virtual GLuint GetTexture() { return 0; }
virtual void DestroyGLResources(){};
LayoutDeviceIntSize GetSize() { return mSize; };
bool IsMatchingSize(const LayoutDeviceIntSize& aSize) {
return aSize == mSize;
}
bool IsAttached() { return mAttached; }
static gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; }
static void BufferReleaseCallbackHandler(void* aData, wl_buffer* aBuffer);
void SetBufferReleaseFunc(void (*aBufferReleaseFunc)(void* aData,
wl_buffer* aBuffer)) {
mBufferReleaseFunc = aBufferReleaseFunc;
}
void SetBufferReleaseData(void* aBufferReleaseData) {
mBufferReleaseData = aBufferReleaseData;
}
protected:
explicit WaylandBuffer(const LayoutDeviceIntSize& aSize);
virtual ~WaylandBuffer() = default;
void BufferReleaseCallbackHandler(wl_buffer* aBuffer);
LayoutDeviceIntSize mSize;
bool mAttached = false;
void (*mBufferReleaseFunc)(void* aData, wl_buffer* aBuffer) = nullptr;
void* mBufferReleaseData = nullptr;
static gfx::SurfaceFormat mFormat;
};
// Holds actual graphics data for wl_surface
class WaylandBufferSHM final : public WaylandBuffer {
public:
static RefPtr<WaylandBufferSHM> Create(const LayoutDeviceIntSize& aSize);
wl_buffer* GetWlBuffer() override { return mWLBuffer; };
already_AddRefed<gfx::DrawTarget> Lock() override;
void* GetImageData() override { return mShmPool->GetImageData(); }
void Clear();
size_t GetBufferAge() { return mBufferAge; };
RefPtr<WaylandShmPool> GetShmPool() { return mShmPool; }
void IncrementBufferAge() { mBufferAge++; };
void ResetBufferAge() { mBufferAge = 0; };
#ifdef MOZ_LOGGING
void DumpToFile(const char* aHint);
#endif
private:
explicit WaylandBufferSHM(const LayoutDeviceIntSize& aSize);
~WaylandBufferSHM() override;
// WaylandShmPoolMB provides actual shared memory we draw into
RefPtr<WaylandShmPool> mShmPool;
// wl_buffer is a wayland object that encapsulates the shared memory
// and passes it to wayland compositor by wl_surface object.
wl_buffer* mWLBuffer = nullptr;
size_t mBufferAge = 0;
#ifdef MOZ_LOGGING
static int mDumpSerial;
static char* mDumpDir;
#endif
};
class WaylandBufferDMABUF final : public WaylandBuffer {
public:
static RefPtr<WaylandBufferDMABUF> Create(const LayoutDeviceIntSize& aSize,
gl::GLContext* aGL);
wl_buffer* GetWlBuffer() override { return mDMABufSurface->GetWlBuffer(); };
GLuint GetTexture() override { return mDMABufSurface->GetTexture(); };
void DestroyGLResources() override { mDMABufSurface->ReleaseTextures(); };
private:
explicit WaylandBufferDMABUF(const LayoutDeviceIntSize& aSize);
~WaylandBufferDMABUF() = default;
RefPtr<DMABufSurfaceRGBA> mDMABufSurface;
};
} // namespace mozilla::widget
#endif // _MOZILLA_WIDGET_GTK_WAYLAND_BUFFER_H
|
