rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/hardware/rockchip/camera/psl/rkisp2/workers/RKISP2PostProcessPipeline.cpp

2471 lines
96 KiB
C++
Raw Blame History

/*
* Copyright (C) 2015-2017 Intel Corporation
* Copyright (c) 2017, Fuzhou Rockchip Electronics Co., Ltd
*
* 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 "RKISP2PostProcessPipeline"
#include "RKISP2PostProcessPipeline.h"
#include <sys/syscall.h>
#include "PerformanceTraces.h"
#include "CameraMetadataHelper.h"
#include "CameraStream.h"
#include "ImageScalerCore.h"
#include "RgaCropScale.h"
#include "LogHelper.h"
#include "FormatUtils.h"
#include "RKISP2FecUnit.h"
//#include "TuningServer.h"
#if defined(ANDROID_VERSION_ABOVE_12_X)
#include <hardware/hardware_rockchip.h>
#endif
#define ALIGN(value, x) ((value + (x-1)) & (~(x-1)))
// disable mirror handling by default
/* #define MIRROR_HANDLING_FOR_FRONT_CAMERA */
namespace android {
namespace camera2 {
namespace rkisp2 {
status_t
IPostProcessSource::attachListener(RKISP2IPostProcessListener* listener) {
LOGD("@%s: %p", __FUNCTION__, listener);
std::lock_guard<std::mutex> l(mListenersLock);
mListeners.push_back(listener);
return OK;
}
status_t
IPostProcessSource::notifyListeners(const std::shared_ptr<PostProcBuffer>& buf,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings,
int err) {
LOGD("@%s", __FUNCTION__);
LOGD("@%s(%d), reqId: %d dmaBufFd:%d",
__FUNCTION__,__LINE__, settings->request->getId(),buf->cambuf->dmaBufFd());
status_t status = OK;
std::lock_guard<std::mutex> l(mListenersLock);
for (auto &listener : mListeners) {
status |= listener->notifyNewFrame(buf, settings, err);
}
return status;
}
status_t
PostProcBufferPools::createBufferPools(RKISP2PostProcessPipeline* pl, const FrameInfo& outfmt, int numBufs) {
LOGD("@%s buffer num %d", __FUNCTION__, numBufs);
mBufferPoolSize = numBufs;
mPipeline = pl;
mPostProcItemsPool.init(mBufferPoolSize, PostProcBuffer::reset);
for (unsigned int i = 0; i < mBufferPoolSize; i++) {
std::shared_ptr<PostProcBuffer> postprocbuf = nullptr;
mPostProcItemsPool.acquireItem(postprocbuf);
if (postprocbuf.get() == nullptr) {
LOGE("Failed to get a post process buffer!");
return UNKNOWN_ERROR;
}
postprocbuf->index = i;
postprocbuf->fmt = outfmt;
}
return OK;
}
status_t
PostProcBufferPools::acquireItem(std::shared_ptr<PostProcBuffer> &procbuf) {
LOGD("@%s : mPostProcItemsPool preallocate buffer %zu", __FUNCTION__, mPostProcItemsPool.availableItems());
mPostProcItemsPool.acquireItem(procbuf);
CheckError((procbuf.get() == nullptr), UNKNOWN_ERROR, "@%s, failed to acquire PostProcBuffer",
__FUNCTION__);
procbuf->cambuf = MemoryUtils::acquireOneBuffer(mPipeline->getCameraId(), procbuf->fmt.width, procbuf->fmt.height);
CheckError((procbuf->cambuf.get() == nullptr), UNKNOWN_ERROR, "@%s, failed to acquire cambuf",
__FUNCTION__);
return OK;
}
std::shared_ptr<PostProcBuffer>
PostProcBufferPools::acquireItem() {
std::shared_ptr<PostProcBuffer> procbuf;
mPostProcItemsPool.acquireItem(procbuf);
CheckError((procbuf.get() == nullptr), nullptr, "@%s, acquire PostProcBuffer failed",
__FUNCTION__);
procbuf->cambuf = MemoryUtils::acquireOneBuffer(mPipeline->getCameraId(), procbuf->fmt.width, procbuf->fmt.height);
CheckError((procbuf->cambuf.get() == nullptr), nullptr, "@%s, acquire cambuf failed",
__FUNCTION__);
return procbuf;
}
RKISP2PostProcessUnit::RKISP2PostProcessUnit(const char* name, int type, uint32_t buftype, RKISP2PostProcessPipeline* pl) :
mInternalBufPool(new PostProcBufferPools()),
mName(name),
mBufType(buftype),
mEnable(true),
mSyncProcess(false),
mThreadRunning(false),
mProcThread(new MessageThread(this, name)),
mProcessUnitType(type),
mPipeline(pl),
mCurPostProcBufIn(nullptr),
mCurProcSettings(nullptr),
mCurPostProcBufOut(nullptr) {
LOGD("%s: @%s ", mName, __FUNCTION__);
}
RKISP2PostProcessUnit::~RKISP2PostProcessUnit() {
LOGD("%s: @%s ", mName, __FUNCTION__);
if (mProcThread != nullptr) {
mProcThread.reset();
mProcThread = nullptr;
}
#ifdef RK_EPTZ
if (mEptzThread){
ALOGI("rk-debug: delete mEptzThread ************");
mEptzThread->runnable = false;
mEptzThread.clear();
mEptzThread = NULL;
}
#endif
mPipeline = NULL;
mInBufferPool.clear();
mOutBufferPool.clear();
mCurPostProcBufIn.reset();
mCurProcSettings.reset();
mCurPostProcBufOut.reset();
}
status_t
RKISP2PostProcessUnit::prepare(const FrameInfo& outfmt, int bufNum) {
LOGD("%s: @%s ", mName, __FUNCTION__);
status_t status = OK;
if (mBufType == kPostProcBufTypeInt) {
status = mInternalBufPool->createBufferPools(mPipeline, outfmt, bufNum);
if (status) {
LOGE("%s: init buffer pool failed %d", __FUNCTION__, status);
return status;
}
}
return OK;
}
status_t
RKISP2PostProcessUnit::start() {
LOGD("%s: @%s ", mName, __FUNCTION__);
std::lock_guard<std::mutex> l(mApiLock);
if (mThreadRunning) {
LOGW("%s: post thread already running!", __FUNCTION__);
return OK;
}
mThreadRunning = true;
return mProcThread->run();
}
status_t
RKISP2PostProcessUnit::stop() {
LOGD("%s: @%s ", mName, __FUNCTION__);
std::unique_lock<std::mutex> l(mApiLock, std::defer_lock);
l.lock();
if (!mThreadRunning) {
LOGW("%s: post thread already stopped!", __FUNCTION__);
return OK;
}
mThreadRunning = false;
mCondition.notify_all();
l.unlock();
return mProcThread->requestExitAndWait();
}
status_t
RKISP2PostProcessUnit::flush() {
LOGD("%s: @%s ", mName, __FUNCTION__);
std::lock_guard<std::mutex> l(mApiLock);
//mInBufferPool.clear();
for (auto iter : mOutBufferPool)
notifyListeners(iter, std::shared_ptr<RKISP2ProcUnitSettings>(), -1);
//mOutBufferPool.clear();
//mCurPostProcBufIn.reset();
//mCurProcSettings.reset();
//mCurPostProcBufOut.reset();
return OK;
}
status_t
RKISP2PostProcessUnit::drain() {
PERFORMANCE_ATRACE_CALL();
LOGD("%s: @%s ", mName, __FUNCTION__);
// the processing frame can't be stopped so just
// wait current frame process done
long timeout = 500 * 1000000; //500ms timeout
nsecs_t startTime = systemTime();
nsecs_t interval = 0;
while (!mInBufferPool.empty() ||
mCurPostProcBufIn.get() != NULL ||
mCurPostProcBufOut.get() != NULL) {
usleep(5000); // wait 5ms
interval = systemTime() - startTime;
if(interval >= timeout) {
LOGE("@%s :%s drain timeout, time spend:%" PRId64 "us > 500ms", __FUNCTION__, mName, interval / 1000);
return UNKNOWN_ERROR;
}
}
LOGI("@%s : It tooks %" PRId64 "us to drain %s", __FUNCTION__, interval / 1000, mName);
return OK;
}
status_t
RKISP2PostProcessUnit::addOutputBuffer(std::shared_ptr<PostProcBuffer> buf) {
LOGD("%s: @%s ", mName, __FUNCTION__);
std::lock_guard<std::mutex> l(mApiLock);
if (mBufType != kPostProcBufTypeExt) {
LOGE("%s: %s can't accept external buffer!"
"buffer type is %d", __FUNCTION__, mName, mBufType);
return UNKNOWN_ERROR;
}
mOutBufferPool.push_back(buf);
return OK;
}
status_t
RKISP2PostProcessUnit::setEnable(bool enable) {
LOGD("%s: @%s ", mName, __FUNCTION__);
std::lock_guard<std::mutex> l(mApiLock);
mEnable = enable;
return OK;
}
status_t
RKISP2PostProcessUnit::setProcessSync(bool sync) {
LOGD("%s: @%s ", mName, __FUNCTION__);
std::lock_guard<std::mutex> l(mApiLock);
mSyncProcess = sync;
return OK;
}
/* called by ThreadLoop */
void
RKISP2PostProcessUnit::prepareProcess() {
// get a frame to be processed from input buffer queue
std::unique_lock<std::mutex> l(mApiLock);
if (mThreadRunning && mInBufferPool.empty())
mCondition.wait(l);
if (!mThreadRunning)
return;
LOGD("%s: @%s, mInBufferPool size:%d, mOutBufferPool size:%d",
mName, __FUNCTION__, mInBufferPool.size(), mOutBufferPool.size());
mCurPostProcBufIn = mInBufferPool[0].first;
mCurProcSettings = mInBufferPool[0].second;
mInBufferPool.erase(mInBufferPool.begin());
// get an output buffer from output buffer queue or internal
// buffer queue
if (mCurPostProcBufOut.get() != nullptr) {
LOGE("%s: %s busy !", __FUNCTION__, mName);
return;
}
switch (mBufType) {
case kPostProcBufTypeInt :
mInternalBufPool->acquireItem(mCurPostProcBufOut);
break;
case kPostProcBufTypeExt :
if (!mOutBufferPool.empty()) {
mCurPostProcBufOut = mOutBufferPool[0];
uint32_t inBufReqId = mCurProcSettings->request->getId();
uint32_t outBufReqId = mCurPostProcBufOut->request->getId();
// check the input buffer is needed for this unit
if(inBufReqId == outBufReqId) {
mOutBufferPool.erase(mOutBufferPool.begin());
} else if(inBufReqId > outBufReqId) {
LOGE("@%s: %s, new request %d is comming, reqeust %d won't be processed",
__FUNCTION__, mName, inBufReqId, outBufReqId);
mCurPostProcBufOut.reset();
return;
} else {
LOGW("@%s: %s, drop the input buffer for reqId mismatch, in(%d)/out(%d)",
__FUNCTION__, mName, inBufReqId, outBufReqId);
mCurPostProcBufOut.reset();
return;
}
if(mCurPostProcBufOut->cambuf->waitOnAcquireFence() != NO_ERROR) {
// if wait on fence failed, just relay the buffer to xxframework
LOGW("Wait on fence for buffer %p timed out", mCurPostProcBufOut->cambuf.get());
relayToNextProcUnit(NO_ERROR);
}
}
break;
case kPostProcBufTypePre :
mCurPostProcBufOut = mCurPostProcBufIn;
break;
default:
LOGE("%s: error buffer type %d.", __FUNCTION__, mBufType);
}
if (mCurPostProcBufOut.get() == nullptr) {
// relay to next proc unit
LOGW("%s: no output buf for unit %s", __FUNCTION__, mName);
relayToNextProcUnit(STATUS_FORWRAD_TO_NEXT_UNIT);
}
}
/* called by ThreadLoop */
status_t
RKISP2PostProcessUnit::relayToNextProcUnit(int err) {
LOGD("%s: @%s ", mName, __FUNCTION__);
status_t status = OK;
int64_t reqId = mCurProcSettings->request->getId();
if (err == STATUS_NEED_NEXT_INPUT_FRAME) {
mCurPostProcBufIn.reset();
mCurProcSettings.reset();
LOGD("@%s(%d) reqId:%d STATUS_NEED_NEXT_INPUT_FRAME",__FUNCTION__,__LINE__,mCurProcSettings->request->getId());
return err;
}
if (err == STATUS_FORWRAD_TO_NEXT_UNIT &&
mBufType != kPostProcBufTypeExt)
status = notifyListeners(mCurPostProcBufIn,
mCurProcSettings, err);
else if (mCurPostProcBufOut.get() != nullptr)
status = notifyListeners(mCurPostProcBufOut,
mCurProcSettings, err);
else
LOGW("%s: %s drop the input frame !", __FUNCTION__, mName);
LOGD("%s(%d) 0:%d done err:%d",__FUNCTION__,__LINE__,reqId,err);
if(err == 0){
mPipeline->mBufferListener->bufferDone(reqId);
}
mCurPostProcBufOut.reset();
mCurPostProcBufIn.reset();
mCurProcSettings.reset();
return status;
}
status_t
RKISP2PostProcessUnit::doProcess() {
LOGD("%s: @%s ", mName, __FUNCTION__);
status_t status = OK;
std::unique_lock<std::mutex> l(mApiLock, std::defer_lock);
l.lock();
do {
l.unlock();
prepareProcess();
if (mCurPostProcBufIn.get() && mCurPostProcBufOut.get()) {
status = processFrame(mCurPostProcBufIn,
mCurPostProcBufOut,
mCurProcSettings);
#ifdef RK_EPTZ
processEptzFrame(mCurPostProcBufOut);
#endif
status = relayToNextProcUnit(status);
}
l.lock();
} while(mThreadRunning && status == STATUS_NEED_NEXT_INPUT_FRAME);
l.unlock();
return OK;
}
void
RKISP2PostProcessUnit::messageThreadLoop(void) {
std::unique_lock<std::mutex> l(mApiLock, std::defer_lock);
l.lock();
#ifdef RK_FEC
if (mFecUnit) {
mFecUnit->distortionInit(2560,1440);
}
#endif
while (mThreadRunning) {
l.unlock();
doProcess();
l.lock();
}
l.unlock();
}
status_t RKISP2PostProcessUnit::notifyNewFrame(const std::shared_ptr<PostProcBuffer>& buf,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings,
int err) {
LOGD("%s: @%s, mInBufferPool size:%d", mName, __FUNCTION__, mInBufferPool.size() + 1);
LOGD("%s: @%s, reqId: %d dmaBufFd:%d",
mName, __FUNCTION__, settings->request->getId(),buf->cambuf->dmaBufFd());
std::unique_lock<std::mutex> l(mApiLock, std::defer_lock);
l.lock();
/* TODO: handle err first ? */
if (mThreadRunning == false) {
LOGW("%s: proc unit %s has been stopped!", __FUNCTION__, mName);
goto unlock_ret;
}
if (!mEnable) {
l.unlock();
return notifyListeners(buf, settings, err);
}
if (mSyncProcess) {
l.unlock();
return doProcess();
} else {
mInBufferPool.push_back(std::make_pair(buf, settings));
mCondition.notify_all();
goto unlock_ret;
}
unlock_ret:
l.unlock();
return OK;
}
/* Consider the performance, this should not hold the ApiLock */
status_t
RKISP2PostProcessUnit::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::shared_ptr<PostProcBuffer>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
PERFORMANCE_ATRACE_CALL();
LOGD("%s: @%s, reqId: %d dmaBufFd:%d",
mName, __FUNCTION__, settings->request->getId(),in->cambuf->dmaBufFd());
status_t status = OK;
bool mirror = false;
#ifdef MIRROR_HANDLING_FOR_FRONT_CAMERA
if(PlatformData::facing(mPipeline->getCameraId()) == CAMERA_FACING_FRONT) {
bool isPreview = false;
camera3_stream_t* stream = mPipeline->getStreamByType(mProcessUnitType);
if(stream) {
isPreview = CHECK_FLAG(stream->usage, GRALLOC_USAGE_HW_COMPOSER);
isPreview |= CHECK_FLAG(stream->usage, GRALLOC_USAGE_HW_TEXTURE);
isPreview |= CHECK_FLAG(stream->usage, GRALLOC_USAGE_HW_RENDER);
}
mirror = isPreview;
LOGD("@%s : mirror(%d) handling for front camera", __FUNCTION__, mirror);
}
#endif
if (mProcessUnitType == kPostProcessTypeDummy) {
LOGD("@%s %d: dummy unit , do nothing", __FUNCTION__, __LINE__);
return OK;
}
/*
* use RGA to do memcpy.
* TODO: using arm to do memcpy has cache issue, the buffer from framework
* may enable cache but not fluch cache when buffer is unlocked.
*/
if (mProcessUnitType == kPostProcessTypeCopy ||
mProcessUnitType == kPostProcessTypeUVC ||
mProcessUnitType == kPostProcessTypeScaleAndRotation) {
int cropw, croph, croptop, cropleft;
float inratio = (float)in->cambuf->width() / in->cambuf->height();
float outratio = (float)out->cambuf->width() / out->cambuf->height();
if (inratio < outratio) {
// crop height
cropw = in->cambuf->width();
croph = in->cambuf->width() / outratio;
} else {
// crop width
cropw = in->cambuf->height() * outratio;
croph = in->cambuf->height();
}
// should align to 2
cropw &= ~0x3;
croph &= ~0x3;
cropleft = (in->cambuf->width() - cropw) / 2;
croptop = (in->cambuf->height() - croph) / 2;
cropleft &= ~0x1;
croptop &= ~0x1;
LOGD("%s: crop region(%d,%d,%d,%d) from (%d,%d) to %dx%d, infmt %d,%d, outfmt %d,%d",
__FUNCTION__, cropw, croph, cropleft, croptop,
in->cambuf->width(), in->cambuf->height(),
out->cambuf->width(), out->cambuf->height(),
in->cambuf->format(),
in->cambuf->v4l2Fmt(),
out->cambuf->format(),
out->cambuf->v4l2Fmt());
RgaCropScale::Params rgain, rgaout;
rgain.fd = in->cambuf->dmaBufFd();
if (in->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
in->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgain.vir_addr = (char*)in->cambuf->data();
rgain.mirror = mirror;
rgain.width = cropw;
rgain.height = croph;
rgain.offset_x = cropleft;
rgain.offset_y = croptop;
rgain.width_stride = in->cambuf->width();
rgain.height_stride = in->cambuf->height();
rgaout.fd = out->cambuf->dmaBufFd();
// HAL_PIXEL_FORMAT_YCbCr_420_888 buffer layout is the same as NV12
// in gralloc module implementation
if (out->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
out->cambuf->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
out->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgaout.vir_addr = (char*)out->cambuf->data();
rgaout.mirror = false;
rgaout.width = out->cambuf->width();
rgaout.height = out->cambuf->height();
rgaout.offset_x = 0;
rgaout.offset_y = 0;
rgaout.width_stride = out->cambuf->width();
rgaout.height_stride = out->cambuf->height();
if (RgaCropScale::CropScaleNV12Or21(&rgain, &rgaout)) {
LOGE("%s: crop&scale by RGA failed...", __FUNCTION__);
PERFORMANCE_ATRACE_NAME("SWCropScale");
ImageScalerCore::cropComposeUpscaleNV12_bl(
in->cambuf->data(), in->cambuf->height(), in->cambuf->width(),
cropleft, croptop, cropw, croph,
out->cambuf->data(), out->cambuf->height(), out->cambuf->width(),
0, 0, out->cambuf->width(), out->cambuf->height());
}
}
return status;
}
#ifdef RK_EPTZ
status_t
RKISP2PostProcessUnit::processEptzFrame(const std::shared_ptr<PostProcBuffer>& mCurPostProcBufOut) {
LOGD("%s, @%s ", mName, __FUNCTION__);
if(!strcmp("JpegEnc",mName) || mBufType == 0){
ALOGI("rk-debug %s, name %s mBufType %d return", __FUNCTION__, mName, mBufType);
return OK;
}
RgaCropScale::Params rgain, rgaout;
rgain.fd = mCurPostProcBufOut->cambuf->dmaBufFd();
if (mCurPostProcBufOut->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
mCurPostProcBufOut->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgain.vir_addr = (char*)mCurPostProcBufOut->cambuf->data();
rgain.mirror = false;
rgain.width = mCurPostProcBufOut->cambuf->width();
rgain.height = mCurPostProcBufOut->cambuf->height();
rgain.offset_x = 0;
rgain.offset_y = 0;
rgain.width_stride = mCurPostProcBufOut->cambuf->width();
rgain.height_stride = mCurPostProcBufOut->cambuf->height();
rgaout.fd = mCurPostProcBufOut->cambuf->dmaBufFd();
if (mCurPostProcBufOut->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
mCurPostProcBufOut->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgaout.vir_addr = (char*)mCurPostProcBufOut->cambuf->data();
rgaout.mirror = false;
rgaout.width = mCurPostProcBufOut->cambuf->width();
rgaout.height = mCurPostProcBufOut->cambuf->height();
rgaout.offset_x = 0;
rgaout.offset_y = 0;
rgaout.width_stride = mCurPostProcBufOut->cambuf->width();
rgaout.height_stride = mCurPostProcBufOut->cambuf->height();
//#ifdef RK_OCCLUSION
char occlusion_property_value[PROPERTY_VALUE_MAX] = {0};
property_get("vendor.camera.occlusion.enable", occlusion_property_value, "0");
//#endif
char eptz_property_value[PROPERTY_VALUE_MAX] = {0};
property_get("vendor.camera.eptz.mode", eptz_property_value, "0");
if(nullptr != mEptzThread){
if(mEptzThread->runnable && mEptzThread->isInit){
mEptzThread->converData(rgain);
mEptzThread->calculateRect(&rgain);
}
}else{
if (atoi(eptz_property_value) != 0 || atoi(occlusion_property_value) != 0){
ALOGI("rk-debug mEptzThread create , name %s", mName);
mEptzThread = new EptzThread();
mEptzThread->setPreviewCfg(mCurPostProcBufOut->cambuf->width(), mCurPostProcBufOut->cambuf->height());
mEptzThread->setMode(atoi(eptz_property_value));
mEptzThread->setOcclusionMode(atoi(occlusion_property_value));
mEptzThread->run("CamEPTZThread", PRIORITY_DISPLAY);
}
}
if (mEptzThread && mEptzThread->getMode() != atoi(eptz_property_value)){
if(atoi(eptz_property_value) == 0){
ALOGI("rk-debug: delete mEptzThread ************");
mEptzThread->runnable = false;
mEptzThread.clear();
mEptzThread = NULL;
}else{
mEptzThread->setMode(atoi(eptz_property_value));
}
}
RgaCropScale::CropScaleNV12Or21(&rgain, &rgaout);
return OK;
}
#endif
bool RKISP2PostProcessUnit::checkFmt(CameraBuffer* in, CameraBuffer* out) {
return true;
}
RKISP2PostProcessPipeline::RKISP2PostProcessPipeline(RKISP2IPostProcessListener* listener,
int camid) :
mPostProcFrameListener(listener),
mCameraId(camid),
mThreadRunning(false),
mMessageQueue("PPThread", static_cast<int>(MESSAGE_ID_MAX)),
mMessageThread(nullptr),
mMayNeedSyncStreamsOutput(false),
mOutputBuffersHandler(new OutputBuffersHandler(this)) {
mMessageThread = std::unique_ptr<MessageThread>(new MessageThread(this, "PPThread"));
mMessageThread->run();
}
RKISP2PostProcessPipeline::RKISP2PostProcessPipeline(RKISP2IPostProcessListener* listener,IBufferDone *bufferListener,
int camid) :
mPostProcFrameListener(listener),
mCameraId(camid),
mThreadRunning(false),
mMessageQueue("PPThread", static_cast<int>(MESSAGE_ID_MAX)),
mMessageThread(nullptr),
mMayNeedSyncStreamsOutput(false),
mOutputBuffersHandler(new OutputBuffersHandler(this)) {
mIsNeedcached = false;
mBufferListener = bufferListener;
mMessageThread = std::unique_ptr<MessageThread>(new MessageThread(this, "PPThread"));
mMessageThread->run();
}
RKISP2PostProcessPipeline::~RKISP2PostProcessPipeline() {
requestExitAndWait();
if (mMessageThread != nullptr) {
mMessageThread.reset();
mMessageThread = nullptr;
}
mPostProcUnits.clear();
mStreamToProcUnitMap.clear();
}
status_t
RKISP2PostProcessPipeline::addOutputBuffer(const std::vector<std::shared_ptr<PostProcBuffer>>& out) {
status_t status = OK;
for (auto iter : out) {
if (iter->cambuf.get() == nullptr)
continue;
camera3_stream_t* stream = iter->cambuf->getOwner()->getStream();
if (stream == nullptr)
continue;
status |= mStreamToProcUnitMap[stream]->addOutputBuffer(iter);
}
return status;
}
bool RKISP2PostProcessPipeline::IsRawStream(camera3_stream_t* stream) {
if (stream == NULL) {
LOGE("@%s : stream is NULL", __FUNCTION__);
return false;
}
if(stream->format == HAL_PIXEL_FORMAT_RAW16 ||
stream->format == HAL_PIXEL_FORMAT_RAW10 ||
stream->format == HAL_PIXEL_FORMAT_RAW12 ||
stream->format == HAL_PIXEL_FORMAT_RAW_OPAQUE)
return true;
return false;
}
status_t
RKISP2PostProcessPipeline::prepare(const FrameInfo& in,
const std::vector<camera3_stream_t*>& streams,
bool& needpostprocess,
int pipelineDepth) {
Message msg;
msg.id = MESSAGE_ID_PREPARE;
msg.prepareMsg.in = in;
msg.prepareMsg.streams = streams;
msg.prepareMsg.needpostprocess = false;
/* TODO should get needpostprocess from link result*/
needpostprocess = true;
msg.prepareMsg.pipelineDepth = pipelineDepth;
status_t status = mMessageQueue.send(&msg);
return status;
}
/*
* TODO:
* notice that the total process time of each other branch pipeline
* should be less than the main pipeline(which output the
* camera3_stream_buffer), or will cause no buffer issue in
* OutputFrameWorker::prepareRun
*
*/
status_t
RKISP2PostProcessPipeline::prepare_internal(const FrameInfo& in,
const std::vector<camera3_stream_t*>& streams,
bool& needpostprocess,
int pipelineDepth) {
LOGD("@%s enter", __FUNCTION__);
status_t status = OK;
int common_process_type = 0;
const camera_metadata_t *meta = PlatformData::getStaticMetadata(mCameraId);
// analyze which process unit do we need
mStreamToTypeMap.clear();
std::vector<std::map<camera3_stream_t*, int>>& streams_post_proc = mStreamToTypeMap;
mMayNeedSyncStreamsOutput = streams.size() > 1;
/* TODO: from metadata */
common_process_type = 0;
mUvc.width = in.width;
mUvc.height = in.height;
for (auto stream : streams) {
int stream_process_type = 0;
if(IsRawStream(stream)) {
LOGD("@%s %d: add Raw unit for rawStream", __FUNCTION__, __LINE__);
streams_post_proc.push_back(std::map<camera3_stream_t*, int> {{stream, kPostProcessTypeRaw}});
continue;
}
// do nothing to app streams data by using dummy unit if
// in fomat is raw. this may happen in the case:
// CAMERA_DUMP_RAW + no rawPath
if (graphconfig::utils::isRawFormat(in.format)) {
LOGD("@%s %d: add dummpy unit for appStreams when raw input", __FUNCTION__, __LINE__);
streams_post_proc.push_back(std::map<camera3_stream_t*, int> {{stream, kPostProcessTypeDummy}});
continue;
}
if (stream->format == HAL_PIXEL_FORMAT_BLOB)
stream_process_type |= kPostProcessTypeJpegEncoder;
if (stream->width * stream->height != in.width * in.height)
stream_process_type |= kPostProcessTypeScaleAndRotation;
if (getRotationDegrees(stream))
common_process_type |= kPostProcessTypeCropRotationScale;
// TuningServer *pserver = TuningServer::GetInstance();
// if (pserver && pserver->isTuningMode()){
// if (stream->format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED){
// streams_post_proc.push_back(std::map<camera3_stream_t*, int> {{&mUvc, kPostProcessTypeUVC}});
// }
// }
camera_metadata_ro_entry entry = MetadataHelper::getMetadataEntry(meta,
ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
float max_digital_zoom = 1.0f;
MetadataHelper::getValueByType(entry, 0, &max_digital_zoom);
#ifdef RK_FEC
if (max_digital_zoom > 1.0)
common_process_type |= kPostProcessTypeFec;
#else
if (max_digital_zoom > 1.0)
common_process_type |= kPostProcessTypeDigitalZoom;
#endif
#ifdef MIRROR_HANDLING_FOR_FRONT_CAMERA
//for front camera mirror handling, front camera preview do twice mirror
if(PlatformData::facing(mCameraId) == CAMERA_FACING_FRONT) {
if(stream_process_type == 0)
stream_process_type |= kPostProcessTypeCopy;
}
#endif
streams_post_proc.push_back(std::map<camera3_stream_t*, int> {{stream, stream_process_type}});
}
// add extra memcpy unit for streams if necessary
int common_types_exclude_buffer_needed = common_process_type &
~NO_NEED_INTERNAL_BUFFER_PROCESS_TYPES;
if (streams_post_proc.size() > 1 ||
(streams_post_proc.size() == 1 && common_types_exclude_buffer_needed == 0)) {
for (auto &stream_type_map : streams_post_proc) {
int stream_process_type = stream_type_map.begin()->second;
if (stream_process_type == 0) {
stream_process_type |= kPostProcessTypeCopy;
stream_type_map[stream_type_map.begin()->first] = stream_process_type;
stream_type_map.begin()->second = stream_process_type;
}
if (stream_process_type & kPostProcessTypeCopy)
mIsNeedcached = true;
else
mIsNeedcached = false;
LOGI("%s: stream %p process type 0x%x, mIsNeedcached(%d)", __FUNCTION__,
(stream_type_map.begin())->first, stream_process_type, mIsNeedcached);
}
} else {
LOGW("%s: no need buffer copy for stream!", __FUNCTION__);
}
LOGI("%s: common process type 0x%x", __FUNCTION__, common_process_type);
// get the last proc unit for streams
int stream_proc_types = 0;
for (auto stream_type_map : streams_post_proc)
stream_proc_types |= stream_type_map.begin()->second;
LOGI("%s: streams process type 0x%x", __FUNCTION__, stream_proc_types);
/* judge the steam's last process unit is the same as the common process */
int last_level_proc_common = 0;
if (stream_proc_types == 0) {
// the last common proc unit is also the stream's last proc unit
for (uint32_t i = 1; i < MAX_COMMON_PROC_UNIT_SHIFT; i++) {
uint32_t test_type = 1 << i;
if (common_process_type & test_type)
last_level_proc_common = test_type;
}
LOGI("%s: the last common process unit is the same as stream's 0x%x.",
__FUNCTION__, last_level_proc_common);
}
/* if there exist buffer needed common processes or
* main stream(always the first stream) is buffer needed,
* then |needpostprocess| is true
*/
if (common_types_exclude_buffer_needed ||
(streams_post_proc[0].begin()->second &
~NO_NEED_INTERNAL_BUFFER_PROCESS_TYPES))
needpostprocess = true;
else
needpostprocess = false;
// link common proc units
std::shared_ptr<RKISP2PostProcessUnit> procunit_from;
std::shared_ptr<RKISP2PostProcessUnit> procunit_to;
std::shared_ptr<RKISP2PostProcessUnit> procunit_main_last;
for (uint32_t i = 1; i < MAX_COMMON_PROC_UNIT_SHIFT; i++) {
uint32_t test_type = 1 << i;
bool last_proc_unit = (last_level_proc_common == test_type);
uint32_t buf_type = last_proc_unit ?
RKISP2PostProcessUnit::kPostProcBufTypeExt :
RKISP2PostProcessUnit::kPostProcBufTypeInt;
const char* process_unit_name = NULL;
if (common_process_type & test_type) {
switch (test_type) {
case kPostProcessTypeFec :
process_unit_name = "fecunit";
procunit_from = std::make_shared<RKISP2PostProcessUnitFec>
(process_unit_name, test_type, mCameraId, buf_type, this);
break;
case kPostProcessTypeDigitalZoom :
process_unit_name = "digitalzoom";
procunit_from = std::make_shared<RKISP2PostProcessUnitDigitalZoom>
(process_unit_name, test_type, mCameraId, buf_type, this);
break;
case kPostprocessTypeUvnr :
process_unit_name = "uvnr";
procunit_from = std::make_shared<RKISP2PostProcessUnit>
(process_unit_name, test_type, buf_type, this);
break;
case kPostProcessTypeCropRotationScale :
process_unit_name = "CropRotationScale";
procunit_from = std::make_shared<RKISP2PostProcessUnit>
(process_unit_name, test_type, buf_type, this);
break;
case kPostProcessTypeSwLsc :
process_unit_name = "SoftwareLsc";
procunit_from = std::make_shared<RKISP2PostProcessUnitSwLsc>
(process_unit_name, test_type, buf_type, this);
break;
case kPostProcessTypeFaceDetection :
process_unit_name = "faceDetection";
buf_type = RKISP2PostProcessUnit::kPostProcBufTypePre;
procunit_from = std::make_shared<RKISP2PostProcessUnit>
(process_unit_name, test_type, buf_type, this);
break;
default:
LOGW("%s: have no common process.", __FUNCTION__);
}
if (process_unit_name) {
if (test_type == kPostProcessTypeFaceDetection) {
procunit_to = nullptr;
} else {
procunit_to = procunit_main_last;
procunit_main_last = procunit_from;
}
LOGI("%s: add unit %s to %s, is the last proc unit %d",
__FUNCTION__, process_unit_name,
procunit_to.get() ? procunit_to.get()->mName : "first level",
last_proc_unit);
if (last_proc_unit) {
linkPostProcUnit(procunit_from, procunit_to,
procunit_to.get() ? kLastLevel : kFirstLevel);
// link streams callback to last correspond procunit
procunit_from->attachListener(mOutputBuffersHandler.get());
/* should exist only one stream */
mStreamToProcUnitMap[streams[0]] = procunit_from.get();
} else {
linkPostProcUnit(procunit_from, procunit_to,
procunit_to.get() ? kMiddleLevel : kFirstLevel);
}
/* TODO: should consider in and out format */
procunit_from->prepare(in, pipelineDepth);
}
}
}
/* link the stream process units */
for (auto proc_map : streams_post_proc) {
std::shared_ptr<RKISP2PostProcessUnit> procunit_stream_last = procunit_main_last;
// get the stream last process unit
uint32_t last_level_proc_stream = 0;
for (uint32_t i = MAX_COMMON_PROC_UNIT_SHIFT + 1;
i < MAX_STREAM_PROC_UNIT_SHIFT; i++) {
uint32_t test_type = 1 << i;
uint32_t stream_proc_type = proc_map.begin()->second;
if (stream_proc_type & test_type)
last_level_proc_stream = test_type;
}
LOGI("%s: stream %p last process unit 0x%x", __FUNCTION__,
proc_map.begin()->first, last_level_proc_stream);
for (uint32_t i = MAX_COMMON_PROC_UNIT_SHIFT + 1;
i < MAX_STREAM_PROC_UNIT_SHIFT; i++) {
uint32_t test_type = 1 << i;
bool last_proc_unit = (last_level_proc_stream == test_type);
uint32_t buf_type = last_proc_unit ?
RKISP2PostProcessUnit::kPostProcBufTypeExt :
RKISP2PostProcessUnit::kPostProcBufTypeInt;
const char* process_unit_name = NULL;
uint32_t stream_proc_type = proc_map.begin()->second;
if (stream_proc_type & test_type) {
switch (test_type) {
case kPostProcessTypeScaleAndRotation :
process_unit_name = "ScaleRotation";
procunit_from = std::make_shared<RKISP2PostProcessUnit>
(process_unit_name, test_type, buf_type, this);
break;
case kPostProcessTypeJpegEncoder :
process_unit_name = "JpegEnc";
procunit_from = std::make_shared<RKISP2PostProcessUnitJpegEnc>
(process_unit_name, test_type, buf_type, this);
break;
case kPostProcessTypeCopy :
process_unit_name = "MemCopy";
procunit_from = std::make_shared<RKISP2PostProcessUnit>
(process_unit_name, test_type, buf_type, this);
break;
case kPostProcessTypeUVC :
process_unit_name = "UVC";
procunit_from = std::make_shared<RKISP2PostProcessUnitUVC>
(process_unit_name, test_type, RKISP2PostProcessUnit::kPostProcBufTypeInt, this);
break;
case kPostProcessTypeRaw :
process_unit_name = "Raw";
// if need process the raw buffer in the future, the
// buffer type should be changed
procunit_from = std::make_shared<RKISP2PostProcessUnitRaw>
(process_unit_name, test_type, RKISP2PostProcessUnit::kPostProcBufTypePre);
break;
case kPostProcessTypeDummy :
process_unit_name = "Dummy";
procunit_from = std::make_shared<RKISP2PostProcessUnit>
(process_unit_name, test_type, buf_type);
break;
default:
LOGE("%s: unknown stream process unit type 0x%x",
__FUNCTION__, test_type);
}
}
if (process_unit_name) {
procunit_to = procunit_stream_last;
procunit_stream_last = procunit_from;
LOGI("%s: add unit %s to %s, is the last proc unit %d",
__FUNCTION__, process_unit_name,
procunit_to.get() ? procunit_to.get()->mName : "first level",
last_proc_unit);
if (last_proc_unit) {
linkPostProcUnit(procunit_from, procunit_to,
procunit_to.get() ? kLastLevel : kFirstLevel);
// link streams callback to last correspond procunit
procunit_from->attachListener(mOutputBuffersHandler.get());
mStreamToProcUnitMap[proc_map.begin()->first] = procunit_from.get();
} else {
linkPostProcUnit(procunit_from, procunit_to,
procunit_to.get() ? kMiddleLevel : kFirstLevel);
}
/* TODO: should consider in and out format */
if (strstr(process_unit_name, "ScaleRotation")) {
FrameInfo outfmt = in;
outfmt.width = proc_map.begin()->first->width;
outfmt.height = proc_map.begin()->first->height;
procunit_from->prepare(outfmt, pipelineDepth);
} else {
procunit_from->prepare(in, pipelineDepth);
}
}
}
}
for (int i = 0; i < RKISP2PostProcessPipeline::kMaxLevel; i++) {
for (auto iter : mPostProcUnitArray[i])
LOGI("level %d, unit %s", i, iter->mName);
}
LOGD("@%s exit", __FUNCTION__);
return status;
}
status_t
RKISP2PostProcessPipeline::start() {
LOGD("@%s", __FUNCTION__);
Message msg;
msg.id = MESSAGE_ID_START;
status_t status = mMessageQueue.send(&msg);
return status;
}
status_t
RKISP2PostProcessPipeline::clear() {
LOGD("@%s", __FUNCTION__);
status_t status = OK;
mPostProcUnits.clear();
mStreamToProcUnitMap.clear();
for (int i = 0; i < RKISP2PostProcessPipeline::kMaxLevel; i++) {
mPostProcUnitArray[i].clear();
}
return status;
}
status_t
RKISP2PostProcessPipeline::stop() {
LOGD("@%s", __FUNCTION__);
Message msg;
msg.id = MESSAGE_ID_STOP;
status_t status = mMessageQueue.send(&msg);
return status;
}
void
RKISP2PostProcessPipeline::flush() {
LOGD("@%s", __FUNCTION__);
Message msg;
msg.id = MESSAGE_ID_FLUSH;
status_t status = mMessageQueue.send(&msg);
/* TODO now only complete dummy flush, just wait all request done,
* and flush here do nothing, in future vertion, add it*/
/* flush from first level unit to last level */
/* for (int i = 0; i < kMaxLevel; i++) */
/* for (auto iter : mPostProcUnitArray[i]) */
/* iter->flush(); */
}
status_t
RKISP2PostProcessPipeline::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::vector<std::shared_ptr<PostProcBuffer>>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
status_t status = OK;
LOGD("@%s in dmaBufFd:%d, out size:%d",__FUNCTION__,in->cambuf->dmaBufFd(),out.size());
if(out.size() == 0){
mBufferListener->bufferDone(settings->request->getId());
return status;
}
Message msg;
msg.id = MESSAGE_ID_PROCESSFRAME;
msg.processMsg.in = in;
msg.processMsg.out = out;
msg.processMsg.settings = settings;
status = mMessageQueue.send(&msg);
return status;
}
camera3_stream_t*
RKISP2PostProcessPipeline::getStreamByType(int stream_type) {
for (auto proc_map : mStreamToTypeMap) {
uint32_t stream_proc_type = proc_map.begin()->second;
if (stream_proc_type & stream_type)
return proc_map.begin()->first;
}
return NULL;
}
int
RKISP2PostProcessPipeline::getRotationDegrees(camera3_stream_t* stream) const {
if (stream->stream_type != CAMERA3_STREAM_OUTPUT) {
LOGI("%s, no need rotation for stream type %d", __FUNCTION__,
stream->stream_type);
return 0;
}
#ifdef CHROME_BOARD
if (stream->crop_rotate_scale_degrees == CAMERA3_STREAM_ROTATION_90)
return 90;
else if (stream->crop_rotate_scale_degrees == CAMERA3_STREAM_ROTATION_270)
return 270;
#endif
return 0;
}
status_t
RKISP2PostProcessPipeline::linkPostProcUnit(const std::shared_ptr<RKISP2PostProcessUnit>& from,
const std::shared_ptr<RKISP2PostProcessUnit>& to,
enum ProcessUnitLevel level) {
LOGD("@%s", __FUNCTION__);
if (from.get() == nullptr)
return UNKNOWN_ERROR;
if (to.get() != nullptr)
to->attachListener(from.get());
else if (level != kFirstLevel)
return UNKNOWN_ERROR;
mPostProcUnits.push_back(from);
mPostProcUnitArray[level].push_back(from.get());
return OK;
}
status_t
RKISP2PostProcessPipeline::enablePostProcUnit(RKISP2PostProcessUnit* procunit, bool enable) {
LOGD("@%s", __FUNCTION__);
status_t status = OK;
if (procunit == nullptr)
return OK;
for (auto iter : mPostProcUnits) {
if (iter.get() == procunit) {
status = procunit->setEnable(enable);
break;
}
}
return status;
}
status_t
RKISP2PostProcessPipeline::setPostProcUnitAsync(RKISP2PostProcessUnit* procunit, bool async) {
LOGD("@%s", __FUNCTION__);
status_t status = OK;
if (procunit == nullptr)
return OK;
for (auto iter : mPostProcUnits) {
if (iter.get() == procunit) {
status = procunit->setProcessSync(async);
break;
}
}
return status;
}
void
RKISP2PostProcessPipeline::messageThreadLoop()
{
LOGD("@%s - Start", __FUNCTION__);
mThreadRunning = true;
while (mThreadRunning) {
status_t status = NO_ERROR;
PERFORMANCE_ATRACE_BEGIN("PP-PollMsg");
Message msg;
mMessageQueue.receive(&msg);
PERFORMANCE_ATRACE_END();
PERFORMANCE_ATRACE_NAME_SNPRINTF("PP-%s", ENUM2STR(PPMsg_stringEnum, msg.id));
PERFORMANCE_HAL_ATRACE_PARAM1("msg", msg.id);
LOGD("@%s, receive message id:%d", __FUNCTION__, msg.id);
switch (msg.id) {
case MESSAGE_ID_EXIT:
status = handleMessageExit();
break;
case MESSAGE_ID_START:
status = handleStart(msg);
break;
case MESSAGE_ID_STOP:
status = handleStop(msg);
break;
case MESSAGE_ID_PREPARE:
status = handlePrepare(msg);
break;
case MESSAGE_ID_PROCESSFRAME:
status = handleProcessFrame(msg);
break;
case MESSAGE_ID_FLUSH:
status = handleFlush(msg);
break;
default:
LOGE("ERROR Unknown message %d", msg.id);
status = BAD_VALUE;
break;
}
if (status != NO_ERROR)
LOGE("error %d in handling message: %d", status,
static_cast<int>(msg.id));
LOGD("@%s, finish message id:%d", __FUNCTION__, msg.id);
mMessageQueue.reply(msg.id, status);
PERFORMANCE_ATRACE_END();
}
LOGD("%s: Exit", __FUNCTION__);
}
status_t
RKISP2PostProcessPipeline::requestExitAndWait()
{
Message msg;
msg.id = MESSAGE_ID_EXIT;
status_t status = mMessageQueue.send(&msg, MESSAGE_ID_EXIT);
status |= mMessageThread->requestExitAndWait();
return status;
}
status_t
RKISP2PostProcessPipeline::handleMessageExit()
{
mThreadRunning = false;
return NO_ERROR;
}
status_t
RKISP2PostProcessPipeline::handleStart(Message &msg)
{
LOGD("@%s : enter", __FUNCTION__);
status_t status = OK;
for (int i = 0; i < kMaxLevel; i++)
for (auto iter : mPostProcUnitArray[i])
status |= iter->start();
return status;
}
status_t
RKISP2PostProcessPipeline::handleStop(Message &msg)
{
LOGD("@%s : enter", __FUNCTION__);
status_t status = OK;
for (int i = 0; i < kMaxLevel; i++)
for (auto iter : mPostProcUnitArray[i])
iter->drain();
for (int i = 0; i < kMaxLevel; i++)
for (auto iter : mPostProcUnitArray[i])
status |= iter->stop();
clear();
return status;
}
status_t
RKISP2PostProcessPipeline::handlePrepare(Message &msg)
{
LOGD("@%s : enter", __FUNCTION__);
prepare_internal(msg.prepareMsg.in, msg.prepareMsg.streams, msg.prepareMsg.needpostprocess, msg.prepareMsg.pipelineDepth);
return NO_ERROR;
}
status_t
RKISP2PostProcessPipeline::handleProcessFrame(Message &msg)
{
LOGD("@%s : enter", __FUNCTION__);
status_t status = OK;
// add |out| to correspond unit
status = addOutputBuffer(msg.processMsg.out);
if (status != OK)
return status;
// LOGE("rk-debug: ======== pid=%d", syscall(SYS_gettid));
mOutputBuffersHandler->addSyncBuffersIfNeed(msg.processMsg.in, msg.processMsg.out);
// send |in| to each first level process unit
for (auto iter : mPostProcUnitArray[kFirstLevel]) {
status |= iter->notifyNewFrame(msg.processMsg.in, msg.processMsg.settings, 0);
LOGD("%s(%d) in dmaBufFd:% reqId:%d",__FUNCTION__,__LINE__,msg.processMsg.in->cambuf->dmaBufFd(),msg.processMsg.settings->request->getId());
}
return status;
}
status_t
RKISP2PostProcessPipeline::handleFlush(Message &msg)
{
LOGD("@%s : enter", __FUNCTION__);
status_t status = OK;
return NO_ERROR;
for (int i = 0; i < kMaxLevel; i++)
for (auto iter : mPostProcUnitArray[i])
status |= iter->flush();
return status;
}
RKISP2PostProcessPipeline::
OutputBuffersHandler::OutputBuffersHandler(RKISP2PostProcessPipeline* pipeline)
: mPipeline(pipeline) {
}
status_t RKISP2PostProcessPipeline::OutputBuffersHandler::
notifyNewFrame(const std::shared_ptr<PostProcBuffer>& buf,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings,
int err) {
status_t status = OK;
LOGD("%s(%d) in dmaBufFd:%d reqId:%d",__FUNCTION__,__LINE__,buf->cambuf->dmaBufFd(),settings->request->getId());
std::map<CameraBuffer*, std::shared_ptr<syncItem>>::iterator it;
if (!mPipeline->mMayNeedSyncStreamsOutput)
return mPipeline->mPostProcFrameListener->notifyNewFrame(buf, settings, err);
{
std::lock_guard<std::mutex> l(mLock);
it = mCamBufToSyncItemMap.find(buf->cambuf.get());
}
if (it != mCamBufToSyncItemMap.end()) {
if (--it->second->sync_nums == 0) {
LOGI("@%s return sync buffer", __FUNCTION__);
for (auto sync_buf : it->second->sync_buffers)
status |= mPipeline->mPostProcFrameListener->notifyNewFrame(sync_buf, settings, err);
}
std::lock_guard<std::mutex> l(mLock);
mCamBufToSyncItemMap.erase(it);
} else {
status = mPipeline->mPostProcFrameListener->notifyNewFrame(buf, settings, err);
}
return status;
}
void RKISP2PostProcessPipeline::OutputBuffersHandler::
addSyncBuffersIfNeed(const std::shared_ptr<PostProcBuffer>& in,
const std::vector<std::shared_ptr<PostProcBuffer>>& out) {
if (mPipeline->mMayNeedSyncStreamsOutput &&
out.size() > 1 &&
in->cambuf->getBufferHandle() != nullptr) {
bool need_sync = false;
LOGD("%s(%d) in dmaBufFd:%d",__FUNCTION__,__LINE__,in->cambuf->dmaBufFd());
for (auto iter : out) {
if (iter->cambuf.get() == in->cambuf.get())
need_sync = true;
}
if (need_sync) {
LOGD("@%s add sync buffer", __FUNCTION__);
struct syncItem* sync_item = new syncItem();
sync_item->sync_buffers = out;
sync_item->sync_nums = out.size();
std::lock_guard<std::mutex> l(mLock);
std::shared_ptr<syncItem> shared_sync_item(sync_item);
for (auto iter : out)
mCamBufToSyncItemMap[iter->cambuf.get()] = shared_sync_item;
}
}
}
RKISP2PostProcessUnitUVC::RKISP2PostProcessUnitUVC(const char* name, int type,
uint32_t buftype, RKISP2PostProcessPipeline* pl)
:RKISP2PostProcessUnit(name, type, buftype, pl) {
// TuningServer *pserver = TuningServer::GetInstance();
// if(pserver) {
// pUvc_vpu_ops = pserver->get_vpu_ops();
// pUvc_proc_ops = pserver->get_proc_ops();
// }
}
RKISP2PostProcessUnitUVC::~RKISP2PostProcessUnitUVC() {
if (pUvc_vpu_ops && pUvc_vpu_ops->encode_deinit)
pUvc_vpu_ops->encode_deinit();
}
status_t
RKISP2PostProcessUnitUVC::prepare(const FrameInfo& outfmt, int bufNum) {
LOGD("@%s %d: instance:%p, name: %s", __FUNCTION__, __LINE__, this, mName);
mOutFmtInfo = outfmt;
mBufNum = bufNum;
uvcFrameW = outfmt.width;
uvcFrameH = outfmt.height;
if (pUvc_vpu_ops && pUvc_vpu_ops->encode_init && pUvc_vpu_ops->encode_init(uvcFrameW, uvcFrameH, 5)) {
LOGE("%s(%d): encode_init failed!",__FUNCTION__,__LINE__);
return BAD_VALUE;
}
return RKISP2PostProcessUnit::prepare(outfmt, bufNum);
}
status_t
RKISP2PostProcessUnitUVC::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::shared_ptr<PostProcBuffer>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
unsigned int fcc;
int width,height;
unsigned char *enc_out_data;
unsigned int enc_out_len;
int ret = 0;
// unsigned char *srcbuf, *dstbuf;
LOGD("@%s %d: instance:%p, name: %s", __FUNCTION__, __LINE__, this, mName);
// RKISP2PostProcessUnit::processFrame(in, out, settings);
// in->cambuf->dumpImage(CAMERA_DUMP_VIDEO, "UVC_IN");
// out->cambuf->dumpImage(CAMERA_DUMP_VIDEO, "UVC_OUT");
if ((pUvc_proc_ops==NULL) || !pUvc_proc_ops->get_state || !pUvc_proc_ops->get_state() || !pUvc_proc_ops->transfer_data_enable()) {
goto out;
}else {
fcc = pUvc_proc_ops->get_fcc();
pUvc_proc_ops->get_res(&width, &height);
if((width != uvcFrameW) || (height != uvcFrameH)){
uvcFrameW = width;
uvcFrameH = height;
if (V4L2_PIX_FMT_MJPEG == fcc) {
pUvc_vpu_ops->encode_deinit();
if (pUvc_vpu_ops->encode_init && pUvc_vpu_ops->encode_init(uvcFrameW, uvcFrameH, 5)) {
LOGE("%s(%d): encode_init failed!",__FUNCTION__,__LINE__);
}
}
}
std::shared_ptr<PostProcBuffer> tempBuf = std::make_shared<PostProcBuffer> ();
if(V4L2_PIX_FMT_MJPEG == fcc){
tempBuf->cambuf = MemoryUtils::acquireOneBufferWithNoCache(mPipeline->getCameraId(), uvcFrameW, uvcFrameH);
}else if(V4L2_PIX_FMT_YUYV == fcc){
tempBuf->cambuf = MemoryUtils::acquireOneBuffer(mPipeline->getCameraId(), uvcFrameW, uvcFrameH);
}
tempBuf->request = in->request;
RKISP2PostProcessUnit::processFrame(in, tempBuf, settings);
switch (fcc) {
case V4L2_PIX_FMT_YUYV:
{
pUvc_proc_ops->transfer_data(NULL, 0, (void *)tempBuf->cambuf->data(), uvcFrameW * uvcFrameH * 2, fcc);
break;
}
case V4L2_PIX_FMT_MJPEG:
{
std::shared_ptr<PostProcBuffer> tempBuf1 = std::make_shared<PostProcBuffer> ();
tempBuf1->cambuf = MemoryUtils::acquireOneBufferWithNoCache(mPipeline->getCameraId(), uvcFrameW, uvcFrameH);
pUvc_vpu_ops->encode_set_buf(tempBuf1->cambuf->dmaBufFd(),(void *)tempBuf1->cambuf->data(),
tempBuf1->cambuf->dmaBufFd(),uvcFrameW * uvcFrameH);
ret = pUvc_vpu_ops->encode_process((void *)tempBuf->cambuf->data(), tempBuf->cambuf->dmaBufFd(), uvcFrameW * uvcFrameH * 3 / 2);
if (!ret) {
pUvc_vpu_ops->encode_get_buf(&enc_out_data, &enc_out_len);
pUvc_proc_ops->transfer_data(NULL, 0, enc_out_data, enc_out_len, fcc);
}
break;
}
}
}
out:
mCurPostProcBufOut.reset();
mCurPostProcBufIn.reset();
mCurProcSettings.reset();
return OK;
}
RKISP2PostProcessUnitJpegEnc::RKISP2PostProcessUnitJpegEnc(const char* name, int type,
uint32_t buftype, RKISP2PostProcessPipeline* pl)
: RKISP2PostProcessUnit(name, type, buftype, pl) {
}
RKISP2PostProcessUnitJpegEnc::~RKISP2PostProcessUnitJpegEnc() {
}
status_t
RKISP2PostProcessUnitJpegEnc::notifyNewFrame(const std::shared_ptr<PostProcBuffer>& buf,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings,
int err) {
std::unique_lock<std::mutex> l(mApiLock, std::defer_lock);
l.lock();
// fix VideoSnapshot exception:
// Compared with normal capture, in videoSnapshot case, app would
// not wait for the jpeg result and keep senting requests to hal.
// Additionally, encoding jpeg may take a long time and block the
// jpeg unit thread, therefor casue the growing of mInBufferPool
// size and then cause the failure of acquiring RKISP2ProcUnitSettings.
// finally lead to a fault error.
if (mOutBufferPool.empty()) {
l.unlock();
return OK;
}
l.unlock();
return RKISP2PostProcessUnit::notifyNewFrame(buf, settings, err);
}
status_t
RKISP2PostProcessUnitJpegEnc::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::shared_ptr<PostProcBuffer>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
PERFORMANCE_ATRACE_CALL();
status_t status = OK;
// to avoid the destruct of the in args
std::shared_ptr<PostProcBuffer> inbuf = in;
std::shared_ptr<PostProcBuffer> outBuf = out;
std::shared_ptr<RKISP2ProcUnitSettings> procsettings = settings;
LOGD("%s: @%s, reqId: %d",
mName, __FUNCTION__, procsettings->request->getId());
inbuf->cambuf->dumpImage(CAMERA_DUMP_JPEG, "before_jpeg_converion_nv12");
#ifdef RK_HW_JPEG_MIRROR_ROTATE
bool isFront = PlatformData::facing(mPipeline->getCameraId()) == CAMERA_FACING_FRONT;
bool flip = false;
bool mirror = false;
int rotation = 0;
if (isFront) {
const CameraMetadata *partRes = settings->request->getAndWaitforFilledResults(CONTROL_UNIT_PARTIAL_RESULT);
if (partRes == nullptr) {
LOGE("No partial result for EXIF in request.");
} else {
camera_metadata_ro_entry_t entry = partRes->find(ANDROID_JPEG_ORIENTATION);
if (entry.count == 1) {
int orientation = *entry.data.i32;
LOGE("PostProcessUnitJpegEnc jpeg orientation:%d", orientation);
if (orientation == 0 || orientation == 180) {
mirror = true;
flip = false;
} else if (orientation == 90 || orientation == 270) {
mirror = false;
flip = true;
}
LOGE("PostProcessUnitJpegEnc jpeg mirror:%d flip:%d", mirror, flip);
} else {
LOGE("No ANDROID_JPEG_ORIENTATION in results for EXIF");
}
}
}
std::shared_ptr<PostProcBuffer> tempBuf = NULL;
if (isFront) {
//alloc a temp buffer for rga flip data.
tempBuf = std::make_shared<PostProcBuffer> ();
int width = in->cambuf->width();
int height = in->cambuf->height();
tempBuf->cambuf = MemoryUtils::acquireOneBufferWithNoCache(mPipeline->getCameraId(), width, height);
tempBuf->request = in->request;
RgaCropScale::Params rgain, rgaout;
rgain.fd = in->cambuf->dmaBufFd();
if (in->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
in->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgain.vir_addr = (char*)in->cambuf->data();
rgain.mirror = mirror;
rgain.flip = flip;
rgain.rotation = rotation;
rgain.width = in->cambuf->width();
rgain.height = in->cambuf->height();
rgain.offset_x = 0;
rgain.offset_y = 0;
rgain.width_stride = in->cambuf->width();
rgain.height_stride = in->cambuf->height();
rgaout.fd = tempBuf->cambuf->dmaBufFd();
// HAL_PIXEL_FORMAT_YCbCr_420_888 buffer layout is the same as NV12
// in gralloc module implementation
if (tempBuf->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
tempBuf->cambuf->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
tempBuf->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgaout.vir_addr = (char*)tempBuf->cambuf->data();
rgaout.width = tempBuf->cambuf->width();
rgaout.height = tempBuf->cambuf->height();
rgaout.offset_x = 0;
rgaout.offset_y = 0;
rgaout.width_stride = tempBuf->cambuf->width();
rgaout.height_stride = tempBuf->cambuf->height();
if (RgaCropScale::CropScaleNV12Or21(&rgain, &rgaout)) {
LOGE("%s: crop&scale by RGA failed...", __FUNCTION__);
PERFORMANCE_ATRACE_NAME("SWCropScale");
ImageScalerCore::cropComposeUpscaleNV12_bl(
in->cambuf->data(), in->cambuf->height(), in->cambuf->width(),
0, 0, in->cambuf->width(), in->cambuf->height(),
out->cambuf->data(), out->cambuf->height(), out->cambuf->width(),
0, 0, out->cambuf->width(), out->cambuf->height());
}
}
#endif
// JPEG encoding
status = mJpegTask->handleMessageSettings(*procsettings.get());
CheckError((status != OK), status, "@%s, set settings failed! [%d]!",
__FUNCTION__, status);
#ifdef RK_HW_JPEG_MIRROR_ROTATE
if (isFront)
status = convertJpeg(tempBuf->cambuf, outBuf->cambuf, outBuf->request);
else
status = convertJpeg(inbuf->cambuf, outBuf->cambuf, outBuf->request);
#else
status = convertJpeg(inbuf->cambuf, outBuf->cambuf, outBuf->request);
#endif
//caputre buffer already done with holding release fence, now signal
//the release fence. In normal case, capture done should be called in
//OutputFrameWorker::notifyNewFrame, but in order to speed up capture
//time in switch capture case, the pipeline flush and stop had been done
//in advance, so it can't notify to outputFrameWork here, just do
//cambuf->captureDone here.
outBuf->cambuf->captureDone(outBuf->cambuf, true);
mCurPostProcBufOut.reset();
#ifdef RK_HW_JPEG_MIRROR_ROTATE
if (tempBuf != NULL)
tempBuf.reset();
#endif
CheckError((status != OK), status, "@%s, JPEG conversion failed! [%d]!",
__FUNCTION__, status);
return status;
}
status_t
RKISP2PostProcessUnitJpegEnc::prepare(const FrameInfo& outfmt, int bufNum) {
if (!mJpegTask.get()) {
LOGI("Create RKISP2JpegEncodeTask");
mJpegTask.reset(new RKISP2JpegEncodeTask(mPipeline->getCameraId()));
if (mJpegTask->init() != NO_ERROR) {
LOGE("Failed to init RKISP2JpegEncodeTask Task");
mJpegTask.reset();
return UNKNOWN_ERROR;
}
}
return RKISP2PostProcessUnit::prepare(outfmt, bufNum);
}
status_t
RKISP2PostProcessUnitJpegEnc::convertJpeg(std::shared_ptr<CameraBuffer> buffer,
std::shared_ptr<CameraBuffer> jpegBuffer,
Camera3Request *request) {
status_t status = NO_ERROR;
RKISP2ITaskEventListener::PUTaskEvent msg;
msg.buffer = jpegBuffer;
msg.jpegInputbuffer = buffer;
msg.request = request;
PERFORMANCE_ATRACE_CALL();
LOGI("jpeg inbuf wxh %dx%d stride %d, fmt 0x%x,0x%x size 0x%x",
buffer->width(), buffer->height(), buffer->stride(),
buffer->format(), buffer->v4l2Fmt(),
buffer->size());
if (mJpegTask.get()) {
status = mJpegTask->handleMessageNewJpegInput(msg);
}
return status;
}
RKISP2PostProcessUnitRaw::RKISP2PostProcessUnitRaw(const char* name, int type,
uint32_t buftype)
: RKISP2PostProcessUnit(name, type, buftype) {
}
RKISP2PostProcessUnitRaw::~RKISP2PostProcessUnitRaw() {
}
status_t
RKISP2PostProcessUnitRaw::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::shared_ptr<PostProcBuffer>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
PERFORMANCE_ATRACE_CALL();
status_t status = OK;
LOGD("@%s: instance:%p, name: %s", __FUNCTION__, this, mName);
/* in->cambuf->dumpImage(CAMERA_DUMP_RAW, "RawUnit"); */
//std::string fileName;
//std::string dumpPrefix = "";
//char dumpSuffix[100] = {};
//char szDateTime[20] = "";
//struct timeval tval;
// TuningServer *pserver = TuningServer::GetInstance();
// if (pserver && (pserver->mStartCapture) && (pserver->mCapRawNum > 0)){
// if(pserver->mSkipFrame > 0){
// pserver->mSkipFrame--;
// return status;
// }
// gettimeofday(&tval, NULL);
// int64_t timestamp = (((int64_t)tval.tv_sec) * 1000000L) + tval.tv_usec;
// strftime( szDateTime, sizeof(szDateTime), "%Y%m%d_%H%M%S", localtime(&tval.tv_sec) );
// snprintf(dumpSuffix, sizeof(dumpSuffix), "t%0.3f_g%0.3f_%dx%d_raw16_%s_%d", pserver->mCurTime/1000.0, pserver->mCurGain,
// out->cambuf->width(), out->cambuf->height(), szDateTime, pserver->mCapRawNum);
// fileName = std::string("/data/isptune/") + dumpPrefix + std::string(dumpSuffix) + std::string(".pgm");
// LOGD("%s filename is %s", __FUNCTION__, fileName.data());
// FILE *fp = fopen (fileName.data(), "w+");
// if (fp == nullptr) {
// LOGE("open file failed,%s",strerror(errno));
// return status;
// }
// //raw format,bayer pattern
// fprintf( fp,
// "P5\n%d %d\n#####<DCT Raw>\n#<Type>%u</Type>\n#<Layout>%u</Layout>\n#<TimeStampUs>%lli</TimeStampUs>\n#####</DCT Raw>\n%d\n",
// out->cambuf->width(), out->cambuf->height(), 0x11/*raw16*/, 0x12, timestamp, 65535);
// if ((fwrite(out->cambuf->data(), out->cambuf->width() * out->cambuf->height() * 2, 1, fp)) != 1)
// LOGW("Error or short count writing %d bytes to %s", out->cambuf->width() * out->cambuf->height() * 2, fileName.data());
// fclose (fp);
// pserver->mCapRawNum--;
// if(pserver->mCapRawNum == 0){
// pserver->stopCatureRaw();
// if(pserver->mMsgType == CMD_TYPE_SYNC)
// pserver->mUvc_proc_ops->uvc_signal();
// }
// }
return status;
}
RKISP2PostProcessUnitSwLsc::RKISP2PostProcessUnitSwLsc(const char* name, int type,
uint32_t buftype, RKISP2PostProcessPipeline* pl)
: RKISP2PostProcessUnit(name, type, buftype, pl) {
memset(&mLscPara, 0, sizeof(mLscPara));
}
RKISP2PostProcessUnitSwLsc::~RKISP2PostProcessUnitSwLsc() {
if (mLscPara.u32_coef_pic_gr)
free(mLscPara.u32_coef_pic_gr);
}
status_t
RKISP2PostProcessUnitSwLsc::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::shared_ptr<PostProcBuffer>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
PERFORMANCE_ATRACE_CALL();
LOGD("%s: @%s, reqId: %d",
mName, __FUNCTION__, settings->request->getId());
ScopedPerfTrace lscper(3, "lscper", 30 * 1000);
status_t status = OK;
status = lsc((uint8_t *)in->cambuf->data(),
in->cambuf->width(),
in->cambuf->height(),
0, // bayer pattern, ignored for Y_lsc
&mLscPara,
(uint8_t *)out->cambuf->data(),
16);
if (status != OK) {
LOGE("%s: failed", __FUNCTION__);
return UNKNOWN_ERROR;
}
uint32_t y_size = in->cambuf->width() * in->cambuf->height();
// copy uv
memcpy((uint8_t *)out->cambuf->data() + y_size,
(uint8_t *)in->cambuf->data() + y_size,
y_size / 2);
return OK;
}
status_t
RKISP2PostProcessUnitSwLsc::prepare(const FrameInfo& outfmt, int bufNum) {
if (mLscPara.u32_coef_pic_gr)
free(mLscPara.u32_coef_pic_gr);
mLscPara.width = outfmt.width;
mLscPara.height = outfmt.height;
LOGI("%s: widthxheigt %dx%d", __FUNCTION__, mLscPara.width, mLscPara.height);
lsc_config(&mLscPara);
return RKISP2PostProcessUnit::prepare(outfmt, bufNum);
}
// parameter defined in rtl
// defined in isp.inc.v
//#define c_dw_do 10 // width of isp data out Y an C used at output of gamma_out
#define c_cfg_lsc 7 // lens shading configuration address width
#define c_lsc_base_adr 0x2200
// defined in ram_sizes.inc.v
#define c_lsc_ram_ad_bw 9 // bit width for the RAM address
#define c_lsc_ram_d_bw 26 // double correction factor, must be even numbers
#define c_lsc_size_bw 10 // bit width for xsize and ysize values
#define c_lsc_grad_bw 12 // bit width of the factor for x and y gradients calculation
#define c_lsc_size_bw_2x (2*c_lsc_size_bw)
#define c_lsc_grad_bw_2x (2*c_lsc_grad_bw)
#define c_lsc_sample_bw (c_lsc_ram_d_bw/2) // bit width of the correction factor values stored in RAM
#define c_lsc_sample_bw_2x c_lsc_ram_d_bw
#define c_lsc_corr_bw 15 // bit width of the correction factor values used internal.
#define c_lsc_corr_frac_bw 12 // bit width of the fractional part of correction factor values used internal
#define c_lsc_grad_exp 15 // fixed exponent for the x and y gradients
#define c_lsc_corr_extend 10 // extended fractal part of dx,dy of internal correction factor
// constraint : c_lsc_corr_extend <= c_lsc_grad_exp
#define c_extend_round (1 << (c_lsc_corr_extend - 1))
#define c_frac_round (1 << (c_lsc_corr_frac_bw-1))
// bit width difference of correction factor values between used internal and stored in RAM
#define c_corr_diff (c_lsc_corr_bw - c_lsc_sample_bw)
#define c_dx_shift (c_lsc_grad_exp - c_lsc_corr_extend)
#define c_dx_round (1 << (c_dx_shift - 1))
#define c_dy_shift (c_lsc_grad_exp - c_lsc_corr_extend - c_corr_diff)
#define c_dy_round (1 << (c_dy_shift - 1))
#define c_dx_bw (c_lsc_corr_bw + c_lsc_grad_bw - c_dx_shift)
#define c_dy_bw (c_lsc_sample_bw + c_lsc_grad_bw - c_dy_shift)
/*****************************************************************************/
/**
* @Purpose bilinear interpolation unit
*
* @param u16_coef_blk input raw data
* @param pu32_coef_pic output coef after bilinear interplation
* @param u32_z_max the total number of lsc coef table
* @param u32_y_max height of image
* @param u32_x_max width of image
* @param plsc_a other parameters
*
* @return Returns the result of the function call.
* @retval RET_SUCCESS
*
*****************************************************************************/
void
RKISP2PostProcessUnitSwLsc::calcu_coef(lsc_para_t const * plsc_a,
uint16_t u16_coef_blk[2][17][18],
uint32_t * pu32_coef_pic,
uint32_t u32_z_max,
uint32_t u32_y_max,
uint32_t u32_x_max) {
int32_t i ;
uint32_t u32_tmp ;
uint32_t u32_tmp2 ;
uint8_t u8_x_blk ; // u32_x coordinate of block number of curent picture
uint8_t u8_y_blk ; // u32_y coordinate of block number of curent picture
uint16_t u16_x_base ; // left up coordinate of curent block
uint16_t u16_y_base ; // left up coordinate of curent block
uint16_t u16_x_offset ; // u32_x coordinate offset of curent block
uint16_t u16_y_offset ; // u32_x coordinate offset of curent block
uint16_t u16_sizey_cur ;
uint16_t u16_grady_cur ;
uint16_t u16_sizex_cur ;
uint16_t u16_gradx_cur ;
uint16_t u16_coef_lu ; // left up
uint16_t u16_coef_ld ; // left down
uint16_t u16_coef_ru ; // right up
uint16_t u16_coef_rd ; // right down
uint32_t u32_coef_l ;
uint32_t u32_coef_r ;
uint32_t u32_coef ;
for (i = 0; i < 2; i++) {
for (u16_y_base = 0, u8_y_blk = 0; u8_y_blk < 16; u8_y_blk++) {
u16_sizey_cur = (u8_y_blk<8)? plsc_a->sizey[u8_y_blk] : plsc_a->sizey[15-u8_y_blk];
u16_grady_cur = (u8_y_blk<8)? plsc_a->grady[u8_y_blk] : plsc_a->grady[15-u8_y_blk];
for (u16_x_base = 0, u8_x_blk = 0; u8_x_blk < 16; u8_x_blk++) {
u16_sizex_cur = (u8_x_blk<8)? plsc_a->sizex[u8_x_blk] : plsc_a->sizex[15-u8_x_blk];
u16_gradx_cur = (u8_x_blk<8)? plsc_a->gradx[u8_x_blk] : plsc_a->gradx[15-u8_x_blk];
u16_coef_lu = u16_coef_blk[i][u8_y_blk][u8_x_blk] ; // left up
u16_coef_ld = u16_coef_blk[i][u8_y_blk+1][u8_x_blk] ; // left down
u16_coef_ru = u16_coef_blk[i][u8_y_blk][u8_x_blk+1] ; // right up
u16_coef_rd = u16_coef_blk[i][u8_y_blk+1][u8_x_blk+1] ; // right down
for (u16_y_offset = 0; u16_y_offset < u16_sizey_cur; u16_y_offset++) {
u32_tmp = abs(u16_coef_lu - u16_coef_ld);
u32_tmp = u32_tmp * u16_grady_cur;
u32_tmp = (u32_tmp + c_dy_round) >> c_dy_shift;
u32_tmp = u32_tmp * u16_y_offset;
u32_tmp = (u32_tmp + c_extend_round) >> c_lsc_corr_extend;
u32_tmp = (u32_tmp << (32-c_lsc_corr_bw)) >> (32-c_lsc_corr_bw);
u32_coef_l = u16_coef_lu << c_corr_diff;
u32_coef_l = (u16_coef_lu > u16_coef_ld)? (u32_coef_l - u32_tmp) : (u32_coef_l + u32_tmp);
u32_tmp = abs(u16_coef_ru - u16_coef_rd);
u32_tmp = u32_tmp * u16_grady_cur;
u32_tmp = (u32_tmp + c_dy_round) >> c_dy_shift;
u32_tmp = u32_tmp * u16_y_offset;
u32_tmp = (u32_tmp + c_extend_round) >> c_lsc_corr_extend;
u32_tmp = (u32_tmp << (32-c_lsc_corr_bw)) >> (32-c_lsc_corr_bw);
u32_coef_r = u16_coef_ru << c_corr_diff;
u32_coef_r = (u16_coef_ru > u16_coef_rd)? (u32_coef_r - u32_tmp) : (u32_coef_r + u32_tmp);
u32_coef = u32_coef_l << c_lsc_corr_extend;
/* TODO */
//u32_tmp = abs(u32_coef_r - u32_coef_l);
u32_tmp = abs(int32_t(u32_coef_r - u32_coef_l));
u32_tmp = u32_tmp * u16_gradx_cur;
u32_tmp = (u32_tmp + c_dx_round) >> c_dx_shift;
for (u16_x_offset = 0; u16_x_offset < u16_sizex_cur; u16_x_offset++) {
u32_tmp2 = (u32_coef + c_extend_round) >> c_lsc_corr_extend;
u32_tmp2 = (u32_tmp2 > ((2<<c_lsc_corr_bw)-1))? ((2<<c_lsc_corr_bw)-1) : u32_tmp2;
*(pu32_coef_pic + i*u32_y_max*u32_x_max + (u16_y_base+u16_y_offset)*u32_x_max
+ (u16_x_base+u16_x_offset)) = (uint16_t)u32_tmp2;
u32_coef = (u32_coef_l > u32_coef_r)? (u32_coef - u32_tmp) : (u32_coef + u32_tmp);
} // for u16_x_offset
} // for u16_y_offset
u16_x_base += u16_sizex_cur;
} // for u8_x_blk
u16_y_base += u16_sizey_cur;
} // for u8_y_blk
} // for i < 2
}
int RKISP2PostProcessUnitSwLsc::lsc_config(void *para_v)
{
lsc_para_t *para= (lsc_para_t*)para_v;
int32_t i ,x,y,z;
int32_t width_align16 = (para->width + 0xf) & ~0xf;
int32_t height_align16 = (para->height + 0xf) & ~0xf;
/* this is for 1080p */
uint16_t sizex[8] = {120 ,120 ,120 ,120 ,120, 120, 120, 120};
uint16_t sizey[8] = {67 ,68 ,67 ,68, 67, 68, 67, 68};
/* generic split for any resolution */
for (i = 0; i++; i < 8) {
sizex[i] = para->width / 2 / 8;
sizey[i] = para->height / 2 / 8;
}
sizex[7] += (para->width % 16) / 2;
sizey[7] += (para->height % 16) / 2;
uint16_t xmlcoef_r[17][17] = {
{2955,2298,1926,1685,1514,1396,1316,1266,1258,1258,1282,1336,1433,1558,1758,2072,2542},
{2727,2134,1827,1599,1435,1327,1251,1209,1192,1195,1222,1276,1359,1486,1668,1932,2359},
{2513,2016,1728,1526,1372,1266,1203,1160,1142,1149,1175,1218,1294,1418,1586,1849,2215},
{2371,1929,1662,1461,1317,1219,1163,1126,1112,1116,1137,1183,1257,1371,1533,1764,2094},
{2271,1862,1601,1411,1282,1188,1132,1095,1081,1080,1108,1151,1222,1322,1479,1713,2028},
{2176,1817,1556,1380,1252,1160,1105,1073,1059,1057,1083,1124,1193,1290,1441,1654,1960},
{2155,1769,1535,1353,1226,1138,1083,1055,1037,1045,1070,1110,1176,1266,1418,1634,1913},
{2107,1758,1509,1330,1209,1128,1082,1040,1030,1033,1060,1098,1163,1254,1401,1612,1902},
{2091,1758,1512,1333,1208,1133,1076,1045,1024,1031,1052,1096,1164,1252,1395,1603,1888},
{2107,1753,1509,1329,1211,1130,1073,1045,1027,1033,1060,1101,1162,1259,1401,1616,1886},
{2111,1769,1524,1338,1219,1137,1076,1055,1037,1045,1066,1107,1173,1262,1409,1610,1921},
{2148,1795,1547,1364,1232,1150,1097,1065,1055,1061,1078,1121,1186,1284,1426,1638,1913},
{2226,1829,1574,1392,1254,1175,1119,1087,1076,1081,1105,1146,1207,1313,1458,1670,1969},
{2287,1891,1630,1430,1294,1205,1150,1118,1104,1106,1137,1177,1241,1349,1506,1726,2046},
{2410,1971,1687,1492,1351,1250,1192,1161,1146,1149,1170,1217,1282,1403,1556,1805,2131},
{2591,2059,1771,1562,1408,1307,1238,1199,1186,1189,1208,1262,1340,1455,1632,1878,2245},
{2761,2193,1875,1640,1465,1372,1295,1259,1235,1244,1266,1323,1405,1526,1719,2004,2401}
};
uint16_t xmlcoef_gr[17][17] = {
{1377,1306,1244,1189,1157,1134,1112,1111,1101,1110,1120,1134,1149,1177,1233,1279,1373},
{1358,1268,1202,1158,1132,1107,1100,1087,1081,1085,1092,1109,1115,1158,1185,1248,1306},
{1301,1234,1184,1136,1110,1090,1077,1065,1068,1068,1075,1085,1109,1127,1170,1212,1294},
{1273,1204,1156,1120,1094,1076,1061,1059,1056,1054,1061,1074,1087,1118,1146,1185,1254},
{1251,1192,1149,1109,1088,1068,1054,1048,1048,1050,1054,1065,1084,1105,1133,1177,1218},
{1235,1182,1130,1100,1073,1056,1053,1039,1039,1042,1049,1059,1078,1091,1123,1160,1216},
{1228,1169,1121,1093,1074,1050,1038,1035,1027,1036,1039,1054,1064,1088,1116,1157,1209},
{1211,1156,1117,1091,1063,1046,1035,1028,1028,1027,1038,1048,1063,1087,1109,1148,1196},
{1210,1161,1114,1081,1065,1048,1035,1024,1024,1029,1035,1048,1064,1080,1112,1141,1193},
{1221,1160,1121,1090,1067,1051,1039,1031,1027,1030,1039,1049,1064,1090,1116,1153,1196},
{1235,1166,1127,1095,1071,1054,1042,1036,1033,1036,1043,1056,1073,1098,1121,1158,1211},
{1239,1179,1132,1102,1073,1063,1049,1043,1042,1040,1052,1066,1084,1104,1135,1173,1239},
{1244,1190,1145,1115,1083,1066,1057,1046,1045,1051,1055,1071,1086,1118,1142,1191,1234},
{1277,1213,1158,1120,1101,1075,1066,1062,1058,1058,1064,1083,1108,1124,1165,1202,1265},
{1322,1228,1192,1141,1119,1096,1081,1072,1074,1071,1083,1098,1124,1153,1180,1240,1288},
{1337,1276,1200,1171,1133,1113,1102,1091,1093,1092,1100,1118,1140,1170,1208,1269,1347},
{1387,1298,1251,1198,1161,1135,1121,1111,1113,1110,1124,1141,1168,1198,1242,1301,1377}
};
uint16_t xmlcoef_gb[17][17] = {
{3351,2558,2124,1838,1631,1505,1411,1346,1320,1326,1352,1415,1527,1678,1900,2246,2813},
{3057,2381,1989,1723,1539,1415,1333,1277,1254,1260,1281,1344,1436,1584,1785,2099,2576},
{2807,2216,1865,1634,1455,1341,1262,1210,1193,1191,1224,1276,1359,1499,1697,1986,2408},
{2636,2112,1785,1558,1391,1281,1218,1168,1149,1150,1172,1224,1308,1438,1628,1903,2298},
{2499,2020,1715,1501,1345,1235,1169,1126,1110,1113,1139,1187,1264,1393,1572,1828,2195},
{2403,1954,1665,1449,1305,1199,1136,1099,1075,1081,1105,1155,1236,1351,1520,1774,2123},
{2349,1914,1627,1420,1271,1176,1108,1074,1055,1059,1086,1137,1209,1319,1497,1736,2094},
{2315,1888,1601,1397,1255,1159,1095,1051,1035,1044,1069,1119,1197,1307,1472,1717,2067},
{2279,1875,1582,1389,1247,1150,1083,1044,1029,1034,1061,1112,1186,1295,1461,1699,2038},
{2273,1869,1584,1382,1240,1145,1083,1042,1024,1032,1057,1111,1184,1296,1457,1701,2050},
{2310,1879,1598,1388,1243,1147,1085,1048,1033,1039,1067,1117,1191,1302,1467,1720,2061},
{2325,1900,1615,1408,1253,1162,1100,1061,1045,1053,1079,1132,1206,1325,1492,1732,2080},
{2399,1946,1647,1432,1279,1184,1119,1087,1068,1076,1100,1153,1226,1345,1520,1770,2119},
{2479,1997,1695,1476,1317,1216,1153,1114,1095,1104,1130,1180,1262,1385,1561,1828,2214},
{2622,2091,1762,1536,1371,1259,1191,1154,1135,1140,1171,1221,1301,1436,1622,1911,2313},
{2776,2191,1840,1602,1432,1317,1239,1200,1177,1182,1209,1271,1361,1503,1698,1994,2434},
{2974,2321,1936,1681,1501,1374,1293,1246,1230,1232,1260,1317,1425,1575,1784,2096,2590}
};
uint16_t xmlcoef_b[17][17] = {
{2740,2166,1837,1621,1485,1387,1328,1289,1292,1302,1337,1387,1483,1628,1815,2102,2610},
{2531,2013,1734,1537,1402,1316,1261,1230,1227,1242,1264,1316,1404,1536,1714,1987,2388},
{2318,1898,1639,1472,1343,1257,1206,1179,1174,1182,1210,1252,1333,1457,1626,1888,2227},
{2211,1828,1581,1413,1283,1213,1171,1139,1131,1142,1163,1211,1277,1389,1561,1797,2129},
{2108,1761,1531,1364,1244,1174,1131,1107,1097,1106,1131,1169,1236,1340,1501,1732,2035},
{2035,1708,1485,1325,1217,1142,1101,1078,1077,1079,1100,1137,1209,1302,1453,1677,1981},
{2003,1679,1459,1302,1194,1120,1077,1056,1051,1057,1080,1120,1183,1279,1422,1642,1930},
{1973,1668,1446,1279,1176,1104,1066,1039,1033,1043,1067,1103,1165,1265,1401,1617,1910},
{1960,1657,1429,1273,1167,1100,1057,1031,1025,1036,1064,1098,1160,1253,1396,1602,1883},
{1973,1651,1431,1273,1163,1101,1053,1033,1024,1028,1054,1098,1156,1251,1394,1605,1898},
{1973,1657,1436,1272,1168,1101,1060,1030,1030,1038,1064,1097,1167,1263,1398,1614,1913},
{2008,1672,1449,1290,1172,1103,1066,1044,1036,1046,1072,1109,1175,1278,1424,1628,1945},
{2041,1695,1470,1311,1186,1120,1082,1057,1055,1061,1088,1126,1196,1302,1452,1674,1976},
{2096,1744,1511,1332,1219,1146,1111,1083,1074,1089,1115,1161,1227,1336,1495,1722,2049},
{2204,1799,1558,1387,1266,1177,1139,1120,1111,1120,1145,1194,1266,1385,1552,1806,2153},
{2318,1881,1621,1446,1314,1225,1175,1155,1150,1157,1191,1242,1319,1438,1626,1891,2258},
{2455,1989,1695,1515,1378,1278,1226,1197,1190,1200,1226,1284,1369,1518,1712,1979,2404}
};
para->lsc_en = 1;
para->table_sel = 1;
for ( i = 0; i < 8; i++)
{
para->sizex[i] = sizex[i];
para->sizey[i] = sizey[i];
para->gradx[i] = (double)32768/(double)para->sizex[i] + 0.5;
if (para->gradx[i] > 4095)
para->gradx[i] = 4095;
para->grady[i] = (double)32768/(double)para->sizey[i] + 0.5;
if (para->grady[i] > 4095)
para->grady[i] = 4095;
}
for ( z = 0; z < 2; z++) //2 table for lens shade correction with the same coef
{
for ( x = 0; x < 17; x++)
{
for ( y = 0; y < 18; y++)
{
if (y==17)
{
para->u16_coef_r[z][x][y] = 0;
para->u16_coef_gr[z][x][y] = 0;
para->u16_coef_gb[z][x][y] = 0;
para->u16_coef_b[z][x][y] = 0;
}
else
{
para->u16_coef_r[z][x][y] = xmlcoef_r[x][y];
para->u16_coef_gr[z][x][y] = xmlcoef_gr[x][y];
para->u16_coef_gb[z][x][y] = xmlcoef_gb[x][y];
para->u16_coef_b[z][x][y] = xmlcoef_b[x][y];
}
}
}
}
para->u32_coef_pic_gr = (uint32_t*)malloc(2* width_align16 * height_align16 * sizeof(uint32_t));
if (para->u32_coef_pic_gr == NULL)
return -1;
return 0;
}
/*****************************************************************************/
/**
* @Purpose lens shading correction unit
*
* @param indata input raw data
* @param outdata output raw data
* @param width width of image
* @param height height of image
* @param bayer_pat bayer pattern of image
* @param lsc_para other parameters
*
* @return Returns the result of the function call.
* @retval RET_SUCCESS
*
*****************************************************************************/
int
RKISP2PostProcessUnitSwLsc::lsc(uint8_t *indata, uint16_t input_h_size, uint16_t input_v_size,
uint8_t bayer_pat, lsc_para_t *lsc_para,
uint8_t *outdata, uint8_t c_dw_si)
{
//input_h_size
//int32_t index = 0;
uint16_t (*u16_coef_gr)[17][18] = lsc_para->u16_coef_gr;
uint32_t *u32_coef_pic_gr;
u32_coef_pic_gr = lsc_para->u32_coef_pic_gr;
calcu_coef(lsc_para, u16_coef_gr, u32_coef_pic_gr, 2, input_v_size, input_h_size);
/* uint16_t c_dw_si_shift = (1 << c_dw_si) - 1; */
//lens shading correction
#if 0
uint16_t u16_data;
for (index = 0 ; index < input_v_size * input_h_size; index++) {
u16_data = (uint16_t)(indata[index]) << 8;
u16_data = (u16_data * u32_coef_pic_gr[index] + c_frac_round) >> c_lsc_corr_frac_bw;
/* u16_data = (u16_data > c_dw_si_shift)? c_dw_si_shift : u16_data; */
outdata[index] = u16_data >> 8;
}
#else
/* uint32_t total = input_v_size * input_h_size; */
/* const uint32_t c_frac_round_tmp = c_frac_round; */
/* asm volatile ( */
/* "0: \n\t" */
/* "vld1.u8 d0, [%[indata]]! @uint8x8 \n\t" */
/* "vshll.u8 q2, d0, #8 @uint16x8 << 8 \n\t" */
/* "vmovl.u16 q3, d4 @uint16x8 --> uint32x4 \n\t" */
/* "vmovl.u16 q4, d5 @uint16x8 --> uint32x4 \n\t" */
/* "vld1.u32 {q0, q1}, [%[u32_coef_pic_gr]]! \n\t" */
/* "vdup.32 q6, %[c_frac_round_tmp] @uint32x4 c_frac_round \n\t" */
/* "vdup.32 q7, %[c_frac_round_tmp] @uint32x4 c_frac_round \n\t" */
/* "vmla.u32 q6, q3, q0 \n\t " */
/* "vmla.u32 q7, q4, q1 \n\t" */
/* "vqshrn.u32 d0, q6, #12 \n\t" */
/* "vqshrn.u32 d1, q7, #12 \n\t" */
/* "vqshrn.u16 d2, q0, #8 \n\t" */
/* "vst1.u8 d2, [%[outdata]]! \n\t" */
/* "add %[index], %[index], #8 \n\t" */
/* "cmp %[index], %[total] \n\t" */
/* "blt 0b \n\t" */
/* : [outdata] "+r" (outdata), [index] "+r" (index), [total] "+r" (total), [u32_coef_pic_gr] "+r" (u32_coef_pic_gr) */
/* : [indata] "r" (indata), [c_frac_round_tmp] "r" (c_frac_round_tmp) */
/* : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7" */
/* ); */
#endif
return 0;
}
RKISP2PostProcessUnitDigitalZoom::RKISP2PostProcessUnitDigitalZoom(
const char* name, int type, int camid, uint32_t buftype, RKISP2PostProcessPipeline* pl)
: RKISP2PostProcessUnit(name, type, buftype, pl) {
mApa = PlatformData::getActivePixelArray(camid);
}
RKISP2PostProcessUnitDigitalZoom::~RKISP2PostProcessUnitDigitalZoom() {
}
bool RKISP2PostProcessUnitDigitalZoom::checkFmt(CameraBuffer* in, CameraBuffer* out) {
if (!in || !out)
return false;
// only support NV12 or NV21 now
bool in_fmt_supported = in->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
in->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
in->format() == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
in->format() == HAL_PIXEL_FORMAT_YCrCb_420_SP ||
in->v4l2Fmt() == V4L2_PIX_FMT_NV12 ||
in->v4l2Fmt() == V4L2_PIX_FMT_NV21;
bool out_fmt_supported = out->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
out->format() == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
out->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
out->format() == HAL_PIXEL_FORMAT_YCrCb_420_SP;
out->v4l2Fmt() == V4L2_PIX_FMT_NV12 ||
out->v4l2Fmt() == V4L2_PIX_FMT_NV21;
return (in_fmt_supported && out_fmt_supported);
}
status_t
RKISP2PostProcessUnitDigitalZoom::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::shared_ptr<PostProcBuffer>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
PERFORMANCE_ATRACE_CALL();
CameraWindow& crop = settings->cropRegion;
int jpegBufCount = settings->request->getBufferCountOfFormat(HAL_PIXEL_FORMAT_BLOB);
bool flip = false;
bool mirror = false;
int rotation = 0;
#ifdef RK_HW_VIDEO_MIRROR_ROTATE
bool isFront = PlatformData::facing(mPipeline->getCameraId()) == CAMERA_FACING_FRONT;
bool isVideo = false;
int usage = out->cambuf->usage();
char value[128];
property_get("sys.camera.orientation", value, "0");
isVideo = CHECK_FLAG(usage, GRALLOC_USAGE_PRIVATE_1|GRALLOC_USAGE_PRIVATE_2)
&& !CHECK_FLAG(usage, GRALLOC_USAGE_HW_TEXTURE);
LOGD("@%s :---zc RKISP2PostProcessUnitDigitalZoom isVideo:%d", __FUNCTION__, isVideo);
if(isVideo && isFront) {
int orientation = atoi(value);
LOGE("---zc PostProcessUnitDigitalZoom orientation:%d", orientation);
if (orientation == 180 || orientation == 0) {
mirror = true;
flip = false;
} if (orientation == 270 || orientation == 90) {
mirror = false;
flip = true;
}
}
#endif
bool mirror_handing = false;
#ifdef MIRROR_HANDLING_FOR_FRONT_CAMERA
//for front camera mirror handling
mirror_handing = PlatformData::facing(mPipeline->getCameraId()) == CAMERA_FACING_FRONT;
#endif
LOGD("@%s : mirror handleing %d pid=%d", __FUNCTION__, mirror_handing, syscall(SYS_gettid));
// check if zoom is required
if (mBufType != kPostProcBufTypeExt &&
crop.width() == mApa.width() && crop.height() == mApa.height()) {
// HwJpeg encode require buffer width and height align to 16 or large enough.
// digital zoom out buffer is internal gralloc buffer with size 2xWxH, so it
// can always meet the Hwjpeg input condition. we use it as a workaround
// for capture case
if(jpegBufCount != 0) {
LOGD("@%s : Use digital zoom out gralloc buffer as hwjpeg input buffer", __FUNCTION__);
} else if(mirror_handing) {
LOGD("@%s : use digitalZoom do mirror for front camera", __FUNCTION__);
} else {
return STATUS_FORWRAD_TO_NEXT_UNIT;
}
}
if (!checkFmt(in->cambuf.get(), out->cambuf.get())) {
LOGE("%s: unsupported format, only support NV12 or NV21 now !", __FUNCTION__);
return UNKNOWN_ERROR;
}
// map crop window to in-buffer crop window
int mapleft, maptop, mapwidth, mapheight;
float wratio = (float)crop.width() / mApa.width();
float hratio = (float)crop.height() / mApa.height();
float hoffratio = (float)crop.left() / mApa.width();
float voffratio = (float)crop.top() / mApa.height();
mapleft = in->cambuf->width() * hoffratio;
maptop = in->cambuf->height() * voffratio;
mapwidth = in->cambuf->width() * wratio;
mapheight = in->cambuf->height() * hratio;
// should align to 2
mapleft &= ~0x1;
maptop &= ~0x1;
mapwidth &= ~0x3;
mapheight &= ~0x3;
// do digital zoom
LOGD("%s: crop region(%d,%d,%d,%d) from (%d,%d), infmt %d,%d, outfmt %d,%d",
__FUNCTION__, mapleft, maptop, mapwidth, mapheight,
in->cambuf->width(), in->cambuf->height(),
in->cambuf->format(),
in->cambuf->v4l2Fmt(),
out->cambuf->format(),
out->cambuf->v4l2Fmt());
// try RGA firstly
RgaCropScale::Params rgain, rgaout;
rgain.fd = in->cambuf->dmaBufFd();
if (in->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
in->cambuf->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
in->cambuf->format() == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
in->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgain.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgain.vir_addr = (char*)in->cambuf->data();
rgain.mirror = mirror;
rgain.flip = flip;
rgain.rotation = rotation;
rgain.width = mapwidth;
rgain.height = mapheight;
rgain.offset_x = mapleft;
rgain.offset_y = maptop;
rgain.width_stride = in->cambuf->width();
rgain.height_stride = in->cambuf->height();
rgaout.fd = out->cambuf->dmaBufFd();
if (out->cambuf->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
out->cambuf->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
out->cambuf->format() == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
out->cambuf->v4l2Fmt() == V4L2_PIX_FMT_NV12)
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
rgaout.fmt = HAL_PIXEL_FORMAT_YCrCb_420_SP;
rgaout.vir_addr = (char*)out->cambuf->data();
rgaout.width = out->cambuf->width();
rgaout.height = out->cambuf->height();
rgaout.offset_x = 0;
rgaout.offset_y = 0;
rgaout.width_stride = out->cambuf->width();
rgaout.height_stride = out->cambuf->height();
if (RgaCropScale::CropScaleNV12Or21(&rgain, &rgaout)) {
LOGW("%s: digital zoom by RGA failed, use arm instead...", __FUNCTION__);
PERFORMANCE_ATRACE_NAME("SWCropScale");
ImageScalerCore::cropComposeUpscaleNV12_bl(
in->cambuf->data(), in->cambuf->height(), in->cambuf->width(),
mapleft, maptop, mapwidth, mapheight,
out->cambuf->data(), out->cambuf->height(), out->cambuf->width(),
0, 0, out->cambuf->width(), out->cambuf->height());
}
return OK;
}
RKISP2PostProcessUnitFec::RKISP2PostProcessUnitFec(
const char* name, int type, int camid, uint32_t buftype, RKISP2PostProcessPipeline* pl)
: RKISP2PostProcessUnit(name, type, buftype, pl) {
mApa = PlatformData::getActivePixelArray(camid);
mFecUnit = std::make_shared<RKISP2FecUnit>();
}
RKISP2PostProcessUnitFec::~RKISP2PostProcessUnitFec() {
LOGE(" distortionDeinit *************");
if (mFecUnit)
mFecUnit->distortionDeinit();
mFecUnit.reset();
}
bool RKISP2PostProcessUnitFec::checkFmt(CameraBuffer* in, CameraBuffer* out) {
if (!in || !out)
return false;
// only support NV12 or NV21 now
bool in_fmt_supported = in->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
in->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
in->format() == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
in->format() == HAL_PIXEL_FORMAT_YCrCb_420_SP ||
in->v4l2Fmt() == V4L2_PIX_FMT_NV12 ||
in->v4l2Fmt() == V4L2_PIX_FMT_NV21;
bool out_fmt_supported = out->format() == HAL_PIXEL_FORMAT_YCrCb_NV12 ||
out->format() == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
out->format() == HAL_PIXEL_FORMAT_YCbCr_420_888 ||
out->format() == HAL_PIXEL_FORMAT_YCrCb_420_SP;
out->v4l2Fmt() == V4L2_PIX_FMT_NV12 ||
out->v4l2Fmt() == V4L2_PIX_FMT_NV21;
return (in_fmt_supported && out_fmt_supported);
}
status_t
RKISP2PostProcessUnitFec::processFrame(const std::shared_ptr<PostProcBuffer>& in,
const std::shared_ptr<PostProcBuffer>& out,
const std::shared_ptr<RKISP2ProcUnitSettings>& settings) {
PERFORMANCE_ATRACE_CALL();
CameraWindow& crop = settings->cropRegion;
int jpegBufCount = settings->request->getBufferCountOfFormat(HAL_PIXEL_FORMAT_BLOB);
bool mirror_handing = false;
#ifdef MIRROR_HANDLING_FOR_FRONT_CAMERA
//for front camera mirror handling
mirror_handing = PlatformData::facing(mPipeline->getCameraId()) == CAMERA_FACING_FRONT;
#endif
LOGD("@%s : mirror handleing %d pid=%d", __FUNCTION__, mirror_handing, syscall(SYS_gettid));
// check if zoom is required
if (mBufType != kPostProcBufTypeExt &&
crop.width() == mApa.width() && crop.height() == mApa.height()) {
// HwJpeg encode require buffer width and height align to 16 or large enough.
// digital zoom out buffer is internal gralloc buffer with size 2xWxH, so it
// can always meet the Hwjpeg input condition. we use it as a workaround
// for capture case
if(jpegBufCount != 0) {
LOGD("@%s : Use digital zoom out gralloc buffer as hwjpeg input buffer", __FUNCTION__);
} else if(mirror_handing) {
LOGD("@%s : use digitalZoom do mirror for front camera", __FUNCTION__);
} else {
return STATUS_FORWRAD_TO_NEXT_UNIT;
}
}
if (!checkFmt(in->cambuf.get(), out->cambuf.get())) {
LOGE("%s: unsupported format, only support NV12 or NV21 now !", __FUNCTION__);
return UNKNOWN_ERROR;
}
// map crop window to in-buffer crop window
int mapleft, maptop, mapwidth, mapheight;
float wratio = (float)crop.width() / mApa.width();
float hratio = (float)crop.height() / mApa.height();
float hoffratio = (float)crop.left() / mApa.width();
float voffratio = (float)crop.top() / mApa.height();
mapleft = in->cambuf->width() * hoffratio;
maptop = in->cambuf->height() * voffratio;
mapwidth = in->cambuf->width() * wratio;
mapheight = in->cambuf->height() * hratio;
// should align to 2
mapleft &= ~0x1;
maptop &= ~0x1;
mapwidth &= ~0x3;
mapheight &= ~0x3;
if (mFecUnit) {
int fencefd = -1;
mFecUnit->distortionInit(3840, 2160);
mFecUnit->doFecProcess(mapwidth, mapheight, in->cambuf->dmaBufFd(),
out->cambuf->width(), out->cambuf->height(), out->cambuf->dmaBufFd(), fencefd);
}
return OK;
}
} /* namespace rkisp2 */
} /* namespace camera2 */
} /* namespace android */
Reference in New Issue View Git Blame Copy Permalink