| /* |
| * 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. |
| */ |
| #define LOG_TAG "BufferAdapter" |
| |
| #include "BufferAdapter.h" |
| |
| #include <libcamera/base/log.h> |
| |
| #include <cutils/properties.h> |
| #include <hardware/hardware.h> |
| #include <inttypes.h> |
| #include <memory> |
| #include <string> |
| #include <cutils/properties.h> |
| |
| using namespace libcamera; |
| |
| LOG_DECLARE_CATEGORY(HAL) |
| |
| #define HANDLE_EINTR(x) \ |
| ({ \ |
| decltype(x) eintr_wrapper_result; \ |
| do \ |
| { \ |
| eintr_wrapper_result = (x); \ |
| } while (eintr_wrapper_result == -1 && errno == EINTR); \ |
| eintr_wrapper_result; \ |
| }) |
| |
| /* This enumeration must match the one in <gralloc_drm.h>. |
| * The functions supported by this gralloc's temporary private API are listed |
| * below. Use of these functions is highly discouraged and should only be |
| * reserved for cases where no alternative to get same information (such as |
| * querying ANativeWindow) exists. |
| */ |
| // clang-format off |
| enum { |
| GRALLOC_DRM_GET_STRIDE, |
| GRALLOC_DRM_GET_FORMAT, |
| GRALLOC_DRM_GET_DIMENSIONS, |
| GRALLOC_DRM_GET_BACKING_STORE, |
| GRALLOC_DRM_GET_BUFFER_INFO, |
| GRALLOC_DRM_GET_USAGE, |
| }; |
| |
| namespace { |
| |
| const struct SupportedFormat { |
| int halFormat; |
| // |drmFormat| is set to 0 for multi-planar formats. The actual format will be resolved in |
| // |SupportedPlanarFormat|. |
| uint32_t drmFormat; |
| } kSupportedFormats[] = { |
| {HAL_PIXEL_FORMAT_BGRA_8888, DRM_FORMAT_ARGB8888}, |
| {HAL_PIXEL_FORMAT_RGBA_8888, DRM_FORMAT_ABGR8888}, |
| {HAL_PIXEL_FORMAT_RGBX_8888, DRM_FORMAT_XBGR8888}, |
| {HAL_PIXEL_FORMAT_YCbCr_422_I, DRM_FORMAT_YUYV}, |
| // There is no exact match for HAL_PIXEL_FORMAT_BLOB in DRM format. Use DRM_FORMAT_R8 |
| // because it is one byte per pixel. |
| {HAL_PIXEL_FORMAT_BLOB, DRM_FORMAT_R8}, |
| {HAL_PIXEL_FORMAT_YV12, 0}, |
| {HAL_PIXEL_FORMAT_YCbCr_420_888, 0}, |
| {HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 0}, |
| // Add more buffer formats when needed. |
| }; |
| |
| const struct SupportedPlanarFormat { |
| int halFormat; |
| bool crcb; |
| bool semiplanar; |
| uint32_t drmFormat; |
| } kSupportedPlanarFormats[] = { |
| {HAL_PIXEL_FORMAT_YV12, true, false, DRM_FORMAT_YVU420}, |
| {HAL_PIXEL_FORMAT_YCbCr_420_888, false, false, DRM_FORMAT_YUV420}, |
| {HAL_PIXEL_FORMAT_YCbCr_420_888, true, false, DRM_FORMAT_YVU420}, |
| {HAL_PIXEL_FORMAT_YCbCr_420_888, false, true, DRM_FORMAT_NV12}, |
| {HAL_PIXEL_FORMAT_YCbCr_420_888, true, true, DRM_FORMAT_NV21}, |
| {HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, false, false, DRM_FORMAT_YUV420}, |
| {HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, true, false, DRM_FORMAT_YVU420}, |
| {HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, false, true, DRM_FORMAT_NV12}, |
| {HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, true, true, DRM_FORMAT_NV21}, |
| // Add more buffer formats when needed. |
| }; |
| |
| static inline int getBpp(uint32_t drmFormat) { |
| switch (drmFormat) { |
| case DRM_FORMAT_ABGR8888: |
| case DRM_FORMAT_ARGB8888: |
| case DRM_FORMAT_XBGR8888: |
| return 4; |
| case DRM_FORMAT_BGR888: |
| return 3; |
| case DRM_FORMAT_RGB565: |
| case DRM_FORMAT_YUYV: |
| case DRM_FORMAT_MTISP_SXYZW10: |
| return 2; |
| case DRM_FORMAT_YVU420: |
| case DRM_FORMAT_NV16: |
| case DRM_FORMAT_NV21: |
| case DRM_FORMAT_NV12: |
| case DRM_FORMAT_R8: |
| return 1; |
| default: |
| LOG(HAL, Error) << "Unsupported DRM fourcc " << drmFormat |
| << ".Forgot to add switch case here?"; |
| return 0; |
| } |
| } |
| |
| // A helper function to get the singleton instance of the gralloc module. |
| static const gralloc_module_t* GetGrallocModule() { |
| static const gralloc_module_t* sGrallocModule; |
| static std::mutex sGrallocModuleLock; |
| |
| std::unique_lock<std::mutex> l(sGrallocModuleLock); |
| if (!sGrallocModule) { |
| if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, |
| reinterpret_cast<const hw_module_t**>(&sGrallocModule))) { |
| LOG(HAL, Error) << "Failed to initialize gralloc module"; |
| return nullptr; |
| } |
| } |
| return sGrallocModule; |
| } |
| |
| } // end of anonymous namespace |
| |
| namespace android { |
| |
| camera3_stream_buffer_t BufferAdapter::prepareStreamBufferPtr(const camera3_stream_buffer* buffer) { |
| std::unique_lock<std::mutex> bufferLock(mBufferHandlesLock); |
| buffer_handle_t* nativeHandle = buffer->buffer; |
| // Use the pointer value of buffer_handle_t as buffer ID. |
| uint64_t bufferId = reinterpret_cast<uint64_t>(nativeHandle); |
| uint32_t drmFormat = 0; |
| uint32_t width, height; |
| uint32_t numPlanes; |
| std::vector<uint32_t> strides; |
| std::vector<uint32_t> offsets; |
| |
| AdaptedHandle &adaptedBuffer = mAdaptedBufferHandles[bufferId]; |
| adaptedBuffer.buffer_handle = reinterpret_cast<buffer_handle_t>(&adaptedBuffer.camera_buffer_handle); |
| |
| camera_buffer_handle_t *handle_ptr = &adaptedBuffer.camera_buffer_handle; |
| |
| // Resolve DRM format fourcc from Android format. |
| int androidFormat; |
| int ret; |
| ret = mGrallocModule->perform(mGrallocModule, GRALLOC_DRM_GET_FORMAT, *nativeHandle, |
| &androidFormat); |
| if (ret) { |
| LOG(HAL, Error) << "Failed to get format"; |
| return *buffer; |
| } |
| auto value = std::find_if( |
| std::begin(kSupportedFormats), std::end(kSupportedFormats), |
| [androidFormat](struct SupportedFormat f) { return f.halFormat == androidFormat; }); |
| if (value == std::end(kSupportedFormats)) { |
| LOG(HAL, Error) << "Unsupported android format: " << androidFormat; |
| return *buffer; |
| } |
| drmFormat = value->drmFormat; |
| if (drmFormat) { |
| // Single-planar buffer. |
| numPlanes = 1; |
| uint32_t stride; |
| ret = mGrallocModule->perform(mGrallocModule, GRALLOC_DRM_GET_STRIDE, *nativeHandle, |
| &stride); |
| if (ret) { |
| LOG(HAL, Error) << "Failed to get stride with format: " << androidFormat; |
| return *buffer; |
| } |
| strides.push_back(stride * getBpp(drmFormat)); |
| offsets.push_back(0); |
| } else { |
| // Multi-planar buffer. |
| drmFormat = resolveFormat(*nativeHandle, androidFormat, buffer->stream->usage, &numPlanes, |
| &strides, &offsets); |
| } |
| |
| ret = mGrallocModule->perform(mGrallocModule, GRALLOC_DRM_GET_DIMENSIONS, *nativeHandle, &width, |
| &height); |
| if (ret) { |
| LOG(HAL, Error) << "Failed to get dimensions with format: " << androidFormat; |
| return *buffer; |
| } |
| const uint32_t numFds = static_cast<uint32_t>((*nativeHandle)->numFds); |
| |
| if (!strcmp(mGrallocModule->common.name, "CrOS Gralloc")) { |
| // minigbm cros gralloc always have the first numPlanes count of fds to match each |
| // plane buffer. The numFds can be (numPlanes + 1) for mapper4 metadata. |
| |
| if (numFds < numPlanes) { |
| LOG(HAL, Error) << "numFds(" << numFds << ") must be at least numPlanes(" << numPlanes << ") for CrOS Gralloc"; |
| return *buffer; |
| } |
| for (uint32_t i = 0; i < numPlanes; i++) { |
| int dupFd = HANDLE_EINTR(dup((*nativeHandle)->data[i])); |
| if (dupFd < 0) { |
| LOG(HAL, Error) << "Failed to dup buffer fd: " << strerror(errno); |
| return *buffer; |
| } |
| handle_ptr->fds[i] = dupFd; |
| } |
| } else if (numFds == 1) { |
| // We assume all planes use the same fd if there's only one fd in the buffer handle (i.e. |
| // in drm_gralloc case). We can remove this code path once we have fully transitioned to |
| // cros_gralloc. |
| for (size_t i = 0; i < numPlanes; ++i) { |
| int dupFd = HANDLE_EINTR(dup((*nativeHandle)->data[0])); |
| if (dupFd == -1) { |
| LOG(HAL, Error) << "Failed to dup buffer fd: " << strerror(errno); |
| return *buffer; |
| } |
| handle_ptr->fds[i] = dupFd; |
| } |
| } else { |
| if (numFds != numPlanes) { |
| LOG(HAL, Error) << "numFds does not match the number of planes"; |
| return *buffer; |
| } |
| for (size_t i = 0; i < numPlanes; ++i) { |
| int dupFd = HANDLE_EINTR(dup((*nativeHandle)->data[i])); |
| if (dupFd == -1) { |
| LOG(HAL, Error) << "Failed to dup buffer fd: " << strerror(errno); |
| return *buffer; |
| } |
| handle_ptr->fds[i] = dupFd; |
| } |
| } |
| |
| // When we return the buffer in process_capture_result, the frameworks expect to see the |
| // same buffer_handle_t that it passed down before. Store the received buffer_handle_t |
| // so we can restore the |buffer| field in camera3_stream_buffer_t to the original value |
| // later in process_capture_result. |
| mBufferHandles[bufferId] = nativeHandle; |
| |
| camera3_stream_buffer_t new_camera3_stream_buffer = {}; |
| new_camera3_stream_buffer = (*buffer); |
| |
| handle_ptr->buffer_id = bufferId; |
| handle_ptr->drm_format = drmFormat; |
| handle_ptr->hal_pixel_format = androidFormat; |
| handle_ptr->width = width; |
| handle_ptr->height = height; |
| std::copy(strides.begin(), strides.end(), handle_ptr->strides); |
| std::copy(offsets.begin(), offsets.end(), handle_ptr->offsets); |
| |
| new_camera3_stream_buffer.buffer = &adaptedBuffer.buffer_handle; |
| |
| return new_camera3_stream_buffer; |
| } |
| |
| bool BufferAdapter::init() { |
| |
| mGrallocModule = GetGrallocModule(); |
| if (!mGrallocModule) { |
| return false; |
| } |
| return true; |
| } |
| |
| int BufferAdapter::decodeStreamBufferPtr(const camera3_stream_buffer_t* ptr, |
| camera3_stream_buffer_t* outBuffer) { |
| |
| std::unique_lock<std::mutex> bufferLock(mBufferHandlesLock); |
| |
| camera_buffer_handle_t *reint_cast_from_buffer_handle_t |
| = const_cast<camera_buffer_handle_t*>(reinterpret_cast<const camera_buffer_handle_t*>(*ptr->buffer)); |
| uint64_t bufferId = reint_cast_from_buffer_handle_t->buffer_id; |
| if (mBufferHandles.count(bufferId) == 0) { |
| LOG(HAL, Error) << "Invalid buffer ID: " << reint_cast_from_buffer_handle_t->buffer_id; |
| return -EINVAL; |
| } |
| |
| if (!mBufferHandles.contains(bufferId)) { |
| LOG(HAL, Error) << "cannot find buffer " << bufferId; |
| return -EINVAL; |
| } |
| |
| outBuffer->buffer = mBufferHandles[bufferId]; |
| |
| for (int i = 0; i < kMaxPlanes; i++) { |
| if (reint_cast_from_buffer_handle_t->fds[i] == -1) { |
| continue; |
| } |
| if (close(reint_cast_from_buffer_handle_t->fds[i])) { |
| LOG(HAL, Error) << "Failed to close FD: " << reint_cast_from_buffer_handle_t->fds[i]; |
| } else { |
| reint_cast_from_buffer_handle_t->fds[i] = -1; |
| } |
| } |
| |
| mBufferHandles.erase(bufferId); |
| mAdaptedBufferHandles.erase(bufferId); |
| |
| return 0; |
| } |
| |
| uint32_t BufferAdapter::resolveFormat(buffer_handle_t buffer, int androidFormat, uint32_t usage, |
| uint32_t* outNumPlanes, std::vector<uint32_t>* outStrides, |
| std::vector<uint32_t>* outOffsets) { |
| struct android_ycbcr ycbcr; |
| memset(&ycbcr, 0, sizeof(ycbcr)); |
| // When we call lock_ycbcr() with zero usage, the offsets are filled in |ycbcr.{y|cb|cr}|. |
| int ret = mGrallocModule->lock_ycbcr(mGrallocModule, buffer, 0, 0, 0, 0, 0, &ycbcr); |
| if (ret && androidFormat == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { |
| // HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED can be single-planar RGBX8888 or any multi-planar |
| // YUV 420 formats. Currently we rely on cros_gralloc to only give us YUV 420 formats since |
| // we don't have a way to tell 420 from 422 with lock_ycbcr(). If we fail to lock_ycbcr() |
| // the implementation defined buffer then we assume it's RGBX8888; otherwise we leave it to |
| // resolveFormat to resolve the exact YUV 420 format. (b/32077885) |
| uint32_t drmFormat = DRM_FORMAT_XBGR8888; |
| // Try to override it to a private format for reprocessing if usage flags include |
| // HW_CAMERA_READ. |
| if (usage & GRALLOC_USAGE_HW_CAMERA_READ) { |
| uint32_t privateFormat = getPrivateFormat(); |
| if (privateFormat) { |
| drmFormat = privateFormat; |
| } |
| } |
| *outNumPlanes = 1; |
| uint32_t stride; |
| ret = mGrallocModule->perform(mGrallocModule, GRALLOC_DRM_GET_STRIDE, buffer, &stride); |
| if (ret) { |
| LOG(HAL, Error) << "Failed to get stride with format: " << androidFormat; |
| return 0; |
| } |
| outStrides->push_back(stride * getBpp(drmFormat)); |
| outOffsets->push_back(0); |
| return drmFormat; |
| } |
| if (ret) { |
| LOG(HAL, Error) << "Failed to lock_ycbcr with format: " << androidFormat; |
| return 0; |
| } |
| mGrallocModule->unlock(mGrallocModule, buffer); |
| |
| uint32_t offsets[3] = {0, 0, 0}; |
| uint32_t strides[3] = {0, 0, 0}; |
| |
| offsets[0] = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(ycbcr.y)); |
| offsets[1] = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(ycbcr.cb)); |
| offsets[2] = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(ycbcr.cr)); |
| |
| strides[0] = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(ycbcr.ystride)); |
| strides[1] = strides[2] = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(ycbcr.cstride)); |
| |
| bool crcb = false; |
| if (offsets[1] > offsets[2]) { |
| crcb = true; |
| std::swap(offsets[1], offsets[2]); |
| } |
| |
| bool semiplanar = true; |
| *outNumPlanes = 2; |
| outStrides->push_back(strides[0]); |
| outStrides->push_back(strides[1]); |
| outOffsets->push_back(offsets[0]); |
| outOffsets->push_back(offsets[1]); |
| if (ycbcr.chroma_step == 1) { |
| semiplanar = false; |
| *outNumPlanes = 3; |
| outStrides->push_back(strides[2]); |
| outOffsets->push_back(offsets[2]); |
| } |
| |
| auto value = std::find_if( |
| std::begin(kSupportedPlanarFormats), std::end(kSupportedPlanarFormats), |
| [androidFormat, crcb, semiplanar](struct SupportedPlanarFormat f) { |
| return f.halFormat == androidFormat && f.crcb == crcb && f.semiplanar == semiplanar; |
| }); |
| if (value == std::end(kSupportedPlanarFormats)) { |
| LOG(HAL, Error) << "Unsupported planar format: " << androidFormat << " (crcb=" << crcb << ", semiplanar=" << semiplanar << ")"; |
| return 0; |
| } |
| return value->drmFormat; |
| } |
| |
| uint32_t BufferAdapter::getPrivateFormat() { |
| const char* prop_key = "ro.product.device"; |
| std::unique_ptr<char[]> device(new char[PROPERTY_VALUE_MAX]); |
| if (property_get(prop_key, device.get(), "") == 0) { |
| LOG(HAL, Error) << "Failed to read system property: " << prop_key; |
| } |
| // The value of ro.product.device is ${BOARD}_(cheets|bertha) |
| // See |
| // http://cs/chromeos_internal/src/private-overlays/project-cheets-private/scripts/board_specific_setup.sh?l=917&rcl=59fdaf4641708433c5ecdcf34fa15e9e36e5aa7e |
| std::string device_string(device.get()); |
| size_t pos = device_string.rfind("_"); |
| if (pos == std::string::npos) { |
| LOG(HAL, Error) << prop_key << " has unexpected format: " << device_string.c_str(); |
| return 1; |
| } |
| std::string board = device_string.substr(0, pos); |
| if (board == "kukui") { |
| return DRM_FORMAT_MTISP_SXYZW10; |
| } |
| return 0; |
| } |
| |
| } // end of namespace android |
