cros_gralloc/gralloc4/CrosGralloc4Mapper.cc

   1 /*
   2  * Copyright 2020 The Chromium OS Authors. All rights reserved.
   3  * Use of this source code is governed by a BSD-style license that can be
   4  * found in the LICENSE file.
   5  */
   6
   7 #include "cros_gralloc/gralloc4/CrosGralloc4Mapper.h"
   8
   9 #include <aidl/android/hardware/graphics/common/BlendMode.h>
  10 #include <aidl/android/hardware/graphics/common/Dataspace.h>
  11 #include <aidl/android/hardware/graphics/common/PlaneLayout.h>
  12 #include <aidl/android/hardware/graphics/common/Rect.h>
  13 #include <cutils/native_handle.h>
  14 #include <gralloctypes/Gralloc4.h>
  15
  16 #include "cros_gralloc/cros_gralloc_helpers.h"
  17 #include "cros_gralloc/gralloc4/CrosGralloc4Utils.h"
  18
  19 #include "helpers.h"
  20
  21 using aidl::android::hardware::graphics::common::BlendMode;
  22 using aidl::android::hardware::graphics::common::Dataspace;
  23 using aidl::android::hardware::graphics::common::PlaneLayout;
  24 using aidl::android::hardware::graphics::common::Rect;
  25 using android::hardware::hidl_handle;
  26 using android::hardware::hidl_vec;
  27 using android::hardware::Return;
  28 using android::hardware::Void;
  29 using android::hardware::graphics::common::V1_2::BufferUsage;
  30 using android::hardware::graphics::common::V1_2::PixelFormat;
  31 using android::hardware::graphics::mapper::V4_0::Error;
  32 using android::hardware::graphics::mapper::V4_0::IMapper;
  33
  34 CrosGralloc4Mapper::CrosGralloc4Mapper() : mDriver(std::make_unique<cros_gralloc_driver>()) {
  35     if (mDriver->init()) {
  36         drv_log("Failed to initialize driver.\n");
  37         mDriver = nullptr;
  38     }
  39 }
  40
  41 Return<void> CrosGralloc4Mapper::createDescriptor(const BufferDescriptorInfo& description,
  42                                                   createDescriptor_cb hidlCb) {
  43     hidl_vec<uint8_t> descriptor;
  44
  45     if (description.width == 0) {
  46         drv_log("Failed to createDescriptor. Bad width: %d.\n", description.width);
  47         hidlCb(Error::BAD_VALUE, descriptor);
  48         return Void();
  49     }
  50
  51     if (description.height == 0) {
  52         drv_log("Failed to createDescriptor. Bad height: %d.\n", description.height);
  53         hidlCb(Error::BAD_VALUE, descriptor);
  54         return Void();
  55     }
  56
  57     if (description.layerCount == 0) {
  58         drv_log("Failed to createDescriptor. Bad layer count: %d.\n", description.layerCount);
  59         hidlCb(Error::BAD_VALUE, descriptor);
  60         return Void();
  61     }
  62
  63     int ret = android::gralloc4::encodeBufferDescriptorInfo(description, &descriptor);
  64     if (ret) {
  65         drv_log("Failed to createDescriptor. Failed to encode: %d.\n", ret);
  66         hidlCb(Error::BAD_VALUE, descriptor);
  67         return Void();
  68     }
  69
  70     hidlCb(Error::NONE, descriptor);
  71     return Void();
  72 }
  73
  74 Return<void> CrosGralloc4Mapper::importBuffer(const hidl_handle& handle, importBuffer_cb hidlCb) {
  75     if (!mDriver) {
  76         drv_log("Failed to import buffer. Driver is uninitialized.\n");
  77         hidlCb(Error::NO_RESOURCES, nullptr);
  78         return Void();
  79     }
  80
  81     const native_handle_t* bufferHandle = handle.getNativeHandle();
  82     if (!bufferHandle || bufferHandle->numFds == 0) {
  83         drv_log("Failed to importBuffer. Bad handle.\n");
  84         hidlCb(Error::BAD_BUFFER, nullptr);
  85         return Void();
  86     }
  87
  88     native_handle_t* importedBufferHandle = native_handle_clone(bufferHandle);
  89     if (!importedBufferHandle) {
  90         drv_log("Failed to importBuffer. Handle clone failed: %s.\n", strerror(errno));
  91         hidlCb(Error::NO_RESOURCES, nullptr);
  92         return Void();
  93     }
  94
  95     int ret = mDriver->retain(importedBufferHandle);
  96     if (ret) {
  97         native_handle_close(importedBufferHandle);
  98         native_handle_delete(importedBufferHandle);
  99         hidlCb(Error::NO_RESOURCES, nullptr);
 100         return Void();
 101     }
 102
 103     hidlCb(Error::NONE, importedBufferHandle);
 104     return Void();
 105 }
 106
 107 Return<Error> CrosGralloc4Mapper::freeBuffer(void* rawHandle) {
 108     if (!mDriver) {
 109         drv_log("Failed to freeBuffer. Driver is uninitialized.\n");
 110         return Error::NO_RESOURCES;
 111     }
 112
 113     native_handle_t* bufferHandle = reinterpret_cast<native_handle_t*>(rawHandle);
 114     if (!bufferHandle) {
 115         drv_log("Failed to freeBuffer. Empty handle.\n");
 116         return Error::BAD_BUFFER;
 117     }
 118
 119     int ret = mDriver->release(bufferHandle);
 120     if (ret) {
 121         return Error::BAD_BUFFER;
 122     }
 123
 124     native_handle_close(bufferHandle);
 125     native_handle_delete(bufferHandle);
 126     return Error::NONE;
 127 }
 128
 129 Return<Error> CrosGralloc4Mapper::validateBufferSize(void* rawHandle,
 130                                                      const BufferDescriptorInfo& descriptor,
 131                                                      uint32_t stride) {
 132     if (!mDriver) {
 133         drv_log("Failed to validateBufferSize. Driver is uninitialized.\n");
 134         return Error::NO_RESOURCES;
 135     }
 136
 137     native_handle_t* bufferHandle = reinterpret_cast<native_handle_t*>(rawHandle);
 138     if (!bufferHandle) {
 139         drv_log("Failed to validateBufferSize. Empty handle.\n");
 140         return Error::BAD_BUFFER;
 141     }
 142
 143     cros_gralloc_handle_t crosHandle = cros_gralloc_convert_handle(bufferHandle);
 144     if (!crosHandle) {
 145         drv_log("Failed to validateBufferSize. Invalid handle.\n");
 146         return Error::BAD_BUFFER;
 147     }
 148
 149     PixelFormat crosHandleFormat = static_cast<PixelFormat>(crosHandle->droid_format);
 150     if (descriptor.format != crosHandleFormat) {
 151         drv_log("Failed to validateBufferSize. Format mismatch.\n");
 152         return Error::BAD_BUFFER;
 153     }
 154
 155     if (descriptor.width != crosHandle->width) {
 156         drv_log("Failed to validateBufferSize. Width mismatch (%d vs %d).\n", descriptor.width,
 157                 crosHandle->width);
 158         return Error::BAD_VALUE;
 159     }
 160
 161     if (descriptor.height != crosHandle->height) {
 162         drv_log("Failed to validateBufferSize. Height mismatch (%d vs %d).\n", descriptor.height,
 163                 crosHandle->height);
 164         return Error::BAD_VALUE;
 165     }
 166
 167     if (stride != crosHandle->pixel_stride) {
 168         drv_log("Failed to validateBufferSize. Stride mismatch (%d vs %d).\n", stride,
 169                 crosHandle->pixel_stride);
 170         return Error::BAD_VALUE;
 171     }
 172
 173     return Error::NONE;
 174 }
 175
 176 Return<void> CrosGralloc4Mapper::getTransportSize(void* rawHandle, getTransportSize_cb hidlCb) {
 177     if (!mDriver) {
 178         drv_log("Failed to getTransportSize. Driver is uninitialized.\n");
 179         hidlCb(Error::BAD_BUFFER, 0, 0);
 180         return Void();
 181     }
 182
 183     native_handle_t* bufferHandle = reinterpret_cast<native_handle_t*>(rawHandle);
 184     if (!bufferHandle) {
 185         drv_log("Failed to getTransportSize. Bad handle.\n");
 186         hidlCb(Error::BAD_BUFFER, 0, 0);
 187         return Void();
 188     }
 189
 190     // No local process data is currently stored on the native handle.
 191     hidlCb(Error::NONE, bufferHandle->numFds, bufferHandle->numInts);
 192     return Void();
 193 }
 194
 195 Return<void> CrosGralloc4Mapper::lock(void* rawBuffer, uint64_t cpuUsage, const Rect& region,
 196                                       const hidl_handle& acquireFence, lock_cb hidlCb) {
 197     if (!mDriver) {
 198         drv_log("Failed to lock. Driver is uninitialized.\n");
 199         hidlCb(Error::NO_RESOURCES, nullptr);
 200         return Void();
 201     }
 202
 203     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawBuffer);
 204     if (!bufferHandle) {
 205         drv_log("Failed to lock. Empty handle.\n");
 206         hidlCb(Error::BAD_BUFFER, nullptr);
 207         return Void();
 208     }
 209
 210     if (cpuUsage == 0) {
 211         drv_log("Failed to lock. Bad cpu usage: %" PRIu64 ".\n", cpuUsage);
 212         hidlCb(Error::BAD_VALUE, nullptr);
 213         return Void();
 214     }
 215
 216     uint32_t mapUsage = 0;
 217     int ret = convertToMapUsage(cpuUsage, &mapUsage);
 218     if (ret) {
 219         drv_log("Failed to lock. Convert usage failed.\n");
 220         hidlCb(Error::BAD_VALUE, nullptr);
 221         return Void();
 222     }
 223
 224     cros_gralloc_handle_t crosHandle = cros_gralloc_convert_handle(bufferHandle);
 225     if (crosHandle == nullptr) {
 226         drv_log("Failed to lock. Invalid handle.\n");
 227         hidlCb(Error::BAD_VALUE, nullptr);
 228         return Void();
 229     }
 230
 231     if (region.left < 0) {
 232         drv_log("Failed to lock. Invalid region: negative left value %d.\n", region.left);
 233         hidlCb(Error::BAD_VALUE, nullptr);
 234         return Void();
 235     }
 236
 237     if (region.top < 0) {
 238         drv_log("Failed to lock. Invalid region: negative top value %d.\n", region.top);
 239         hidlCb(Error::BAD_VALUE, nullptr);
 240         return Void();
 241     }
 242
 243     if (region.width < 0) {
 244         drv_log("Failed to lock. Invalid region: negative width value %d.\n", region.width);
 245         hidlCb(Error::BAD_VALUE, nullptr);
 246         return Void();
 247     }
 248
 249     if (region.height < 0) {
 250         drv_log("Failed to lock. Invalid region: negative height value %d.\n", region.height);
 251         hidlCb(Error::BAD_VALUE, nullptr);
 252         return Void();
 253     }
 254
 255     if (region.width > crosHandle->width) {
 256         drv_log("Failed to lock. Invalid region: width greater than buffer width (%d vs %d).\n",
 257                 region.width, crosHandle->width);
 258         hidlCb(Error::BAD_VALUE, nullptr);
 259         return Void();
 260     }
 261
 262     if (region.height > crosHandle->height) {
 263         drv_log("Failed to lock. Invalid region: height greater than buffer height (%d vs %d).\n",
 264                 region.height, crosHandle->height);
 265         hidlCb(Error::BAD_VALUE, nullptr);
 266         return Void();
 267     }
 268
 269     struct rectangle rect = {static_cast<uint32_t>(region.left), static_cast<uint32_t>(region.top),
 270                              static_cast<uint32_t>(region.width),
 271                              static_cast<uint32_t>(region.height)};
 272
 273     // An access region of all zeros means the entire buffer.
 274     if (rect.x == 0 && rect.y == 0 && rect.width == 0 && rect.height == 0) {
 275         rect.width = crosHandle->width;
 276         rect.height = crosHandle->height;
 277     }
 278
 279     int acquireFenceFd = -1;
 280     ret = convertToFenceFd(acquireFence, &acquireFenceFd);
 281     if (ret) {
 282         drv_log("Failed to lock. Bad acquire fence.\n");
 283         hidlCb(Error::BAD_VALUE, nullptr);
 284         return Void();
 285     }
 286
 287     uint8_t* addr[DRV_MAX_PLANES];
 288     ret = mDriver->lock(bufferHandle, acquireFenceFd, /*close_acquire_fence=*/false, &rect,
 289                         mapUsage, addr);
 290     if (ret) {
 291         hidlCb(Error::BAD_VALUE, nullptr);
 292         return Void();
 293     }
 294
 295     hidlCb(Error::NONE, addr[0]);
 296     return Void();
 297 }
 298
 299 Return<void> CrosGralloc4Mapper::unlock(void* rawHandle, unlock_cb hidlCb) {
 300     if (!mDriver) {
 301         drv_log("Failed to unlock. Driver is uninitialized.\n");
 302         hidlCb(Error::BAD_BUFFER, nullptr);
 303         return Void();
 304     }
 305
 306     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawHandle);
 307     if (!bufferHandle) {
 308         drv_log("Failed to unlock. Empty handle.\n");
 309         hidlCb(Error::BAD_BUFFER, nullptr);
 310         return Void();
 311     }
 312
 313     int releaseFenceFd = -1;
 314     int ret = mDriver->unlock(bufferHandle, &releaseFenceFd);
 315     if (ret) {
 316         drv_log("Failed to unlock.\n");
 317         hidlCb(Error::BAD_BUFFER, nullptr);
 318         return Void();
 319     }
 320
 321     hidl_handle releaseFenceHandle;
 322     ret = convertToFenceHandle(releaseFenceFd, &releaseFenceHandle);
 323     if (ret) {
 324         drv_log("Failed to unlock. Failed to convert release fence to handle.\n");
 325         hidlCb(Error::BAD_BUFFER, nullptr);
 326         return Void();
 327     }
 328
 329     hidlCb(Error::NONE, releaseFenceHandle);
 330     return Void();
 331 }
 332
 333 Return<void> CrosGralloc4Mapper::flushLockedBuffer(void* rawHandle, flushLockedBuffer_cb hidlCb) {
 334     if (!mDriver) {
 335         drv_log("Failed to flushLockedBuffer. Driver is uninitialized.\n");
 336         hidlCb(Error::NO_RESOURCES, nullptr);
 337         return Void();
 338     }
 339
 340     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawHandle);
 341     if (!bufferHandle) {
 342         drv_log("Failed to flushLockedBuffer. Empty handle.\n");
 343         hidlCb(Error::BAD_BUFFER, nullptr);
 344         return Void();
 345     }
 346
 347     int releaseFenceFd = -1;
 348     int ret = mDriver->flush(bufferHandle, &releaseFenceFd);
 349     if (ret) {
 350         drv_log("Failed to flushLockedBuffer. Flush failed.\n");
 351         hidlCb(Error::BAD_BUFFER, nullptr);
 352         return Void();
 353     }
 354
 355     hidl_handle releaseFenceHandle;
 356     ret = convertToFenceHandle(releaseFenceFd, &releaseFenceHandle);
 357     if (ret) {
 358         drv_log("Failed to flushLockedBuffer. Failed to convert release fence to handle.\n");
 359         hidlCb(Error::BAD_BUFFER, nullptr);
 360         return Void();
 361     }
 362
 363     hidlCb(Error::NONE, releaseFenceHandle);
 364     return Void();
 365 }
 366
 367 Return<Error> CrosGralloc4Mapper::rereadLockedBuffer(void* rawHandle) {
 368     if (!mDriver) {
 369         drv_log("Failed to rereadLockedBuffer. Driver is uninitialized.\n");
 370         return Error::NO_RESOURCES;
 371     }
 372
 373     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawHandle);
 374     if (!bufferHandle) {
 375         drv_log("Failed to rereadLockedBuffer. Empty handle.\n");
 376         return Error::BAD_BUFFER;
 377     }
 378
 379     int ret = mDriver->invalidate(bufferHandle);
 380     if (ret) {
 381         drv_log("Failed to rereadLockedBuffer. Failed to invalidate.\n");
 382         return Error::BAD_BUFFER;
 383     }
 384
 385     return Error::NONE;
 386 }
 387
 388 Return<void> CrosGralloc4Mapper::isSupported(const BufferDescriptorInfo& descriptor,
 389                                              isSupported_cb hidlCb) {
 390     if (!mDriver) {
 391         drv_log("Failed to isSupported. Driver is uninitialized.\n");
 392         hidlCb(Error::BAD_VALUE, false);
 393         return Void();
 394     }
 395
 396     struct cros_gralloc_buffer_descriptor crosDescriptor;
 397     if (convertToCrosDescriptor(descriptor, &crosDescriptor)) {
 398         hidlCb(Error::NONE, false);
 399         return Void();
 400     }
 401
 402     bool supported = mDriver->is_supported(&crosDescriptor);
 403     if (!supported) {
 404         crosDescriptor.use_flags &= ~BO_USE_SCANOUT;
 405         supported = mDriver->is_supported(&crosDescriptor);
 406     }
 407
 408     hidlCb(Error::NONE, supported);
 409     return Void();
 410 }
 411
 412 Return<void> CrosGralloc4Mapper::get(void* rawHandle, const MetadataType& metadataType,
 413                                      get_cb hidlCb) {
 414     hidl_vec<uint8_t> encodedMetadata;
 415
 416     if (!mDriver) {
 417         drv_log("Failed to get. Driver is uninitialized.\n");
 418         hidlCb(Error::NO_RESOURCES, encodedMetadata);
 419         return Void();
 420     }
 421
 422     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawHandle);
 423     if (!bufferHandle) {
 424         drv_log("Failed to get. Empty handle.\n");
 425         hidlCb(Error::BAD_BUFFER, encodedMetadata);
 426         return Void();
 427     }
 428
 429     cros_gralloc_handle_t crosHandle = cros_gralloc_convert_handle(bufferHandle);
 430     if (!crosHandle) {
 431         drv_log("Failed to get. Invalid handle.\n");
 432         hidlCb(Error::BAD_BUFFER, encodedMetadata);
 433         return Void();
 434     }
 435
 436     get(crosHandle, metadataType, hidlCb);
 437     return Void();
 438 }
 439
 440 Return<void> CrosGralloc4Mapper::get(cros_gralloc_handle_t crosHandle,
 441                                      const MetadataType& metadataType, get_cb hidlCb) {
 442     hidl_vec<uint8_t> encodedMetadata;
 443
 444     if (!mDriver) {
 445         drv_log("Failed to get. Driver is uninitialized.\n");
 446         hidlCb(Error::NO_RESOURCES, encodedMetadata);
 447         return Void();
 448     }
 449
 450     if (!crosHandle) {
 451         drv_log("Failed to get. Invalid handle.\n");
 452         hidlCb(Error::BAD_BUFFER, encodedMetadata);
 453         return Void();
 454     }
 455
 456     android::status_t status = android::NO_ERROR;
 457     if (metadataType == android::gralloc4::MetadataType_BufferId) {
 458         status = android::gralloc4::encodeBufferId(crosHandle->id, &encodedMetadata);
 459     } else if (metadataType == android::gralloc4::MetadataType_Name) {
 460         const char* name = (const char*)(&crosHandle->base.data[crosHandle->name_offset]);
 461         status = android::gralloc4::encodeName(name, &encodedMetadata);
 462     } else if (metadataType == android::gralloc4::MetadataType_Width) {
 463         status = android::gralloc4::encodeWidth(crosHandle->width, &encodedMetadata);
 464     } else if (metadataType == android::gralloc4::MetadataType_Height) {
 465         status = android::gralloc4::encodeHeight(crosHandle->height, &encodedMetadata);
 466     } else if (metadataType == android::gralloc4::MetadataType_LayerCount) {
 467         status = android::gralloc4::encodeLayerCount(1, &encodedMetadata);
 468     } else if (metadataType == android::gralloc4::MetadataType_PixelFormatRequested) {
 469         PixelFormat pixelFormat = static_cast<PixelFormat>(crosHandle->droid_format);
 470         status = android::gralloc4::encodePixelFormatRequested(pixelFormat, &encodedMetadata);
 471     } else if (metadataType == android::gralloc4::MetadataType_PixelFormatFourCC) {
 472         status = android::gralloc4::encodePixelFormatFourCC(
 473                 drv_get_standard_fourcc(crosHandle->format), &encodedMetadata);
 474     } else if (metadataType == android::gralloc4::MetadataType_PixelFormatModifier) {
 475         status = android::gralloc4::encodePixelFormatModifier(crosHandle->format_modifier,
 476                                                               &encodedMetadata);
 477     } else if (metadataType == android::gralloc4::MetadataType_Usage) {
 478         uint64_t usage = static_cast<uint64_t>(crosHandle->usage);
 479         status = android::gralloc4::encodeUsage(usage, &encodedMetadata);
 480     } else if (metadataType == android::gralloc4::MetadataType_AllocationSize) {
 481         status = android::gralloc4::encodeAllocationSize(crosHandle->total_size, &encodedMetadata);
 482     } else if (metadataType == android::gralloc4::MetadataType_ProtectedContent) {
 483         uint64_t hasProtectedContent = crosHandle->usage & BufferUsage::PROTECTED ? 1 : 0;
 484         status = android::gralloc4::encodeProtectedContent(hasProtectedContent, &encodedMetadata);
 485     } else if (metadataType == android::gralloc4::MetadataType_Compression) {
 486         status = android::gralloc4::encodeCompression(android::gralloc4::Compression_None,
 487                                                       &encodedMetadata);
 488     } else if (metadataType == android::gralloc4::MetadataType_Interlaced) {
 489         status = android::gralloc4::encodeInterlaced(android::gralloc4::Interlaced_None,
 490                                                      &encodedMetadata);
 491     } else if (metadataType == android::gralloc4::MetadataType_ChromaSiting) {
 492         status = android::gralloc4::encodeChromaSiting(android::gralloc4::ChromaSiting_None,
 493                                                        &encodedMetadata);
 494     } else if (metadataType == android::gralloc4::MetadataType_PlaneLayouts) {
 495         std::vector<PlaneLayout> planeLayouts;
 496         getPlaneLayouts(crosHandle->format, &planeLayouts);
 497
 498         for (size_t plane = 0; plane < planeLayouts.size(); plane++) {
 499             PlaneLayout& planeLayout = planeLayouts[plane];
 500             planeLayout.offsetInBytes = crosHandle->offsets[plane];
 501             planeLayout.strideInBytes = crosHandle->strides[plane];
 502             planeLayout.totalSizeInBytes = crosHandle->sizes[plane];
 503             planeLayout.widthInSamples = crosHandle->width / planeLayout.horizontalSubsampling;
 504             planeLayout.heightInSamples = crosHandle->height / planeLayout.verticalSubsampling;
 505         }
 506
 507         status = android::gralloc4::encodePlaneLayouts(planeLayouts, &encodedMetadata);
 508     } else if (metadataType == android::gralloc4::MetadataType_Crop) {
 509         std::vector<aidl::android::hardware::graphics::common::Rect> crops;
 510         for (size_t plane = 0; plane < crosHandle->num_planes; plane++) {
 511             aidl::android::hardware::graphics::common::Rect crop;
 512             crop.left = 0;
 513             crop.top = 0;
 514             crop.right = crosHandle->width;
 515             crop.bottom = crosHandle->height;
 516             crops.push_back(crop);
 517         }
 518
 519         status = android::gralloc4::encodeCrop(crops, &encodedMetadata);
 520     } else if (metadataType == android::gralloc4::MetadataType_Dataspace) {
 521         status = android::gralloc4::encodeDataspace(Dataspace::UNKNOWN, &encodedMetadata);
 522     } else if (metadataType == android::gralloc4::MetadataType_BlendMode) {
 523         status = android::gralloc4::encodeBlendMode(BlendMode::INVALID, &encodedMetadata);
 524     } else if (metadataType == android::gralloc4::MetadataType_Smpte2086) {
 525         status = android::gralloc4::encodeSmpte2086(std::nullopt, &encodedMetadata);
 526     } else if (metadataType == android::gralloc4::MetadataType_Cta861_3) {
 527         status = android::gralloc4::encodeCta861_3(std::nullopt, &encodedMetadata);
 528     } else if (metadataType == android::gralloc4::MetadataType_Smpte2094_40) {
 529         status = android::gralloc4::encodeSmpte2094_40(std::nullopt, &encodedMetadata);
 530     } else {
 531         hidlCb(Error::UNSUPPORTED, encodedMetadata);
 532         return Void();
 533     }
 534
 535     if (status != android::NO_ERROR) {
 536         hidlCb(Error::NO_RESOURCES, encodedMetadata);
 537         drv_log("Failed to get. Failed to encode metadata.\n");
 538         return Void();
 539     }
 540
 541     hidlCb(Error::NONE, encodedMetadata);
 542     return Void();
 543 }
 544
 545 Return<Error> CrosGralloc4Mapper::set(void* rawHandle, const MetadataType& metadataType,
 546                                       const hidl_vec<uint8_t>& /*metadata*/) {
 547     if (!mDriver) {
 548         drv_log("Failed to set. Driver is uninitialized.\n");
 549         return Error::NO_RESOURCES;
 550     }
 551
 552     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawHandle);
 553     if (!bufferHandle) {
 554         drv_log("Failed to set. Empty handle.\n");
 555         return Error::BAD_BUFFER;
 556     }
 557
 558     cros_gralloc_handle_t crosHandle = cros_gralloc_convert_handle(bufferHandle);
 559     if (!crosHandle) {
 560         drv_log("Failed to set. Invalid handle.\n");
 561         return Error::BAD_BUFFER;
 562     }
 563
 564     if (metadataType == android::gralloc4::MetadataType_BufferId) {
 565         return Error::BAD_VALUE;
 566     } else if (metadataType == android::gralloc4::MetadataType_Name) {
 567         return Error::BAD_VALUE;
 568     } else if (metadataType == android::gralloc4::MetadataType_Width) {
 569         return Error::BAD_VALUE;
 570     } else if (metadataType == android::gralloc4::MetadataType_Height) {
 571         return Error::BAD_VALUE;
 572     } else if (metadataType == android::gralloc4::MetadataType_LayerCount) {
 573         return Error::BAD_VALUE;
 574     } else if (metadataType == android::gralloc4::MetadataType_PixelFormatRequested) {
 575         return Error::BAD_VALUE;
 576     } else if (metadataType == android::gralloc4::MetadataType_Usage) {
 577         return Error::BAD_VALUE;
 578     }
 579
 580     return Error::UNSUPPORTED;
 581 }
 582
 583 int CrosGralloc4Mapper::getResolvedDrmFormat(PixelFormat pixelFormat, uint64_t bufferUsage,
 584                                              uint32_t* outDrmFormat) {
 585     uint32_t drmFormat;
 586     if (convertToDrmFormat(pixelFormat, &drmFormat)) {
 587         std::string pixelFormatString = getPixelFormatString(pixelFormat);
 588         drv_log("Failed to getResolvedDrmFormat. Failed to convert format %s\n",
 589                 pixelFormatString.c_str());
 590         return -1;
 591     }
 592
 593     uint64_t usage;
 594     if (convertToBufferUsage(bufferUsage, &usage)) {
 595         std::string usageString = getUsageString(bufferUsage);
 596         drv_log("Failed to getResolvedDrmFormat. Failed to convert usage %s\n",
 597                 usageString.c_str());
 598         return -1;
 599     }
 600
 601     uint32_t resolvedDrmFormat = mDriver->get_resolved_drm_format(drmFormat, usage);
 602     if (resolvedDrmFormat == DRM_FORMAT_INVALID) {
 603         std::string drmFormatString = get_drm_format_string(drmFormat);
 604         drv_log("Failed to getResolvedDrmFormat. Failed to resolve drm format %s\n",
 605                 drmFormatString.c_str());
 606         return -1;
 607     }
 608
 609     *outDrmFormat = resolvedDrmFormat;
 610
 611     return 0;
 612 }
 613
 614 Return<void> CrosGralloc4Mapper::getFromBufferDescriptorInfo(
 615         const BufferDescriptorInfo& descriptor, const MetadataType& metadataType,
 616         getFromBufferDescriptorInfo_cb hidlCb) {
 617     hidl_vec<uint8_t> encodedMetadata;
 618
 619     if (!mDriver) {
 620         drv_log("Failed to getFromBufferDescriptorInfo. Driver is uninitialized.\n");
 621         hidlCb(Error::NO_RESOURCES, encodedMetadata);
 622         return Void();
 623     }
 624
 625     android::status_t status = android::NO_ERROR;
 626     if (metadataType == android::gralloc4::MetadataType_Name) {
 627         status = android::gralloc4::encodeName(descriptor.name, &encodedMetadata);
 628     } else if (metadataType == android::gralloc4::MetadataType_Width) {
 629         status = android::gralloc4::encodeWidth(descriptor.width, &encodedMetadata);
 630     } else if (metadataType == android::gralloc4::MetadataType_Height) {
 631         status = android::gralloc4::encodeHeight(descriptor.height, &encodedMetadata);
 632     } else if (metadataType == android::gralloc4::MetadataType_LayerCount) {
 633         status = android::gralloc4::encodeLayerCount(1, &encodedMetadata);
 634     } else if (metadataType == android::gralloc4::MetadataType_PixelFormatRequested) {
 635         status = android::gralloc4::encodePixelFormatRequested(descriptor.format, &encodedMetadata);
 636     } else if (metadataType == android::gralloc4::MetadataType_PixelFormatFourCC) {
 637         uint32_t drmFormat;
 638         if (getResolvedDrmFormat(descriptor.format, descriptor.usage, &drmFormat)) {
 639             hidlCb(Error::BAD_VALUE, encodedMetadata);
 640             return Void();
 641         }
 642         status = android::gralloc4::encodePixelFormatFourCC(drv_get_standard_fourcc(drmFormat),
 643                                                             &encodedMetadata);
 644     } else if (metadataType == android::gralloc4::MetadataType_Usage) {
 645         status = android::gralloc4::encodeUsage(descriptor.usage, &encodedMetadata);
 646     } else if (metadataType == android::gralloc4::MetadataType_ProtectedContent) {
 647         uint64_t hasProtectedContent = descriptor.usage & BufferUsage::PROTECTED ? 1 : 0;
 648         status = android::gralloc4::encodeProtectedContent(hasProtectedContent, &encodedMetadata);
 649     } else if (metadataType == android::gralloc4::MetadataType_Compression) {
 650         status = android::gralloc4::encodeCompression(android::gralloc4::Compression_None,
 651                                                       &encodedMetadata);
 652     } else if (metadataType == android::gralloc4::MetadataType_Interlaced) {
 653         status = android::gralloc4::encodeInterlaced(android::gralloc4::Interlaced_None,
 654                                                      &encodedMetadata);
 655     } else if (metadataType == android::gralloc4::MetadataType_ChromaSiting) {
 656         status = android::gralloc4::encodeChromaSiting(android::gralloc4::ChromaSiting_None,
 657                                                        &encodedMetadata);
 658     } else if (metadataType == android::gralloc4::MetadataType_Crop) {
 659         uint32_t drmFormat;
 660         if (getResolvedDrmFormat(descriptor.format, descriptor.usage, &drmFormat)) {
 661             hidlCb(Error::BAD_VALUE, encodedMetadata);
 662             return Void();
 663         }
 664
 665         size_t numPlanes = drv_num_planes_from_format(drmFormat);
 666
 667         std::vector<aidl::android::hardware::graphics::common::Rect> crops;
 668         for (size_t plane = 0; plane < numPlanes; plane++) {
 669             aidl::android::hardware::graphics::common::Rect crop;
 670             crop.left = 0;
 671             crop.top = 0;
 672             crop.right = descriptor.width;
 673             crop.bottom = descriptor.height;
 674             crops.push_back(crop);
 675         }
 676         status = android::gralloc4::encodeCrop(crops, &encodedMetadata);
 677     } else if (metadataType == android::gralloc4::MetadataType_Dataspace) {
 678         status = android::gralloc4::encodeDataspace(Dataspace::UNKNOWN, &encodedMetadata);
 679     } else if (metadataType == android::gralloc4::MetadataType_BlendMode) {
 680         status = android::gralloc4::encodeBlendMode(BlendMode::INVALID, &encodedMetadata);
 681     } else if (metadataType == android::gralloc4::MetadataType_Smpte2086) {
 682         status = android::gralloc4::encodeSmpte2086(std::nullopt, &encodedMetadata);
 683     } else if (metadataType == android::gralloc4::MetadataType_Cta861_3) {
 684         status = android::gralloc4::encodeCta861_3(std::nullopt, &encodedMetadata);
 685     } else if (metadataType == android::gralloc4::MetadataType_Smpte2094_40) {
 686         status = android::gralloc4::encodeSmpte2094_40(std::nullopt, &encodedMetadata);
 687     } else {
 688         hidlCb(Error::UNSUPPORTED, encodedMetadata);
 689         return Void();
 690     }
 691
 692     if (status != android::NO_ERROR) {
 693         hidlCb(Error::NO_RESOURCES, encodedMetadata);
 694         return Void();
 695     }
 696
 697     hidlCb(Error::NONE, encodedMetadata);
 698     return Void();
 699 }
 700
 701 Return<void> CrosGralloc4Mapper::listSupportedMetadataTypes(listSupportedMetadataTypes_cb hidlCb) {
 702     hidl_vec<MetadataTypeDescription> supported;
 703
 704     if (!mDriver) {
 705         drv_log("Failed to listSupportedMetadataTypes. Driver is uninitialized.\n");
 706         hidlCb(Error::NO_RESOURCES, supported);
 707         return Void();
 708     }
 709
 710     supported = hidl_vec<IMapper::MetadataTypeDescription>({
 711             {
 712                     android::gralloc4::MetadataType_BufferId,
 713                     "",
 714                     /*isGettable=*/true,
 715                     /*isSettable=*/false,
 716             },
 717             {
 718                     android::gralloc4::MetadataType_Name,
 719                     "",
 720                     /*isGettable=*/true,
 721                     /*isSettable=*/false,
 722             },
 723             {
 724                     android::gralloc4::MetadataType_Width,
 725                     "",
 726                     /*isGettable=*/true,
 727                     /*isSettable=*/false,
 728             },
 729             {
 730                     android::gralloc4::MetadataType_Height,
 731                     "",
 732                     /*isGettable=*/true,
 733                     /*isSettable=*/false,
 734             },
 735             {
 736                     android::gralloc4::MetadataType_LayerCount,
 737                     "",
 738                     /*isGettable=*/true,
 739                     /*isSettable=*/false,
 740             },
 741             {
 742                     android::gralloc4::MetadataType_PixelFormatRequested,
 743                     "",
 744                     /*isGettable=*/true,
 745                     /*isSettable=*/false,
 746             },
 747             {
 748                     android::gralloc4::MetadataType_PixelFormatFourCC,
 749                     "",
 750                     /*isGettable=*/true,
 751                     /*isSettable=*/false,
 752             },
 753             {
 754                     android::gralloc4::MetadataType_PixelFormatModifier,
 755                     "",
 756                     /*isGettable=*/true,
 757                     /*isSettable=*/false,
 758             },
 759             {
 760                     android::gralloc4::MetadataType_Usage,
 761                     "",
 762                     /*isGettable=*/true,
 763                     /*isSettable=*/false,
 764             },
 765             {
 766                     android::gralloc4::MetadataType_AllocationSize,
 767                     "",
 768                     /*isGettable=*/true,
 769                     /*isSettable=*/false,
 770             },
 771             {
 772                     android::gralloc4::MetadataType_ProtectedContent,
 773                     "",
 774                     /*isGettable=*/true,
 775                     /*isSettable=*/false,
 776             },
 777             {
 778                     android::gralloc4::MetadataType_Compression,
 779                     "",
 780                     /*isGettable=*/true,
 781                     /*isSettable=*/false,
 782             },
 783             {
 784                     android::gralloc4::MetadataType_Interlaced,
 785                     "",
 786                     /*isGettable=*/true,
 787                     /*isSettable=*/false,
 788             },
 789             {
 790                     android::gralloc4::MetadataType_ChromaSiting,
 791                     "",
 792                     /*isGettable=*/true,
 793                     /*isSettable=*/false,
 794             },
 795             {
 796                     android::gralloc4::MetadataType_PlaneLayouts,
 797                     "",
 798                     /*isGettable=*/true,
 799                     /*isSettable=*/false,
 800             },
 801             {
 802                     android::gralloc4::MetadataType_Dataspace,
 803                     "",
 804                     /*isGettable=*/true,
 805                     /*isSettable=*/false,
 806             },
 807             {
 808                     android::gralloc4::MetadataType_BlendMode,
 809                     "",
 810                     /*isGettable=*/true,
 811                     /*isSettable=*/false,
 812             },
 813             {
 814                     android::gralloc4::MetadataType_Smpte2086,
 815                     "",
 816                     /*isGettable=*/true,
 817                     /*isSettable=*/false,
 818             },
 819             {
 820                     android::gralloc4::MetadataType_Cta861_3,
 821                     "",
 822                     /*isGettable=*/true,
 823                     /*isSettable=*/false,
 824             },
 825             {
 826                     android::gralloc4::MetadataType_Smpte2094_40,
 827                     "",
 828                     /*isGettable=*/true,
 829                     /*isSettable=*/false,
 830             },
 831     });
 832
 833     hidlCb(Error::NONE, supported);
 834     return Void();
 835 }
 836
 837 Return<void> CrosGralloc4Mapper::dumpBuffer(void* rawHandle, dumpBuffer_cb hidlCb) {
 838     BufferDump bufferDump;
 839
 840     if (!mDriver) {
 841         drv_log("Failed to dumpBuffer. Driver is uninitialized.\n");
 842         hidlCb(Error::NO_RESOURCES, bufferDump);
 843         return Void();
 844     }
 845
 846     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawHandle);
 847     if (!bufferHandle) {
 848         drv_log("Failed to dumpBuffer. Empty handle.\n");
 849         hidlCb(Error::BAD_BUFFER, bufferDump);
 850         return Void();
 851     }
 852
 853     cros_gralloc_handle_t crosHandle = cros_gralloc_convert_handle(bufferHandle);
 854     if (!crosHandle) {
 855         drv_log("Failed to dumpBuffer. Invalid handle.\n");
 856         hidlCb(Error::BAD_BUFFER, bufferDump);
 857         return Void();
 858     }
 859
 860     return dumpBuffer(crosHandle, hidlCb);
 861 }
 862
 863 Return<void> CrosGralloc4Mapper::dumpBuffer(cros_gralloc_handle_t crosHandle,
 864                                             dumpBuffer_cb hidlCb) {
 865     BufferDump bufferDump;
 866
 867     if (!mDriver) {
 868         drv_log("Failed to dumpBuffer. Driver is uninitialized.\n");
 869         hidlCb(Error::NO_RESOURCES, bufferDump);
 870         return Void();
 871     }
 872
 873     if (!crosHandle) {
 874         drv_log("Failed to dumpBuffer. Invalid handle.\n");
 875         hidlCb(Error::BAD_BUFFER, bufferDump);
 876         return Void();
 877     }
 878
 879     std::vector<MetadataDump> metadataDumps;
 880
 881     MetadataType metadataType = android::gralloc4::MetadataType_BufferId;
 882     auto metadata_get_callback = [&](Error, hidl_vec<uint8_t> metadata) {
 883         MetadataDump metadataDump;
 884         metadataDump.metadataType = metadataType;
 885         metadataDump.metadata = metadata;
 886         metadataDumps.push_back(metadataDump);
 887     };
 888
 889     metadataType = android::gralloc4::MetadataType_BufferId;
 890     get(crosHandle, metadataType, metadata_get_callback);
 891
 892     metadataType = android::gralloc4::MetadataType_Name;
 893     get(crosHandle, metadataType, metadata_get_callback);
 894
 895     metadataType = android::gralloc4::MetadataType_Width;
 896     get(crosHandle, metadataType, metadata_get_callback);
 897
 898     metadataType = android::gralloc4::MetadataType_Height;
 899     get(crosHandle, metadataType, metadata_get_callback);
 900
 901     metadataType = android::gralloc4::MetadataType_LayerCount;
 902     get(crosHandle, metadataType, metadata_get_callback);
 903
 904     metadataType = android::gralloc4::MetadataType_PixelFormatRequested;
 905     get(crosHandle, metadataType, metadata_get_callback);
 906
 907     metadataType = android::gralloc4::MetadataType_PixelFormatFourCC;
 908     get(crosHandle, metadataType, metadata_get_callback);
 909
 910     metadataType = android::gralloc4::MetadataType_PixelFormatModifier;
 911     get(crosHandle, metadataType, metadata_get_callback);
 912
 913     metadataType = android::gralloc4::MetadataType_Usage;
 914     get(crosHandle, metadataType, metadata_get_callback);
 915
 916     metadataType = android::gralloc4::MetadataType_AllocationSize;
 917     get(crosHandle, metadataType, metadata_get_callback);
 918
 919     metadataType = android::gralloc4::MetadataType_ProtectedContent;
 920     get(crosHandle, metadataType, metadata_get_callback);
 921
 922     metadataType = android::gralloc4::MetadataType_Compression;
 923     get(crosHandle, metadataType, metadata_get_callback);
 924
 925     metadataType = android::gralloc4::MetadataType_Interlaced;
 926     get(crosHandle, metadataType, metadata_get_callback);
 927
 928     metadataType = android::gralloc4::MetadataType_ChromaSiting;
 929     get(crosHandle, metadataType, metadata_get_callback);
 930
 931     metadataType = android::gralloc4::MetadataType_PlaneLayouts;
 932     get(crosHandle, metadataType, metadata_get_callback);
 933
 934     metadataType = android::gralloc4::MetadataType_Dataspace;
 935     get(crosHandle, metadataType, metadata_get_callback);
 936
 937     metadataType = android::gralloc4::MetadataType_BlendMode;
 938     get(crosHandle, metadataType, metadata_get_callback);
 939
 940     bufferDump.metadataDump = metadataDumps;
 941     hidlCb(Error::NONE, bufferDump);
 942     return Void();
 943 }
 944
 945 Return<void> CrosGralloc4Mapper::dumpBuffers(dumpBuffers_cb hidlCb) {
 946     std::vector<BufferDump> bufferDumps;
 947
 948     if (!mDriver) {
 949         drv_log("Failed to dumpBuffers. Driver is uninitialized.\n");
 950         hidlCb(Error::NO_RESOURCES, bufferDumps);
 951         return Void();
 952     }
 953
 954     Error error = Error::NONE;
 955
 956     auto handleCallback = [&](cros_gralloc_handle_t crosHandle) {
 957         auto dumpBufferCallback = [&](Error err, BufferDump bufferDump) {
 958             error = err;
 959             if (error == Error::NONE) {
 960                 bufferDumps.push_back(bufferDump);
 961             }
 962         };
 963
 964         dumpBuffer(crosHandle, dumpBufferCallback);
 965     };
 966     mDriver->for_each_handle(handleCallback);
 967
 968     hidlCb(error, bufferDumps);
 969     return Void();
 970 }
 971
 972 Return<void> CrosGralloc4Mapper::getReservedRegion(void* rawHandle, getReservedRegion_cb hidlCb) {
 973     if (!mDriver) {
 974         drv_log("Failed to getReservedRegion. Driver is uninitialized.\n");
 975         hidlCb(Error::NO_RESOURCES, nullptr, 0);
 976         return Void();
 977     }
 978
 979     buffer_handle_t bufferHandle = reinterpret_cast<buffer_handle_t>(rawHandle);
 980     if (!bufferHandle) {
 981         drv_log("Failed to getReservedRegion. Empty handle.\n");
 982         hidlCb(Error::BAD_BUFFER, nullptr, 0);
 983         return Void();
 984     }
 985
 986     cros_gralloc_handle_t crosHandle = cros_gralloc_convert_handle(bufferHandle);
 987     if (!crosHandle) {
 988         drv_log("Failed to getReservedRegion. Invalid handle.\n");
 989         hidlCb(Error::BAD_BUFFER, nullptr, 0);
 990         return Void();
 991     }
 992
 993     void* reservedRegionAddr = nullptr;
 994     uint64_t reservedRegionSize = 0;
 995     int ret = mDriver->get_reserved_region(bufferHandle, &reservedRegionAddr, &reservedRegionSize);
 996     if (ret) {
 997         drv_log("Failed to getReservedRegion.\n");
 998         hidlCb(Error::BAD_BUFFER, nullptr, 0);
 999         return Void();
1000     }
1001
1002     hidlCb(Error::NONE, reservedRegionAddr, reservedRegionSize);
1003     return Void();
1004 }
1005
1006 android::hardware::graphics::mapper::V4_0::IMapper* HIDL_FETCH_IMapper(const char* /*name*/) {
1007     return static_cast<android::hardware::graphics::mapper::V4_0::IMapper*>(new CrosGralloc4Mapper);
1008 }