The Tor Browser / file comparison

comparison: gfx/layers/YCbCrImageDataSerializer.h

gfx/layers/YCbCrImageDataSerializer.h

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:41ffb1286270
1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #ifndef MOZILLA_LAYERS_BLOBYCBCRSURFACE_H
7 #define MOZILLA_LAYERS_BLOBYCBCRSURFACE_H
8
9 #include <stddef.h> // for size_t
10 #include <stdint.h> // for uint8_t, uint32_t
11 #include "ImageTypes.h" // for StereoMode
12 #include "mozilla/Attributes.h" // for MOZ_STACK_CLASS
13 #include "mozilla/RefPtr.h" // for TemporaryRef
14 #include "mozilla/gfx/Point.h" // for IntSize
15
16 namespace mozilla {
17 namespace gfx {
18 class DataSourceSurface;
19 }
20
21 namespace layers {
22
23 class Image;
24
25 /**
26 * Convenience class to share code between YCbCrImageDataSerializer
27 * and YCbCrImageDataDeserializer.
28 * Do not use it.
29 */
30 class YCbCrImageDataDeserializerBase
31 {
32 public:
33 bool IsValid() const { return mIsValid; }
34
35 /**
36 * Returns the Y channel data pointer.
37 */
38 uint8_t* GetYData();
39 /**
40 * Returns the Cb channel data pointer.
41 */
42 uint8_t* GetCbData();
43 /**
44 * Returns the Cr channel data pointer.
45 */
46 uint8_t* GetCrData();
47
48 /**
49 * Returns the Y channel stride.
50 */
51 uint32_t GetYStride();
52 /**
53 * Returns the stride of the Cb and Cr channels.
54 */
55 uint32_t GetCbCrStride();
56
57 /**
58 * Returns the dimensions of the Y Channel.
59 */
60 gfx::IntSize GetYSize();
61
62 /**
63 * Returns the dimensions of the Cb and Cr Channel.
64 */
65 gfx::IntSize GetCbCrSize();
66
67 /**
68 * Stereo mode for the image.
69 */
70 StereoMode GetStereoMode();
71
72 /**
73 * Return a pointer to the begining of the data buffer.
74 */
75 uint8_t* GetData();
76
77 /**
78 * This function is meant as a helper to know how much shared memory we need
79 * to allocate in a shmem in order to place a shared YCbCr image blob of
80 * given dimensions.
81 */
82 static size_t ComputeMinBufferSize(const gfx::IntSize& aYSize,
83 uint32_t aYStride,
84 const gfx::IntSize& aCbCrSize,
85 uint32_t aCbCrStride);
86 static size_t ComputeMinBufferSize(const gfx::IntSize& aYSize,
87 const gfx::IntSize& aCbCrSize);
88 static size_t ComputeMinBufferSize(uint32_t aSize);
89
90 protected:
91 YCbCrImageDataDeserializerBase(uint8_t* aData, size_t aDataSize)
92 : mData (aData)
93 , mDataSize(aDataSize)
94 , mIsValid(false)
95 {}
96
97 void Validate();
98
99 uint8_t* mData;
100 size_t mDataSize;
101 bool mIsValid;
102 };
103
104 /**
105 * A view on a YCbCr image stored with its metadata in a blob of memory.
106 * It is only meant as a convenience to access the image data, and does not own
107 * the data. The instance can live on the stack and used as follows:
108 *
109 * const YCbCrImage& yuv = sharedImage.get_YCbCrImage();
110 * YCbCrImageDataDeserializer deserializer(yuv.data().get<uint8_t>());
111 * if (!deserializer.IsValid()) {
112 * // handle error
113 * }
114 * size = deserializer.GetYSize(); // work with the data, etc...
115 */
116 class MOZ_STACK_CLASS YCbCrImageDataSerializer : public YCbCrImageDataDeserializerBase
117 {
118 public:
119 YCbCrImageDataSerializer(uint8_t* aData, size_t aDataSize)
120 : YCbCrImageDataDeserializerBase(aData, aDataSize)
121 {
122 // a serializer needs to be usable before correct buffer info has been written to it
123 mIsValid = !!mData;
124 }
125
126 /**
127 * Write the image informations in the buffer for given dimensions.
128 * The provided pointer should point to the beginning of the (chunk of)
129 * buffer on which we want to store the image.
130 */
131 void InitializeBufferInfo(uint32_t aYOffset,
132 uint32_t aCbOffset,
133 uint32_t aCrOffset,
134 uint32_t aYStride,
135 uint32_t aCbCrStride,
136 const gfx::IntSize& aYSize,
137 const gfx::IntSize& aCbCrSize,
138 StereoMode aStereoMode);
139 void InitializeBufferInfo(uint32_t aYStride,
140 uint32_t aCbCrStride,
141 const gfx::IntSize& aYSize,
142 const gfx::IntSize& aCbCrSize,
143 StereoMode aStereoMode);
144 void InitializeBufferInfo(const gfx::IntSize& aYSize,
145 const gfx::IntSize& aCbCrSize,
146 StereoMode aStereoMode);
147 bool CopyData(const uint8_t* aYData,
148 const uint8_t* aCbData, const uint8_t* aCrData,
149 gfx::IntSize aYSize, uint32_t aYStride,
150 gfx::IntSize aCbCrSize, uint32_t aCbCrStride,
151 uint32_t aYSkip, uint32_t aCbCrSkip);
152 };
153
154 /**
155 * A view on a YCbCr image stored with its metadata in a blob of memory.
156 * It is only meant as a convenience to access the image data, and does not own
157 * the data. The instance can live on the stack and used as follows:
158 *
159 * const YCbCrImage& yuv = sharedImage.get_YCbCrImage();
160 * YCbCrImageDataDeserializer deserializer(yuv.data().get<uint8_t>());
161 * if (!deserializer.IsValid()) {
162 * // handle error
163 * }
164 * size = deserializer.GetYSize(); // work with the data, etc...
165 */
166 class MOZ_STACK_CLASS YCbCrImageDataDeserializer : public YCbCrImageDataDeserializerBase
167 {
168 public:
169 YCbCrImageDataDeserializer(uint8_t* aData, size_t aDataSize)
170 : YCbCrImageDataDeserializerBase(aData, aDataSize)
171 {
172 Validate();
173 }
174
175 /**
176 * Convert the YCbCr data into RGB and return a DataSourceSurface.
177 * This is a costly operation, so use it only when YCbCr compositing is
178 * not supported.
179 */
180 TemporaryRef<gfx::DataSourceSurface> ToDataSourceSurface();
181 };
182
183 } // namespace
184 } // namespace
185
186 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial