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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* 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 GFX_IMAGESURFACE_H
#define GFX_IMAGESURFACE_H
#include "mozilla/MemoryReporting.h"
#include "mozilla/RefPtr.h"
#include "gfxASurface.h"
#include "nsSize.h"
// ARGB -- raw buffer.. wont be changed.. good for storing data.
class gfxSubimageSurface;
namespace mozilla {
namespace gfx {
class DataSourceSurface;
class SourceSurface;
} // namespace gfx
} // namespace mozilla
/**
* A raw image buffer. The format can be set in the constructor. Its main
* purpose is for storing read-only images and using it as a source surface,
* but it can also be drawn to.
*/
class gfxImageSurface : public gfxASurface {
public:
/**
* Construct an image surface around an existing buffer of image data.
* @param aData A buffer containing the image data
* @param aSize The size of the buffer
* @param aStride The stride of the buffer
* @param format Format of the data
*
* @see gfxImageFormat
*/
gfxImageSurface(unsigned char *aData, const mozilla::gfx::IntSize& aSize,
long aStride, gfxImageFormat aFormat);
/**
* Construct an image surface.
* @param aSize The size of the buffer
* @param format Format of the data
*
* @see gfxImageFormat
*/
gfxImageSurface(const mozilla::gfx::IntSize& size, gfxImageFormat format, bool aClear = true);
/**
* Construct an image surface, with a specified stride and allowing the
* allocation of more memory than required for the storage of the surface
* itself. When aStride and aMinimalAllocation are <=0, this constructor
* is the equivalent of the preceeding one.
*
* @param format Format of the data
* @param aSize The size of the buffer
* @param aStride The stride of the buffer - if <=0, use ComputeStride()
* @param aMinimalAllocation Allocate at least this many bytes. If smaller
* than width * stride, or width*stride <=0, this value is ignored.
* @param aClear
*
* @see gfxImageFormat
*/
gfxImageSurface(const mozilla::gfx::IntSize& aSize, gfxImageFormat aFormat,
long aStride, int32_t aMinimalAllocation, bool aClear);
explicit gfxImageSurface(cairo_surface_t *csurf);
virtual ~gfxImageSurface();
// ImageSurface methods
gfxImageFormat Format() const { return mFormat; }
virtual const mozilla::gfx::IntSize GetSize() const override { return mSize; }
int32_t Width() const {
if (mSize.width < 0) {
return 0;
}
return mSize.width;
}
int32_t Height() const {
if (mSize.height < 0) {
return 0;
}
return mSize.height;
}
/**
* Distance in bytes between the start of a line and the start of the
* next line.
*/
int32_t Stride() const { return mStride; }
/**
* Returns a pointer for the image data. Users of this function can
* write to it, but must not attempt to free the buffer.
*/
unsigned char* Data() const { return mData; } // delete this data under us and die.
/**
* Returns the total size of the image data.
*/
int32_t GetDataSize() const {
if (mStride < 0 || mSize.height < 0) {
return 0;
}
return mStride*mSize.height;
}
/* Fast copy from another image surface; returns TRUE if successful, FALSE otherwise */
bool CopyFrom (gfxImageSurface *other);
/**
* Fast copy from a source surface; returns TRUE if successful, FALSE otherwise
* Assumes that the format of this surface is compatable with aSurface
*/
bool CopyFrom (mozilla::gfx::SourceSurface *aSurface);
/**
* Fast copy to a source surface; returns TRUE if successful, FALSE otherwise
* Assumes that the format of this surface is compatible with aSurface
*/
bool CopyTo (mozilla::gfx::SourceSurface *aSurface);
/**
* Copy to a Moz2D DataSourceSurface.
* Marked as virtual so that browsercomps can access this method.
*/
virtual already_AddRefed<mozilla::gfx::DataSourceSurface> CopyToB8G8R8A8DataSourceSurface();
/* return new Subimage with pointing to original image starting from aRect.pos
* and size of aRect.size. New subimage keeping current image reference
*/
already_AddRefed<gfxSubimageSurface> GetSubimage(const gfxRect& aRect);
virtual already_AddRefed<gfxImageSurface> GetAsImageSurface() override;
/** See gfxASurface.h. */
static long ComputeStride(const mozilla::gfx::IntSize&, gfxImageFormat);
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
override;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
override;
virtual bool SizeOfIsMeasured() const override;
protected:
gfxImageSurface();
void InitWithData(unsigned char *aData, const mozilla::gfx::IntSize& aSize,
long aStride, gfxImageFormat aFormat);
/**
* See the parameters to the matching constructor. This should only
* be called once, in the constructor, which has already set mSize
* and mFormat.
*/
void AllocateAndInit(long aStride, int32_t aMinimalAllocation, bool aClear);
void InitFromSurface(cairo_surface_t *csurf);
long ComputeStride() const {
if (mSize.height < 0 || mSize.width < 0) {
return 0;
}
return ComputeStride(mSize, mFormat);
}
void MakeInvalid();
mozilla::gfx::IntSize mSize;
bool mOwnsData;
unsigned char *mData;
gfxImageFormat mFormat;
long mStride;
};
class gfxSubimageSurface : public gfxImageSurface {
protected:
friend class gfxImageSurface;
gfxSubimageSurface(gfxImageSurface* aParent,
unsigned char* aData,
const mozilla::gfx::IntSize& aSize,
gfxImageFormat aFormat);
private:
RefPtr<gfxImageSurface> mParent;
};
#endif /* GFX_IMAGESURFACE_H */
|
