namespace V1_0 {
namespace helper {
-HandleImporter HandleImporter::sHandleImporter;
+using MapperError = android::hardware::graphics::mapper::V2_0::Error;
-HandleImporter& HandleImporter::getInstance() {
- sHandleImporter.initialize();
- return sHandleImporter;
-}
+HandleImporter::HandleImporter() : mInitialized(false) {}
-bool HandleImporter::initialize() {
- // allow only one client
+void HandleImporter::initializeLocked() {
if (mInitialized) {
- return false;
+ return;
}
- if (!openGralloc()) {
- return false;
+ mMapper = IMapper::getService();
+ if (mMapper == nullptr) {
+ ALOGE("%s: cannnot acccess graphics mapper HAL!", __FUNCTION__);
+ return;
}
mInitialized = true;
- return true;
+ return;
}
void HandleImporter::cleanup() {
- if (!mInitialized) {
- return;
- }
-
- closeGralloc();
+ mMapper.clear();
mInitialized = false;
}
return true;
}
- buffer_handle_t clone = cloneBuffer(handle);
- if (!clone) {
+ Mutex::Autolock lock(mLock);
+ if (!mInitialized) {
+ initializeLocked();
+ }
+
+ if (mMapper == nullptr) {
+ ALOGE("%s: mMapper is null!", __FUNCTION__);
return false;
}
- handle = clone;
+ MapperError error;
+ buffer_handle_t importedHandle;
+ auto ret = mMapper->importBuffer(
+ hidl_handle(handle),
+ [&](const auto& tmpError, const auto& tmpBufferHandle) {
+ error = tmpError;
+ importedHandle = static_cast<buffer_handle_t>(tmpBufferHandle);
+ });
+
+ if (!ret.isOk()) {
+ ALOGE("%s: mapper importBuffer failed: %s",
+ __FUNCTION__, ret.description().c_str());
+ return false;
+ }
+
+ if (error != MapperError::NONE) {
+ return false;
+ }
+
+ handle = importedHandle;
+
return true;
}
return;
}
- releaseBuffer(handle);
+ Mutex::Autolock lock(mLock);
+ if (mMapper == nullptr) {
+ ALOGE("%s: mMapper is null!", __FUNCTION__);
+ return;
+ }
+
+ auto ret = mMapper->freeBuffer(const_cast<native_handle_t*>(handle));
+ if (!ret.isOk()) {
+ ALOGE("%s: mapper freeBuffer failed: %s",
+ __FUNCTION__, ret.description().c_str());
+ }
}
-bool HandleImporter::importFence(const native_handle_t* handle, int& fd) {
+bool HandleImporter::importFence(const native_handle_t* handle, int& fd) const {
if (handle == nullptr || handle->numFds == 0) {
fd = -1;
} else if (handle->numFds == 1) {
return true;
}
-void HandleImporter::closeFence(int fd) {
+void HandleImporter::closeFence(int fd) const {
if (fd >= 0) {
close(fd);
}
}
-bool HandleImporter::openGralloc() {
- const hw_module_t* module;
- int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
- if (err) {
- ALOGE("failed to get gralloc module");
- return false;
- }
-
- uint8_t major = (module->module_api_version >> 8) & 0xff;
- if (major > 1) {
- ALOGE("unknown gralloc module major version %d", major);
- return false;
- }
-
- if (major == 1) {
- err = gralloc1_open(module, &mDevice);
- if (err) {
- ALOGE("failed to open gralloc1 device");
- return false;
- }
-
- mRetain = reinterpret_cast<GRALLOC1_PFN_RETAIN>(
- mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RETAIN));
- mRelease = reinterpret_cast<GRALLOC1_PFN_RELEASE>(
- mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RELEASE));
- if (!mRetain || !mRelease) {
- ALOGE("invalid gralloc1 device");
- gralloc1_close(mDevice);
- return false;
- }
- } else {
- mModule = reinterpret_cast<const gralloc_module_t*>(module);
- }
-
- return true;
-}
-
-void HandleImporter::closeGralloc() {
- if (mDevice) {
- gralloc1_close(mDevice);
- }
-}
-
-buffer_handle_t HandleImporter::cloneBuffer(buffer_handle_t handle) {
- native_handle_t* clone = native_handle_clone(handle);
- if (!clone) {
- ALOGE("failed to clone buffer %p", handle);
- return nullptr;
- }
-
- bool err;
- if (mDevice) {
- err = (mRetain(mDevice, clone) != GRALLOC1_ERROR_NONE);
- } else {
- err = (mModule->registerBuffer(mModule, clone) != 0);
- }
-
- if (err) {
- ALOGE("failed to retain/register buffer %p", clone);
- native_handle_close(clone);
- native_handle_delete(clone);
- return nullptr;
- }
-
- return clone;
-}
-
-void HandleImporter::releaseBuffer(buffer_handle_t handle) {
- if (mDevice) {
- mRelease(mDevice, handle);
- } else {
- mModule->unregisterBuffer(mModule, handle);
- }
- native_handle_close(handle);
- native_handle_delete(const_cast<native_handle_t*>(handle));
-}
-
} // namespace helper
} // namespace V1_0
} // namespace common
#ifndef CAMERA_COMMON_1_0_HANDLEIMPORTED_H
#define CAMERA_COMMON_1_0_HANDLEIMPORTED_H
-#include <hardware/gralloc.h>
-#include <hardware/gralloc1.h>
#include <system/window.h>
+#include <utils/Mutex.h>
+#include <android/hardware/graphics/mapper/2.0/IMapper.h>
+
+using android::hardware::graphics::mapper::V2_0::IMapper;
namespace android {
namespace hardware {
// Borrowed from graphics HAL. Use this until gralloc mapper HAL is working
class HandleImporter {
public:
- static HandleImporter& getInstance();
+ HandleImporter();
// In IComposer, any buffer_handle_t is owned by the caller and we need to
// make a clone for hwcomposer2. We also need to translate empty handle
// to nullptr. This function does that, in-place.
bool importBuffer(buffer_handle_t& handle);
void freeBuffer(buffer_handle_t handle);
- bool importFence(const native_handle_t* handle, int& fd);
- void closeFence(int fd);
+ bool importFence(const native_handle_t* handle, int& fd) const;
+ void closeFence(int fd) const;
private:
-
- HandleImporter() : mInitialized(false) {}
- bool initialize();
+ void initializeLocked();
void cleanup();
- bool openGralloc();
- void closeGralloc();
- buffer_handle_t cloneBuffer(buffer_handle_t handle);
- void releaseBuffer(buffer_handle_t handle);
- static HandleImporter sHandleImporter;
+ Mutex mLock;
bool mInitialized;
+ sp<IMapper> mMapper;
- // gralloc1
- gralloc1_device_t* mDevice;
- GRALLOC1_PFN_RETAIN mRetain;
- GRALLOC1_PFN_RELEASE mRelease;
-
- // gralloc0
- const gralloc_module_t* mModule;
};
} // namespace helper
OSDN Git Service
