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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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_ANDROID_HARDWARE_BUFFER
#define MOZILLA_LAYERS_ANDROID_HARDWARE_BUFFER
#include <android/hardware_buffer.h>
#include <atomic>
#include <unordered_map>
#include "mozilla/layers/TextureClient.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/Monitor.h"
#include "mozilla/RefPtr.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/ThreadSafeWeakPtr.h"
#include "mozilla/UniquePtrExtensions.h"
namespace mozilla {
namespace layers {
/**
* AndroidHardwareBuffer is a wrapper of AHardwareBuffer. AHardwareBuffer wraps
* android GraphicBuffer. It is supported since Android O(APIVersion 26).
* The manager is mainly used for release fences delivery from
* host side to client side.
*/
class AndroidHardwareBuffer
: public SupportsThreadSafeWeakPtr<AndroidHardwareBuffer> {
public:
MOZ_DECLARE_REFCOUNTED_TYPENAME(AndroidHardwareBuffer)
static already_AddRefed<AndroidHardwareBuffer> Create(
gfx::IntSize aSize, gfx::SurfaceFormat aFormat);
virtual ~AndroidHardwareBuffer();
// Serializes the AndroidHardwareBuffer to a file descriptor that can, if
// desired, be shared to another process, and deserialized with
// DeserializeFromFileDescriptor(). Note that while an AndroidHardwareBuffer
// deserialized from the returned file descriptor will refer to the same
// underlying system buffer, it will be a different instance of this class.
// Fences will therefore not be propagated between the instances.
UniqueFileHandle SerializeToFileDescriptor() const;
// Creates an AndroidHardwareBuffer from a file descriptor that was previously
// obtained from ToFileDescriptor(). The file descriptor may have been shared
// from another process. Note that while the returned AndroidHardwareBuffer
// refers to the same underlying system buffer as the one that was originally
// serialized, it will be a different instance of this class. Fences will
// therefore not be propagated between the instances.
static already_AddRefed<AndroidHardwareBuffer> DeserializeFromFileDescriptor(
UniqueFileHandle&& aFd);
int Lock(uint64_t aUsage, const ARect* aRect, void** aOutVirtualAddress);
int Unlock();
AHardwareBuffer* GetNativeBuffer() const { return mNativeBuffer; }
void SetAcquireFence(UniqueFileHandle&& aFenceFd);
void SetReleaseFence(UniqueFileHandle&& aFenceFd);
UniqueFileHandle GetAndResetReleaseFence();
UniqueFileHandle GetAndResetAcquireFence();
UniqueFileHandle GetAcquireFence() const;
const gfx::IntSize mSize;
const uint32_t mStride;
const gfx::SurfaceFormat mFormat;
const uint64_t mId;
protected:
AndroidHardwareBuffer(AHardwareBuffer* aNativeBuffer, gfx::IntSize aSize,
uint32_t aStride, gfx::SurfaceFormat aFormat);
AHardwareBuffer* mNativeBuffer;
// When true, AndroidHardwareBuffer is registered to
// AndroidHardwareBufferManager.
bool mIsRegistered;
mutable Monitor mMonitor{"AndroidHardwareBuffer::mMonitor"};
// FileDescriptor of release fence.
// Release fence is a fence that is used for waiting until usage/composite of
// AHardwareBuffer is ended. The fence is delivered via ImageBridge.
UniqueFileHandle mReleaseFenceFd MOZ_GUARDED_BY(mMonitor);
// FileDescriptor of acquire fence.
// Acquire fence is a fence that is used for waiting until rendering to
// its AHardwareBuffer is completed.
UniqueFileHandle mAcquireFenceFd MOZ_GUARDED_BY(mMonitor);
static uint64_t GetNextId();
friend class AndroidHardwareBufferManager;
};
/**
* AndroidHardwareBufferManager manages AndroidHardwareBuffers that is
* allocated by client side.
* Host side only uses mMonitor for thread safety of AndroidHardwareBuffer.
*/
class AndroidHardwareBufferManager {
public:
static void Init();
static void Shutdown();
static AndroidHardwareBufferManager* Get() { return sInstance; }
void Register(RefPtr<AndroidHardwareBuffer> aBuffer);
void Unregister(AndroidHardwareBuffer* aBuffer);
already_AddRefed<AndroidHardwareBuffer> GetBuffer(uint64_t aBufferId) const;
private:
AndroidHardwareBufferManager() = default;
mutable Monitor mMonitor{"AndroidHardwareBufferManager::mMonitor"};
std::unordered_map<uint64_t, ThreadSafeWeakPtr<AndroidHardwareBuffer>>
mBuffers MOZ_GUARDED_BY(mMonitor);
static StaticAutoPtr<AndroidHardwareBufferManager> sInstance;
};
} // namespace layers
} // namespace mozilla
#endif
|
