| // Copyright 2024 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "GrallocEmulated.h" |
| |
| #include <cutils/log.h> |
| |
| #include <optional> |
| #include <unordered_map> |
| |
| #include "drm_fourcc.h" |
| |
| namespace gfxstream { |
| namespace { |
| |
| static constexpr int numFds = 0; |
| static constexpr int numInts = 1; |
| |
| #define DRM_FORMAT_R8_BLOB fourcc_code('9', '9', '9', '9') |
| |
| template <typename T, typename N> |
| T DivideRoundUp(T n, N divisor) { |
| const T div = static_cast<T>(divisor); |
| const T q = n / div; |
| return n % div == 0 ? q : q + 1; |
| } |
| |
| template <typename T, typename N> |
| T Align(T number, N n) { |
| return DivideRoundUp(number, n) * n; |
| } |
| |
| std::optional<uint32_t> GlFormatToDrmFormat(uint32_t glFormat) { |
| switch (glFormat) { |
| case kGlRGB: |
| return DRM_FORMAT_BGR888; |
| case kGlRGB565: |
| return DRM_FORMAT_BGR565; |
| case kGlRGBA: |
| return DRM_FORMAT_ABGR8888; |
| } |
| return std::nullopt; |
| } |
| |
| std::optional<uint32_t> AhbToDrmFormat(uint32_t ahbFormat) { |
| switch (ahbFormat) { |
| case GFXSTREAM_AHB_FORMAT_R8G8B8A8_UNORM: |
| return DRM_FORMAT_ABGR8888; |
| case GFXSTREAM_AHB_FORMAT_R8G8B8X8_UNORM: |
| return DRM_FORMAT_XBGR8888; |
| case GFXSTREAM_AHB_FORMAT_R8G8B8_UNORM: |
| return DRM_FORMAT_BGR888; |
| /* |
| * Confusingly, AHARDWAREBUFFER_FORMAT_RGB_565 is defined as: |
| * |
| * "16-bit packed format that has 5-bit R, 6-bit G, and 5-bit B components, in that |
| * order, from the most-sigfinicant bits to the least-significant bits." |
| * |
| * so the order of the components is intentionally not flipped between the pixel |
| * format and the DRM format. |
| */ |
| case GFXSTREAM_AHB_FORMAT_R5G6B5_UNORM: |
| return DRM_FORMAT_RGB565; |
| case GFXSTREAM_AHB_FORMAT_B8G8R8A8_UNORM: |
| return DRM_FORMAT_ARGB8888; |
| case GFXSTREAM_AHB_FORMAT_BLOB: |
| return DRM_FORMAT_R8_BLOB; |
| case GFXSTREAM_AHB_FORMAT_R8_UNORM: |
| return DRM_FORMAT_R8; |
| case GFXSTREAM_AHB_FORMAT_YV12: |
| return DRM_FORMAT_YVU420; |
| case GFXSTREAM_AHB_FORMAT_R16G16B16A16_FLOAT: |
| return DRM_FORMAT_ABGR16161616F; |
| case GFXSTREAM_AHB_FORMAT_R10G10B10A2_UNORM: |
| return DRM_FORMAT_ABGR2101010; |
| case GFXSTREAM_AHB_FORMAT_Y8Cb8Cr8_420: |
| return DRM_FORMAT_NV12; |
| } |
| return std::nullopt; |
| } |
| |
| struct DrmFormatPlaneInfo { |
| uint32_t horizontalSubsampling; |
| uint32_t verticalSubsampling; |
| uint32_t bytesPerPixel; |
| }; |
| struct DrmFormatInfo { |
| uint32_t androidFormat; |
| uint32_t virglFormat; |
| bool isYuv; |
| uint32_t horizontalAlignmentPixels; |
| uint32_t verticalAlignmentPixels; |
| std::vector<DrmFormatPlaneInfo> planes; |
| }; |
| const std::unordered_map<uint32_t, DrmFormatInfo>& GetDrmFormatInfoMap() { |
| static const auto* kFormatInfoMap = new std::unordered_map<uint32_t, DrmFormatInfo>({ |
| {DRM_FORMAT_ABGR8888, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_R8G8B8A8_UNORM, |
| .virglFormat = VIRGL_FORMAT_R8G8B8A8_UNORM, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 4, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_ARGB8888, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_B8G8R8A8_UNORM, |
| .virglFormat = VIRGL_FORMAT_B8G8R8A8_UNORM, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 4, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_BGR888, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_R8G8B8_UNORM, |
| .virglFormat = VIRGL_FORMAT_R8G8B8_UNORM, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 3, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_BGR565, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_R5G6B5_UNORM, |
| .virglFormat = VIRGL_FORMAT_B5G6R5_UNORM, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 2, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_R8, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_R8_UNORM, |
| .virglFormat = VIRGL_FORMAT_R8_UNORM, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 1, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_R8_BLOB, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_BLOB, |
| .virglFormat = VIRGL_FORMAT_R8_UNORM, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 1, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_ABGR16161616F, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_R16G16B16A16_FLOAT, |
| .virglFormat = VIRGL_FORMAT_R16G16B16A16_FLOAT, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 8, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_ABGR2101010, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_R10G10B10A2_UNORM, |
| .virglFormat = VIRGL_FORMAT_R10G10B10A2_UNORM, |
| .isYuv = false, |
| .horizontalAlignmentPixels = 1, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 4, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_NV12, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_Y8Cb8Cr8_420, |
| .virglFormat = VIRGL_FORMAT_NV12, |
| .isYuv = true, |
| .horizontalAlignmentPixels = 2, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 1, |
| }, |
| { |
| .horizontalSubsampling = 2, |
| .verticalSubsampling = 2, |
| .bytesPerPixel = 2, |
| }, |
| }, |
| }}, |
| {DRM_FORMAT_YVU420, |
| { |
| .androidFormat = GFXSTREAM_AHB_FORMAT_YV12, |
| .virglFormat = VIRGL_FORMAT_YV12, |
| .isYuv = true, |
| .horizontalAlignmentPixels = 32, |
| .verticalAlignmentPixels = 1, |
| .planes = |
| { |
| { |
| .horizontalSubsampling = 1, |
| .verticalSubsampling = 1, |
| .bytesPerPixel = 1, |
| }, |
| { |
| .horizontalSubsampling = 2, |
| .verticalSubsampling = 2, |
| .bytesPerPixel = 1, |
| }, |
| { |
| .horizontalSubsampling = 2, |
| .verticalSubsampling = 2, |
| .bytesPerPixel = 1, |
| }, |
| }, |
| }}, |
| }); |
| return *kFormatInfoMap; |
| } |
| |
| } // namespace |
| |
| EmulatedAHardwareBuffer::EmulatedAHardwareBuffer(uint32_t width, uint32_t height, |
| uint32_t drmFormat, VirtGpuResourcePtr resource) |
| : mRefCount(1), mWidth(width), mHeight(height), mDrmFormat(drmFormat), mResource(resource) {} |
| |
| EmulatedAHardwareBuffer::~EmulatedAHardwareBuffer() {} |
| |
| uint32_t EmulatedAHardwareBuffer::getResourceId() const { return mResource->getResourceHandle(); } |
| |
| uint32_t EmulatedAHardwareBuffer::getWidth() const { return mWidth; } |
| |
| uint32_t EmulatedAHardwareBuffer::getHeight() const { return mHeight; } |
| |
| int EmulatedAHardwareBuffer::getAndroidFormat() const { |
| const auto& formatInfosMap = GetDrmFormatInfoMap(); |
| auto formatInfoIt = formatInfosMap.find(mDrmFormat); |
| if (formatInfoIt == formatInfosMap.end()) { |
| ALOGE("Unhandled DRM format:%u", mDrmFormat); |
| return -1; |
| } |
| const auto& formatInfo = formatInfoIt->second; |
| return formatInfo.androidFormat; |
| } |
| |
| uint32_t EmulatedAHardwareBuffer::getDrmFormat() const { return mDrmFormat; } |
| |
| AHardwareBuffer* EmulatedAHardwareBuffer::asAHardwareBuffer() { |
| return reinterpret_cast<AHardwareBuffer*>(this); |
| } |
| |
| buffer_handle_t EmulatedAHardwareBuffer::asBufferHandle() { |
| return reinterpret_cast<buffer_handle_t>(this); |
| } |
| |
| EGLClientBuffer EmulatedAHardwareBuffer::asEglClientBuffer() { |
| return reinterpret_cast<EGLClientBuffer>(this); |
| } |
| |
| void EmulatedAHardwareBuffer::acquire() { ++mRefCount; } |
| |
| void EmulatedAHardwareBuffer::release() { |
| --mRefCount; |
| if (mRefCount == 0) { |
| delete this; |
| } |
| } |
| |
| int EmulatedAHardwareBuffer::lock(uint8_t** ptr) { |
| if (!mMapped) { |
| mMapped = mResource->createMapping(); |
| if (!mMapped) { |
| ALOGE("Failed to lock EmulatedAHardwareBuffer: failed to create mapping."); |
| return -1; |
| } |
| |
| mResource->transferFromHost(0, 0, mWidth, mHeight); |
| mResource->wait(); |
| } |
| |
| *ptr = (*mMapped)->asRawPtr(); |
| return 0; |
| } |
| |
| int EmulatedAHardwareBuffer::lockPlanes(std::vector<Gralloc::LockedPlane>* ahbPlanes) { |
| uint8_t* data = 0; |
| int ret = lock(&data); |
| if (ret) { |
| return ret; |
| } |
| |
| const auto& formatInfosMap = GetDrmFormatInfoMap(); |
| auto formatInfoIt = formatInfosMap.find(mDrmFormat); |
| if (formatInfoIt == formatInfosMap.end()) { |
| ALOGE("Failed to lock: failed to find format info for drm format:%u", mDrmFormat); |
| return -1; |
| } |
| const auto& formatInfo = formatInfoIt->second; |
| |
| const uint32_t alignedWidth = Align(mWidth, formatInfo.horizontalAlignmentPixels); |
| const uint32_t alignedHeight = Align(mHeight, formatInfo.verticalAlignmentPixels); |
| uint32_t cumulativeSize = 0; |
| for (const DrmFormatPlaneInfo& planeInfo : formatInfo.planes) { |
| const uint32_t planeWidth = DivideRoundUp(alignedWidth, planeInfo.horizontalSubsampling); |
| const uint32_t planeHeight = DivideRoundUp(alignedHeight, planeInfo.verticalSubsampling); |
| const uint32_t planeBpp = planeInfo.bytesPerPixel; |
| const uint32_t planeStrideBytes = planeWidth * planeBpp; |
| const uint32_t planeSizeBytes = planeHeight * planeStrideBytes; |
| ahbPlanes->emplace_back(Gralloc::LockedPlane{ |
| .data = data + cumulativeSize, |
| .pixelStrideBytes = planeBpp, |
| .rowStrideBytes = planeStrideBytes, |
| }); |
| cumulativeSize += planeSizeBytes; |
| } |
| |
| if (mDrmFormat == DRM_FORMAT_NV12) { |
| const auto& uPlane = (*ahbPlanes)[1]; |
| auto vPlane = uPlane; |
| vPlane.data += 1; |
| |
| ahbPlanes->push_back(vPlane); |
| } else if (mDrmFormat == DRM_FORMAT_YVU420) { |
| // Note: lockPlanes() always returns Y, then U, then V but YV12 is Y, then V, then U. |
| auto& plane1 = (*ahbPlanes)[1]; |
| auto& plane2 = (*ahbPlanes)[2]; |
| std::swap(plane1, plane2); |
| } |
| |
| return 0; |
| } |
| |
| int EmulatedAHardwareBuffer::unlock() { |
| if (!mMapped) { |
| ALOGE("Failed to unlock EmulatedAHardwareBuffer: never locked?"); |
| return -1; |
| } |
| mResource->transferToHost(0, 0, mWidth, mHeight); |
| mResource->wait(); |
| mMapped.reset(); |
| return 0; |
| } |
| |
| EmulatedGralloc::EmulatedGralloc() {} |
| |
| uint32_t EmulatedGralloc::createColorBuffer(void*, int width, int height, uint32_t glFormat) { |
| auto drmFormat = GlFormatToDrmFormat(glFormat); |
| if (!drmFormat) { |
| ALOGE("Unhandled format"); |
| return -1; |
| } |
| |
| auto ahb = allocate(width, height, *drmFormat); |
| if (ahb == nullptr) { |
| return -1; |
| } |
| |
| EmulatedAHardwareBuffer* rahb = reinterpret_cast<EmulatedAHardwareBuffer*>(ahb); |
| |
| mOwned.emplace_back(rahb); |
| |
| return rahb->getResourceId(); |
| } |
| |
| int EmulatedGralloc::allocate(uint32_t width, uint32_t height, uint32_t ahbFormat, uint64_t usage, |
| AHardwareBuffer** outputAhb) { |
| (void)usage; |
| |
| auto drmFormat = AhbToDrmFormat(ahbFormat); |
| if (!drmFormat) { |
| ALOGE("Unhandled AHB format:%u", ahbFormat); |
| return -1; |
| } |
| |
| *outputAhb = allocate(width, height, *drmFormat); |
| if (*outputAhb == nullptr) { |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| AHardwareBuffer* EmulatedGralloc::allocate(uint32_t width, uint32_t height, uint32_t drmFormat) { |
| ALOGE("Allocating AHB w:%u, h:%u, format %u", width, height, drmFormat); |
| |
| auto device = VirtGpuDevice::getInstance(); |
| if (!device) { |
| ALOGE("Failed to allocate: no virtio gpu device."); |
| return nullptr; |
| } |
| |
| const auto& formatInfosMap = GetDrmFormatInfoMap(); |
| auto formatInfoIt = formatInfosMap.find(drmFormat); |
| if (formatInfoIt == formatInfosMap.end()) { |
| ALOGE("Failed to allocate: failed to find format info for drm format:%u", drmFormat); |
| return nullptr; |
| } |
| const auto& formatInfo = formatInfoIt->second; |
| |
| const uint32_t alignedWidth = Align(width, formatInfo.horizontalAlignmentPixels); |
| const uint32_t alignedHeight = Align(height, formatInfo.verticalAlignmentPixels); |
| uint32_t stride = 0; |
| uint32_t size = 0; |
| for (uint32_t i = 0; i < formatInfo.planes.size(); i++) { |
| const DrmFormatPlaneInfo& planeInfo = formatInfo.planes[i]; |
| const uint32_t planeWidth = DivideRoundUp(alignedWidth, planeInfo.horizontalSubsampling); |
| const uint32_t planeHeight = DivideRoundUp(alignedHeight, planeInfo.verticalSubsampling); |
| const uint32_t planeBpp = planeInfo.bytesPerPixel; |
| const uint32_t planeStrideBytes = planeWidth * planeBpp; |
| const uint32_t planeSizeBytes = planeHeight * planeStrideBytes; |
| size += planeSizeBytes; |
| if (i == 0) stride = planeStrideBytes; |
| } |
| |
| const uint32_t bind = (drmFormat == DRM_FORMAT_R8_BLOB || drmFormat == DRM_FORMAT_NV12 || |
| drmFormat == DRM_FORMAT_YVU420) |
| ? VIRGL_BIND_LINEAR |
| : VIRGL_BIND_RENDER_TARGET; |
| |
| auto resource = device->createResource(width, height, stride, size, formatInfo.virglFormat, |
| PIPE_TEXTURE_2D, bind); |
| if (!resource) { |
| ALOGE("Failed to allocate: failed to create virtio resource."); |
| return nullptr; |
| } |
| |
| resource->wait(); |
| |
| return reinterpret_cast<AHardwareBuffer*>( |
| new EmulatedAHardwareBuffer(width, height, drmFormat, std::move(resource))); |
| } |
| |
| void EmulatedGralloc::acquire(AHardwareBuffer* ahb) { |
| auto* rahb = reinterpret_cast<EmulatedAHardwareBuffer*>(ahb); |
| rahb->acquire(); |
| } |
| |
| void EmulatedGralloc::release(AHardwareBuffer* ahb) { |
| auto* rahb = reinterpret_cast<EmulatedAHardwareBuffer*>(ahb); |
| rahb->release(); |
| } |
| |
| int EmulatedGralloc::lock(AHardwareBuffer* ahb, uint8_t** ptr) { |
| auto* rahb = reinterpret_cast<EmulatedAHardwareBuffer*>(ahb); |
| return rahb->lock(ptr); |
| } |
| |
| int EmulatedGralloc::lockPlanes(AHardwareBuffer* ahb, std::vector<LockedPlane>* ahbPlanes) { |
| auto* rahb = reinterpret_cast<EmulatedAHardwareBuffer*>(ahb); |
| return rahb->lockPlanes(ahbPlanes); |
| } |
| |
| int EmulatedGralloc::unlock(AHardwareBuffer* ahb) { |
| auto* rahb = reinterpret_cast<EmulatedAHardwareBuffer*>(ahb); |
| return rahb->unlock(); |
| } |
| |
| uint32_t EmulatedGralloc::getHostHandle(const native_handle_t* handle) { |
| const auto* ahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(handle); |
| return ahb->getResourceId(); |
| } |
| |
| uint32_t EmulatedGralloc::getHostHandle(const AHardwareBuffer* handle) { |
| const auto* ahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(handle); |
| return ahb->getResourceId(); |
| } |
| |
| const native_handle_t* EmulatedGralloc::getNativeHandle(const AHardwareBuffer* ahb) { |
| return reinterpret_cast<const native_handle_t*>(ahb); |
| } |
| |
| int EmulatedGralloc::getFormat(const native_handle_t* handle) { |
| const auto* ahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(handle); |
| return ahb->getAndroidFormat(); |
| } |
| |
| int EmulatedGralloc::getFormat(const AHardwareBuffer* handle) { |
| const auto* ahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(handle); |
| return ahb->getAndroidFormat(); |
| } |
| |
| uint32_t EmulatedGralloc::getFormatDrmFourcc(const AHardwareBuffer* handle) { |
| const auto* ahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(handle); |
| return ahb->getDrmFormat(); |
| } |
| |
| uint32_t EmulatedGralloc::getWidth(const AHardwareBuffer* handle) { |
| const auto* ahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(handle); |
| return ahb->getWidth(); |
| } |
| |
| uint32_t EmulatedGralloc::getHeight(const AHardwareBuffer* handle) { |
| const auto* ahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(handle); |
| return ahb->getHeight(); |
| } |
| |
| size_t EmulatedGralloc::getAllocatedSize(const native_handle_t*) { |
| ALOGE("Unimplemented."); |
| return 0; |
| } |
| |
| size_t EmulatedGralloc::getAllocatedSize(const AHardwareBuffer*) { |
| ALOGE("Unimplemented."); |
| return 0; |
| } |
| |
| int EmulatedGralloc::getId(const AHardwareBuffer* ahb, uint64_t* id) { |
| const auto* rahb = reinterpret_cast<const EmulatedAHardwareBuffer*>(ahb); |
| *id = rahb->getResourceId(); |
| return 0; |
| } |
| |
| Gralloc* createPlatformGralloc(int /*deviceFd*/) { |
| return new EmulatedGralloc(); |
| } |
| |
| } // namespace gfxstream |
