blob: 4d2ed90603f53bd9a0710a21018780b48d81b474 (
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
|
/* -*- 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/. */
#include "KnowsCompositor.h"
#include "mozilla/layers/ImageDataSerializer.h"
#include "mozilla/layers/ImageBridgeChild.h"
#include "mozilla/ipc/ProtocolUtils.h"
namespace mozilla {
namespace layers {
void KnowsCompositor::IdentifyTextureHost(
const TextureFactoryIdentifier& aIdentifier) {
auto lock = mData.Lock();
lock.ref().mTextureFactoryIdentifier = aIdentifier;
lock.ref().mSyncObject =
SyncObjectClient::CreateSyncObjectClientForContentDevice(
aIdentifier.mSyncHandle);
}
KnowsCompositor::KnowsCompositor()
: mData("KnowsCompositorMutex"), mSerial(++sSerialCounter) {}
KnowsCompositor::~KnowsCompositor() = default;
KnowsCompositorMediaProxy::KnowsCompositorMediaProxy(
const TextureFactoryIdentifier& aIdentifier) {
auto lock = mData.Lock();
lock.ref().mTextureFactoryIdentifier = aIdentifier;
// overwrite mSerial's value set by the parent class because we use the same
// serial as the KnowsCompositor we are proxying.
mThreadSafeAllocator = ImageBridgeChild::GetSingleton();
lock.ref().mSyncObject = mThreadSafeAllocator->GetSyncObject();
}
KnowsCompositorMediaProxy::~KnowsCompositorMediaProxy() = default;
TextureForwarder* KnowsCompositorMediaProxy::GetTextureForwarder() {
return mThreadSafeAllocator->GetTextureForwarder();
}
LayersIPCActor* KnowsCompositorMediaProxy::GetLayersIPCActor() {
return mThreadSafeAllocator->GetLayersIPCActor();
}
ActiveResourceTracker* KnowsCompositorMediaProxy::GetActiveResourceTracker() {
return mThreadSafeAllocator->GetActiveResourceTracker();
}
void KnowsCompositorMediaProxy::SyncWithCompositor() {
mThreadSafeAllocator->SyncWithCompositor();
}
bool IsSurfaceDescriptorValid(const SurfaceDescriptor& aSurface) {
return aSurface.type() != SurfaceDescriptor::T__None &&
aSurface.type() != SurfaceDescriptor::Tnull_t;
}
uint8_t* GetAddressFromDescriptor(const SurfaceDescriptor& aDescriptor) {
MOZ_ASSERT(IsSurfaceDescriptorValid(aDescriptor));
MOZ_RELEASE_ASSERT(
aDescriptor.type() == SurfaceDescriptor::TSurfaceDescriptorBuffer,
"GFX: surface descriptor is not the right type.");
auto memOrShmem = aDescriptor.get_SurfaceDescriptorBuffer().data();
if (memOrShmem.type() == MemoryOrShmem::TShmem) {
return memOrShmem.get_Shmem().get<uint8_t>();
} else {
return reinterpret_cast<uint8_t*>(memOrShmem.get_uintptr_t());
}
}
already_AddRefed<gfx::DataSourceSurface> GetSurfaceForDescriptor(
const SurfaceDescriptor& aDescriptor) {
if (aDescriptor.type() != SurfaceDescriptor::TSurfaceDescriptorBuffer) {
return nullptr;
}
uint8_t* data = GetAddressFromDescriptor(aDescriptor);
auto rgb =
aDescriptor.get_SurfaceDescriptorBuffer().desc().get_RGBDescriptor();
uint32_t stride = ImageDataSerializer::GetRGBStride(rgb);
return gfx::Factory::CreateWrappingDataSourceSurface(data, stride, rgb.size(),
rgb.format());
}
void DestroySurfaceDescriptor(ipc::IShmemAllocator* aAllocator,
SurfaceDescriptor* aSurface) {
MOZ_ASSERT(aSurface);
SurfaceDescriptorBuffer& desc = aSurface->get_SurfaceDescriptorBuffer();
switch (desc.data().type()) {
case MemoryOrShmem::TShmem: {
aAllocator->DeallocShmem(desc.data().get_Shmem());
break;
}
case MemoryOrShmem::Tuintptr_t: {
uint8_t* ptr = (uint8_t*)desc.data().get_uintptr_t();
GfxMemoryImageReporter::WillFree(ptr);
delete[] ptr;
break;
}
default:
MOZ_CRASH("surface type not implemented!");
}
*aSurface = SurfaceDescriptor();
}
} // namespace layers
} // namespace mozilla
|
