cros_gralloc/gralloc3/CrosGralloc3Utils.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/gralloc3/CrosGralloc3Utils.h"
   8
   9 #include <array>
  10 #include <limits>
  11 #include <unordered_map>
  12
  13 #include <android-base/stringprintf.h>
  14 #include <android-base/strings.h>
  15 #include <cutils/native_handle.h>
  16
  17 #include "cros_gralloc/cros_gralloc_helpers.h"
  18
  19 using android::hardware::hidl_bitfield;
  20 using android::hardware::hidl_handle;
  21 using android::hardware::hidl_vec;
  22 using android::hardware::graphics::common::V1_2::BufferUsage;
  23 using android::hardware::graphics::common::V1_2::PixelFormat;
  24
  25 using BufferDescriptorInfo =
  26         android::hardware::graphics::mapper::V3_0::IMapper::BufferDescriptorInfo;
  27
  28 std::string getDrmFormatString(uint32_t drmFormat) {
  29     switch (drmFormat) {
  30         case DRM_FORMAT_ABGR1555:
  31             return "DRM_FORMAT_ABGR1555";
  32         case DRM_FORMAT_ABGR2101010:
  33             return "DRM_FORMAT_ABGR2101010";
  34         case DRM_FORMAT_ABGR4444:
  35             return "DRM_FORMAT_ABGR4444";
  36         case DRM_FORMAT_ABGR8888:
  37             return "DRM_FORMAT_ABGR8888";
  38         case DRM_FORMAT_ARGB1555:
  39             return "DRM_FORMAT_ARGB1555";
  40         case DRM_FORMAT_ARGB2101010:
  41             return "DRM_FORMAT_ARGB2101010";
  42         case DRM_FORMAT_ARGB4444:
  43             return "DRM_FORMAT_ARGB4444";
  44         case DRM_FORMAT_ARGB8888:
  45             return "DRM_FORMAT_ARGB8888";
  46         case DRM_FORMAT_AYUV:
  47             return "DRM_FORMAT_AYUV";
  48         case DRM_FORMAT_BGR233:
  49             return "DRM_FORMAT_BGR233";
  50         case DRM_FORMAT_BGR565:
  51             return "DRM_FORMAT_BGR565";
  52         case DRM_FORMAT_BGR888:
  53             return "DRM_FORMAT_BGR888";
  54         case DRM_FORMAT_BGRA1010102:
  55             return "DRM_FORMAT_BGRA1010102";
  56         case DRM_FORMAT_BGRA4444:
  57             return "DRM_FORMAT_BGRA4444";
  58         case DRM_FORMAT_BGRA5551:
  59             return "DRM_FORMAT_BGRA5551";
  60         case DRM_FORMAT_BGRA8888:
  61             return "DRM_FORMAT_BGRA8888";
  62         case DRM_FORMAT_BGRX1010102:
  63             return "DRM_FORMAT_BGRX1010102";
  64         case DRM_FORMAT_BGRX4444:
  65             return "DRM_FORMAT_BGRX4444";
  66         case DRM_FORMAT_BGRX5551:
  67             return "DRM_FORMAT_BGRX5551";
  68         case DRM_FORMAT_BGRX8888:
  69             return "DRM_FORMAT_BGRX8888";
  70         case DRM_FORMAT_C8:
  71             return "DRM_FORMAT_C8";
  72         case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
  73             return "DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED";
  74         case DRM_FORMAT_GR88:
  75             return "DRM_FORMAT_GR88";
  76         case DRM_FORMAT_NV12:
  77             return "DRM_FORMAT_NV12";
  78         case DRM_FORMAT_NV21:
  79             return "DRM_FORMAT_NV21";
  80         case DRM_FORMAT_R8:
  81             return "DRM_FORMAT_R8";
  82         case DRM_FORMAT_RG88:
  83             return "DRM_FORMAT_RG88";
  84         case DRM_FORMAT_RGB332:
  85             return "DRM_FORMAT_RGB332";
  86         case DRM_FORMAT_RGB565:
  87             return "DRM_FORMAT_RGB565";
  88         case DRM_FORMAT_RGB888:
  89             return "DRM_FORMAT_RGB888";
  90         case DRM_FORMAT_RGBA1010102:
  91             return "DRM_FORMAT_RGBA1010102";
  92         case DRM_FORMAT_RGBA4444:
  93             return "DRM_FORMAT_RGBA4444";
  94         case DRM_FORMAT_RGBA5551:
  95             return "DRM_FORMAT_RGBA5551";
  96         case DRM_FORMAT_RGBA8888:
  97             return "DRM_FORMAT_RGBA8888";
  98         case DRM_FORMAT_RGBX1010102:
  99             return "DRM_FORMAT_RGBX1010102";
 100         case DRM_FORMAT_RGBX4444:
 101             return "DRM_FORMAT_RGBX4444";
 102         case DRM_FORMAT_RGBX5551:
 103             return "DRM_FORMAT_RGBX5551";
 104         case DRM_FORMAT_RGBX8888:
 105             return "DRM_FORMAT_RGBX8888";
 106         case DRM_FORMAT_UYVY:
 107             return "DRM_FORMAT_UYVY";
 108         case DRM_FORMAT_VYUY:
 109             return "DRM_FORMAT_VYUY";
 110         case DRM_FORMAT_XBGR1555:
 111             return "DRM_FORMAT_XBGR1555";
 112         case DRM_FORMAT_XBGR2101010:
 113             return "DRM_FORMAT_XBGR2101010";
 114         case DRM_FORMAT_XBGR4444:
 115             return "DRM_FORMAT_XBGR4444";
 116         case DRM_FORMAT_XBGR8888:
 117             return "DRM_FORMAT_XBGR8888";
 118         case DRM_FORMAT_XRGB1555:
 119             return "DRM_FORMAT_XRGB1555";
 120         case DRM_FORMAT_XRGB2101010:
 121             return "DRM_FORMAT_XRGB2101010";
 122         case DRM_FORMAT_XRGB4444:
 123             return "DRM_FORMAT_XRGB4444";
 124         case DRM_FORMAT_XRGB8888:
 125             return "DRM_FORMAT_XRGB8888";
 126         case DRM_FORMAT_YUYV:
 127             return "DRM_FORMAT_YUYV";
 128         case DRM_FORMAT_YVU420:
 129             return "DRM_FORMAT_YVU420";
 130         case DRM_FORMAT_YVU420_ANDROID:
 131             return "DRM_FORMAT_YVU420";
 132         case DRM_FORMAT_YVYU:
 133             return "DRM_FORMAT_YVYU";
 134     }
 135     return android::base::StringPrintf("Unknown(%d)", drmFormat);
 136 }
 137
 138 std::string getPixelFormatString(PixelFormat format) {
 139     switch (format) {
 140         case PixelFormat::BGRA_8888:
 141             return "PixelFormat::BGRA_8888";
 142         case PixelFormat::BLOB:
 143             return "PixelFormat::BLOB";
 144         case PixelFormat::DEPTH_16:
 145             return "PixelFormat::DEPTH_16";
 146         case PixelFormat::DEPTH_24:
 147             return "PixelFormat::DEPTH_24";
 148         case PixelFormat::DEPTH_24_STENCIL_8:
 149             return "PixelFormat::DEPTH_24_STENCIL_8";
 150         case PixelFormat::DEPTH_32F:
 151             return "PixelFormat::DEPTH_24";
 152         case PixelFormat::DEPTH_32F_STENCIL_8:
 153             return "PixelFormat::DEPTH_24_STENCIL_8";
 154         case PixelFormat::HSV_888:
 155             return "PixelFormat::HSV_888";
 156         case PixelFormat::IMPLEMENTATION_DEFINED:
 157             return "PixelFormat::IMPLEMENTATION_DEFINED";
 158         case PixelFormat::RAW10:
 159             return "PixelFormat::RAW10";
 160         case PixelFormat::RAW12:
 161             return "PixelFormat::RAW12";
 162         case PixelFormat::RAW16:
 163             return "PixelFormat::RAW16";
 164         case PixelFormat::RAW_OPAQUE:
 165             return "PixelFormat::RAW_OPAQUE";
 166         case PixelFormat::RGBA_1010102:
 167             return "PixelFormat::RGBA_1010102";
 168         case PixelFormat::RGBA_8888:
 169             return "PixelFormat::RGBA_8888";
 170         case PixelFormat::RGBA_FP16:
 171             return "PixelFormat::RGBA_FP16";
 172         case PixelFormat::RGBX_8888:
 173             return "PixelFormat::RGBX_8888";
 174         case PixelFormat::RGB_565:
 175             return "PixelFormat::RGB_565";
 176         case PixelFormat::RGB_888:
 177             return "PixelFormat::RGB_888";
 178         case PixelFormat::STENCIL_8:
 179             return "PixelFormat::STENCIL_8";
 180         case PixelFormat::Y16:
 181             return "PixelFormat::Y16";
 182         case PixelFormat::Y8:
 183             return "PixelFormat::Y8";
 184         case PixelFormat::YCBCR_420_888:
 185             return "PixelFormat::YCBCR_420_888";
 186         case PixelFormat::YCBCR_422_I:
 187             return "PixelFormat::YCBCR_422_I";
 188         case PixelFormat::YCBCR_422_SP:
 189             return "PixelFormat::YCBCR_422_SP";
 190         case PixelFormat::YCBCR_P010:
 191             return "PixelFormat::YCBCR_P010";
 192         case PixelFormat::YCRCB_420_SP:
 193             return "PixelFormat::YCRCB_420_SP";
 194         case PixelFormat::YV12:
 195             return "PixelFormat::YV12";
 196     }
 197     return android::base::StringPrintf("PixelFormat::Unknown(%d)", static_cast<uint32_t>(format));
 198 }
 199
 200 std::string getUsageString(hidl_bitfield<BufferUsage> bufferUsage) {
 201     using Underlying = typename std::underlying_type<BufferUsage>::type;
 202
 203     Underlying usage = static_cast<Underlying>(bufferUsage);
 204
 205     std::vector<std::string> usages;
 206     if (usage & BufferUsage::CAMERA_INPUT) {
 207         usage &= ~static_cast<Underlying>(BufferUsage::CAMERA_INPUT);
 208         usages.push_back("BufferUsage::CAMERA_INPUT");
 209     }
 210     if (usage & BufferUsage::CAMERA_OUTPUT) {
 211         usage &= ~static_cast<Underlying>(BufferUsage::CAMERA_OUTPUT);
 212         usages.push_back("BufferUsage::CAMERA_OUTPUT");
 213     }
 214     if (usage & BufferUsage::COMPOSER_CURSOR) {
 215         usage &= ~static_cast<Underlying>(BufferUsage::COMPOSER_CURSOR);
 216         usages.push_back("BufferUsage::COMPOSER_CURSOR");
 217     }
 218     if (usage & BufferUsage::COMPOSER_OVERLAY) {
 219         usage &= ~static_cast<Underlying>(BufferUsage::COMPOSER_OVERLAY);
 220         usages.push_back("BufferUsage::COMPOSER_OVERLAY");
 221     }
 222     if (usage & BufferUsage::CPU_READ_OFTEN) {
 223         usage &= ~static_cast<Underlying>(BufferUsage::CPU_READ_OFTEN);
 224         usages.push_back("BufferUsage::CPU_READ_OFTEN");
 225     }
 226     if (usage & BufferUsage::CPU_READ_NEVER) {
 227         usage &= ~static_cast<Underlying>(BufferUsage::CPU_READ_NEVER);
 228         usages.push_back("BufferUsage::CPU_READ_NEVER");
 229     }
 230     if (usage & BufferUsage::CPU_READ_RARELY) {
 231         usage &= ~static_cast<Underlying>(BufferUsage::CPU_READ_RARELY);
 232         usages.push_back("BufferUsage::CPU_READ_RARELY");
 233     }
 234     if (usage & BufferUsage::CPU_WRITE_NEVER) {
 235         usage &= ~static_cast<Underlying>(BufferUsage::CPU_WRITE_NEVER);
 236         usages.push_back("BufferUsage::CPU_WRITE_NEVER");
 237     }
 238     if (usage & BufferUsage::CPU_WRITE_OFTEN) {
 239         usage &= ~static_cast<Underlying>(BufferUsage::CPU_WRITE_OFTEN);
 240         usages.push_back("BufferUsage::CPU_WRITE_OFTEN");
 241     }
 242     if (usage & BufferUsage::CPU_WRITE_RARELY) {
 243         usage &= ~static_cast<Underlying>(BufferUsage::CPU_WRITE_RARELY);
 244         usages.push_back("BufferUsage::CPU_WRITE_RARELY");
 245     }
 246     if (usage & BufferUsage::GPU_RENDER_TARGET) {
 247         usage &= ~static_cast<Underlying>(BufferUsage::GPU_RENDER_TARGET);
 248         usages.push_back("BufferUsage::GPU_RENDER_TARGET");
 249     }
 250     if (usage & BufferUsage::GPU_TEXTURE) {
 251         usage &= ~static_cast<Underlying>(BufferUsage::GPU_TEXTURE);
 252         usages.push_back("BufferUsage::GPU_TEXTURE");
 253     }
 254     if (usage & BufferUsage::PROTECTED) {
 255         usage &= ~static_cast<Underlying>(BufferUsage::PROTECTED);
 256         usages.push_back("BufferUsage::PROTECTED");
 257     }
 258     if (usage & BufferUsage::RENDERSCRIPT) {
 259         usage &= ~static_cast<Underlying>(BufferUsage::RENDERSCRIPT);
 260         usages.push_back("BufferUsage::RENDERSCRIPT");
 261     }
 262     if (usage & BufferUsage::VIDEO_DECODER) {
 263         usage &= ~static_cast<Underlying>(BufferUsage::VIDEO_DECODER);
 264         usages.push_back("BufferUsage::VIDEO_DECODER");
 265     }
 266     if (usage & BufferUsage::VIDEO_ENCODER) {
 267         usage &= ~static_cast<Underlying>(BufferUsage::VIDEO_ENCODER);
 268         usages.push_back("BufferUsage::VIDEO_ENCODER");
 269     }
 270
 271     if (usage) {
 272         usages.push_back(android::base::StringPrintf("UnknownUsageBits-%" PRIu64, usage));
 273     }
 274
 275     return android::base::Join(usages, '|');
 276 }
 277
 278 int convertToDrmFormat(PixelFormat format, uint32_t* outDrmFormat) {
 279     switch (format) {
 280         case PixelFormat::BGRA_8888:
 281             *outDrmFormat = DRM_FORMAT_ARGB8888;
 282             return 0;
 283         /**
 284          * Choose DRM_FORMAT_R8 because <system/graphics.h> requires the buffers
 285          * with a format HAL_PIXEL_FORMAT_BLOB have a height of 1, and width
 286          * equal to their size in bytes.
 287          */
 288         case PixelFormat::BLOB:
 289             *outDrmFormat = DRM_FORMAT_R8;
 290             return 0;
 291         case PixelFormat::DEPTH_16:
 292             return -EINVAL;
 293         case PixelFormat::DEPTH_24:
 294             return -EINVAL;
 295         case PixelFormat::DEPTH_24_STENCIL_8:
 296             return -EINVAL;
 297         case PixelFormat::DEPTH_32F:
 298             return -EINVAL;
 299         case PixelFormat::DEPTH_32F_STENCIL_8:
 300             return -EINVAL;
 301         case PixelFormat::HSV_888:
 302             return -EINVAL;
 303         case PixelFormat::IMPLEMENTATION_DEFINED:
 304             *outDrmFormat = DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED;
 305             return 0;
 306         case PixelFormat::RAW10:
 307             return -EINVAL;
 308         case PixelFormat::RAW12:
 309             return -EINVAL;
 310         case PixelFormat::RAW16:
 311             *outDrmFormat = DRM_FORMAT_R16;
 312             return 0;
 313         /* TODO use blob */
 314         case PixelFormat::RAW_OPAQUE:
 315             return -EINVAL;
 316         case PixelFormat::RGBA_1010102:
 317             *outDrmFormat = DRM_FORMAT_ABGR2101010;
 318             return 0;
 319         case PixelFormat::RGBA_8888:
 320             *outDrmFormat = DRM_FORMAT_ABGR8888;
 321             return 0;
 322         case PixelFormat::RGBA_FP16:
 323             *outDrmFormat = DRM_FORMAT_ABGR16161616F;
 324             return 0;
 325         case PixelFormat::RGBX_8888:
 326             *outDrmFormat = DRM_FORMAT_XBGR8888;
 327             return 0;
 328         case PixelFormat::RGB_565:
 329             *outDrmFormat = DRM_FORMAT_RGB565;
 330             return 0;
 331         case PixelFormat::RGB_888:
 332             *outDrmFormat = DRM_FORMAT_RGB888;
 333             return 0;
 334         case PixelFormat::STENCIL_8:
 335             return -EINVAL;
 336         case PixelFormat::Y16:
 337             *outDrmFormat = DRM_FORMAT_R16;
 338             return 0;
 339         case PixelFormat::Y8:
 340             *outDrmFormat = DRM_FORMAT_R8;
 341             return 0;
 342         case PixelFormat::YCBCR_420_888:
 343             *outDrmFormat = DRM_FORMAT_FLEX_YCbCr_420_888;
 344             return 0;
 345         case PixelFormat::YCBCR_422_SP:
 346             return -EINVAL;
 347         case PixelFormat::YCBCR_422_I:
 348             return -EINVAL;
 349         case PixelFormat::YCBCR_P010:
 350             *outDrmFormat = DRM_FORMAT_P010;
 351             return 0;
 352         case PixelFormat::YCRCB_420_SP:
 353             *outDrmFormat = DRM_FORMAT_NV21;
 354             return 0;
 355         case PixelFormat::YV12:
 356             *outDrmFormat = DRM_FORMAT_YVU420_ANDROID;
 357             return 0;
 358     };
 359     return -EINVAL;
 360 }
 361
 362 int convertToBufferUsage(uint64_t grallocUsage, uint64_t* outBufferUsage) {
 363     uint64_t bufferUsage = BO_USE_NONE;
 364
 365     if ((grallocUsage & BufferUsage::CPU_READ_MASK) ==
 366         static_cast<uint64_t>(BufferUsage::CPU_READ_RARELY)) {
 367         bufferUsage |= BO_USE_SW_READ_RARELY;
 368     }
 369     if ((grallocUsage & BufferUsage::CPU_READ_MASK) ==
 370         static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN)) {
 371         bufferUsage |= BO_USE_SW_READ_OFTEN;
 372     }
 373     if ((grallocUsage & BufferUsage::CPU_WRITE_MASK) ==
 374         static_cast<uint64_t>(BufferUsage::CPU_WRITE_RARELY)) {
 375         bufferUsage |= BO_USE_SW_WRITE_RARELY;
 376     }
 377     if ((grallocUsage & BufferUsage::CPU_WRITE_MASK) ==
 378         static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN)) {
 379         bufferUsage |= BO_USE_SW_WRITE_OFTEN;
 380     }
 381     if (grallocUsage & BufferUsage::GPU_TEXTURE) {
 382         bufferUsage |= BO_USE_TEXTURE;
 383     }
 384     if (grallocUsage & BufferUsage::GPU_RENDER_TARGET) {
 385         bufferUsage |= BO_USE_RENDERING;
 386     }
 387     if (grallocUsage & BufferUsage::COMPOSER_OVERLAY) {
 388         /* HWC wants to use display hardware, but can defer to OpenGL. */
 389         bufferUsage |= BO_USE_SCANOUT | BO_USE_TEXTURE;
 390     }
 391     if (grallocUsage & BufferUsage::PROTECTED) {
 392         bufferUsage |= BO_USE_PROTECTED;
 393     }
 394     if (grallocUsage & BufferUsage::COMPOSER_CURSOR) {
 395         bufferUsage |= BO_USE_NONE;
 396     }
 397     if (grallocUsage & BufferUsage::VIDEO_ENCODER) {
 398         /*HACK: See b/30054495 */
 399         bufferUsage |= BO_USE_SW_READ_OFTEN;
 400     }
 401     if (grallocUsage & BufferUsage::CAMERA_OUTPUT) {
 402         bufferUsage |= BO_USE_CAMERA_WRITE;
 403     }
 404     if (grallocUsage & BufferUsage::CAMERA_INPUT) {
 405         bufferUsage |= BO_USE_CAMERA_READ;
 406     }
 407     if (grallocUsage & BufferUsage::RENDERSCRIPT) {
 408         bufferUsage |= BO_USE_RENDERSCRIPT;
 409     }
 410     if (grallocUsage & BufferUsage::VIDEO_DECODER) {
 411         bufferUsage |= BO_USE_HW_VIDEO_DECODER;
 412     }
 413
 414     *outBufferUsage = bufferUsage;
 415     return 0;
 416 }
 417
 418 int convertToMapUsage(uint64_t grallocUsage, uint32_t* outMapUsage) {
 419     uint32_t mapUsage = BO_MAP_NONE;
 420
 421     if (grallocUsage & BufferUsage::CPU_READ_MASK) {
 422         mapUsage |= BO_MAP_READ;
 423     }
 424     if (grallocUsage & BufferUsage::CPU_WRITE_MASK) {
 425         mapUsage |= BO_MAP_WRITE;
 426     }
 427
 428     *outMapUsage = mapUsage;
 429     return 0;
 430 }
 431
 432 int convertToCrosDescriptor(const BufferDescriptorInfo& descriptor,
 433                             struct cros_gralloc_buffer_descriptor* outCrosDescriptor) {
 434     outCrosDescriptor->width = descriptor.width;
 435     outCrosDescriptor->height = descriptor.height;
 436     outCrosDescriptor->droid_format = static_cast<int32_t>(descriptor.format);
 437     outCrosDescriptor->droid_usage = descriptor.usage;
 438     outCrosDescriptor->reserved_region_size = 0;
 439
 440     if (convertToDrmFormat(descriptor.format, &outCrosDescriptor->drm_format)) {
 441         std::string pixelFormatString = getPixelFormatString(descriptor.format);
 442         drv_log("Failed to convert descriptor. Unsupported format %s\n", pixelFormatString.c_str());
 443         return -1;
 444     }
 445     if (convertToBufferUsage(descriptor.usage, &outCrosDescriptor->use_flags)) {
 446         std::string usageString = getUsageString(descriptor.usage);
 447         drv_log("Failed to convert descriptor. Unsupported usage flags %s\n", usageString.c_str());
 448         return -1;
 449     }
 450     return 0;
 451 }
 452
 453 int convertToFenceFd(const hidl_handle& fenceHandle, int* outFenceFd) {
 454     if (!outFenceFd) {
 455         return -EINVAL;
 456     }
 457
 458     const native_handle_t* nativeHandle = fenceHandle.getNativeHandle();
 459     if (nativeHandle && nativeHandle->numFds > 1) {
 460         return -EINVAL;
 461     }
 462
 463     *outFenceFd = (nativeHandle && nativeHandle->numFds == 1) ? nativeHandle->data[0] : -1;
 464     return 0;
 465 }
 466
 467 int convertToFenceHandle(int fenceFd, hidl_handle* outFenceHandle) {
 468     if (!outFenceHandle) {
 469         return -EINVAL;
 470     }
 471     if (fenceFd < 0) {
 472         return 0;
 473     }
 474
 475     NATIVE_HANDLE_DECLARE_STORAGE(handleStorage, 1, 0);
 476     auto fenceHandle = native_handle_init(handleStorage, 1, 0);
 477     fenceHandle->data[0] = fenceFd;
 478
 479     *outFenceHandle = fenceHandle;
 480     return 0;
 481 }
 482
 483 std::optional<BufferDescriptorInfo> decodeBufferDescriptorInfo(const hidl_vec<uint32_t>& encoded) {
 484     if (encoded.size() != 5) {
 485         drv_log("Failed to decodeBufferDescriptorInfo. Invalid size: %zd.\n", encoded.size());
 486         return {};
 487     }
 488
 489     BufferDescriptorInfo descriptor;
 490     descriptor.width = encoded[0];
 491     descriptor.height = encoded[1];
 492     descriptor.layerCount = encoded[2];
 493     descriptor.format = static_cast<PixelFormat>(encoded[3]);
 494     descriptor.usage = encoded[4];
 495     return std::move(descriptor);
 496 }
 497
 498 std::optional<hidl_vec<uint32_t>> encodeBufferDescriptorInfo(const BufferDescriptorInfo& info) {
 499     hidl_vec<uint32_t> encoded;
 500     encoded.resize(5);
 501     encoded[0] = info.width;
 502     encoded[1] = info.height;
 503     encoded[2] = info.layerCount;
 504     encoded[3] = static_cast<uint32_t>(info.format);
 505     encoded[4] = info.usage & std::numeric_limits<uint32_t>::max();
 506     return std::move(encoded);
 507 }