/*
* Copyright (C) 2017 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 "HandleImporter"
#include "HandleImporter.h"
#include <log/log.h>
namespace android {
namespace hardware {
namespace camera {
namespace common {
namespace V1_0 {
namespace helper {
using MapperErrorV2 = android::hardware::graphics::mapper::V2_0::Error;
using MapperErrorV3 = android::hardware::graphics::mapper::V3_0::Error;
using IMapperV3 = android::hardware::graphics::mapper::V3_0::IMapper;
HandleImporter::HandleImporter() : mInitialized(false) {}
void HandleImporter::initializeLocked() {
if (mInitialized) {
return;
}
mMapperV3 = IMapperV3::getService();
if (mMapperV3 != nullptr) {
mInitialized = true;
return;
}
mMapperV2 = IMapper::getService();
if (mMapperV2 == nullptr) {
ALOGE("%s: cannnot acccess graphics mapper HAL!", __FUNCTION__);
return;
}
mInitialized = true;
return;
}
void HandleImporter::cleanup() {
mMapperV3.clear();
mMapperV2.clear();
mInitialized = false;
}
template<class M, class E>
bool HandleImporter::importBufferInternal(const sp<M> mapper, buffer_handle_t& handle) {
E error;
buffer_handle_t importedHandle;
auto ret = mapper->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 != E::NONE) {
return false;
}
handle = importedHandle;
return true;
}
template<class M, class E>
YCbCrLayout HandleImporter::lockYCbCrInternal(const sp<M> mapper, buffer_handle_t& buf,
uint64_t cpuUsage, const IMapper::Rect& accessRegion) {
hidl_handle acquireFenceHandle;
auto buffer = const_cast<native_handle_t*>(buf);
YCbCrLayout layout = {};
typename M::Rect accessRegionCopy = {accessRegion.left, accessRegion.top,
accessRegion.width, accessRegion.height};
mapper->lockYCbCr(buffer, cpuUsage, accessRegionCopy, acquireFenceHandle,
[&](const auto& tmpError, const auto& tmpLayout) {
if (tmpError == E::NONE) {
// Member by member copy from different versions of YCbCrLayout.
layout.y = tmpLayout.y;
layout.cb = tmpLayout.cb;
layout.cr = tmpLayout.cr;
layout.yStride = tmpLayout.yStride;
layout.cStride = tmpLayout.cStride;
layout.chromaStep = tmpLayout.chromaStep;
} else {
ALOGE("%s: failed to lockYCbCr error %d!", __FUNCTION__, tmpError);
}
});
return layout;
}
template<class M, class E>
int HandleImporter::unlockInternal(const sp<M> mapper, buffer_handle_t& buf) {
int releaseFence = -1;
auto buffer = const_cast<native_handle_t*>(buf);
mapper->unlock(
buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {
if (tmpError == E::NONE) {
auto fenceHandle = tmpReleaseFence.getNativeHandle();
if (fenceHandle) {
if (fenceHandle->numInts != 0 || fenceHandle->numFds != 1) {
ALOGE("%s: bad release fence numInts %d numFds %d",
__FUNCTION__, fenceHandle->numInts, fenceHandle->numFds);
return;
}
releaseFence = dup(fenceHandle->data[0]);
if (releaseFence < 0) {
ALOGE("%s: bad release fence FD %d",
__FUNCTION__, releaseFence);
}
}
} else {
ALOGE("%s: failed to unlock error %d!", __FUNCTION__, tmpError);
}
});
return releaseFence;
}
// 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 HandleImporter::importBuffer(buffer_handle_t& handle) {
if (!handle->numFds && !handle->numInts) {
handle = nullptr;
return true;
}
Mutex::Autolock lock(mLock);
if (!mInitialized) {
initializeLocked();
}
if (mMapperV3 != nullptr) {
return importBufferInternal<IMapperV3, MapperErrorV3>(mMapperV3, handle);
}
if (mMapperV2 != nullptr) {
return importBufferInternal<IMapper, MapperErrorV2>(mMapperV2, handle);
}
ALOGE("%s: mMapperV3 and mMapperV2 are both null!", __FUNCTION__);
return false;
}
void HandleImporter::freeBuffer(buffer_handle_t handle) {
if (!handle) {
return;
}
Mutex::Autolock lock(mLock);
if (mMapperV3 == nullptr && mMapperV2 == nullptr) {
ALOGE("%s: mMapperV3 and mMapperV2 are both null!", __FUNCTION__);
return;
}
if (mMapperV3 != nullptr) {
auto ret = mMapperV3->freeBuffer(const_cast<native_handle_t*>(handle));
if (!ret.isOk()) {
ALOGE("%s: mapper freeBuffer failed: %s",
__FUNCTION__, ret.description().c_str());
}
} else {
auto ret = mMapperV2->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) const {
if (handle == nullptr || handle->numFds == 0) {
fd = -1;
} else if (handle->numFds == 1) {
fd = dup(handle->data[0]);
if (fd < 0) {
ALOGE("failed to dup fence fd %d", handle->data[0]);
return false;
}
} else {
ALOGE("invalid fence handle with %d file descriptors",
handle->numFds);
return false;
}
return true;
}
void HandleImporter::closeFence(int fd) const {
if (fd >= 0) {
close(fd);
}
}
void* HandleImporter::lock(
buffer_handle_t& buf, uint64_t cpuUsage, size_t size) {
Mutex::Autolock lock(mLock);
void *ret = 0;
if (!mInitialized) {
initializeLocked();
}
if (mMapperV3 == nullptr && mMapperV2 == nullptr) {
ALOGE("%s: mMapperV3 and mMapperV2 are both null!", __FUNCTION__);
return ret;
}
hidl_handle acquireFenceHandle;
auto buffer = const_cast<native_handle_t*>(buf);
if (mMapperV3 != nullptr) {
IMapperV3::Rect accessRegion { 0, 0, static_cast<int>(size), 1 };
// No need to use bytesPerPixel and bytesPerStride because we are using
// an 1-D buffer and accressRegion.
mMapperV3->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle,
[&](const auto& tmpError, const auto& tmpPtr, const auto& /*bytesPerPixel*/,
const auto& /*bytesPerStride*/) {
if (tmpError == MapperErrorV3::NONE) {
ret = tmpPtr;
} else {
ALOGE("%s: failed to lock error %d!",
__FUNCTION__, tmpError);
}
});
} else {
IMapper::Rect accessRegion { 0, 0, static_cast<int>(size), 1 };
mMapperV2->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle,
[&](const auto& tmpError, const auto& tmpPtr) {
if (tmpError == MapperErrorV2::NONE) {
ret = tmpPtr;
} else {
ALOGE("%s: failed to lock error %d!",
__FUNCTION__, tmpError);
}
});
}
ALOGV("%s: ptr %p size: %zu", __FUNCTION__, ret, size);
return ret;
}
YCbCrLayout HandleImporter::lockYCbCr(
buffer_handle_t& buf, uint64_t cpuUsage,
const IMapper::Rect& accessRegion) {
Mutex::Autolock lock(mLock);
if (!mInitialized) {
initializeLocked();
}
if (mMapperV3 != nullptr) {
return lockYCbCrInternal<IMapperV3, MapperErrorV3>(
mMapperV3, buf, cpuUsage, accessRegion);
}
if (mMapperV2 != nullptr) {
return lockYCbCrInternal<IMapper, MapperErrorV2>(
mMapperV2, buf, cpuUsage, accessRegion);
}
ALOGE("%s: mMapperV3 and mMapperV2 are both null!", __FUNCTION__);
return {};
}
int HandleImporter::unlock(buffer_handle_t& buf) {
if (mMapperV3 != nullptr) {
return unlockInternal<IMapperV3, MapperErrorV3>(mMapperV3, buf);
}
if (mMapperV2 != nullptr) {
return unlockInternal<IMapper, MapperErrorV2>(mMapperV2, buf);
}
ALOGE("%s: mMapperV3 and mMapperV2 are both null!", __FUNCTION__);
return -1;
}
} // namespace helper
} // namespace V1_0
} // namespace common
} // namespace camera
} // namespace hardware
} // namespace android