1 /*
2 * Copyright (c) 2017, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22
23 #include "cm_test.h"
24
25 class Surface2DTest: public CmTest
26 {
27 public:
28 static const uint32_t WIDTH = 64;
29 static const uint32_t HEIGHT = 64;
30
Surface2DTest()31 Surface2DTest(): m_surface(nullptr) {}
32
~Surface2DTest()33 ~Surface2DTest() {}
34
CreateDestroy(CM_SURFACE_FORMAT format,uint32_t width,uint32_t height)35 int32_t CreateDestroy(CM_SURFACE_FORMAT format,
36 uint32_t width,
37 uint32_t height)
38 {
39 int32_t result = m_mockDevice->CreateSurface2D(
40 width, height, format, m_surface);
41 if (result != CM_SUCCESS)
42 {
43 return result;
44 }
45 SurfaceIndex *surface_index = nullptr;
46 result = m_surface->GetIndex(surface_index);
47 EXPECT_EQ(CM_SUCCESS, result);
48 EXPECT_GT(surface_index->get_data(), static_cast<uint32_t>(0));
49 return m_mockDevice->DestroySurface(m_surface);
50 }//================================================
51
DestroyNull()52 int32_t DestroyNull() { return m_mockDevice->DestroySurface(m_surface); }
53 //=======================================================================
54
ReadWrite(uint32_t width,uint32_t height,uint8_t * to_surface,uint8_t * from_surface)55 int32_t ReadWrite(uint32_t width,
56 uint32_t height,
57 uint8_t *to_surface,
58 uint8_t *from_surface)
59 {
60 int32_t result = m_mockDevice->CreateSurface2D(
61 width, height, CM_SURFACE_FORMAT_A8R8G8B8, m_surface);
62 EXPECT_EQ(CM_SUCCESS, result);
63
64 result = m_surface->WriteSurface(to_surface, nullptr);
65 if (CM_SUCCESS != result)
66 {
67 m_mockDevice->DestroySurface(m_surface);
68 return result;
69 }
70
71 result = m_surface->ReadSurface(from_surface, nullptr);
72 if (CM_SUCCESS != result)
73 {
74 m_mockDevice->DestroySurface(m_surface);
75 return result;
76 }
77
78 result = memcmp(to_surface, from_surface, 4*width*height);
79 EXPECT_EQ(0, result);
80
81 return m_mockDevice->DestroySurface(m_surface);
82 }//================================================
83
ReadWriteWithStride()84 int32_t ReadWriteWithStride()
85 {
86 uint8_t to_surface[2*WIDTH*HEIGHT] = {1};
87 uint8_t from_surface[2*WIDTH*HEIGHT] = {2};
88 for (uint32_t i = 0; i < 2*WIDTH*HEIGHT; ++i)
89 {
90 to_surface[i] = i%255;
91 }
92 to_surface[WIDTH] = 41;
93 from_surface[WIDTH] = 42;
94
95 int32_t result = m_mockDevice->CreateSurface2D(
96 WIDTH, HEIGHT, CM_SURFACE_FORMAT_A8, m_surface);
97 EXPECT_EQ(CM_SUCCESS, result);
98
99 result = m_surface->WriteSurfaceStride(to_surface, nullptr, 2*WIDTH);
100 EXPECT_EQ(CM_SUCCESS, result);
101
102 result = m_surface->ReadSurfaceStride(from_surface, nullptr, 2*WIDTH);
103 EXPECT_EQ(CM_SUCCESS, result);
104
105 result = 0;
106 for (uint32_t row = 0; row < HEIGHT; ++row)
107 {
108 uint32_t offset = 2*WIDTH*row;
109 result += memcmp(to_surface + offset, from_surface + offset, WIDTH);
110 }
111 EXPECT_EQ(0, result);
112 EXPECT_EQ(from_surface[WIDTH], 42);
113
114 return m_mockDevice->DestroySurface(m_surface);
115 }//================================================
116
Initialize()117 int32_t Initialize()
118 {
119 int32_t result = m_mockDevice->CreateSurface2D(
120 WIDTH, HEIGHT, CM_SURFACE_FORMAT_A8R8G8B8, m_surface);
121 EXPECT_EQ(CM_SUCCESS, result);
122
123 result = m_surface->InitSurface(0x42424242, nullptr);
124 EXPECT_EQ(CM_SUCCESS, result);
125
126 uint8_t data[4*WIDTH*HEIGHT] = {0};
127 result = m_surface->ReadSurface(data, nullptr);
128 EXPECT_EQ(CM_SUCCESS, result);
129 EXPECT_EQ(0x42, data[0]);
130 EXPECT_EQ(0x42, data[4*WIDTH*HEIGHT - 1]);
131 return m_mockDevice->DestroySurface(m_surface);
132 }//================================================
133
GetAllocationSize(uint32_t width,uint32_t height,CM_SURFACE_FORMAT format)134 uint32_t GetAllocationSize(uint32_t width,
135 uint32_t height,
136 CM_SURFACE_FORMAT format)
137 {
138 uint32_t pitch = 0, physical_size = 0;
139 int32_t result = m_mockDevice->GetSurface2DInfo(width, height, format,
140 pitch, physical_size);
141 EXPECT_GE(pitch, width);
142 return physical_size;
143 }//======================
144
145 protected:
146 CMRT_UMD::CmSurface2D *m_surface;
147 };//=================================
148
TEST_F(Surface2DTest,MultipleSizes)149 TEST_F(Surface2DTest, MultipleSizes)
150 {
151 RunEach<int32_t>(CM_SUCCESS,
152 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
153 WIDTH, HEIGHT); });
154
155 RunEach<int32_t>(
156 CM_SUCCESS,
157 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
158 CM_MAX_2D_SURF_WIDTH, HEIGHT); });
159
160 RunEach<int32_t>(
161 CM_SUCCESS,
162 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
163 WIDTH, CM_MAX_2D_SURF_HEIGHT); });
164
165 RunEach<int32_t>(
166 CM_SUCCESS,
167 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
168 CM_MIN_SURF_WIDTH, HEIGHT); });
169
170 RunEach<int32_t>(
171 CM_SUCCESS,
172 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
173 WIDTH, CM_MIN_SURF_HEIGHT); });
174
175 RunEach<int32_t>(CM_SUCCESS,
176 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
177 2048, 2048); });
178
179 RunEach<int32_t>(CM_SUCCESS,
180 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
181 2048, 8192); });
182
183 RunEach<int32_t>(CM_SUCCESS,
184 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
185 8192, 2048); });
186
187 RunEach<int32_t>(CM_INVALID_WIDTH,
188 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
189 0, HEIGHT); });
190
191 RunEach<int32_t>(CM_INVALID_WIDTH,
192 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
193 CM_MAX_2D_SURF_WIDTH + 1,
194 HEIGHT); });
195
196 RunEach<int32_t>(CM_INVALID_HEIGHT,
197 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
198 WIDTH, 0); });
199
200 RunEach<int32_t>(
201 CM_INVALID_HEIGHT,
202 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
203 WIDTH,
204 CM_MAX_2D_SURF_HEIGHT + 1); });
205
206 RunEach<int32_t>(CM_SUCCESS,
207 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_A8R8G8B8,
208 CM_MAX_2D_SURF_WIDTH,
209 CM_MAX_2D_SURF_HEIGHT); });
210 return;
211 }//========
212
TEST_F(Surface2DTest,PlanarFormats)213 TEST_F(Surface2DTest, PlanarFormats)
214 {
215 RunEach<int32_t>(CM_SUCCESS,
216 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_YV12,
217 WIDTH, HEIGHT); });
218
219 RunEach<int32_t>(CM_SUCCESS,
220 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_444P,
221 WIDTH, HEIGHT); });
222
223 RunEach<int32_t>(CM_SUCCESS,
224 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_422H,
225 WIDTH, HEIGHT); });
226
227 RunEach<int32_t>(CM_SUCCESS,
228 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_422V,
229 WIDTH, HEIGHT); });
230
231 RunEach<int32_t>(CM_SUCCESS,
232 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_IMC3,
233 WIDTH, HEIGHT); });
234
235 RunEach<int32_t>(CM_SUCCESS,
236 [this]() { return CreateDestroy(CM_SURFACE_FORMAT_411P,
237 WIDTH, HEIGHT); });
238
239 return;
240 }//========
241
TEST_F(Surface2DTest,DestroyNull)242 TEST_F(Surface2DTest, DestroyNull)
243 {
244 auto DestroyNullPointer = [this]() { return CM_SUCCESS == DestroyNull(); };
245 RunEach(false, DestroyNullPointer);
246 return;
247 }//========
248
TEST_F(Surface2DTest,ReadWrite)249 TEST_F(Surface2DTest, ReadWrite)
250 {
251 uint8_t src[4*WIDTH*HEIGHT] = {1};
252 uint8_t dst[4*WIDTH*HEIGHT] = {2};
253 for (uint32_t i = 0; i < WIDTH*HEIGHT; ++i)
254 {
255 src[4*i] = src[4*i + 1] = src[4*i + 2] = src[4*i + 3] = i%255;
256 }
257 uint8_t *to_surface = src;
258 uint8_t *from_surface = dst;
259
260 auto NormalReadWrite
261 = [this, to_surface, from_surface]()
262 { return ReadWrite(WIDTH, HEIGHT, to_surface, from_surface); };
263 RunEach<int32_t>(CM_SUCCESS, NormalReadWrite);
264
265 auto ReadToNull
266 = [this, to_surface, from_surface]()
267 { return ReadWrite(WIDTH, HEIGHT, to_surface, nullptr); };
268 RunEach<int32_t>(CM_INVALID_ARG_VALUE, ReadToNull);
269
270 return;
271 }//========
272
TEST_F(Surface2DTest,ReadWriteWithStride)273 TEST_F(Surface2DTest, ReadWriteWithStride)
274 {
275 RunEach<int32_t>(CM_SUCCESS,
276 [this]() { return ReadWriteWithStride(); });
277 return;
278 }//========
279
TEST_F(Surface2DTest,Initialization)280 TEST_F(Surface2DTest, Initialization)
281 {
282 RunEach<int32_t>(CM_SUCCESS,
283 [this]() { return Initialize(); });
284 return;
285 }//========
286
TEST_F(Surface2DTest,GetInfo)287 TEST_F(Surface2DTest, GetInfo)
288 {
289 auto argb8_size0 =
290 [this]() { return GetAllocationSize(WIDTH, HEIGHT,
291 CM_SURFACE_FORMAT_A8R8G8B8)
292 == 4*WIDTH*HEIGHT; };
293 RunEach(true, argb8_size0);
294
295 uint32_t width = 15;
296 auto argb8_size1 =
297 [this, width]() { return GetAllocationSize(width, HEIGHT,
298 CM_SURFACE_FORMAT_A8R8G8B8)
299 > 4*width*HEIGHT; };
300 RunEach(true, argb8_size1);
301
302 return;
303 }//========
304