1 /*
2  * Copyright 2022 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 #undef LOG_TAG
18 #define LOG_TAG "VtsHalGraphicsMapperStableC_TargetTest"
19 
20 #include <aidl/Vintf.h>
21 #include <aidl/android/hardware/graphics/allocator/AllocationError.h>
22 #include <aidl/android/hardware/graphics/allocator/AllocationResult.h>
23 #include <aidl/android/hardware/graphics/allocator/IAllocator.h>
24 #include <aidl/android/hardware/graphics/common/BufferUsage.h>
25 #include <aidl/android/hardware/graphics/common/PixelFormat.h>
26 #include <aidlcommonsupport/NativeHandle.h>
27 #include <android/binder_enums.h>
28 #include <android/binder_manager.h>
29 #include <android/dlext.h>
30 #include <android/hardware/graphics/mapper/IMapper.h>
31 #include <android/hardware/graphics/mapper/utils/IMapperMetadataTypes.h>
32 #include <gralloctypes/Gralloc4.h>
33 #include <hidl/GtestPrinter.h>
34 #include <system/graphics.h>
35 
36 #include <dlfcn.h>
37 #include <drm/drm_fourcc.h>
38 #include <gtest/gtest.h>
39 #include <vndksupport/linker.h>
40 #include <initializer_list>
41 #include <optional>
42 #include <string>
43 #include <tuple>
44 #include <vector>
45 
46 using namespace aidl::android::hardware::graphics::allocator;
47 using namespace aidl::android::hardware::graphics::common;
48 using namespace android;
49 using namespace android::hardware;
50 using namespace ::android::hardware::graphics::mapper;
51 
52 typedef AIMapper_Error (*AIMapper_loadIMapperFn)(AIMapper* _Nullable* _Nonnull outImplementation);
53 
operator |(BufferUsage lhs,BufferUsage rhs)54 inline constexpr BufferUsage operator|(BufferUsage lhs, BufferUsage rhs) {
55     using T = std::underlying_type_t<BufferUsage>;
56     return static_cast<BufferUsage>(static_cast<T>(lhs) | static_cast<T>(rhs));
57 }
58 
operator |=(BufferUsage & lhs,BufferUsage rhs)59 inline BufferUsage& operator|=(BufferUsage& lhs, BufferUsage rhs) {
60     lhs = lhs | rhs;
61     return lhs;
62 }
63 
64 struct YCbCr {
65     android_ycbcr yCbCr;
66     int64_t horizontalSubSampling;
67     int64_t verticalSubSampling;
68 };
69 
70 constexpr const char* STANDARD_METADATA_NAME =
71         "android.hardware.graphics.common.StandardMetadataType";
72 
isStandardMetadata(AIMapper_MetadataType metadataType)73 static bool isStandardMetadata(AIMapper_MetadataType metadataType) {
74     return strcmp(STANDARD_METADATA_NAME, metadataType.name) == 0;
75 }
76 
toString(const std::vector<StandardMetadataType> types)77 static std::string toString(const std::vector<StandardMetadataType> types) {
78     std::stringstream buf;
79     buf << "[";
80     for (auto type : types) {
81         buf << toString(type) << ", ";
82     }
83     buf.seekp(-2, buf.cur);
84     buf << "]";
85     return buf.str();
86 }
87 
88 class BufferHandle {
89     AIMapper* mIMapper;
90     buffer_handle_t mHandle = nullptr;
91 
92   public:
BufferHandle(AIMapper * mapper,native_handle_t * rawHandle)93     explicit BufferHandle(AIMapper* mapper, native_handle_t* rawHandle) : mIMapper(mapper) {
94         EXPECT_EQ(AIMAPPER_ERROR_NONE, mIMapper->v5.importBuffer(rawHandle, &mHandle));
95     }
96 
BufferHandle(BufferHandle && other)97     explicit BufferHandle(BufferHandle&& other) { *this = std::move(other); }
98 
operator =(BufferHandle && other)99     BufferHandle& operator=(BufferHandle&& other) noexcept {
100         reset();
101         mIMapper = other.mIMapper;
102         mHandle = other.mHandle;
103         other.mHandle = nullptr;
104         return *this;
105     }
106 
~BufferHandle()107     ~BufferHandle() { reset(); }
108 
operator bool() const109     constexpr explicit operator bool() const noexcept { return mHandle != nullptr; }
110 
operator *() const111     buffer_handle_t operator*() const noexcept { return mHandle; }
112 
reset()113     void reset() {
114         if (mHandle != nullptr) {
115             EXPECT_EQ(AIMAPPER_ERROR_NONE, mIMapper->v5.freeBuffer(mHandle));
116             mHandle = nullptr;
117         }
118     }
119 };
120 
121 class BufferAllocation {
122     AIMapper* mIMapper;
123     native_handle_t* mRawHandle;
124     uint32_t mStride;
125     const BufferDescriptorInfo mInfo;
126 
127   public:
128     BufferAllocation(const BufferAllocation&) = delete;
129     void operator=(const BufferAllocation&) = delete;
130 
BufferAllocation(AIMapper * mapper,native_handle_t * handle,uint32_t stride,const BufferDescriptorInfo & info)131     BufferAllocation(AIMapper* mapper, native_handle_t* handle, uint32_t stride,
132                      const BufferDescriptorInfo& info)
133         : mIMapper(mapper), mRawHandle(handle), mStride(stride), mInfo(info) {}
134 
~BufferAllocation()135     ~BufferAllocation() {
136         if (mRawHandle == nullptr) return;
137 
138         native_handle_close(mRawHandle);
139         native_handle_delete(mRawHandle);
140     }
141 
stride() const142     uint32_t stride() const { return mStride; }
info() const143     const BufferDescriptorInfo& info() const { return mInfo; }
144 
import()145     BufferHandle import() { return BufferHandle{mIMapper, mRawHandle}; }
146 
rawHandle() const147     const native_handle_t* rawHandle() const { return mRawHandle; }
148 };
149 
150 class GraphicsTestsBase {
151   private:
152     friend class BufferAllocation;
153     int32_t mIAllocatorVersion = 1;
154     std::shared_ptr<IAllocator> mAllocator;
155     AIMapper* mIMapper = nullptr;
156     AIMapper_loadIMapperFn mIMapperLoader;
157     int32_t* mIMapperHALVersion = nullptr;
158 
159   protected:
Initialize(std::shared_ptr<IAllocator> allocator)160     void Initialize(std::shared_ptr<IAllocator> allocator) {
161         mAllocator = allocator;
162         ASSERT_NE(nullptr, mAllocator.get()) << "failed to get allocator service";
163         ASSERT_TRUE(mAllocator->getInterfaceVersion(&mIAllocatorVersion).isOk());
164         ASSERT_GE(mIAllocatorVersion, 2);
165         std::string mapperSuffix;
166         auto status = mAllocator->getIMapperLibrarySuffix(&mapperSuffix);
167         ASSERT_TRUE(status.isOk()) << "Failed to get IMapper library suffix";
168         std::string lib_name = "mapper." + mapperSuffix + ".so";
169         void* so = AServiceManager_openDeclaredPassthroughHal("mapper", mapperSuffix.c_str(),
170                                                               RTLD_LOCAL | RTLD_NOW);
171         ASSERT_NE(nullptr, so) << "Failed to load " << lib_name;
172         mIMapperLoader = (AIMapper_loadIMapperFn)dlsym(so, "AIMapper_loadIMapper");
173         ASSERT_NE(nullptr, mIMapperLoader) << "AIMapper_locaIMapper missing from " << lib_name;
174         ASSERT_EQ(AIMAPPER_ERROR_NONE, mIMapperLoader(&mIMapper));
175         ASSERT_NE(mIMapper, nullptr);
176         mIMapperHALVersion = (int32_t*)dlsym(so, "ANDROID_HAL_MAPPER_VERSION");
177     }
178 
179   public:
getIMapperLoader() const180     AIMapper_loadIMapperFn getIMapperLoader() const { return mIMapperLoader; }
getHalVersion() const181     int32_t* getHalVersion() const { return mIMapperHALVersion; }
182 
allocate(const BufferDescriptorInfo & descriptorInfo)183     std::unique_ptr<BufferAllocation> allocate(const BufferDescriptorInfo& descriptorInfo) {
184         AllocationResult result;
185         ::ndk::ScopedAStatus status = mAllocator->allocate2(descriptorInfo, 1, &result);
186         if (!status.isOk()) {
187             status_t error = status.getExceptionCode();
188             if (error == EX_SERVICE_SPECIFIC) {
189                 error = status.getServiceSpecificError();
190                 EXPECT_NE(OK, error) << "Failed to set error properly";
191             } else {
192                 EXPECT_EQ(OK, error) << "Allocation transport failure";
193             }
194             return nullptr;
195         } else {
196             return std::make_unique<BufferAllocation>(mIMapper, dupFromAidl(result.buffers[0]),
197                                                       result.stride, descriptorInfo);
198         }
199     }
200 
allocateGeneric()201     std::unique_ptr<BufferAllocation> allocateGeneric() {
202         return allocate({
203                 .name = {"VTS_TEMP"},
204                 .width = 64,
205                 .height = 64,
206                 .layerCount = 1,
207                 .format = PixelFormat::RGBA_8888,
208                 .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
209                 .reservedSize = 0,
210         });
211     }
212 
isSupported(const BufferDescriptorInfo & descriptorInfo)213     bool isSupported(const BufferDescriptorInfo& descriptorInfo) {
214         bool ret = false;
215         EXPECT_TRUE(mAllocator->isSupported(descriptorInfo, &ret).isOk());
216         return ret;
217     }
218 
mapper() const219     AIMapper* mapper() const { return mIMapper; }
220 
221     template <StandardMetadataType T>
getStandardMetadata(buffer_handle_t bufferHandle)222     auto getStandardMetadata(buffer_handle_t bufferHandle)
223             -> decltype(StandardMetadata<T>::value::decode(nullptr, 0)) {
224         using Value = typename StandardMetadata<T>::value;
225         std::vector<uint8_t> buffer;
226         // Initial guess
227         buffer.resize(512);
228         int32_t sizeRequired = mapper()->v5.getStandardMetadata(
229                 bufferHandle, static_cast<int64_t>(T), buffer.data(), buffer.size());
230         if (sizeRequired < 0) {
231             EXPECT_EQ(-AIMAPPER_ERROR_UNSUPPORTED, sizeRequired)
232                     << "Received something other than UNSUPPORTED from valid getStandardMetadata "
233                        "call";
234             return std::nullopt;
235         }
236         if (sizeRequired > buffer.size()) {
237             buffer.resize(sizeRequired);
238             sizeRequired = mapper()->v5.getStandardMetadata(bufferHandle, static_cast<int64_t>(T),
239                                                             buffer.data(), buffer.size());
240         }
241         if (sizeRequired < 0 || sizeRequired > buffer.size()) {
242             ADD_FAILURE() << "getStandardMetadata failed, received " << sizeRequired
243                           << " with buffer size " << buffer.size();
244             // Generate a fail type
245             return std::nullopt;
246         }
247         return Value::decode(buffer.data(), sizeRequired);
248     }
249 
250     template <StandardMetadataType T>
setStandardMetadata(buffer_handle_t bufferHandle,const typename StandardMetadata<T>::value_type & value)251     AIMapper_Error setStandardMetadata(buffer_handle_t bufferHandle,
252                                        const typename StandardMetadata<T>::value_type& value) {
253         using Value = typename StandardMetadata<T>::value;
254         int32_t sizeRequired = Value::encode(value, nullptr, 0);
255         if (sizeRequired < 0) {
256             EXPECT_GE(sizeRequired, 0) << "Failed to calculate required size";
257             return static_cast<AIMapper_Error>(-sizeRequired);
258         }
259         std::vector<uint8_t> buffer;
260         buffer.resize(sizeRequired);
261         sizeRequired = Value::encode(value, buffer.data(), buffer.size());
262         if (sizeRequired < 0 || sizeRequired > buffer.size()) {
263             ADD_FAILURE() << "Failed to encode with calculated size " << sizeRequired
264                           << "; buffer size" << buffer.size();
265             return static_cast<AIMapper_Error>(-sizeRequired);
266         }
267         return mapper()->v5.setStandardMetadata(bufferHandle, static_cast<int64_t>(T),
268                                                 buffer.data(), sizeRequired);
269     }
270 
verifyRGBA8888PlaneLayouts(const std::vector<PlaneLayout> & planeLayouts)271     void verifyRGBA8888PlaneLayouts(const std::vector<PlaneLayout>& planeLayouts) {
272         ASSERT_EQ(1, planeLayouts.size());
273 
274         const auto& planeLayout = planeLayouts.front();
275 
276         ASSERT_EQ(4, planeLayout.components.size());
277 
278         int64_t offsetInBitsR = -1;
279         int64_t offsetInBitsG = -1;
280         int64_t offsetInBitsB = -1;
281         int64_t offsetInBitsA = -1;
282 
283         for (const auto& component : planeLayout.components) {
284             if (!gralloc4::isStandardPlaneLayoutComponentType(component.type)) {
285                 continue;
286             }
287             EXPECT_EQ(8, component.sizeInBits);
288             if (component.type.value == gralloc4::PlaneLayoutComponentType_R.value) {
289                 offsetInBitsR = component.offsetInBits;
290             }
291             if (component.type.value == gralloc4::PlaneLayoutComponentType_G.value) {
292                 offsetInBitsG = component.offsetInBits;
293             }
294             if (component.type.value == gralloc4::PlaneLayoutComponentType_B.value) {
295                 offsetInBitsB = component.offsetInBits;
296             }
297             if (component.type.value == gralloc4::PlaneLayoutComponentType_A.value) {
298                 offsetInBitsA = component.offsetInBits;
299             }
300         }
301 
302         EXPECT_EQ(0, offsetInBitsR);
303         EXPECT_EQ(8, offsetInBitsG);
304         EXPECT_EQ(16, offsetInBitsB);
305         EXPECT_EQ(24, offsetInBitsA);
306 
307         EXPECT_EQ(0, planeLayout.offsetInBytes);
308         EXPECT_EQ(32, planeLayout.sampleIncrementInBits);
309         // Skip testing stride because any stride is valid
310         EXPECT_LE(planeLayout.widthInSamples * planeLayout.heightInSamples * 4,
311                   planeLayout.totalSizeInBytes);
312         EXPECT_EQ(1, planeLayout.horizontalSubsampling);
313         EXPECT_EQ(1, planeLayout.verticalSubsampling);
314     }
315 
fillRGBA8888(uint8_t * data,uint32_t height,size_t strideInBytes,size_t widthInBytes)316     void fillRGBA8888(uint8_t* data, uint32_t height, size_t strideInBytes, size_t widthInBytes) {
317         for (uint32_t y = 0; y < height; y++) {
318             memset(data, y, widthInBytes);
319             data += strideInBytes;
320         }
321     }
322 
verifyRGBA8888(const buffer_handle_t bufferHandle,const uint8_t * data,uint32_t height,size_t strideInBytes,size_t widthInBytes)323     void verifyRGBA8888(const buffer_handle_t bufferHandle, const uint8_t* data, uint32_t height,
324                         size_t strideInBytes, size_t widthInBytes) {
325         auto decodeResult = getStandardMetadata<StandardMetadataType::PLANE_LAYOUTS>(bufferHandle);
326         ASSERT_TRUE(decodeResult.has_value());
327         const auto& planeLayouts = *decodeResult;
328         ASSERT_TRUE(planeLayouts.size() > 0);
329 
330         verifyRGBA8888PlaneLayouts(planeLayouts);
331 
332         for (uint32_t y = 0; y < height; y++) {
333             for (size_t i = 0; i < widthInBytes; i++) {
334                 EXPECT_EQ(static_cast<uint8_t>(y), data[i]);
335             }
336             data += strideInBytes;
337         }
338     }
339 
traverseYCbCrData(const android_ycbcr & yCbCr,int32_t width,int32_t height,int64_t hSubsampling,int64_t vSubsampling,std::function<void (uint8_t *,uint8_t)> traverseFuncion)340     void traverseYCbCrData(const android_ycbcr& yCbCr, int32_t width, int32_t height,
341                            int64_t hSubsampling, int64_t vSubsampling,
342                            std::function<void(uint8_t*, uint8_t)> traverseFuncion) {
343         auto yData = static_cast<uint8_t*>(yCbCr.y);
344         auto cbData = static_cast<uint8_t*>(yCbCr.cb);
345         auto crData = static_cast<uint8_t*>(yCbCr.cr);
346         auto yStride = yCbCr.ystride;
347         auto cStride = yCbCr.cstride;
348         auto chromaStep = yCbCr.chroma_step;
349 
350         for (uint32_t y = 0; y < height; y++) {
351             for (uint32_t x = 0; x < width; x++) {
352                 auto val = static_cast<uint8_t>(height * y + x);
353 
354                 traverseFuncion(yData + yStride * y + x, val);
355 
356                 if (y % vSubsampling == 0 && x % hSubsampling == 0) {
357                     uint32_t subSampleX = x / hSubsampling;
358                     uint32_t subSampleY = y / vSubsampling;
359                     const auto subSampleOffset = cStride * subSampleY + chromaStep * subSampleX;
360                     const auto subSampleVal =
361                             static_cast<uint8_t>(height * subSampleY + subSampleX);
362 
363                     traverseFuncion(cbData + subSampleOffset, subSampleVal);
364                     traverseFuncion(crData + subSampleOffset, subSampleVal + 1);
365                 }
366             }
367         }
368     }
369 
fillYCbCrData(const android_ycbcr & yCbCr,int32_t width,int32_t height,int64_t hSubsampling,int64_t vSubsampling)370     void fillYCbCrData(const android_ycbcr& yCbCr, int32_t width, int32_t height,
371                        int64_t hSubsampling, int64_t vSubsampling) {
372         traverseYCbCrData(yCbCr, width, height, hSubsampling, vSubsampling,
373                           [](auto address, auto fillingData) { *address = fillingData; });
374     }
375 
verifyYCbCrData(const android_ycbcr & yCbCr,int32_t width,int32_t height,int64_t hSubsampling,int64_t vSubsampling)376     void verifyYCbCrData(const android_ycbcr& yCbCr, int32_t width, int32_t height,
377                          int64_t hSubsampling, int64_t vSubsampling) {
378         traverseYCbCrData(
379                 yCbCr, width, height, hSubsampling, vSubsampling,
380                 [](auto address, auto expectedData) { EXPECT_EQ(*address, expectedData); });
381     }
382 
bitsToBytes(int64_t bits)383     constexpr uint64_t bitsToBytes(int64_t bits) { return bits / 8; }
bytesToBits(int64_t bytes)384     constexpr uint64_t bytesToBits(int64_t bytes) { return bytes * 8; }
385 
getAndroidYCbCr(buffer_handle_t bufferHandle,uint8_t * data,android_ycbcr * outYCbCr,int64_t * hSubsampling,int64_t * vSubsampling)386     void getAndroidYCbCr(buffer_handle_t bufferHandle, uint8_t* data, android_ycbcr* outYCbCr,
387                          int64_t* hSubsampling, int64_t* vSubsampling) {
388         auto decodeResult = getStandardMetadata<StandardMetadataType::PLANE_LAYOUTS>(bufferHandle);
389         ASSERT_TRUE(decodeResult.has_value());
390         const auto& planeLayouts = *decodeResult;
391         ASSERT_TRUE(planeLayouts.size() > 0);
392 
393         outYCbCr->y = nullptr;
394         outYCbCr->cb = nullptr;
395         outYCbCr->cr = nullptr;
396         outYCbCr->ystride = 0;
397         outYCbCr->cstride = 0;
398         outYCbCr->chroma_step = 0;
399 
400         for (const auto& planeLayout : planeLayouts) {
401             for (const auto& planeLayoutComponent : planeLayout.components) {
402                 if (!gralloc4::isStandardPlaneLayoutComponentType(planeLayoutComponent.type)) {
403                     continue;
404                 }
405                 ASSERT_EQ(0, planeLayoutComponent.offsetInBits % 8);
406 
407                 uint8_t* tmpData = data + planeLayout.offsetInBytes +
408                                    bitsToBytes(planeLayoutComponent.offsetInBits);
409                 uint64_t sampleIncrementInBytes;
410 
411                 auto type = static_cast<PlaneLayoutComponentType>(planeLayoutComponent.type.value);
412                 switch (type) {
413                     case PlaneLayoutComponentType::Y:
414                         ASSERT_EQ(nullptr, outYCbCr->y);
415                         ASSERT_EQ(8, planeLayoutComponent.sizeInBits);
416                         ASSERT_EQ(8, planeLayout.sampleIncrementInBits);
417                         outYCbCr->y = tmpData;
418                         outYCbCr->ystride = planeLayout.strideInBytes;
419                         break;
420 
421                     case PlaneLayoutComponentType::CB:
422                     case PlaneLayoutComponentType::CR:
423                         ASSERT_EQ(0, planeLayout.sampleIncrementInBits % 8);
424 
425                         sampleIncrementInBytes = planeLayout.sampleIncrementInBits / 8;
426                         ASSERT_TRUE(sampleIncrementInBytes == 1 || sampleIncrementInBytes == 2);
427 
428                         if (outYCbCr->cstride == 0 && outYCbCr->chroma_step == 0) {
429                             outYCbCr->cstride = planeLayout.strideInBytes;
430                             outYCbCr->chroma_step = sampleIncrementInBytes;
431                         } else {
432                             ASSERT_EQ(outYCbCr->cstride, planeLayout.strideInBytes);
433                             ASSERT_EQ(outYCbCr->chroma_step, sampleIncrementInBytes);
434                         }
435 
436                         if (*hSubsampling == 0 && *vSubsampling == 0) {
437                             *hSubsampling = planeLayout.horizontalSubsampling;
438                             *vSubsampling = planeLayout.verticalSubsampling;
439                         } else {
440                             ASSERT_EQ(*hSubsampling, planeLayout.horizontalSubsampling);
441                             ASSERT_EQ(*vSubsampling, planeLayout.verticalSubsampling);
442                         }
443 
444                         if (type == PlaneLayoutComponentType::CB) {
445                             ASSERT_EQ(nullptr, outYCbCr->cb);
446                             outYCbCr->cb = tmpData;
447                         } else {
448                             ASSERT_EQ(nullptr, outYCbCr->cr);
449                             outYCbCr->cr = tmpData;
450                         }
451                         break;
452                     default:
453                         break;
454                 };
455             }
456         }
457 
458         ASSERT_NE(nullptr, outYCbCr->y);
459         ASSERT_NE(nullptr, outYCbCr->cb);
460         ASSERT_NE(nullptr, outYCbCr->cr);
461     }
462 
getAndroidYCbCr_P010(const native_handle_t * bufferHandle,uint8_t * data)463     YCbCr getAndroidYCbCr_P010(const native_handle_t* bufferHandle, uint8_t* data) {
464         YCbCr yCbCr_P010;
465         auto decodeResult = getStandardMetadata<StandardMetadataType::PLANE_LAYOUTS>(bufferHandle);
466         if (!decodeResult.has_value()) {
467             ADD_FAILURE() << "failed to get plane layout";
468             return YCbCr{};
469         }
470         const auto& planeLayouts = *decodeResult;
471         EXPECT_EQ(2, planeLayouts.size());
472         EXPECT_EQ(1, planeLayouts[0].components.size());
473         EXPECT_EQ(2, planeLayouts[1].components.size());
474 
475         yCbCr_P010.yCbCr.y = nullptr;
476         yCbCr_P010.yCbCr.cb = nullptr;
477         yCbCr_P010.yCbCr.cr = nullptr;
478         yCbCr_P010.yCbCr.ystride = 0;
479         yCbCr_P010.yCbCr.cstride = 0;
480         yCbCr_P010.yCbCr.chroma_step = 0;
481         int64_t cb_offset = 0;
482         int64_t cr_offset = 0;
483 
484         for (const auto& planeLayout : planeLayouts) {
485             for (const auto& planeLayoutComponent : planeLayout.components) {
486                 if (!gralloc4::isStandardPlaneLayoutComponentType(planeLayoutComponent.type)) {
487                     continue;
488                 }
489 
490                 uint8_t* tmpData = data + planeLayout.offsetInBytes +
491                                    bitsToBytes(planeLayoutComponent.offsetInBits);
492                 uint64_t sampleIncrementInBytes = 0;
493                 auto type = static_cast<PlaneLayoutComponentType>(planeLayoutComponent.type.value);
494                 switch (type) {
495                     case PlaneLayoutComponentType::Y:
496                         // For specs refer:
497                         // https://docs.microsoft.com/en-us/windows/win32/medfound/10-bit-and-16-bit-yuv-video-formats
498                         EXPECT_EQ(6, planeLayoutComponent.offsetInBits);
499                         EXPECT_EQ(nullptr, yCbCr_P010.yCbCr.y);
500                         EXPECT_EQ(10, planeLayoutComponent.sizeInBits);
501                         EXPECT_EQ(16, planeLayout.sampleIncrementInBits);
502 
503                         yCbCr_P010.yCbCr.y = tmpData;
504                         yCbCr_P010.yCbCr.ystride = planeLayout.strideInBytes;
505                         break;
506 
507                     case PlaneLayoutComponentType::CB:
508                     case PlaneLayoutComponentType::CR:
509                         sampleIncrementInBytes = bitsToBytes(planeLayout.sampleIncrementInBits);
510                         EXPECT_EQ(4, sampleIncrementInBytes);
511 
512                         if (yCbCr_P010.yCbCr.cstride == 0 && yCbCr_P010.yCbCr.chroma_step == 0) {
513                             yCbCr_P010.yCbCr.cstride = planeLayout.strideInBytes;
514                             yCbCr_P010.yCbCr.chroma_step = sampleIncrementInBytes;
515                         } else {
516                             EXPECT_EQ(yCbCr_P010.yCbCr.cstride, planeLayout.strideInBytes);
517                             EXPECT_EQ(yCbCr_P010.yCbCr.chroma_step, sampleIncrementInBytes);
518                         }
519 
520                         if (yCbCr_P010.horizontalSubSampling == 0 &&
521                             yCbCr_P010.verticalSubSampling == 0) {
522                             yCbCr_P010.horizontalSubSampling = planeLayout.horizontalSubsampling;
523                             yCbCr_P010.verticalSubSampling = planeLayout.verticalSubsampling;
524                         } else {
525                             EXPECT_EQ(yCbCr_P010.horizontalSubSampling,
526                                       planeLayout.horizontalSubsampling);
527                             EXPECT_EQ(yCbCr_P010.verticalSubSampling,
528                                       planeLayout.verticalSubsampling);
529                         }
530 
531                         if (type == PlaneLayoutComponentType::CB) {
532                             EXPECT_EQ(nullptr, yCbCr_P010.yCbCr.cb);
533                             yCbCr_P010.yCbCr.cb = tmpData;
534                             cb_offset = planeLayoutComponent.offsetInBits;
535                         } else {
536                             EXPECT_EQ(nullptr, yCbCr_P010.yCbCr.cr);
537                             yCbCr_P010.yCbCr.cr = tmpData;
538                             cr_offset = planeLayoutComponent.offsetInBits;
539                         }
540                         break;
541                     default:
542                         break;
543                 };
544             }
545         }
546 
547         EXPECT_EQ(cb_offset + bytesToBits(2), cr_offset);
548         EXPECT_NE(nullptr, yCbCr_P010.yCbCr.y);
549         EXPECT_NE(nullptr, yCbCr_P010.yCbCr.cb);
550         EXPECT_NE(nullptr, yCbCr_P010.yCbCr.cr);
551         return yCbCr_P010;
552     }
553 };
554 
555 class GraphicsMapperStableCTests
556     : public GraphicsTestsBase,
557       public ::testing::TestWithParam<std::tuple<std::string, std::shared_ptr<IAllocator>>> {
558   public:
SetUp()559     void SetUp() override { Initialize(std::get<1>(GetParam())); }
560 
TearDown()561     void TearDown() override {}
562 };
563 
TEST_P(GraphicsMapperStableCTests,VersionChecks)564 TEST_P(GraphicsMapperStableCTests, VersionChecks) {
565     ASSERT_NE(nullptr, getHalVersion()) << "Resolving ANDROID_HAL_MAPPER_VERSION symbol failed";
566     int32_t halVersion = *getHalVersion();
567     EXPECT_EQ(halVersion, AIMAPPER_VERSION_5) << "Unrecognized ANDROID_HAL_MAPPER_VERSION";
568     EXPECT_EQ(mapper()->version, AIMAPPER_VERSION_5) << "Unrecognized AIMapper::version";
569     EXPECT_EQ(halVersion, mapper()->version)
570             << "AIMapper version & ANDROID_HAL_MAPPER_VERSION don't agree";
571 }
572 
TEST_P(GraphicsMapperStableCTests,AllV5CallbacksDefined)573 TEST_P(GraphicsMapperStableCTests, AllV5CallbacksDefined) {
574     ASSERT_GE(mapper()->version, AIMAPPER_VERSION_5);
575 
576     EXPECT_TRUE(mapper()->v5.importBuffer);
577     EXPECT_TRUE(mapper()->v5.freeBuffer);
578     EXPECT_TRUE(mapper()->v5.getTransportSize);
579     EXPECT_TRUE(mapper()->v5.lock);
580     EXPECT_TRUE(mapper()->v5.unlock);
581     EXPECT_TRUE(mapper()->v5.flushLockedBuffer);
582     EXPECT_TRUE(mapper()->v5.rereadLockedBuffer);
583     EXPECT_TRUE(mapper()->v5.getMetadata);
584     EXPECT_TRUE(mapper()->v5.getStandardMetadata);
585     EXPECT_TRUE(mapper()->v5.setMetadata);
586     EXPECT_TRUE(mapper()->v5.setStandardMetadata);
587     EXPECT_TRUE(mapper()->v5.listSupportedMetadataTypes);
588     EXPECT_TRUE(mapper()->v5.dumpBuffer);
589     EXPECT_TRUE(mapper()->v5.getReservedRegion);
590 }
591 
TEST_P(GraphicsMapperStableCTests,DualLoadIsIdentical)592 TEST_P(GraphicsMapperStableCTests, DualLoadIsIdentical) {
593     ASSERT_GE(mapper()->version, AIMAPPER_VERSION_5);
594     AIMapper* secondMapper;
595     ASSERT_EQ(AIMAPPER_ERROR_NONE, getIMapperLoader()(&secondMapper));
596 
597     EXPECT_EQ(secondMapper->v5.importBuffer, mapper()->v5.importBuffer);
598     EXPECT_EQ(secondMapper->v5.freeBuffer, mapper()->v5.freeBuffer);
599     EXPECT_EQ(secondMapper->v5.getTransportSize, mapper()->v5.getTransportSize);
600     EXPECT_EQ(secondMapper->v5.lock, mapper()->v5.lock);
601     EXPECT_EQ(secondMapper->v5.unlock, mapper()->v5.unlock);
602     EXPECT_EQ(secondMapper->v5.flushLockedBuffer, mapper()->v5.flushLockedBuffer);
603     EXPECT_EQ(secondMapper->v5.rereadLockedBuffer, mapper()->v5.rereadLockedBuffer);
604     EXPECT_EQ(secondMapper->v5.getMetadata, mapper()->v5.getMetadata);
605     EXPECT_EQ(secondMapper->v5.getStandardMetadata, mapper()->v5.getStandardMetadata);
606     EXPECT_EQ(secondMapper->v5.setMetadata, mapper()->v5.setMetadata);
607     EXPECT_EQ(secondMapper->v5.setStandardMetadata, mapper()->v5.setStandardMetadata);
608     EXPECT_EQ(secondMapper->v5.listSupportedMetadataTypes, mapper()->v5.listSupportedMetadataTypes);
609     EXPECT_EQ(secondMapper->v5.dumpBuffer, mapper()->v5.dumpBuffer);
610     EXPECT_EQ(secondMapper->v5.getReservedRegion, mapper()->v5.getReservedRegion);
611 }
612 
TEST_P(GraphicsMapperStableCTests,CanAllocate)613 TEST_P(GraphicsMapperStableCTests, CanAllocate) {
614     auto buffer = allocate({
615             .name = {"VTS_TEMP"},
616             .width = 64,
617             .height = 64,
618             .layerCount = 1,
619             .format = PixelFormat::RGBA_8888,
620             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
621             .reservedSize = 0,
622     });
623     ASSERT_NE(nullptr, buffer.get());
624     EXPECT_GE(buffer->stride(), 64);
625 }
626 
TEST_P(GraphicsMapperStableCTests,ImportFreeBuffer)627 TEST_P(GraphicsMapperStableCTests, ImportFreeBuffer) {
628     auto buffer = allocate({
629             .name = {"VTS_TEMP"},
630             .width = 64,
631             .height = 64,
632             .layerCount = 1,
633             .format = PixelFormat::RGBA_8888,
634             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
635             .reservedSize = 0,
636     });
637     ASSERT_NE(nullptr, buffer.get());
638     EXPECT_GE(buffer->stride(), 64);
639 
640     {
641         auto import1 = buffer->import();
642         auto import2 = buffer->import();
643         EXPECT_TRUE(import1);
644         EXPECT_TRUE(import2);
645         EXPECT_NE(*import1, *import2);
646     }
647 }
648 
649 /**
650  * Test IMapper::importBuffer and IMapper::freeBuffer cross mapper instances.
651  */
TEST_P(GraphicsMapperStableCTests,ImportFreeBufferSingleton)652 TEST_P(GraphicsMapperStableCTests, ImportFreeBufferSingleton) {
653     auto buffer = allocate({
654             .name = {"VTS_TEMP"},
655             .width = 64,
656             .height = 64,
657             .layerCount = 1,
658             .format = PixelFormat::RGBA_8888,
659             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
660             .reservedSize = 0,
661     });
662     ASSERT_NE(nullptr, buffer.get());
663     EXPECT_GE(buffer->stride(), 64);
664 
665     buffer_handle_t bufferHandle = nullptr;
666     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.importBuffer(buffer->rawHandle(), &bufferHandle));
667     ASSERT_NE(nullptr, bufferHandle);
668 
669     AIMapper* secondMapper;
670     ASSERT_EQ(AIMAPPER_ERROR_NONE, getIMapperLoader()(&secondMapper));
671     ASSERT_EQ(AIMAPPER_ERROR_NONE, secondMapper->v5.freeBuffer(bufferHandle));
672 }
673 
674 /**
675  * Test IMapper::importBuffer with invalid buffers.
676  */
TEST_P(GraphicsMapperStableCTests,ImportBufferNegative)677 TEST_P(GraphicsMapperStableCTests, ImportBufferNegative) {
678     native_handle_t* invalidHandle = nullptr;
679     buffer_handle_t bufferHandle = nullptr;
680     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.importBuffer(invalidHandle, &bufferHandle))
681             << "importBuffer with nullptr did not fail with BAD_BUFFER";
682 
683     invalidHandle = native_handle_create(0, 0);
684     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.importBuffer(invalidHandle, &bufferHandle))
685             << "importBuffer with invalid handle did not fail with BAD_BUFFER";
686     native_handle_delete(invalidHandle);
687 }
688 
689 /**
690  * Test IMapper::freeBuffer with invalid buffers.
691  */
TEST_P(GraphicsMapperStableCTests,FreeBufferNegative)692 TEST_P(GraphicsMapperStableCTests, FreeBufferNegative) {
693     native_handle_t* bufferHandle = nullptr;
694     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.freeBuffer(bufferHandle))
695             << "freeBuffer with nullptr did not fail with BAD_BUFFER";
696 
697     bufferHandle = native_handle_create(0, 0);
698     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.freeBuffer(bufferHandle))
699             << "freeBuffer with invalid handle did not fail with BAD_BUFFER";
700     native_handle_delete(bufferHandle);
701 
702     auto buffer = allocateGeneric();
703     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.freeBuffer(buffer->rawHandle()))
704             << "freeBuffer with un-imported handle did not fail with BAD_BUFFER";
705 }
706 
707 /**
708  * Test IMapper::lock and IMapper::unlock.
709  */
TEST_P(GraphicsMapperStableCTests,LockUnlockBasic)710 TEST_P(GraphicsMapperStableCTests, LockUnlockBasic) {
711     constexpr auto usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN;
712     auto buffer = allocate({
713             .name = {"VTS_TEMP"},
714             .width = 64,
715             .height = 64,
716             .layerCount = 1,
717             .format = PixelFormat::RGBA_8888,
718             .usage = usage,
719             .reservedSize = 0,
720     });
721     ASSERT_NE(nullptr, buffer.get());
722 
723     // lock buffer for writing
724     const auto& info = buffer->info();
725     const auto stride = buffer->stride();
726     const ARect region{0, 0, info.width, info.height};
727     auto handle = buffer->import();
728     uint8_t* data = nullptr;
729     ASSERT_EQ(AIMAPPER_ERROR_NONE,
730               mapper()->v5.lock(*handle, static_cast<int64_t>(usage), region, -1, (void**)&data));
731 
732     // RGBA_8888
733     fillRGBA8888(data, info.height, stride * 4, info.width * 4);
734 
735     int releaseFence = -1;
736     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
737 
738     // lock again for reading
739     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(usage), region,
740                                                      releaseFence, (void**)&data));
741     releaseFence = -1;
742 
743     ASSERT_NO_FATAL_FAILURE(verifyRGBA8888(*handle, data, info.height, stride * 4, info.width * 4));
744 
745     releaseFence = -1;
746     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
747     if (releaseFence != -1) {
748         close(releaseFence);
749     }
750 }
751 
752 /**
753  *  Test multiple operations associated with different color formats
754  */
TEST_P(GraphicsMapperStableCTests,Lock_YCRCB_420_SP)755 TEST_P(GraphicsMapperStableCTests, Lock_YCRCB_420_SP) {
756     BufferDescriptorInfo info{
757             .name = {"VTS_TEMP"},
758             .width = 64,
759             .height = 64,
760             .layerCount = 1,
761             .format = PixelFormat::YCRCB_420_SP,
762             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
763             .reservedSize = 0,
764     };
765     auto buffer = allocate(info);
766     if (!buffer) {
767         ASSERT_FALSE(isSupported(info));
768         GTEST_SUCCEED() << "YCRCB_420_SP format is unsupported";
769         return;
770     }
771 
772     // lock buffer for writing
773     const ARect region{0, 0, info.width, info.height};
774     auto handle = buffer->import();
775     uint8_t* data = nullptr;
776     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
777                                                      region, -1, (void**)&data));
778 
779     android_ycbcr yCbCr;
780     int64_t hSubsampling = 0;
781     int64_t vSubsampling = 0;
782     ASSERT_NO_FATAL_FAILURE(getAndroidYCbCr(*handle, data, &yCbCr, &hSubsampling, &vSubsampling));
783 
784     constexpr uint32_t kCbCrSubSampleFactor = 2;
785     ASSERT_EQ(kCbCrSubSampleFactor, hSubsampling);
786     ASSERT_EQ(kCbCrSubSampleFactor, vSubsampling);
787 
788     auto cbData = static_cast<uint8_t*>(yCbCr.cb);
789     auto crData = static_cast<uint8_t*>(yCbCr.cr);
790     ASSERT_EQ(crData + 1, cbData);
791     ASSERT_EQ(2, yCbCr.chroma_step);
792 
793     fillYCbCrData(yCbCr, info.width, info.height, hSubsampling, vSubsampling);
794 
795     int releaseFence = -1;
796     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
797 
798     // lock again for reading
799     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
800                                                      region, releaseFence, (void**)&data));
801     releaseFence = -1;
802 
803     ASSERT_NO_FATAL_FAILURE(getAndroidYCbCr(*handle, data, &yCbCr, &hSubsampling, &vSubsampling));
804 
805     verifyYCbCrData(yCbCr, info.width, info.height, hSubsampling, vSubsampling);
806 
807     releaseFence = -1;
808     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
809     if (releaseFence != -1) {
810         close(releaseFence);
811     }
812 }
813 
TEST_P(GraphicsMapperStableCTests,YV12SubsampleMetadata)814 TEST_P(GraphicsMapperStableCTests, YV12SubsampleMetadata) {
815     BufferDescriptorInfo info{
816             .name = {"VTS_TEMP"},
817             .width = 64,
818             .height = 64,
819             .layerCount = 1,
820             .format = PixelFormat::YV12,
821             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
822             .reservedSize = 0,
823     };
824     auto buffer = allocate(info);
825     ASSERT_NE(nullptr, buffer.get());
826 
827     // lock buffer for writing
828     const ARect region{0, 0, info.width, info.height};
829     auto handle = buffer->import();
830     uint8_t* data = nullptr;
831     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
832                                                      region, -1, (void**)&data));
833 
834     auto decodeResult = getStandardMetadata<StandardMetadataType::PLANE_LAYOUTS>(*handle);
835     ASSERT_TRUE(decodeResult.has_value());
836     const auto& planeLayouts = *decodeResult;
837 
838     ASSERT_EQ(3, planeLayouts.size());
839 
840     auto yPlane = planeLayouts[0];
841     auto crPlane = planeLayouts[1];
842     auto cbPlane = planeLayouts[2];
843 
844     constexpr uint32_t kCbCrSubSampleFactor = 2;
845     EXPECT_EQ(kCbCrSubSampleFactor, crPlane.horizontalSubsampling);
846     EXPECT_EQ(kCbCrSubSampleFactor, crPlane.verticalSubsampling);
847 
848     EXPECT_EQ(kCbCrSubSampleFactor, cbPlane.horizontalSubsampling);
849     EXPECT_EQ(kCbCrSubSampleFactor, cbPlane.verticalSubsampling);
850 
851     const long chromaSampleWidth = info.width / kCbCrSubSampleFactor;
852     const long chromaSampleHeight = info.height / kCbCrSubSampleFactor;
853 
854     EXPECT_EQ(info.width, yPlane.widthInSamples);
855     EXPECT_EQ(info.height, yPlane.heightInSamples);
856 
857     EXPECT_EQ(chromaSampleWidth, crPlane.widthInSamples);
858     EXPECT_EQ(chromaSampleHeight, crPlane.heightInSamples);
859 
860     EXPECT_EQ(chromaSampleWidth, cbPlane.widthInSamples);
861     EXPECT_EQ(chromaSampleHeight, cbPlane.heightInSamples);
862 
863     EXPECT_LE(crPlane.widthInSamples, crPlane.strideInBytes);
864     EXPECT_LE(cbPlane.widthInSamples, cbPlane.strideInBytes);
865 
866     int releaseFence = -1;
867     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
868     if (releaseFence != -1) {
869         close(releaseFence);
870     }
871 }
872 
TEST_P(GraphicsMapperStableCTests,Lock_YV12)873 TEST_P(GraphicsMapperStableCTests, Lock_YV12) {
874     BufferDescriptorInfo info{
875             .name = {"VTS_TEMP"},
876             .width = 64,
877             .height = 64,
878             .layerCount = 1,
879             .format = PixelFormat::YV12,
880             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
881             .reservedSize = 0,
882     };
883     auto buffer = allocate(info);
884     ASSERT_NE(nullptr, buffer.get());
885 
886     // lock buffer for writing
887     const ARect region{0, 0, info.width, info.height};
888     auto handle = buffer->import();
889     uint8_t* data = nullptr;
890     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
891                                                      region, -1, (void**)&data));
892 
893     android_ycbcr yCbCr;
894     int64_t hSubsampling = 0;
895     int64_t vSubsampling = 0;
896     ASSERT_NO_FATAL_FAILURE(getAndroidYCbCr(*handle, data, &yCbCr, &hSubsampling, &vSubsampling));
897 
898     constexpr uint32_t kCbCrSubSampleFactor = 2;
899     ASSERT_EQ(kCbCrSubSampleFactor, hSubsampling);
900     ASSERT_EQ(kCbCrSubSampleFactor, vSubsampling);
901 
902     auto cbData = static_cast<uint8_t*>(yCbCr.cb);
903     auto crData = static_cast<uint8_t*>(yCbCr.cr);
904     ASSERT_EQ(crData + yCbCr.cstride * info.height / vSubsampling, cbData);
905     ASSERT_EQ(1, yCbCr.chroma_step);
906 
907     fillYCbCrData(yCbCr, info.width, info.height, hSubsampling, vSubsampling);
908 
909     int releaseFence = -1;
910     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
911 
912     // lock again for reading
913     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
914                                                      region, releaseFence, (void**)&data));
915     releaseFence = -1;
916 
917     ASSERT_NO_FATAL_FAILURE(getAndroidYCbCr(*handle, data, &yCbCr, &hSubsampling, &vSubsampling));
918 
919     verifyYCbCrData(yCbCr, info.width, info.height, hSubsampling, vSubsampling);
920 
921     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
922     if (releaseFence != -1) {
923         close(releaseFence);
924     }
925 }
926 
TEST_P(GraphicsMapperStableCTests,Lock_YCBCR_420_888)927 TEST_P(GraphicsMapperStableCTests, Lock_YCBCR_420_888) {
928     BufferDescriptorInfo info{
929             .name = {"VTS_TEMP"},
930             .width = 64,
931             .height = 64,
932             .layerCount = 1,
933             .format = PixelFormat::YCBCR_420_888,
934             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
935             .reservedSize = 0,
936     };
937     auto buffer = allocate(info);
938     ASSERT_NE(nullptr, buffer.get());
939 
940     // lock buffer for writing
941     const ARect region{0, 0, info.width, info.height};
942     auto handle = buffer->import();
943     uint8_t* data = nullptr;
944     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
945                                                      region, -1, (void**)&data));
946 
947     android_ycbcr yCbCr;
948     int64_t hSubsampling = 0;
949     int64_t vSubsampling = 0;
950     ASSERT_NO_FATAL_FAILURE(getAndroidYCbCr(*handle, data, &yCbCr, &hSubsampling, &vSubsampling));
951 
952     constexpr uint32_t kCbCrSubSampleFactor = 2;
953     ASSERT_EQ(kCbCrSubSampleFactor, hSubsampling);
954     ASSERT_EQ(kCbCrSubSampleFactor, vSubsampling);
955 
956     fillYCbCrData(yCbCr, info.width, info.height, hSubsampling, vSubsampling);
957 
958     int releaseFence = -1;
959     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
960 
961     // lock again for reading
962     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
963                                                      region, releaseFence, (void**)&data));
964     releaseFence = -1;
965 
966     ASSERT_NO_FATAL_FAILURE(getAndroidYCbCr(*handle, data, &yCbCr, &hSubsampling, &vSubsampling));
967 
968     verifyYCbCrData(yCbCr, info.width, info.height, hSubsampling, vSubsampling);
969 
970     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
971     if (releaseFence != -1) {
972         close(releaseFence);
973     }
974 }
975 
TEST_P(GraphicsMapperStableCTests,Lock_RAW10)976 TEST_P(GraphicsMapperStableCTests, Lock_RAW10) {
977     BufferDescriptorInfo info{
978             .name = {"VTS_TEMP"},
979             .width = 64,
980             .height = 64,
981             .layerCount = 1,
982             .format = PixelFormat::RAW10,
983             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
984             .reservedSize = 0,
985     };
986     auto buffer = allocate(info);
987     if (!buffer) {
988         ASSERT_FALSE(isSupported(info));
989         GTEST_SUCCEED() << "RAW10 format is unsupported";
990         return;
991     }
992 
993     // lock buffer for writing
994     const ARect region{0, 0, info.width, info.height};
995     auto handle = buffer->import();
996     uint8_t* data = nullptr;
997     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
998                                                      region, -1, (void**)&data));
999 
1000     auto decodeResult = getStandardMetadata<StandardMetadataType::PLANE_LAYOUTS>(*handle);
1001     ASSERT_TRUE(decodeResult.has_value());
1002     const auto& planeLayouts = *decodeResult;
1003 
1004     ASSERT_EQ(1, planeLayouts.size());
1005     auto planeLayout = planeLayouts[0];
1006 
1007     EXPECT_EQ(0, planeLayout.sampleIncrementInBits);
1008     EXPECT_EQ(1, planeLayout.horizontalSubsampling);
1009     EXPECT_EQ(1, planeLayout.verticalSubsampling);
1010 
1011     ASSERT_EQ(1, planeLayout.components.size());
1012     auto planeLayoutComponent = planeLayout.components[0];
1013 
1014     EXPECT_EQ(PlaneLayoutComponentType::RAW,
1015               static_cast<PlaneLayoutComponentType>(planeLayoutComponent.type.value));
1016     EXPECT_EQ(0, planeLayoutComponent.offsetInBits % 8);
1017     EXPECT_EQ(-1, planeLayoutComponent.sizeInBits);
1018 
1019     int releaseFence = -1;
1020     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
1021     if (releaseFence != -1) {
1022         close(releaseFence);
1023     }
1024 }
1025 
TEST_P(GraphicsMapperStableCTests,Lock_RAW12)1026 TEST_P(GraphicsMapperStableCTests, Lock_RAW12) {
1027     BufferDescriptorInfo info{
1028             .name = {"VTS_TEMP"},
1029             .width = 64,
1030             .height = 64,
1031             .layerCount = 1,
1032             .format = PixelFormat::RAW12,
1033             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
1034             .reservedSize = 0,
1035     };
1036     auto buffer = allocate(info);
1037     if (!buffer) {
1038         ASSERT_FALSE(isSupported(info));
1039         GTEST_SUCCEED() << "RAW12 format is unsupported";
1040         return;
1041     }
1042 
1043     // lock buffer for writing
1044     const ARect region{0, 0, info.width, info.height};
1045     auto handle = buffer->import();
1046     uint8_t* data = nullptr;
1047     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
1048                                                      region, -1, (void**)&data));
1049 
1050     auto decodeResult = getStandardMetadata<StandardMetadataType::PLANE_LAYOUTS>(*handle);
1051     ASSERT_TRUE(decodeResult.has_value());
1052     const auto& planeLayouts = *decodeResult;
1053 
1054     ASSERT_EQ(1, planeLayouts.size());
1055     auto planeLayout = planeLayouts[0];
1056 
1057     EXPECT_EQ(0, planeLayout.sampleIncrementInBits);
1058     EXPECT_EQ(1, planeLayout.horizontalSubsampling);
1059     EXPECT_EQ(1, planeLayout.verticalSubsampling);
1060 
1061     ASSERT_EQ(1, planeLayout.components.size());
1062     auto planeLayoutComponent = planeLayout.components[0];
1063 
1064     EXPECT_EQ(PlaneLayoutComponentType::RAW,
1065               static_cast<PlaneLayoutComponentType>(planeLayoutComponent.type.value));
1066     EXPECT_EQ(0, planeLayoutComponent.offsetInBits % 8);
1067     EXPECT_EQ(-1, planeLayoutComponent.sizeInBits);
1068 
1069     int releaseFence = -1;
1070     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
1071     if (releaseFence != -1) {
1072         close(releaseFence);
1073     }
1074 }
1075 
TEST_P(GraphicsMapperStableCTests,Lock_YCBCR_P010)1076 TEST_P(GraphicsMapperStableCTests, Lock_YCBCR_P010) {
1077     BufferDescriptorInfo info{
1078             .name = {"VTS_TEMP"},
1079             .width = 64,
1080             .height = 64,
1081             .layerCount = 1,
1082             .format = PixelFormat::YCBCR_P010,
1083             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
1084             .reservedSize = 0,
1085     };
1086     auto buffer = allocate(info);
1087     if (!buffer) {
1088         ASSERT_FALSE(isSupported(info));
1089         GTEST_SUCCEED() << "YCBCR_P010 format is unsupported";
1090         return;
1091     }
1092 
1093     // lock buffer for writing
1094     const ARect region{0, 0, info.width, info.height};
1095     auto handle = buffer->import();
1096     uint8_t* data = nullptr;
1097     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
1098                                                      region, -1, (void**)&data));
1099 
1100     YCbCr yCbCr;
1101     ASSERT_NO_FATAL_FAILURE(yCbCr = getAndroidYCbCr_P010(*handle, data));
1102 
1103     constexpr uint32_t kCbCrSubSampleFactor = 2;
1104     ASSERT_EQ(kCbCrSubSampleFactor, yCbCr.horizontalSubSampling);
1105     ASSERT_EQ(kCbCrSubSampleFactor, yCbCr.verticalSubSampling);
1106 
1107     ASSERT_EQ(0, info.height % 2);
1108 
1109     // fill the data
1110     fillYCbCrData(yCbCr.yCbCr, info.width, info.height, yCbCr.horizontalSubSampling,
1111                   yCbCr.verticalSubSampling);
1112     // verify the YCbCr data
1113     verifyYCbCrData(yCbCr.yCbCr, info.width, info.height, yCbCr.horizontalSubSampling,
1114                     yCbCr.verticalSubSampling);
1115 
1116     int releaseFence = -1;
1117     ASSERT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
1118     if (releaseFence != -1) {
1119         close(releaseFence);
1120     }
1121 }
1122 
TEST_P(GraphicsMapperStableCTests,LockBadAccessRegion)1123 TEST_P(GraphicsMapperStableCTests, LockBadAccessRegion) {
1124     auto buffer = allocateGeneric();
1125     ASSERT_NE(nullptr, buffer);
1126     const auto& info = buffer->info();
1127 
1128     // lock buffer for writing
1129     const ARect region{0, 0, info.width * 2, info.height * 2};
1130     auto handle = buffer->import();
1131     uint8_t* data = nullptr;
1132     EXPECT_EQ(AIMAPPER_ERROR_BAD_VALUE, mapper()->v5.lock(*handle, static_cast<int64_t>(info.usage),
1133                                                           region, -1, (void**)&data));
1134 }
1135 
TEST_P(GraphicsMapperStableCTests,UnlockNegative)1136 TEST_P(GraphicsMapperStableCTests, UnlockNegative) {
1137     native_handle_t* invalidHandle = nullptr;
1138     int releaseFence = -1;
1139     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.unlock(invalidHandle, &releaseFence))
1140             << "unlock with nullptr did not fail with BAD_BUFFER";
1141 
1142     invalidHandle = native_handle_create(0, 0);
1143     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.unlock(invalidHandle, &releaseFence))
1144             << "unlock with invalid handle did not fail with BAD_BUFFER";
1145     native_handle_delete(invalidHandle);
1146 
1147     auto buffer = allocateGeneric();
1148     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.unlock(buffer->rawHandle(), &releaseFence))
1149             << "unlock with un-imported handle did not fail with BAD_BUFFER";
1150 }
1151 
TEST_P(GraphicsMapperStableCTests,UnlockNotImported)1152 TEST_P(GraphicsMapperStableCTests, UnlockNotImported) {
1153     int releaseFence = -1;
1154     auto buffer = allocateGeneric();
1155     ASSERT_TRUE(buffer);
1156     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.unlock(buffer->rawHandle(), &releaseFence))
1157             << "unlock with un-imported handle did not fail with BAD_BUFFER";
1158 }
1159 
TEST_P(GraphicsMapperStableCTests,UnlockNotLocked)1160 TEST_P(GraphicsMapperStableCTests, UnlockNotLocked) {
1161     int releaseFence = -1;
1162     auto buffer = allocateGeneric();
1163     ASSERT_TRUE(buffer);
1164     auto bufferHandle = buffer->import();
1165     ASSERT_TRUE(bufferHandle);
1166     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.unlock(*bufferHandle, &releaseFence))
1167             << "unlock with unlocked handle did not fail with BAD_BUFFER";
1168 }
1169 
TEST_P(GraphicsMapperStableCTests,LockUnlockNested)1170 TEST_P(GraphicsMapperStableCTests, LockUnlockNested) {
1171     auto buffer = allocateGeneric();
1172     ASSERT_TRUE(buffer);
1173     auto bufferHandle = buffer->import();
1174     ASSERT_TRUE(bufferHandle);
1175     const ARect region{0, 0, buffer->info().width, buffer->info().height};
1176     auto usage = static_cast<int64_t>(buffer->info().usage);
1177     auto handle = buffer->import();
1178     uint8_t* data = nullptr;
1179     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, usage, region, -1, (void**)&data));
1180     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.lock(*handle, usage, region, -1, (void**)&data))
1181             << "Second lock failed";
1182     int releaseFence = -1;
1183     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence));
1184     if (releaseFence != -1) {
1185         close(releaseFence);
1186         releaseFence = -1;
1187     }
1188     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*handle, &releaseFence))
1189             << "Second unlock failed";
1190     if (releaseFence != -1) {
1191         close(releaseFence);
1192         releaseFence = -1;
1193     }
1194     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.unlock(*handle, &releaseFence))
1195             << "Third, unmatched, unlock should have failed with BAD_BUFFER";
1196 }
1197 
TEST_P(GraphicsMapperStableCTests,FlushRereadBasic)1198 TEST_P(GraphicsMapperStableCTests, FlushRereadBasic) {
1199     auto buffer = allocateGeneric();
1200     ASSERT_TRUE(buffer);
1201     auto bufferHandle = buffer->import();
1202     ASSERT_TRUE(bufferHandle);
1203     const auto& info = buffer->info();
1204     const auto stride = buffer->stride();
1205     const ARect region{0, 0, buffer->info().width, buffer->info().height};
1206 
1207     auto writeHandle = buffer->import();
1208     auto readHandle = buffer->import();
1209     ASSERT_TRUE(writeHandle && readHandle);
1210 
1211     // lock buffer for writing
1212 
1213     uint8_t* writeData;
1214     EXPECT_EQ(AIMAPPER_ERROR_NONE,
1215               mapper()->v5.lock(*writeHandle, static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN),
1216                                 region, -1, (void**)&writeData));
1217 
1218     uint8_t* readData;
1219     EXPECT_EQ(AIMAPPER_ERROR_NONE,
1220               mapper()->v5.lock(*readHandle, static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN),
1221                                 region, -1, (void**)&readData));
1222 
1223     fillRGBA8888(writeData, info.height, stride * 4, info.width * 4);
1224 
1225     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.flushLockedBuffer(*writeHandle));
1226     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.rereadLockedBuffer(*readHandle));
1227 
1228     ASSERT_NO_FATAL_FAILURE(
1229             verifyRGBA8888(*readHandle, readData, info.height, stride * 4, info.width * 4));
1230 
1231     int releaseFence = -1;
1232 
1233     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*readHandle, &releaseFence));
1234     if (releaseFence != -1) {
1235         close(releaseFence);
1236         releaseFence = -1;
1237     }
1238 
1239     EXPECT_EQ(AIMAPPER_ERROR_NONE, mapper()->v5.unlock(*writeHandle, &releaseFence));
1240     if (releaseFence != -1) {
1241         close(releaseFence);
1242         releaseFence = -1;
1243     }
1244 }
1245 
TEST_P(GraphicsMapperStableCTests,FlushLockedBufferBadBuffer)1246 TEST_P(GraphicsMapperStableCTests, FlushLockedBufferBadBuffer) {
1247     // Amazingly this is enough to make the compiler happy even though flushLockedBuffer
1248     // is _Nonnull :shrug:
1249     buffer_handle_t badBuffer = nullptr;
1250     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.flushLockedBuffer(badBuffer));
1251 }
1252 
TEST_P(GraphicsMapperStableCTests,RereadLockedBufferBadBuffer)1253 TEST_P(GraphicsMapperStableCTests, RereadLockedBufferBadBuffer) {
1254     buffer_handle_t badBuffer = nullptr;
1255     EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, mapper()->v5.rereadLockedBuffer(badBuffer));
1256 }
1257 
TEST_P(GraphicsMapperStableCTests,GetBufferId)1258 TEST_P(GraphicsMapperStableCTests, GetBufferId) {
1259     auto buffer = allocateGeneric();
1260     auto bufferHandle = buffer->import();
1261     auto bufferId = getStandardMetadata<StandardMetadataType::BUFFER_ID>(*bufferHandle);
1262     ASSERT_TRUE(bufferId.has_value());
1263 
1264     auto buffer2 = allocateGeneric();
1265     auto bufferHandle2 = buffer2->import();
1266     auto bufferId2 = getStandardMetadata<StandardMetadataType::BUFFER_ID>(*bufferHandle2);
1267     ASSERT_TRUE(bufferId2.has_value());
1268 
1269     EXPECT_NE(*bufferId, *bufferId2);
1270 }
1271 
TEST_P(GraphicsMapperStableCTests,GetName)1272 TEST_P(GraphicsMapperStableCTests, GetName) {
1273     auto buffer = allocate({
1274             .name = {"Hello, World!"},
1275             .width = 64,
1276             .height = 64,
1277             .layerCount = 1,
1278             .format = PixelFormat::RGBA_8888,
1279             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
1280             .reservedSize = 0,
1281     });
1282     auto bufferHandle = buffer->import();
1283     auto name = getStandardMetadata<StandardMetadataType::NAME>(*bufferHandle);
1284     ASSERT_TRUE(name.has_value());
1285     EXPECT_EQ(*name, "Hello, World!");
1286 }
1287 
TEST_P(GraphicsMapperStableCTests,GetWidthHeight)1288 TEST_P(GraphicsMapperStableCTests, GetWidthHeight) {
1289     auto buffer = allocate({
1290             .name = {"Hello, World!"},
1291             .width = 64,
1292             .height = 128,
1293             .layerCount = 1,
1294             .format = PixelFormat::RGBA_8888,
1295             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
1296             .reservedSize = 0,
1297     });
1298     auto bufferHandle = buffer->import();
1299     auto value = getStandardMetadata<StandardMetadataType::WIDTH>(*bufferHandle);
1300     ASSERT_TRUE(value.has_value());
1301     EXPECT_EQ(*value, 64);
1302     value = getStandardMetadata<StandardMetadataType::HEIGHT>(*bufferHandle);
1303     ASSERT_TRUE(value.has_value());
1304     EXPECT_EQ(*value, 128);
1305 }
1306 
TEST_P(GraphicsMapperStableCTests,GetLayerCount)1307 TEST_P(GraphicsMapperStableCTests, GetLayerCount) {
1308     auto buffer = allocateGeneric();
1309     auto bufferHandle = buffer->import();
1310     auto value = getStandardMetadata<StandardMetadataType::LAYER_COUNT>(*bufferHandle);
1311     ASSERT_TRUE(value.has_value());
1312     EXPECT_EQ(*value, buffer->info().layerCount);
1313 }
1314 
TEST_P(GraphicsMapperStableCTests,GetPixelFormatRequested)1315 TEST_P(GraphicsMapperStableCTests, GetPixelFormatRequested) {
1316     auto buffer = allocateGeneric();
1317     auto bufferHandle = buffer->import();
1318     auto value = getStandardMetadata<StandardMetadataType::PIXEL_FORMAT_REQUESTED>(*bufferHandle);
1319     ASSERT_TRUE(value.has_value());
1320     EXPECT_EQ(*value, buffer->info().format);
1321 }
1322 
TEST_P(GraphicsMapperStableCTests,GetPixelFormatFourCC)1323 TEST_P(GraphicsMapperStableCTests, GetPixelFormatFourCC) {
1324     auto buffer = allocate({
1325             .name = {"Hello, World!"},
1326             .width = 64,
1327             .height = 128,
1328             .layerCount = 1,
1329             .format = PixelFormat::RGBA_8888,
1330             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
1331             .reservedSize = 0,
1332     });
1333     {
1334         auto bufferHandle = buffer->import();
1335         auto value = getStandardMetadata<StandardMetadataType::PIXEL_FORMAT_FOURCC>(*bufferHandle);
1336         ASSERT_TRUE(value.has_value());
1337         EXPECT_EQ(*value, DRM_FORMAT_ABGR8888);
1338     }
1339 
1340     buffer = allocate({
1341             .name = {"yv12"},
1342             .width = 64,
1343             .height = 128,
1344             .layerCount = 1,
1345             .format = PixelFormat::YV12,
1346             .usage = BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN,
1347             .reservedSize = 0,
1348     });
1349     {
1350         auto bufferHandle = buffer->import();
1351         auto value = getStandardMetadata<StandardMetadataType::PIXEL_FORMAT_FOURCC>(*bufferHandle);
1352         ASSERT_TRUE(value.has_value());
1353         EXPECT_EQ(*value, DRM_FORMAT_YVU420);
1354     }
1355 }
1356 
TEST_P(GraphicsMapperStableCTests,GetPixelFormatModifier)1357 TEST_P(GraphicsMapperStableCTests, GetPixelFormatModifier) {
1358     auto buffer = allocateGeneric();
1359     auto bufferHandle = buffer->import();
1360     auto value = getStandardMetadata<StandardMetadataType::PIXEL_FORMAT_MODIFIER>(*bufferHandle);
1361     ASSERT_TRUE(value.has_value());
1362     // Only the upper 8-bits are defined and is just the vendor ID, the lower 56 bits are
1363     // then vendor specific. So there's not anything useful to assert here beyond just that
1364     // we successfully queried a value
1365 }
1366 
TEST_P(GraphicsMapperStableCTests,GetUsage)1367 TEST_P(GraphicsMapperStableCTests, GetUsage) {
1368     auto buffer = allocateGeneric();
1369     auto bufferHandle = buffer->import();
1370     auto value = getStandardMetadata<StandardMetadataType::USAGE>(*bufferHandle);
1371     ASSERT_TRUE(value.has_value());
1372     EXPECT_EQ(buffer->info().usage, *value);
1373 }
1374 
TEST_P(GraphicsMapperStableCTests,GetUsage64)1375 TEST_P(GraphicsMapperStableCTests, GetUsage64) {
1376     BufferDescriptorInfo info{
1377             .name = {"VTS_TEMP"},
1378             .width = 64,
1379             .height = 64,
1380             .layerCount = 1,
1381             .format = PixelFormat::RGBA_8888,
1382             .usage = BufferUsage::FRONT_BUFFER | BufferUsage::GPU_RENDER_TARGET |
1383                      BufferUsage::COMPOSER_OVERLAY | BufferUsage::GPU_TEXTURE,
1384             .reservedSize = 0,
1385     };
1386     if (!isSupported(info)) {
1387         GTEST_SKIP();
1388     }
1389     auto buffer = allocate(info);
1390     auto bufferHandle = buffer->import();
1391     auto value = getStandardMetadata<StandardMetadataType::USAGE>(*bufferHandle);
1392     ASSERT_TRUE(value.has_value());
1393     using T = std::underlying_type_t<BufferUsage>;
1394     EXPECT_EQ(static_cast<T>(buffer->info().usage), static_cast<T>(*value));
1395 }
1396 
TEST_P(GraphicsMapperStableCTests,GetAllocationSize)1397 TEST_P(GraphicsMapperStableCTests, GetAllocationSize) {
1398     auto buffer = allocateGeneric();
1399     auto bufferHandle = buffer->import();
1400     auto value = getStandardMetadata<StandardMetadataType::ALLOCATION_SIZE>(*bufferHandle);
1401     ASSERT_TRUE(value.has_value());
1402     const auto estimatedSize = buffer->stride() * buffer->info().height * 4;
1403     // This buffer has CPU usage, so we expect at least stride * height * 4 since it should be
1404     // generally linear uncompressed.
1405     EXPECT_GE(*value, estimatedSize)
1406             << "Expected allocation size to be at least stride * height * 4bpp";
1407     // Might need refining, but hopefully this a generous-enough upper-bound?
1408     EXPECT_LT(*value, estimatedSize * 2)
1409             << "Expected allocation size to less than double stride * height * 4bpp";
1410 }
1411 
TEST_P(GraphicsMapperStableCTests,GetProtectedContent)1412 TEST_P(GraphicsMapperStableCTests, GetProtectedContent) {
1413     const BufferDescriptorInfo info{
1414             .name = {"prot8888"},
1415             .width = 64,
1416             .height = 64,
1417             .layerCount = 1,
1418             .format = PixelFormat::RGBA_8888,
1419             .usage = BufferUsage::PROTECTED | BufferUsage::COMPOSER_OVERLAY,
1420             .reservedSize = 0,
1421     };
1422     auto buffer = allocate(info);
1423     if (!buffer) {
1424         ASSERT_FALSE(isSupported(info))
1425                 << "Allocation of trivial sized buffer failed, so isSupported() must be false";
1426         GTEST_SUCCEED() << "PROTECTED RGBA_8888 is unsupported";
1427         return;
1428     }
1429     auto bufferHandle = buffer->import();
1430     auto value = getStandardMetadata<StandardMetadataType::PROTECTED_CONTENT>(*bufferHandle);
1431     ASSERT_TRUE(value.has_value());
1432     EXPECT_EQ(*value, 1);
1433 }
1434 
TEST_P(GraphicsMapperStableCTests,GetCompression)1435 TEST_P(GraphicsMapperStableCTests, GetCompression) {
1436     auto buffer = allocateGeneric();
1437     ASSERT_TRUE(buffer);
1438     auto bufferHandle = buffer->import();
1439     ASSERT_TRUE(bufferHandle);
1440     auto value = getStandardMetadata<StandardMetadataType::COMPRESSION>(*bufferHandle);
1441     ASSERT_TRUE(value.has_value());
1442     EXPECT_EQ(gralloc4::Compression_None.name, value->name);
1443     EXPECT_EQ(gralloc4::Compression_None.value, value->value);
1444 }
1445 
TEST_P(GraphicsMapperStableCTests,GetInterlaced)1446 TEST_P(GraphicsMapperStableCTests, GetInterlaced) {
1447     auto buffer = allocateGeneric();
1448     ASSERT_TRUE(buffer);
1449     auto bufferHandle = buffer->import();
1450     ASSERT_TRUE(bufferHandle);
1451     auto value = getStandardMetadata<StandardMetadataType::INTERLACED>(*bufferHandle);
1452     ASSERT_TRUE(value.has_value());
1453     EXPECT_EQ(gralloc4::Interlaced_None.name, value->name);
1454     EXPECT_EQ(gralloc4::Interlaced_None.value, value->value);
1455 }
1456 
TEST_P(GraphicsMapperStableCTests,GetChromaSiting)1457 TEST_P(GraphicsMapperStableCTests, GetChromaSiting) {
1458     auto buffer = allocateGeneric();
1459     ASSERT_TRUE(buffer);
1460     auto bufferHandle = buffer->import();
1461     ASSERT_TRUE(bufferHandle);
1462     auto value = getStandardMetadata<StandardMetadataType::CHROMA_SITING>(*bufferHandle);
1463     ASSERT_TRUE(value.has_value());
1464     EXPECT_EQ(gralloc4::ChromaSiting_None.name, value->name);
1465     EXPECT_EQ(gralloc4::ChromaSiting_None.value, value->value);
1466 }
1467 
TEST_P(GraphicsMapperStableCTests,GetPlaneLayouts)1468 TEST_P(GraphicsMapperStableCTests, GetPlaneLayouts) {
1469     auto buffer = allocateGeneric();
1470     ASSERT_TRUE(buffer);
1471     auto bufferHandle = buffer->import();
1472     ASSERT_TRUE(bufferHandle);
1473     auto value = getStandardMetadata<StandardMetadataType::PLANE_LAYOUTS>(*bufferHandle);
1474     ASSERT_TRUE(value.has_value());
1475     ASSERT_NO_FATAL_FAILURE(verifyRGBA8888PlaneLayouts(*value));
1476 }
1477 
TEST_P(GraphicsMapperStableCTests,GetCrop)1478 TEST_P(GraphicsMapperStableCTests, GetCrop) {
1479     auto buffer = allocateGeneric();
1480     ASSERT_TRUE(buffer);
1481     auto bufferHandle = buffer->import();
1482     ASSERT_TRUE(bufferHandle);
1483     auto value = getStandardMetadata<StandardMetadataType::CROP>(*bufferHandle);
1484     ASSERT_TRUE(value.has_value());
1485     EXPECT_EQ(1, value->size());
1486     const Rect expected{0, 0, buffer->info().width, buffer->info().height};
1487     EXPECT_EQ(expected, value->at(0));
1488 }
1489 
TEST_P(GraphicsMapperStableCTests,GetSetDataspace)1490 TEST_P(GraphicsMapperStableCTests, GetSetDataspace) {
1491     auto buffer = allocateGeneric();
1492     ASSERT_TRUE(buffer);
1493     auto bufferHandle = buffer->import();
1494     ASSERT_TRUE(bufferHandle);
1495     auto value = getStandardMetadata<StandardMetadataType::DATASPACE>(*bufferHandle);
1496     ASSERT_TRUE(value.has_value());
1497     EXPECT_EQ(Dataspace::UNKNOWN, *value);
1498     EXPECT_EQ(AIMAPPER_ERROR_NONE, setStandardMetadata<StandardMetadataType::DATASPACE>(
1499                                            *bufferHandle, Dataspace::DISPLAY_P3));
1500     value = getStandardMetadata<StandardMetadataType::DATASPACE>(*bufferHandle);
1501     ASSERT_TRUE(value.has_value());
1502     EXPECT_EQ(Dataspace::DISPLAY_P3, *value);
1503 }
1504 
TEST_P(GraphicsMapperStableCTests,GetSetBlendMode)1505 TEST_P(GraphicsMapperStableCTests, GetSetBlendMode) {
1506     auto buffer = allocateGeneric();
1507     ASSERT_TRUE(buffer);
1508     auto bufferHandle = buffer->import();
1509     ASSERT_TRUE(bufferHandle);
1510     auto value = getStandardMetadata<StandardMetadataType::BLEND_MODE>(*bufferHandle);
1511     ASSERT_TRUE(value.has_value());
1512     EXPECT_EQ(BlendMode::INVALID, *value);
1513     EXPECT_EQ(AIMAPPER_ERROR_NONE, setStandardMetadata<StandardMetadataType::BLEND_MODE>(
1514                                            *bufferHandle, BlendMode::COVERAGE));
1515     value = getStandardMetadata<StandardMetadataType::BLEND_MODE>(*bufferHandle);
1516     ASSERT_TRUE(value.has_value());
1517     EXPECT_EQ(BlendMode::COVERAGE, *value);
1518 }
1519 
TEST_P(GraphicsMapperStableCTests,GetSetSmpte2086)1520 TEST_P(GraphicsMapperStableCTests, GetSetSmpte2086) {
1521     auto buffer = allocateGeneric();
1522     ASSERT_TRUE(buffer);
1523     auto bufferHandle = buffer->import();
1524     ASSERT_TRUE(bufferHandle);
1525     auto value = getStandardMetadata<StandardMetadataType::SMPTE2086>(*bufferHandle);
1526     ASSERT_TRUE(value.has_value());
1527     EXPECT_FALSE(value->has_value());
1528 
1529     // TODO: Maybe use something resembling real values, but validation isn't supposed to happen
1530     // here anyway so :shrug:
1531     const Smpte2086 awesomeHdr{
1532             XyColor{1.f, 1.f},      XyColor{2.f, 2.f}, XyColor{3.f, 3.f},
1533             XyColor{400.f, 1000.f}, 100000.0f,         0.0001f,
1534     };
1535     EXPECT_EQ(AIMAPPER_ERROR_NONE,
1536               setStandardMetadata<StandardMetadataType::SMPTE2086>(*bufferHandle, awesomeHdr));
1537     value = getStandardMetadata<StandardMetadataType::SMPTE2086>(*bufferHandle);
1538     ASSERT_TRUE(value.has_value());
1539     ASSERT_TRUE(value->has_value());
1540     EXPECT_EQ(awesomeHdr, *value);
1541 
1542     EXPECT_EQ(AIMAPPER_ERROR_NONE,
1543               setStandardMetadata<StandardMetadataType::SMPTE2086>(*bufferHandle, std::nullopt));
1544     value = getStandardMetadata<StandardMetadataType::SMPTE2086>(*bufferHandle);
1545     ASSERT_TRUE(value.has_value());
1546     EXPECT_FALSE(value->has_value());
1547 }
1548 
TEST_P(GraphicsMapperStableCTests,GetCta861_3)1549 TEST_P(GraphicsMapperStableCTests, GetCta861_3) {
1550     auto buffer = allocateGeneric();
1551     ASSERT_TRUE(buffer);
1552     auto bufferHandle = buffer->import();
1553     ASSERT_TRUE(bufferHandle);
1554     auto value = getStandardMetadata<StandardMetadataType::CTA861_3>(*bufferHandle);
1555     ASSERT_TRUE(value.has_value());
1556     EXPECT_FALSE(value->has_value());
1557 
1558     const Cta861_3 genericHlgish{1000.f, 140.f};
1559     EXPECT_EQ(AIMAPPER_ERROR_NONE,
1560               setStandardMetadata<StandardMetadataType::CTA861_3>(*bufferHandle, genericHlgish));
1561     value = getStandardMetadata<StandardMetadataType::CTA861_3>(*bufferHandle);
1562     ASSERT_TRUE(value.has_value());
1563     ASSERT_TRUE(value->has_value());
1564     EXPECT_EQ(genericHlgish, *value);
1565 
1566     EXPECT_EQ(AIMAPPER_ERROR_NONE,
1567               setStandardMetadata<StandardMetadataType::CTA861_3>(*bufferHandle, std::nullopt));
1568     value = getStandardMetadata<StandardMetadataType::CTA861_3>(*bufferHandle);
1569     ASSERT_TRUE(value.has_value());
1570     EXPECT_FALSE(value->has_value());
1571 }
1572 
TEST_P(GraphicsMapperStableCTests,GetSmpte2094_10)1573 TEST_P(GraphicsMapperStableCTests, GetSmpte2094_10) {
1574     auto buffer = allocateGeneric();
1575     ASSERT_TRUE(buffer);
1576     auto bufferHandle = buffer->import();
1577     ASSERT_TRUE(bufferHandle);
1578     auto value = getStandardMetadata<StandardMetadataType::SMPTE2094_10>(*bufferHandle);
1579     if (value.has_value()) {
1580         EXPECT_FALSE(value->has_value());
1581     }
1582 }
1583 
TEST_P(GraphicsMapperStableCTests,GetSmpte2094_40)1584 TEST_P(GraphicsMapperStableCTests, GetSmpte2094_40) {
1585     auto buffer = allocateGeneric();
1586     ASSERT_TRUE(buffer);
1587     auto bufferHandle = buffer->import();
1588     ASSERT_TRUE(bufferHandle);
1589     auto value = getStandardMetadata<StandardMetadataType::SMPTE2094_40>(*bufferHandle);
1590     if (value.has_value()) {
1591         EXPECT_FALSE(value->has_value());
1592     }
1593 }
1594 
TEST_P(GraphicsMapperStableCTests,GetStride)1595 TEST_P(GraphicsMapperStableCTests, GetStride) {
1596     auto buffer = allocateGeneric();
1597     ASSERT_TRUE(buffer);
1598     auto bufferHandle = buffer->import();
1599     ASSERT_TRUE(bufferHandle);
1600     auto value = getStandardMetadata<StandardMetadataType::STRIDE>(*bufferHandle);
1601     ASSERT_TRUE(value.has_value());
1602     EXPECT_EQ(buffer->stride(), *value);
1603 }
1604 
TEST_P(GraphicsMapperStableCTests,SupportsRequiredGettersSetters)1605 TEST_P(GraphicsMapperStableCTests, SupportsRequiredGettersSetters) {
1606     auto buffer = allocateGeneric();
1607     ASSERT_TRUE(buffer);
1608     auto bufferHandle = buffer->import();
1609     ASSERT_TRUE(bufferHandle);
1610     const AIMapper_MetadataTypeDescription* descriptions = nullptr;
1611     size_t descriptionCount = 0;
1612     ASSERT_EQ(AIMAPPER_ERROR_NONE,
1613               mapper()->v5.listSupportedMetadataTypes(&descriptions, &descriptionCount));
1614     std::vector<StandardMetadataType> requiredGetters = {
1615             StandardMetadataType::BUFFER_ID,
1616             StandardMetadataType::NAME,
1617             StandardMetadataType::WIDTH,
1618             StandardMetadataType::HEIGHT,
1619             StandardMetadataType::LAYER_COUNT,
1620             StandardMetadataType::PIXEL_FORMAT_REQUESTED,
1621             StandardMetadataType::PIXEL_FORMAT_FOURCC,
1622             StandardMetadataType::PIXEL_FORMAT_MODIFIER,
1623             StandardMetadataType::USAGE,
1624             StandardMetadataType::ALLOCATION_SIZE,
1625             StandardMetadataType::PROTECTED_CONTENT,
1626             StandardMetadataType::COMPRESSION,
1627             StandardMetadataType::INTERLACED,
1628             StandardMetadataType::CHROMA_SITING,
1629             StandardMetadataType::PLANE_LAYOUTS,
1630             StandardMetadataType::CROP,
1631             StandardMetadataType::DATASPACE,
1632             StandardMetadataType::BLEND_MODE,
1633             StandardMetadataType::SMPTE2086,
1634             StandardMetadataType::CTA861_3,
1635             StandardMetadataType::STRIDE,
1636     };
1637 
1638     std::vector<StandardMetadataType> requiredSetters = {
1639             StandardMetadataType::DATASPACE,
1640             StandardMetadataType::BLEND_MODE,
1641             StandardMetadataType::SMPTE2086,
1642             StandardMetadataType::CTA861_3,
1643     };
1644 
1645     for (int i = 0; i < descriptionCount; i++) {
1646         const auto& it = descriptions[i];
1647         if (isStandardMetadata(it.metadataType)) {
1648             EXPECT_GT(it.metadataType.value, static_cast<int64_t>(StandardMetadataType::INVALID));
1649             EXPECT_LT(it.metadataType.value,
1650                       ndk::internal::enum_values<StandardMetadataType>.size());
1651 
1652             if (it.isGettable) {
1653                 std::erase(requiredGetters,
1654                            static_cast<StandardMetadataType>(it.metadataType.value));
1655             }
1656             if (it.isSettable) {
1657                 std::erase(requiredSetters,
1658                            static_cast<StandardMetadataType>(it.metadataType.value));
1659             }
1660         } else {
1661             EXPECT_NE(nullptr, it.description) << "Non-standard metadata must have a description";
1662             int len = strlen(it.description);
1663             EXPECT_GE(len, 0) << "Non-standard metadata must have a description";
1664         }
1665     }
1666 
1667     EXPECT_EQ(0, requiredGetters.size()) << "Missing required getters" << toString(requiredGetters);
1668     EXPECT_EQ(0, requiredSetters.size()) << "Missing required setters" << toString(requiredSetters);
1669 }
1670 
1671 /*
1672  * Test that verifies that if the optional StandardMetadataTypes have getters, they have
1673  * the required setters as well
1674  */
TEST_P(GraphicsMapperStableCTests,CheckRequiredSettersIfHasGetters)1675 TEST_P(GraphicsMapperStableCTests, CheckRequiredSettersIfHasGetters) {
1676     auto buffer = allocateGeneric();
1677     ASSERT_TRUE(buffer);
1678     auto bufferHandle = buffer->import();
1679     ASSERT_TRUE(bufferHandle);
1680     const AIMapper_MetadataTypeDescription* descriptions = nullptr;
1681     size_t descriptionCount = 0;
1682     ASSERT_EQ(AIMAPPER_ERROR_NONE,
1683               mapper()->v5.listSupportedMetadataTypes(&descriptions, &descriptionCount));
1684 
1685     for (int i = 0; i < descriptionCount; i++) {
1686         const auto& it = descriptions[i];
1687         if (isStandardMetadata(it.metadataType)) {
1688             const auto type = static_cast<StandardMetadataType>(it.metadataType.value);
1689             switch (type) {
1690                 case StandardMetadataType::SMPTE2094_10:
1691                 case StandardMetadataType::SMPTE2094_40:
1692                     if (it.isGettable) {
1693                         EXPECT_TRUE(it.isSettable)
1694                                 << "Type " << toString(type) << " must be settable if gettable";
1695                     }
1696                     break;
1697                 default:
1698                     break;
1699             }
1700         }
1701     }
1702 }
1703 
TEST_P(GraphicsMapperStableCTests,ListSupportedWorks)1704 TEST_P(GraphicsMapperStableCTests, ListSupportedWorks) {
1705     auto buffer = allocateGeneric();
1706     ASSERT_TRUE(buffer);
1707     auto bufferHandle = buffer->import();
1708     ASSERT_TRUE(bufferHandle);
1709     const AIMapper_MetadataTypeDescription* descriptions = nullptr;
1710     size_t descriptionCount = 0;
1711     ASSERT_EQ(AIMAPPER_ERROR_NONE,
1712               mapper()->v5.listSupportedMetadataTypes(&descriptions, &descriptionCount));
1713 
1714     std::vector<uint8_t> metadataBuffer;
1715     auto get = [&](AIMapper_MetadataType metadataType) -> int32_t {
1716         int32_t size = mapper()->v5.getMetadata(*bufferHandle, metadataType, nullptr, 0);
1717         if (size >= 0) {
1718             metadataBuffer.resize(size);
1719             size = mapper()->v5.getMetadata(*bufferHandle, metadataType, metadataBuffer.data(),
1720                                             metadataBuffer.size());
1721             EXPECT_EQ(size, metadataBuffer.size());
1722         }
1723         return size;
1724     };
1725 
1726     for (int i = 0; i < descriptionCount; i++) {
1727         const auto& it = descriptions[i];
1728         if (!isStandardMetadata(it.metadataType)) {
1729             continue;
1730         }
1731         if (!it.isGettable) {
1732             EXPECT_FALSE(it.isSettable)
1733                     << "StandardMetadata that isn't gettable must not be settable";
1734             continue;
1735         }
1736         EXPECT_GE(get(it.metadataType), 0)
1737                 << "Get failed for claimed supported getter of "
1738                 << toString(static_cast<StandardMetadataType>(it.metadataType.value));
1739         if (it.isSettable) {
1740             EXPECT_EQ(AIMAPPER_ERROR_NONE,
1741                       mapper()->v5.setMetadata(*bufferHandle, it.metadataType,
1742                                                metadataBuffer.data(), metadataBuffer.size()))
1743                     << "Failed to set metadata for "
1744                     << toString(static_cast<StandardMetadataType>(it.metadataType.value));
1745         }
1746     }
1747 }
1748 
TEST_P(GraphicsMapperStableCTests,GetMetadataBadValue)1749 TEST_P(GraphicsMapperStableCTests, GetMetadataBadValue) {
1750     auto get = [this](StandardMetadataType type) -> AIMapper_Error {
1751         // This is a _Nonnull parameter, but this is enough obfuscation to fool the linter
1752         buffer_handle_t buffer = nullptr;
1753         int32_t ret =
1754                 mapper()->v5.getStandardMetadata(buffer, static_cast<int64_t>(type), nullptr, 0);
1755         return (ret < 0) ? (AIMapper_Error)-ret : AIMAPPER_ERROR_NONE;
1756     };
1757 
1758     for (auto type : ndk::enum_range<StandardMetadataType>()) {
1759         if (type == StandardMetadataType::INVALID) {
1760             continue;
1761         }
1762         EXPECT_EQ(AIMAPPER_ERROR_BAD_BUFFER, get(type)) << "Wrong error for " << toString(type);
1763     }
1764 }
1765 
TEST_P(GraphicsMapperStableCTests,GetUnsupportedMetadata)1766 TEST_P(GraphicsMapperStableCTests, GetUnsupportedMetadata) {
1767     auto buffer = allocateGeneric();
1768     ASSERT_TRUE(buffer);
1769     auto bufferHandle = buffer->import();
1770     ASSERT_TRUE(bufferHandle);
1771 
1772     int result = mapper()->v5.getMetadata(*bufferHandle, {"Fake", 1}, nullptr, 0);
1773     EXPECT_EQ(AIMAPPER_ERROR_UNSUPPORTED, -result);
1774 
1775     result = mapper()->v5.getStandardMetadata(
1776             *bufferHandle, static_cast<int64_t>(StandardMetadataType::INVALID), nullptr, 0);
1777     EXPECT_EQ(AIMAPPER_ERROR_UNSUPPORTED, -result);
1778 
1779     constexpr int64_t unknownStandardType = ndk::internal::enum_values<StandardMetadataType>.size();
1780     result = mapper()->v5.getStandardMetadata(*bufferHandle, unknownStandardType, nullptr, 0);
1781     EXPECT_EQ(AIMAPPER_ERROR_UNSUPPORTED, -result);
1782 }
1783 
getIAllocatorsAtLeastVersion(int32_t minVersion)1784 std::vector<std::tuple<std::string, std::shared_ptr<IAllocator>>> getIAllocatorsAtLeastVersion(
1785         int32_t minVersion) {
1786     auto instanceNames = getAidlHalInstanceNames(IAllocator::descriptor);
1787     std::vector<std::tuple<std::string, std::shared_ptr<IAllocator>>> filteredInstances;
1788     filteredInstances.reserve(instanceNames.size());
1789     for (const auto& name : instanceNames) {
1790         auto allocator =
1791                 IAllocator::fromBinder(ndk::SpAIBinder(AServiceManager_checkService(name.c_str())));
1792         int32_t version = 0;
1793         if (allocator->getInterfaceVersion(&version).isOk()) {
1794             if (version >= minVersion) {
1795                 filteredInstances.emplace_back(name, std::move(allocator));
1796             }
1797         }
1798     }
1799     return filteredInstances;
1800 }
1801 
1802 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsMapperStableCTests);
1803 INSTANTIATE_TEST_CASE_P(PerInstance, GraphicsMapperStableCTests,
1804                         testing::ValuesIn(getIAllocatorsAtLeastVersion(2)),
__anon3feb85e60502(auto info) 1805                         [](auto info) -> std::string {
1806                             std::string name =
1807                                     std::to_string(info.index) + "/" + std::get<0>(info.param);
1808                             return Sanitize(name);
1809                         });