1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "AHardwareBuffer_test"
18 //#define LOG_NDEBUG 0
19 
20 #include <android-base/properties.h>
21 #include <android/data_space.h>
22 #include <android/hardware/graphics/common/1.0/types.h>
23 #include <gtest/gtest.h>
24 #include <private/android/AHardwareBufferHelpers.h>
25 #include <ui/GraphicBuffer.h>
26 #include <vndk/hardware_buffer.h>
27 
28 using namespace android;
29 using android::hardware::graphics::common::V1_0::BufferUsage;
30 
IsCuttlefish()31 static bool IsCuttlefish() {
32     return ::android::base::GetProperty("ro.product.board", "") == "cutf";
33 }
34 
BuildHexFailureMessage(uint64_t expected,uint64_t actual,const char * type)35 static ::testing::AssertionResult BuildHexFailureMessage(uint64_t expected,
36         uint64_t actual, const char* type) {
37     std::ostringstream ss;
38     ss << type << " 0x" << std::hex << actual
39             << " does not match expected " << type << " 0x" << std::hex
40             << expected;
41     return ::testing::AssertionFailure() << ss.str();
42 }
43 
TestUsageConversion(uint64_t grallocUsage,uint64_t hardwareBufferUsage)44 static ::testing::AssertionResult TestUsageConversion(
45         uint64_t grallocUsage, uint64_t hardwareBufferUsage) {
46     uint64_t convertedGrallocUsage = AHardwareBuffer_convertToGrallocUsageBits(hardwareBufferUsage);
47     if (convertedGrallocUsage != grallocUsage)
48         return BuildHexFailureMessage(grallocUsage, convertedGrallocUsage, "converToGralloc");
49 
50     uint64_t convertedHArdwareBufferUsage = AHardwareBuffer_convertFromGrallocUsageBits(grallocUsage);
51     if (convertedHArdwareBufferUsage != grallocUsage)
52         return BuildHexFailureMessage(grallocUsage, convertedHArdwareBufferUsage, "convertFromGralloc");
53 
54     return testing::AssertionSuccess();
55 }
56 
57 // This is a unit test rather than going through AHardwareBuffer because not
58 // all flags may be supported by the host device.
TEST(AHardwareBufferTest,ConvertToAndFromGrallocBits)59 TEST(AHardwareBufferTest, ConvertToAndFromGrallocBits) {
60     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::CPU_READ_RARELY,
61             AHARDWAREBUFFER_USAGE_CPU_READ_RARELY));
62     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::CPU_READ_OFTEN,
63             AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN));
64     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::CPU_WRITE_RARELY,
65             AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY));
66     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::CPU_WRITE_OFTEN,
67             AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN));
68 
69     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::GPU_TEXTURE,
70             AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE));
71     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::GPU_RENDER_TARGET,
72             AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT));
73     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::GPU_DATA_BUFFER,
74             AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER));
75     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::PROTECTED,
76             AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT));
77     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::SENSOR_DIRECT_DATA,
78             AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA));
79     EXPECT_TRUE(TestUsageConversion((uint64_t)BufferUsage::VIDEO_ENCODER,
80             AHARDWAREBUFFER_USAGE_VIDEO_ENCODE));
81 
82     EXPECT_TRUE(TestUsageConversion(1ull<<28, AHARDWAREBUFFER_USAGE_VENDOR_0));
83     EXPECT_TRUE(TestUsageConversion(1ull<<29, AHARDWAREBUFFER_USAGE_VENDOR_1));
84     EXPECT_TRUE(TestUsageConversion(1ull<<30, AHARDWAREBUFFER_USAGE_VENDOR_2));
85     EXPECT_TRUE(TestUsageConversion(1ull<<31, AHARDWAREBUFFER_USAGE_VENDOR_3));
86     EXPECT_TRUE(TestUsageConversion(1ull<<48, AHARDWAREBUFFER_USAGE_VENDOR_4));
87     EXPECT_TRUE(TestUsageConversion(1ull<<49, AHARDWAREBUFFER_USAGE_VENDOR_5));
88     EXPECT_TRUE(TestUsageConversion(1ull<<50, AHARDWAREBUFFER_USAGE_VENDOR_6));
89     EXPECT_TRUE(TestUsageConversion(1ull<<51, AHARDWAREBUFFER_USAGE_VENDOR_7));
90     EXPECT_TRUE(TestUsageConversion(1ull<<52, AHARDWAREBUFFER_USAGE_VENDOR_8));
91     EXPECT_TRUE(TestUsageConversion(1ull<<53, AHARDWAREBUFFER_USAGE_VENDOR_9));
92     EXPECT_TRUE(TestUsageConversion(1ull<<54, AHARDWAREBUFFER_USAGE_VENDOR_10));
93     EXPECT_TRUE(TestUsageConversion(1ull<<55, AHARDWAREBUFFER_USAGE_VENDOR_11));
94     EXPECT_TRUE(TestUsageConversion(1ull<<56, AHARDWAREBUFFER_USAGE_VENDOR_12));
95     EXPECT_TRUE(TestUsageConversion(1ull<<57, AHARDWAREBUFFER_USAGE_VENDOR_13));
96     EXPECT_TRUE(TestUsageConversion(1ull<<58, AHARDWAREBUFFER_USAGE_VENDOR_14));
97     EXPECT_TRUE(TestUsageConversion(1ull<<59, AHARDWAREBUFFER_USAGE_VENDOR_15));
98     EXPECT_TRUE(TestUsageConversion(1ull<<60, AHARDWAREBUFFER_USAGE_VENDOR_16));
99     EXPECT_TRUE(TestUsageConversion(1ull<<61, AHARDWAREBUFFER_USAGE_VENDOR_17));
100     EXPECT_TRUE(TestUsageConversion(1ull<<62, AHARDWAREBUFFER_USAGE_VENDOR_18));
101     EXPECT_TRUE(TestUsageConversion(1ull<<63, AHARDWAREBUFFER_USAGE_VENDOR_19));
102 
103     // Test some more complex flag combinations.
104     EXPECT_TRUE(TestUsageConversion(
105             (uint64_t)BufferUsage::CPU_READ_RARELY |
106             (uint64_t)BufferUsage::CPU_WRITE_RARELY,
107             AHARDWAREBUFFER_USAGE_CPU_READ_RARELY | AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY));
108 
109     EXPECT_TRUE(TestUsageConversion(
110         (uint64_t)BufferUsage::GPU_RENDER_TARGET | (uint64_t)BufferUsage::GPU_TEXTURE |
111         1ull << 29 | 1ull << 57,
112         AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
113         AHARDWAREBUFFER_USAGE_VENDOR_1 | AHARDWAREBUFFER_USAGE_VENDOR_13));
114 }
115 
TEST(AHardwareBufferTest,GetCreateHandleTest)116 TEST(AHardwareBufferTest, GetCreateHandleTest) {
117     AHardwareBuffer_Desc desc{
118             .width = 64,
119             .height = 1,
120             .layers = 1,
121             .format = AHARDWAREBUFFER_FORMAT_BLOB,
122             .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
123             .stride = 64,
124     };
125 
126     AHardwareBuffer* buffer = nullptr;
127     EXPECT_EQ(0, AHardwareBuffer_allocate(&desc, &buffer));
128     const native_handle_t* handle = AHardwareBuffer_getNativeHandle(buffer);
129     EXPECT_NE(nullptr, handle);
130 
131     AHardwareBuffer* otherBuffer = nullptr;
132     EXPECT_EQ(0, AHardwareBuffer_createFromHandle(
133         &desc, handle, AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE, &otherBuffer));
134     EXPECT_NE(nullptr, otherBuffer);
135 
136     AHardwareBuffer_release(buffer);
137     AHardwareBuffer_release(otherBuffer);
138 }
139 
TEST(AHardwareBufferTest,GetIdTest)140 TEST(AHardwareBufferTest, GetIdTest) {
141     const uint32_t testWidth = 4;
142     const uint32_t testHeight = 4;
143     const uint32_t testLayers = 1;
144 
145     AHardwareBuffer* ahb1 = nullptr;
146     uint64_t id1 = 0;
147     const AHardwareBuffer_Desc desc = {
148             .width = testWidth,
149             .height = testHeight,
150             .layers = testLayers,
151             .format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
152             .usage = AHARDWAREBUFFER_USAGE_CPU_READ_RARELY,
153     };
154     int res = AHardwareBuffer_allocate(&desc, &ahb1);
155     EXPECT_EQ(NO_ERROR, res);
156     EXPECT_NE(nullptr, ahb1);
157     EXPECT_EQ(0, AHardwareBuffer_getId(ahb1, &id1));
158     const GraphicBuffer* gb1 = AHardwareBuffer_to_GraphicBuffer(ahb1);
159     EXPECT_NE(nullptr, gb1);
160     EXPECT_EQ(id1, gb1->getId());
161     EXPECT_NE(id1, 0);
162 
163     sp<GraphicBuffer> gb2(new GraphicBuffer(testWidth,
164                                             testHeight,
165                                             PIXEL_FORMAT_RGBA_8888,
166                                             testLayers,
167                                             GraphicBuffer::USAGE_SW_READ_RARELY,
168                                             std::string("test")));
169     EXPECT_NE(nullptr, gb2.get());
170     const AHardwareBuffer* ahb2 = AHardwareBuffer_from_GraphicBuffer(gb2.get());
171     EXPECT_NE(nullptr, ahb2);
172     uint64_t id2 = 0;
173     EXPECT_EQ(0, AHardwareBuffer_getId(ahb2, &id2));
174     EXPECT_EQ(id2, gb2->getId());
175     EXPECT_NE(id2, 0);
176 
177     EXPECT_NE(id1, id2);
178 }
179 
TEST(AHardwareBufferTest,Allocate2NoExtras)180 TEST(AHardwareBufferTest, Allocate2NoExtras) {
181     AHardwareBuffer_Desc desc{
182             .width = 64,
183             .height = 1,
184             .layers = 1,
185             .format = AHARDWAREBUFFER_FORMAT_BLOB,
186             .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
187             .stride = 0,
188     };
189 
190     AHardwareBuffer* buffer = nullptr;
191     ASSERT_EQ(0, AHardwareBuffer_allocateWithOptions(&desc, nullptr, 0, &buffer));
192     uint64_t id = 0;
193     EXPECT_EQ(0, AHardwareBuffer_getId(buffer, &id));
194     EXPECT_NE(0, id);
195     AHardwareBuffer_Desc desc2{};
196     AHardwareBuffer_describe(buffer, &desc2);
197     EXPECT_EQ(desc.width, desc2.width);
198     EXPECT_EQ(desc.height, desc2.height);
199     EXPECT_GE(desc2.stride, desc2.width);
200 
201     AHardwareBuffer_release(buffer);
202 }
203 
TEST(AHardwareBufferTest,Allocate2WithExtras)204 TEST(AHardwareBufferTest, Allocate2WithExtras) {
205     if (!IsCuttlefish()) {
206         GTEST_SKIP() << "Unknown gralloc HAL, cannot test extras";
207     }
208 
209     AHardwareBuffer_Desc desc{
210             .width = 64,
211             .height = 48,
212             .layers = 1,
213             .format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
214             .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
215             .stride = 0,
216     };
217 
218     AHardwareBuffer* buffer = nullptr;
219     std::array<AHardwareBufferLongOptions, 1> extras = {{
220             {.name = "android.hardware.graphics.common.Dataspace", ADATASPACE_DISPLAY_P3},
221     }};
222     ASSERT_EQ(0, AHardwareBuffer_allocateWithOptions(&desc, extras.data(), extras.size(), &buffer));
223     uint64_t id = 0;
224     EXPECT_EQ(0, AHardwareBuffer_getId(buffer, &id));
225     EXPECT_NE(0, id);
226     AHardwareBuffer_Desc desc2{};
227     AHardwareBuffer_describe(buffer, &desc2);
228     EXPECT_EQ(desc.width, desc2.width);
229     EXPECT_EQ(desc.height, desc2.height);
230     EXPECT_GE(desc2.stride, desc2.width);
231 
232     EXPECT_EQ(ADATASPACE_DISPLAY_P3, AHardwareBuffer_getDataSpace(buffer));
233 
234     AHardwareBuffer_release(buffer);
235 }
236 
TEST(AHardwareBufferTest,GetSetDataspace)237 TEST(AHardwareBufferTest, GetSetDataspace) {
238     AHardwareBuffer_Desc desc{
239             .width = 64,
240             .height = 48,
241             .layers = 1,
242             .format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
243             .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
244             .stride = 0,
245     };
246 
247     AHardwareBuffer* buffer = nullptr;
248     ASSERT_EQ(0, AHardwareBuffer_allocate(&desc, &buffer));
249 
250     EXPECT_EQ(ADATASPACE_UNKNOWN, AHardwareBuffer_getDataSpace(buffer));
251     AHardwareBufferStatus status = AHardwareBuffer_setDataSpace(buffer, ADATASPACE_DISPLAY_P3);
252     if (status != AHARDWAREBUFFER_STATUS_UNSUPPORTED) {
253         EXPECT_EQ(0, status);
254         EXPECT_EQ(ADATASPACE_DISPLAY_P3, AHardwareBuffer_getDataSpace(buffer));
255     }
256 
257     AHardwareBuffer_release(buffer);
258 }