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
|
/* -*- 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 "SourceSurfaceRawData.h"
#include "DataSurfaceHelpers.h"
#include "Logging.h"
#include "nsIMemoryReporter.h"
namespace mozilla {
namespace gfx {
class SourceSurfaceAlignedRawDataReporter final : public nsIMemoryReporter {
~SourceSurfaceAlignedRawDataReporter() = default;
public:
NS_DECL_ISUPPORTS
NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
nsISupports* aData, bool aAnonymize) override {
MOZ_COLLECT_REPORT("explicit/gfx/source-surface-aligned-raw-data",
KIND_HEAP, UNITS_BYTES, sTotalDataBytes,
"Total memory used by source surface aligned raw data.");
return NS_OK;
}
private:
friend class SourceSurfaceAlignedRawData;
static Atomic<size_t> sTotalDataBytes;
};
NS_IMPL_ISUPPORTS(SourceSurfaceAlignedRawDataReporter, nsIMemoryReporter)
/* static */
Atomic<size_t> SourceSurfaceAlignedRawDataReporter::sTotalDataBytes(0);
/* static */
void SourceSurfaceAlignedRawData::RegisterMemoryReporter() {
RegisterStrongMemoryReporter(new SourceSurfaceAlignedRawDataReporter);
}
void SourceSurfaceRawData::InitWrappingData(
uint8_t* aData, const IntSize& aSize, int32_t aStride,
SurfaceFormat aFormat, Factory::SourceSurfaceDeallocator aDeallocator,
void* aClosure) {
mRawData = aData;
mSize = aSize;
mStride = aStride;
mFormat = aFormat;
mDeallocator = aDeallocator;
mClosure = aClosure;
}
void SourceSurfaceRawData::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
SizeOfInfo& aInfo) const {
aInfo.AddType(SurfaceType::DATA);
if (mDeallocator) {
aInfo.mUnknownBytes = mStride * mSize.height;
}
}
SourceSurfaceAlignedRawData::SourceSurfaceAlignedRawData()
: mStride(0), mFormat(SurfaceFormat::UNKNOWN) {}
SourceSurfaceAlignedRawData::~SourceSurfaceAlignedRawData() {
size_t bufLen = BufferSizeFromStrideAndHeight(mStride, mSize.height);
SourceSurfaceAlignedRawDataReporter::sTotalDataBytes -= bufLen;
}
bool SourceSurfaceAlignedRawData::Init(const IntSize& aSize,
SurfaceFormat aFormat, bool aClearMem,
uint8_t aClearValue, int32_t aStride) {
mFormat = aFormat;
mStride = aStride ? aStride
: GetAlignedStride<16>(aSize.width, BytesPerPixel(aFormat));
size_t bufLen = BufferSizeFromStrideAndHeight(mStride, aSize.height);
if (bufLen > 0) {
bool zeroMem = aClearMem && !aClearValue;
static_assert(sizeof(decltype(mArray[0])) == 1,
"mArray.Realloc() takes an object count, so its objects must "
"be 1-byte sized if we use bufLen");
// AlignedArray uses cmalloc to zero mem for a fast path.
mArray.Realloc(/* actually an object count */ bufLen, zeroMem);
mSize = aSize;
SourceSurfaceAlignedRawDataReporter::sTotalDataBytes += bufLen;
if (mArray && aClearMem && aClearValue) {
memset(mArray, aClearValue, mStride * aSize.height);
}
} else {
mArray.Dealloc();
mSize.SizeTo(0, 0);
}
return mArray != nullptr;
}
void SourceSurfaceAlignedRawData::SizeOfExcludingThis(
MallocSizeOf aMallocSizeOf, SizeOfInfo& aInfo) const {
aInfo.AddType(SurfaceType::DATA_ALIGNED);
// This memory is accounted for in aggregate by sTotalDataBytes. We return
// zero here to prevent double-counting.
aInfo.mHeapBytes = 0;
}
} // namespace gfx
} // namespace mozilla
|
