910 lines
32 KiB
C++
910 lines
32 KiB
C++
/*
|
|
* Copyright 2020 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 ATRACE_TAG ATRACE_TAG_CAMERA
|
|
|
|
#include "SurroundView2dSession.h"
|
|
|
|
#include "CameraUtils.h"
|
|
|
|
#include <android-base/logging.h>
|
|
#include <android/hardware/camera/device/3.2/ICameraDevice.h>
|
|
#include <android/hardware_buffer.h>
|
|
#include <system/camera_metadata.h>
|
|
#include <utils/SystemClock.h>
|
|
#include <utils/Trace.h>
|
|
#include <vndk/hardware_buffer.h>
|
|
|
|
#include <thread>
|
|
|
|
using ::std::adopt_lock;
|
|
using ::std::lock;
|
|
using ::std::lock_guard;
|
|
using ::std::map;
|
|
using ::std::mutex;
|
|
using ::std::scoped_lock;
|
|
using ::std::string;
|
|
using ::std::thread;
|
|
using ::std::unique_lock;
|
|
using ::std::unique_ptr;
|
|
using ::std::vector;
|
|
|
|
using ::android::hardware::automotive::evs::V1_0::EvsResult;
|
|
using ::android::hardware::camera::device::V3_2::Stream;
|
|
|
|
using GraphicsPixelFormat = ::android::hardware::graphics::common::V1_0::PixelFormat;
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace automotive {
|
|
namespace sv {
|
|
namespace V1_0 {
|
|
namespace implementation {
|
|
|
|
// TODO(b/158479099): There are a lot of redundant code between 2d and 3d.
|
|
// Decrease the degree of redundancy.
|
|
typedef struct {
|
|
int32_t id;
|
|
int32_t width;
|
|
int32_t height;
|
|
int32_t format;
|
|
int32_t direction;
|
|
int32_t framerate;
|
|
} RawStreamConfig;
|
|
|
|
static const size_t kStreamCfgSz = sizeof(RawStreamConfig) / sizeof(int32_t);
|
|
static const int kInputNumChannels = 4;
|
|
static const int kOutputNumChannels = 3;
|
|
static const int kNumFrames = 4;
|
|
static const int kSv2dViewId = 0;
|
|
static const float kUndistortionScales[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
|
|
|
SurroundView2dSession::FramesHandler::FramesHandler(
|
|
sp<IEvsCamera> pCamera, sp<SurroundView2dSession> pSession)
|
|
: mCamera(pCamera),
|
|
mSession(pSession) {}
|
|
|
|
Return<void> SurroundView2dSession::FramesHandler::deliverFrame(
|
|
const BufferDesc_1_0& bufDesc_1_0) {
|
|
LOG(INFO) << "Ignores a frame delivered from v1.0 EVS service.";
|
|
mCamera->doneWithFrame(bufDesc_1_0);
|
|
|
|
return {};
|
|
}
|
|
|
|
Return<void> SurroundView2dSession::FramesHandler::deliverFrame_1_1(
|
|
const hidl_vec<BufferDesc_1_1>& buffers) {
|
|
ATRACE_BEGIN(__PRETTY_FUNCTION__);
|
|
|
|
LOG(INFO) << "Received " << buffers.size() << " frames from the camera";
|
|
mSession->mSequenceId++;
|
|
|
|
{
|
|
scoped_lock<mutex> lock(mSession->mAccessLock);
|
|
if (mSession->mProcessingEvsFrames) {
|
|
LOG(WARNING) << "EVS frames are being processed. Skip frames:"
|
|
<< mSession->mSequenceId;
|
|
mCamera->doneWithFrame_1_1(buffers);
|
|
return {};
|
|
} else {
|
|
// Sets the flag to true immediately so the new coming frames will
|
|
// be skipped.
|
|
mSession->mProcessingEvsFrames = true;
|
|
}
|
|
}
|
|
|
|
if (buffers.size() != kNumFrames) {
|
|
scoped_lock<mutex> lock(mSession->mAccessLock);
|
|
LOG(ERROR) << "The number of incoming frames is " << buffers.size()
|
|
<< ", which is different from the number " << kNumFrames
|
|
<< ", specified in config file";
|
|
mSession->mProcessingEvsFrames = false;
|
|
mCamera->doneWithFrame_1_1(buffers);
|
|
return {};
|
|
}
|
|
|
|
{
|
|
scoped_lock<mutex> lock(mSession->mAccessLock);
|
|
vector<int> indices;
|
|
for (const auto& id
|
|
: mSession->mIOModuleConfig->cameraConfig.evsCameraIds) {
|
|
for (int i = 0; i < kNumFrames; i++) {
|
|
if (buffers[i].deviceId == id) {
|
|
indices.emplace_back(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (indices.size() != kNumFrames) {
|
|
LOG(ERROR) << "The frames are not from the cameras we expected!";
|
|
mSession->mProcessingEvsFrames = false;
|
|
mCamera->doneWithFrame_1_1(buffers);
|
|
return {};
|
|
}
|
|
|
|
if (mSession->mGpuAccelerationEnabled) {
|
|
for (int i = 0; i < kNumFrames; i++) {
|
|
LOG(DEBUG) << "Importing graphic buffer from camera ["
|
|
<< buffers[indices[i]].deviceId << "]";
|
|
const AHardwareBuffer_Desc* pDesc = reinterpret_cast<const AHardwareBuffer_Desc*>(
|
|
&buffers[indices[i]].buffer.description);
|
|
|
|
AHardwareBuffer* hardwareBuffer;
|
|
status_t status = AHardwareBuffer_createFromHandle(
|
|
pDesc, buffers[indices[i]].buffer.nativeHandle,
|
|
AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE, &hardwareBuffer);
|
|
|
|
if (status != NO_ERROR) {
|
|
LOG(ERROR) << "Can't create AHardwareBuffer from handle. Error: " << status;
|
|
return {};
|
|
}
|
|
|
|
mSession->mInputPointers[i].gpu_data_pointer = static_cast<void*>(hardwareBuffer);
|
|
|
|
// Keep a reference to the EVS graphic buffers, so we can
|
|
// release them after Surround View stitching is done.
|
|
mSession->mEvsGraphicBuffers = buffers;
|
|
}
|
|
} else {
|
|
for (int i = 0; i < kNumFrames; i++) {
|
|
LOG(DEBUG) << "Copying buffer from camera [" << buffers[indices[i]].deviceId
|
|
<< "] to Surround View Service";
|
|
mSession->copyFromBufferToPointers(buffers[indices[i]],
|
|
mSession->mInputPointers[i]);
|
|
}
|
|
|
|
// On the CPU version, we do not need to hold the Graphic Buffers
|
|
// any more since they are copied already.
|
|
mCamera->doneWithFrame_1_1(buffers);
|
|
}
|
|
}
|
|
|
|
// Notify the session that a new set of frames is ready
|
|
mSession->mFramesSignal.notify_all();
|
|
|
|
ATRACE_END();
|
|
|
|
return {};
|
|
}
|
|
|
|
Return<void> SurroundView2dSession::FramesHandler::notify(const EvsEventDesc& event) {
|
|
switch(event.aType) {
|
|
case EvsEventType::STREAM_STOPPED:
|
|
// The Surround View STREAM_STOPPED event is generated when the
|
|
// service finished processing the queued frames. So it does not
|
|
// rely on the Evs STREAM_STOPPED event.
|
|
LOG(INFO) << "Received a STREAM_STOPPED event from Evs.";
|
|
break;
|
|
|
|
case EvsEventType::PARAMETER_CHANGED:
|
|
LOG(INFO) << "Camera parameter " << std::hex << event.payload[0]
|
|
<< " is set to " << event.payload[1];
|
|
break;
|
|
|
|
// Below events are ignored in reference implementation.
|
|
case EvsEventType::STREAM_STARTED:
|
|
[[fallthrough]];
|
|
case EvsEventType::FRAME_DROPPED:
|
|
[[fallthrough]];
|
|
case EvsEventType::TIMEOUT:
|
|
LOG(INFO) << "Event " << std::hex << static_cast<unsigned>(event.aType)
|
|
<< "is received but ignored.";
|
|
break;
|
|
default:
|
|
LOG(ERROR) << "Unknown event id: " << static_cast<unsigned>(event.aType);
|
|
break;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
bool SurroundView2dSession::copyFromBufferToPointers(
|
|
BufferDesc_1_1 buffer, SurroundViewInputBufferPointers pointers) {
|
|
ATRACE_BEGIN(__PRETTY_FUNCTION__);
|
|
|
|
AHardwareBuffer_Desc* pDesc =
|
|
reinterpret_cast<AHardwareBuffer_Desc *>(&buffer.buffer.description);
|
|
|
|
ATRACE_BEGIN("Create Graphic Buffer");
|
|
// create a GraphicBuffer from the existing handle
|
|
sp<GraphicBuffer> inputBuffer = new GraphicBuffer(
|
|
buffer.buffer.nativeHandle, GraphicBuffer::CLONE_HANDLE, pDesc->width,
|
|
pDesc->height, pDesc->format, pDesc->layers,
|
|
GRALLOC_USAGE_HW_TEXTURE, pDesc->stride);
|
|
|
|
if (inputBuffer == nullptr) {
|
|
LOG(ERROR) << "Failed to allocate GraphicBuffer to wrap image handle";
|
|
// Returning "true" in this error condition because we already released the
|
|
// previous image (if any) and so the texture may change in unpredictable
|
|
// ways now!
|
|
return false;
|
|
} else {
|
|
LOG(INFO) << "Managed to allocate GraphicBuffer with "
|
|
<< " width: " << pDesc->width
|
|
<< " height: " << pDesc->height
|
|
<< " format: " << pDesc->format
|
|
<< " stride: " << pDesc->stride;
|
|
}
|
|
ATRACE_END();
|
|
|
|
ATRACE_BEGIN("Lock input buffer (gpu to cpu)");
|
|
// Lock the input GraphicBuffer and map it to a pointer. If we failed to
|
|
// lock, return false.
|
|
void* inputDataPtr;
|
|
inputBuffer->lock(
|
|
GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_NEVER,
|
|
&inputDataPtr);
|
|
if (!inputDataPtr) {
|
|
LOG(ERROR) << "Failed to gain read access to GraphicBuffer";
|
|
inputBuffer->unlock();
|
|
return false;
|
|
} else {
|
|
LOG(INFO) << "Managed to get read access to GraphicBuffer";
|
|
}
|
|
ATRACE_END();
|
|
|
|
ATRACE_BEGIN("Copy input data");
|
|
// Both source and destination are with 4 channels
|
|
memcpy(pointers.cpu_data_pointer, inputDataPtr,
|
|
pDesc->height * pDesc->width * kInputNumChannels);
|
|
LOG(DEBUG) << "Buffer copying finished";
|
|
ATRACE_END();
|
|
|
|
ATRACE_BEGIN("Unlock input buffer (cpu to gpu)");
|
|
inputBuffer->unlock();
|
|
ATRACE_END();
|
|
|
|
// Paired with ATRACE_BEGIN in the beginning of the method.
|
|
ATRACE_END();
|
|
|
|
return true;
|
|
}
|
|
|
|
void SurroundView2dSession::processFrames() {
|
|
ATRACE_BEGIN(__PRETTY_FUNCTION__);
|
|
|
|
while (true) {
|
|
{
|
|
unique_lock<mutex> lock(mAccessLock);
|
|
|
|
if (mStreamState != RUNNING) {
|
|
break;
|
|
}
|
|
|
|
mFramesSignal.wait(lock, [this]() { return mProcessingEvsFrames; });
|
|
}
|
|
|
|
handleFrames(mSequenceId);
|
|
|
|
{
|
|
// Set the boolean to false to receive the next set of frames.
|
|
scoped_lock<mutex> lock(mAccessLock);
|
|
mProcessingEvsFrames = false;
|
|
}
|
|
}
|
|
|
|
// Notify the SV client that no new results will be delivered.
|
|
LOG(DEBUG) << "Notify SvEvent::STREAM_STOPPED";
|
|
mStream->notify(SvEvent::STREAM_STOPPED);
|
|
|
|
{
|
|
scoped_lock<mutex> lock(mAccessLock);
|
|
mStreamState = STOPPED;
|
|
mStream = nullptr;
|
|
LOG(DEBUG) << "Stream marked STOPPED.";
|
|
}
|
|
|
|
ATRACE_END();
|
|
}
|
|
|
|
SurroundView2dSession::SurroundView2dSession(sp<IEvsEnumerator> pEvs,
|
|
IOModuleConfig* pConfig)
|
|
: mEvs(pEvs),
|
|
mIOModuleConfig(pConfig),
|
|
mStreamState(STOPPED) {}
|
|
|
|
SurroundView2dSession::~SurroundView2dSession() {
|
|
// In case the client did not call stopStream properly, we should stop the
|
|
// stream explicitly. Otherwise the process thread will take forever to
|
|
// join.
|
|
stopStream();
|
|
|
|
// Waiting for the process thread to finish the buffered frames.
|
|
if (mProcessThread.joinable()) {
|
|
mProcessThread.join();
|
|
}
|
|
|
|
mEvs->closeCamera(mCamera);
|
|
|
|
// TODO(b/175176576): properly release the mInputPointers and mOutputPointer
|
|
}
|
|
|
|
// Methods from ::android::hardware::automotive::sv::V1_0::ISurroundViewSession
|
|
Return<SvResult> SurroundView2dSession::startStream(
|
|
const sp<ISurroundViewStream>& stream) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
scoped_lock<mutex> lock(mAccessLock);
|
|
|
|
if (!mIsInitialized && !initialize()) {
|
|
LOG(ERROR) << "There is an error while initializing the use case. "
|
|
<< "Exiting";
|
|
return SvResult::INTERNAL_ERROR;
|
|
}
|
|
|
|
if (mStreamState != STOPPED) {
|
|
LOG(ERROR) << "Ignoring startVideoStream call"
|
|
<< "when a stream is already running.";
|
|
return SvResult::INTERNAL_ERROR;
|
|
}
|
|
|
|
if (stream == nullptr) {
|
|
LOG(ERROR) << "The input stream is invalid";
|
|
return SvResult::INTERNAL_ERROR;
|
|
}
|
|
mStream = stream;
|
|
|
|
mSequenceId = 0;
|
|
startEvs();
|
|
|
|
// TODO(b/158131080): the STREAM_STARTED event is not implemented in EVS
|
|
// reference implementation yet. Once implemented, this logic should be
|
|
// moved to EVS notify callback.
|
|
LOG(DEBUG) << "Notify SvEvent::STREAM_STARTED";
|
|
mStream->notify(SvEvent::STREAM_STARTED);
|
|
mProcessingEvsFrames = false;
|
|
|
|
// Start the frame generation thread
|
|
mStreamState = RUNNING;
|
|
|
|
mProcessThread = thread([this]() {
|
|
processFrames();
|
|
});
|
|
|
|
return SvResult::OK;
|
|
}
|
|
|
|
Return<void> SurroundView2dSession::stopStream() {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
unique_lock<mutex> lock(mAccessLock);
|
|
|
|
if (mStreamState == RUNNING) {
|
|
// Tell the processFrames loop to stop processing frames
|
|
mStreamState = STOPPING;
|
|
|
|
// Stop the EVS stream asynchronizely
|
|
mCamera->stopVideoStream();
|
|
mFramesHandler = nullptr;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
Return<void> SurroundView2dSession::doneWithFrames(
|
|
const SvFramesDesc& svFramesDesc){
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
scoped_lock <mutex> lock(mAccessLock);
|
|
|
|
mFramesRecord.inUse = false;
|
|
|
|
(void)svFramesDesc;
|
|
return {};
|
|
}
|
|
|
|
// Methods from ISurroundView2dSession follow.
|
|
Return<void> SurroundView2dSession::get2dMappingInfo(
|
|
get2dMappingInfo_cb _hidl_cb) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
|
|
_hidl_cb(mInfo);
|
|
return {};
|
|
}
|
|
|
|
Return<SvResult> SurroundView2dSession::set2dConfig(
|
|
const Sv2dConfig& sv2dConfig) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
scoped_lock <mutex> lock(mAccessLock);
|
|
|
|
if (sv2dConfig.width <=0 || sv2dConfig.width > 4096) {
|
|
LOG(WARNING) << "The width of 2d config is out of the range (0, 4096]"
|
|
<< "Ignored!";
|
|
return SvResult::INVALID_ARG;
|
|
}
|
|
|
|
mConfig.width = sv2dConfig.width;
|
|
mConfig.blending = sv2dConfig.blending;
|
|
mHeight = mConfig.width * mInfo.height / mInfo.width;
|
|
|
|
if (mStream != nullptr) {
|
|
LOG(DEBUG) << "Notify SvEvent::CONFIG_UPDATED";
|
|
mStream->notify(SvEvent::CONFIG_UPDATED);
|
|
}
|
|
|
|
return SvResult::OK;
|
|
}
|
|
|
|
Return<void> SurroundView2dSession::get2dConfig(get2dConfig_cb _hidl_cb) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
|
|
_hidl_cb(mConfig);
|
|
return {};
|
|
}
|
|
|
|
Return<void> SurroundView2dSession::projectCameraPoints(const hidl_vec<Point2dInt>& points2dCamera,
|
|
const hidl_string& cameraId,
|
|
projectCameraPoints_cb _hidl_cb) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
std::vector<Point2dFloat> outPoints;
|
|
bool cameraIdFound = false;
|
|
int cameraIndex = 0;
|
|
// Note: mEvsCameraIds must be in the order front, right, rear, left.
|
|
for (auto& evsCameraId : mEvsCameraIds) {
|
|
if (cameraId == evsCameraId) {
|
|
cameraIdFound = true;
|
|
LOG(DEBUG) << "Camera id found for projection: " << cameraId;
|
|
break;
|
|
}
|
|
cameraIndex++;
|
|
}
|
|
|
|
if (!cameraIdFound) {
|
|
LOG(ERROR) << "Camera id not found for projection: " << cameraId;
|
|
_hidl_cb(outPoints);
|
|
return {};
|
|
}
|
|
|
|
int width = mConfig.width;
|
|
int height = mHeight;
|
|
for (const auto& cameraPoint : points2dCamera) {
|
|
Point2dFloat outPoint = {false, 0.0, 0.0};
|
|
// Check of the camear point is within the camera resolution bounds.
|
|
if (cameraPoint.x < 0 || cameraPoint.x > width - 1 || cameraPoint.y < 0 ||
|
|
cameraPoint.y > height - 1) {
|
|
LOG(WARNING) << "Camera point (" << cameraPoint.x << ", " << cameraPoint.y
|
|
<< ") is out of camera resolution bounds.";
|
|
outPoint.isValid = false;
|
|
outPoints.push_back(outPoint);
|
|
continue;
|
|
}
|
|
|
|
// Project points using mSurroundView function.
|
|
const Coordinate2dInteger camPoint(cameraPoint.x, cameraPoint.y);
|
|
Coordinate2dFloat projPoint2d(0.0, 0.0);
|
|
|
|
outPoint.isValid =
|
|
mSurroundView->GetProjectionPointFromRawCameraToSurroundView2d(camPoint,
|
|
cameraIndex,
|
|
&projPoint2d);
|
|
outPoint.x = projPoint2d.x;
|
|
outPoint.y = projPoint2d.y;
|
|
outPoints.push_back(outPoint);
|
|
}
|
|
|
|
_hidl_cb(outPoints);
|
|
return {};
|
|
}
|
|
|
|
// TODO(b/175176765): implement a GPU version of this method separately.
|
|
bool SurroundView2dSession::handleFrames(int sequenceId) {
|
|
LOG(INFO) << __FUNCTION__ << "Handling sequenceId " << sequenceId << ".";
|
|
|
|
ATRACE_BEGIN(__PRETTY_FUNCTION__);
|
|
|
|
// TODO(b/157498592): Now only one sets of EVS input frames and one SV
|
|
// output frame is supported. Implement buffer queue for both of them.
|
|
{
|
|
scoped_lock<mutex> lock(mAccessLock);
|
|
|
|
if (mFramesRecord.inUse) {
|
|
LOG(DEBUG) << "Notify SvEvent::FRAME_DROPPED";
|
|
mStream->notify(SvEvent::FRAME_DROPPED);
|
|
|
|
// For GPU solution only (the frames were released already for CPU solution).
|
|
if (mGpuAccelerationEnabled) {
|
|
mCamera->doneWithFrame_1_1(mEvsGraphicBuffers);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// TODO(b/175177030): modifying the width/length on the fly is not supported by the GPU approach
|
|
// yet.
|
|
if (!mGpuAccelerationEnabled) {
|
|
if (mOutputWidth != mConfig.width || mOutputHeight != mHeight) {
|
|
LOG(DEBUG) << "Config changed. Re-allocate memory."
|
|
<< " Old width: " << mOutputWidth << " Old height: " << mOutputHeight
|
|
<< " New width: " << mConfig.width << " New height: " << mHeight;
|
|
delete[] static_cast<char*>(mOutputPointer.cpu_data_pointer);
|
|
mOutputWidth = mConfig.width;
|
|
mOutputHeight = mHeight;
|
|
mOutputPointer.height = mOutputHeight;
|
|
mOutputPointer.width = mOutputWidth;
|
|
mOutputPointer.format = Format::RGB;
|
|
mOutputPointer.cpu_data_pointer =
|
|
static_cast<void*>(new char[mOutputHeight * mOutputWidth * kOutputNumChannels]);
|
|
|
|
if (!mOutputPointer.cpu_data_pointer) {
|
|
LOG(ERROR) << "Memory allocation failed. Exiting.";
|
|
return false;
|
|
}
|
|
|
|
Size2dInteger size = Size2dInteger(mOutputWidth, mOutputHeight);
|
|
mSurroundView->Update2dOutputResolution(size);
|
|
|
|
mSvTexture = new GraphicBuffer(mOutputWidth, mOutputHeight, HAL_PIXEL_FORMAT_RGB_888, 1,
|
|
GRALLOC_USAGE_HW_TEXTURE, "SvTexture");
|
|
if (mSvTexture->initCheck() == OK) {
|
|
LOG(INFO) << "Successfully allocated Graphic Buffer";
|
|
} else {
|
|
LOG(ERROR) << "Failed to allocate Graphic Buffer";
|
|
return false;
|
|
}
|
|
}
|
|
LOG(INFO) << "Output Pointer data format: " << mOutputPointer.format;
|
|
}
|
|
|
|
ATRACE_BEGIN("SV core lib method: Get2dSurroundView");
|
|
const string gpuEnabledText = mGpuAccelerationEnabled ? " with GPU acceleration flag enabled"
|
|
: " with GPU acceleration flag disabled";
|
|
if (mSurroundView->Get2dSurroundView(mInputPointers, &mOutputPointer)) {
|
|
LOG(INFO) << "Get2dSurroundView succeeded" << gpuEnabledText;
|
|
} else {
|
|
LOG(ERROR) << "Get2dSurroundView failed" << gpuEnabledText;
|
|
}
|
|
ATRACE_END();
|
|
|
|
// For GPU solution only (the frames were released already for CPU solution).
|
|
if (mGpuAccelerationEnabled) {
|
|
ATRACE_BEGIN("Release the evs frames");
|
|
mCamera->doneWithFrame_1_1(mEvsGraphicBuffers);
|
|
ATRACE_END();
|
|
}
|
|
|
|
ANativeWindowBuffer* buffer;
|
|
if (mGpuAccelerationEnabled) {
|
|
buffer = mOutputHolder->getNativeBuffer();
|
|
} else {
|
|
ATRACE_BEGIN("Lock output texture (gpu to cpu)");
|
|
void* textureDataPtr = nullptr;
|
|
mSvTexture->lock(GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_NEVER,
|
|
&textureDataPtr);
|
|
ATRACE_END();
|
|
|
|
if (!textureDataPtr) {
|
|
LOG(ERROR) << "Failed to gain write access to GraphicBuffer!";
|
|
return false;
|
|
}
|
|
|
|
ATRACE_BEGIN("Copy output result");
|
|
// Note: there is a chance that the stride of the texture is not the same
|
|
// as the width. For example, when the input frame is 1920 * 1080, the
|
|
// width is 1080, but the stride is 2048. So we'd better copy the data line
|
|
// by line, instead of single memcpy.
|
|
uint8_t* writePtr = static_cast<uint8_t*>(textureDataPtr);
|
|
uint8_t* readPtr = static_cast<uint8_t*>(mOutputPointer.cpu_data_pointer);
|
|
const int readStride = mOutputWidth * kOutputNumChannels;
|
|
const int writeStride = mSvTexture->getStride() * kOutputNumChannels;
|
|
if (readStride == writeStride) {
|
|
memcpy(writePtr, readPtr, readStride * mSvTexture->getHeight());
|
|
} else {
|
|
for (int i = 0; i < mSvTexture->getHeight(); i++) {
|
|
memcpy(writePtr, readPtr, readStride);
|
|
writePtr = writePtr + writeStride;
|
|
readPtr = readPtr + readStride;
|
|
}
|
|
}
|
|
LOG(DEBUG) << "memcpy finished";
|
|
ATRACE_END();
|
|
|
|
ATRACE_BEGIN("Unlock output texture (cpu to gpu)");
|
|
mSvTexture->unlock();
|
|
ATRACE_END();
|
|
|
|
buffer = mSvTexture->getNativeBuffer();
|
|
LOG(DEBUG) << "ANativeWindowBuffer->handle: " << buffer->handle;
|
|
}
|
|
|
|
{
|
|
scoped_lock<mutex> lock(mAccessLock);
|
|
|
|
mFramesRecord.frames.svBuffers.resize(1);
|
|
SvBuffer& svBuffer = mFramesRecord.frames.svBuffers[0];
|
|
svBuffer.viewId = kSv2dViewId;
|
|
svBuffer.hardwareBuffer.nativeHandle = buffer->handle;
|
|
AHardwareBuffer_Desc* pDesc =
|
|
reinterpret_cast<AHardwareBuffer_Desc*>(
|
|
&svBuffer.hardwareBuffer.description);
|
|
if (mGpuAccelerationEnabled) {
|
|
pDesc->width = mOutputPointer.width;
|
|
pDesc->height = mOutputPointer.height;
|
|
pDesc->stride = mOutputHolder->getStride();
|
|
pDesc->format = HAL_PIXEL_FORMAT_RGBA_8888;
|
|
} else {
|
|
pDesc->width = mOutputWidth;
|
|
pDesc->height = mOutputHeight;
|
|
pDesc->stride = mSvTexture->getStride();
|
|
pDesc->format = HAL_PIXEL_FORMAT_RGB_888;
|
|
}
|
|
pDesc->layers = 1;
|
|
pDesc->usage = GRALLOC_USAGE_HW_TEXTURE;
|
|
mFramesRecord.frames.timestampNs = elapsedRealtimeNano();
|
|
mFramesRecord.frames.sequenceId = sequenceId;
|
|
|
|
mFramesRecord.inUse = true;
|
|
mStream->receiveFrames(mFramesRecord.frames);
|
|
}
|
|
|
|
ATRACE_END();
|
|
|
|
return true;
|
|
}
|
|
|
|
// TODO(b/175176765): consider to HW-specific initialization procedures into
|
|
// separate methods.
|
|
bool SurroundView2dSession::initialize() {
|
|
lock_guard<mutex> lock(mAccessLock, adopt_lock);
|
|
|
|
ATRACE_BEGIN(__PRETTY_FUNCTION__);
|
|
|
|
if (!setupEvs()) {
|
|
LOG(ERROR) << "Failed to setup EVS components for 2d session";
|
|
return false;
|
|
}
|
|
|
|
// TODO(b/150412555): ask core-lib team to add API description for "create"
|
|
// method in the .h file.
|
|
// The create method will never return a null pointer based the API
|
|
// description.
|
|
mSurroundView = unique_ptr<SurroundView>(Create());
|
|
|
|
SurroundViewStaticDataParams params =
|
|
SurroundViewStaticDataParams(mCameraParams,
|
|
mIOModuleConfig->sv2dConfig.sv2dParams,
|
|
mIOModuleConfig->sv3dConfig.sv3dParams,
|
|
vector<float>(std::begin(kUndistortionScales),
|
|
std::end(kUndistortionScales)),
|
|
mIOModuleConfig->sv2dConfig.carBoundingBox,
|
|
mIOModuleConfig->carModelConfig.carModel.texturesMap,
|
|
mIOModuleConfig->carModelConfig.carModel.partsMap);
|
|
mGpuAccelerationEnabled = mIOModuleConfig->sv2dConfig.sv2dParams.gpu_acceleration_enabled;
|
|
|
|
ATRACE_BEGIN("SV core lib method: SetStaticData");
|
|
mSurroundView->SetStaticData(params);
|
|
ATRACE_END();
|
|
|
|
ATRACE_BEGIN("SV core lib method: Start2dPipeline");
|
|
const string gpuEnabledText = mGpuAccelerationEnabled ? "with GPU acceleration flag enabled"
|
|
: "with GPU acceleration flag disabled";
|
|
if (mSurroundView->Start2dPipeline()) {
|
|
LOG(INFO) << "Start2dPipeline succeeded " << gpuEnabledText;
|
|
} else {
|
|
LOG(ERROR) << "Start2dPipeline failed " << gpuEnabledText;
|
|
return false;
|
|
}
|
|
ATRACE_END();
|
|
|
|
ATRACE_BEGIN("Allocate cpu buffers");
|
|
mInputPointers.resize(kNumFrames);
|
|
for (int i = 0; i < kNumFrames; i++) {
|
|
mInputPointers[i].width = mCameraParams[i].size.width;
|
|
mInputPointers[i].height = mCameraParams[i].size.height;
|
|
|
|
// Only allocate CPU memory for CPU solution
|
|
// For GPU solutions, the Graphic Buffers from EVS will be converted and
|
|
// stored in gpu_data_pointer
|
|
if (!mGpuAccelerationEnabled) {
|
|
mInputPointers[i].format = Format::RGBA;
|
|
mInputPointers[i].cpu_data_pointer =
|
|
static_cast<void*>(new char[mInputPointers[i].width * mInputPointers[i].height *
|
|
kInputNumChannels]);
|
|
}
|
|
}
|
|
LOG(INFO) << "Allocated " << kNumFrames << " input pointers";
|
|
|
|
mOutputWidth = mIOModuleConfig->sv2dConfig.sv2dParams.resolution.width;
|
|
mOutputHeight = mIOModuleConfig->sv2dConfig.sv2dParams.resolution.height;
|
|
|
|
mConfig.width = mOutputWidth;
|
|
mConfig.blending = SvQuality::HIGH;
|
|
mHeight = mOutputHeight;
|
|
|
|
mOutputPointer.height = mOutputHeight;
|
|
mOutputPointer.width = mOutputWidth;
|
|
|
|
// Only allocate CPU memory for CPU solution
|
|
if (!mGpuAccelerationEnabled) {
|
|
mOutputPointer.format = Format::RGB;
|
|
mOutputPointer.cpu_data_pointer =
|
|
static_cast<void*>(new char[mOutputHeight * mOutputWidth * kOutputNumChannels]);
|
|
|
|
if (!mOutputPointer.cpu_data_pointer) {
|
|
LOG(ERROR) << "Memory allocation failed. Exiting.";
|
|
return false;
|
|
}
|
|
}
|
|
ATRACE_END();
|
|
|
|
ATRACE_BEGIN("Allocate output texture");
|
|
if (mGpuAccelerationEnabled) {
|
|
mOutputHolder = new GraphicBuffer(mOutputWidth, mOutputHeight, HAL_PIXEL_FORMAT_RGBA_8888,
|
|
1, GRALLOC_USAGE_HW_TEXTURE, "SvOutputHolder");
|
|
if (mOutputHolder->initCheck() == OK) {
|
|
LOG(INFO) << "Successfully allocated Graphic Buffer for SvOutputHolder";
|
|
} else {
|
|
LOG(ERROR) << "Failed to allocate Graphic Buffer for SvOutputHolder";
|
|
return false;
|
|
}
|
|
mOutputPointer.gpu_data_pointer = static_cast<void*>(mOutputHolder->toAHardwareBuffer());
|
|
} else {
|
|
mSvTexture = new GraphicBuffer(mOutputWidth, mOutputHeight, HAL_PIXEL_FORMAT_RGB_888, 1,
|
|
GRALLOC_USAGE_HW_TEXTURE, "SvTexture");
|
|
if (mSvTexture->initCheck() == OK) {
|
|
LOG(INFO) << "Successfully allocated Graphic Buffer";
|
|
} else {
|
|
LOG(ERROR) << "Failed to allocate Graphic Buffer";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Note: sv2dParams is in meters while mInfo must be in milli-meters.
|
|
mInfo.width = mIOModuleConfig->sv2dConfig.sv2dParams.physical_size.width * 1000.0;
|
|
mInfo.height = mIOModuleConfig->sv2dConfig.sv2dParams.physical_size.height * 1000.0;
|
|
mInfo.center.isValid = true;
|
|
mInfo.center.x = mIOModuleConfig->sv2dConfig.sv2dParams.physical_center.x * 1000.0;
|
|
mInfo.center.y = mIOModuleConfig->sv2dConfig.sv2dParams.physical_center.y * 1000.0;
|
|
|
|
mIsInitialized = true;
|
|
|
|
ATRACE_END();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool SurroundView2dSession::setupEvs() {
|
|
ATRACE_BEGIN(__PRETTY_FUNCTION__);
|
|
|
|
// Reads the camera related information from the config object
|
|
const string evsGroupId = mIOModuleConfig->cameraConfig.evsGroupId;
|
|
|
|
// Setup for EVS
|
|
LOG(INFO) << "Requesting camera list";
|
|
mEvs->getCameraList_1_1(
|
|
[this, evsGroupId] (hidl_vec<CameraDesc> cameraList) {
|
|
LOG(INFO) << "Camera list callback received " << cameraList.size();
|
|
for (auto&& cam : cameraList) {
|
|
LOG(INFO) << "Found camera " << cam.v1.cameraId;
|
|
if (cam.v1.cameraId == evsGroupId) {
|
|
mCameraDesc = cam;
|
|
}
|
|
}
|
|
});
|
|
|
|
bool foundCfg = false;
|
|
std::unique_ptr<Stream> targetCfg(new Stream());
|
|
|
|
// This logic picks the configuration with the largest area that supports
|
|
// RGBA8888 format
|
|
int32_t maxArea = 0;
|
|
camera_metadata_entry_t streamCfgs;
|
|
if (!find_camera_metadata_entry(
|
|
reinterpret_cast<camera_metadata_t *>(mCameraDesc.metadata.data()),
|
|
ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
|
|
&streamCfgs)) {
|
|
// Stream configurations are found in metadata
|
|
RawStreamConfig *ptr = reinterpret_cast<RawStreamConfig *>(
|
|
streamCfgs.data.i32);
|
|
for (unsigned idx = 0; idx < streamCfgs.count; idx += kStreamCfgSz) {
|
|
if (ptr->direction ==
|
|
ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
|
|
ptr->format == HAL_PIXEL_FORMAT_RGBA_8888) {
|
|
|
|
if (ptr->width * ptr->height > maxArea) {
|
|
targetCfg->id = ptr->id;
|
|
targetCfg->width = ptr->width;
|
|
targetCfg->height = ptr->height;
|
|
|
|
// This client always wants below input data format
|
|
targetCfg->format =
|
|
static_cast<GraphicsPixelFormat>(
|
|
HAL_PIXEL_FORMAT_RGBA_8888);
|
|
|
|
maxArea = ptr->width * ptr->height;
|
|
|
|
foundCfg = true;
|
|
}
|
|
}
|
|
++ptr;
|
|
}
|
|
} else {
|
|
LOG(WARNING) << "No stream configuration data is found; "
|
|
<< "default parameters will be used.";
|
|
}
|
|
|
|
if (!foundCfg) {
|
|
LOG(INFO) << "No config was found";
|
|
targetCfg = nullptr;
|
|
return false;
|
|
}
|
|
|
|
string camId = mCameraDesc.v1.cameraId.c_str();
|
|
mCamera = mEvs->openCamera_1_1(camId.c_str(), *targetCfg);
|
|
if (mCamera == nullptr) {
|
|
LOG(ERROR) << "Failed to allocate EVS Camera interface for " << camId;
|
|
return false;
|
|
} else {
|
|
LOG(INFO) << "Logical camera " << camId << " is opened successfully";
|
|
}
|
|
|
|
mEvsCameraIds = mIOModuleConfig->cameraConfig.evsCameraIds;
|
|
if (mEvsCameraIds.size() < kNumFrames) {
|
|
LOG(ERROR) << "Incorrect camera info is stored in the camera config";
|
|
return false;
|
|
}
|
|
|
|
map<string, AndroidCameraParams> cameraIdToAndroidParameters;
|
|
for (const auto& id : mEvsCameraIds) {
|
|
AndroidCameraParams params;
|
|
if (getAndroidCameraParams(mCamera, id, params)) {
|
|
cameraIdToAndroidParameters.emplace(id, params);
|
|
LOG(INFO) << "Camera parameters are fetched successfully for "
|
|
<< "physical camera: " << id;
|
|
} else {
|
|
LOG(ERROR) << "Failed to get camera parameters for "
|
|
<< "physical camera: " << id;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
mCameraParams =
|
|
convertToSurroundViewCameraParams(cameraIdToAndroidParameters);
|
|
|
|
for (auto& camera : mCameraParams) {
|
|
camera.size.width = targetCfg->width;
|
|
camera.size.height = targetCfg->height;
|
|
camera.circular_fov = 179;
|
|
}
|
|
|
|
// Add validity mask filenames.
|
|
for (int i = 0; i < mCameraParams.size(); i++) {
|
|
mCameraParams[i].validity_mask_filename = mIOModuleConfig->cameraConfig.maskFilenames[i];
|
|
}
|
|
ATRACE_END();
|
|
return true;
|
|
}
|
|
|
|
bool SurroundView2dSession::startEvs() {
|
|
ATRACE_BEGIN(__PRETTY_FUNCTION__);
|
|
|
|
mFramesHandler = new FramesHandler(mCamera, this);
|
|
Return<EvsResult> result = mCamera->startVideoStream(mFramesHandler);
|
|
if (result != EvsResult::OK) {
|
|
LOG(ERROR) << "Failed to start video stream";
|
|
return false;
|
|
} else {
|
|
LOG(INFO) << "Video stream was started successfully";
|
|
}
|
|
|
|
ATRACE_END();
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace implementation
|
|
} // namespace V1_0
|
|
} // namespace sv
|
|
} // namespace automotive
|
|
} // namespace hardware
|
|
} // namespace android
|