8692 lines
298 KiB
C++
8692 lines
298 KiB
C++
/* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
|
|
#define LOG_TAG "QCamera3Channel"
|
|
|
|
// To remove
|
|
#include <cutils/properties.h>
|
|
|
|
// System dependencies
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "hardware/gralloc.h"
|
|
#include <utils/Timers.h>
|
|
|
|
// Camera dependencies
|
|
#include "QCamera3Channel.h"
|
|
#include "QCamera3HWI.h"
|
|
#include "QCameraTrace.h"
|
|
#include "QCameraFormat.h"
|
|
extern "C" {
|
|
#include "mm_camera_dbg.h"
|
|
}
|
|
|
|
#ifdef ENABLE_QC_BOKEH
|
|
#include "dualcameraddm_wrapper.h"
|
|
#endif //ENABLE_QC_BOKEH
|
|
|
|
#define PAD_TO_SIZE(size, padding) \
|
|
((size + (typeof(size))(padding - 1)) & \
|
|
(typeof(size))(~(padding - 1)))
|
|
|
|
using namespace android;
|
|
|
|
namespace qcamera {
|
|
#define IS_BUFFER_ERROR(x) (((x) & V4L2_BUF_FLAG_ERROR) == V4L2_BUF_FLAG_ERROR)
|
|
|
|
QCamera3ZSLChannel::~QCamera3ZSLChannel ()
|
|
{
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3Channel
|
|
*
|
|
* DESCRIPTION: constrcutor of QCamera3Channel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : camera handle
|
|
* @cam_ops : ptr to camera ops table
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3Channel::QCamera3Channel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buffer_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
cam_feature_mask_t postprocess_mask,
|
|
void *userData, uint32_t numBuffers)
|
|
: mMasterCam(CAM_TYPE_MAIN)
|
|
{
|
|
m_camHandle = cam_handle;
|
|
m_handle = channel_handle;
|
|
m_camOps = cam_ops;
|
|
m_bIsActive = false;
|
|
m_bUBWCenable = true;
|
|
m_numStreams = 0;
|
|
memset(mStreams, 0, sizeof(mStreams));
|
|
mUserData = userData;
|
|
|
|
mStreamInfoBuf = NULL;
|
|
mChannelCB = cb_routine;
|
|
mChannelCbBufErr = cb_buffer_err;
|
|
mPaddingInfo = *paddingInfo;
|
|
mPaddingInfo.offset_info.offset_x = 0;
|
|
mPaddingInfo.offset_info.offset_y = 0;
|
|
|
|
mPostProcMask = postprocess_mask;
|
|
|
|
mIsType = IS_TYPE_NONE;
|
|
mNumBuffers = numBuffers;
|
|
mPerFrameMapUnmapEnable = true;
|
|
mDumpFrmCnt = 0;
|
|
m_bDualChannel = false;
|
|
m_bIsSecureMode = ((QCamera3HardwareInterface*)mUserData)->isSecureMode();
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCamera3Channel
|
|
*
|
|
* DESCRIPTION: destructor of QCamera3Channel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3Channel::~QCamera3Channel()
|
|
{
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : destroy
|
|
*
|
|
* DESCRIPTION: internal destructor of QCamera3Channel called by the subclasses
|
|
* this destructor will call pure virtual functions. stop will eventuall call
|
|
* QCamera3Stream::putBufs. The putBufs function will
|
|
* call QCamera3Channel::putStreamBufs which is pure virtual
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3Channel::destroy()
|
|
{
|
|
if (m_bIsActive)
|
|
stop();
|
|
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (mStreams[i] != NULL) {
|
|
delete mStreams[i];
|
|
mStreams[i] = 0;
|
|
}
|
|
}
|
|
m_numStreams = 0;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : addStream
|
|
*
|
|
* DESCRIPTION: add a stream into channel
|
|
*
|
|
* PARAMETERS :
|
|
* @streamType : stream type
|
|
* @streamFormat : stream format
|
|
* @streamDim : stream dimension
|
|
* @streamRotation : rotation of the stream
|
|
* @minStreamBufNum : minimal buffer count for particular stream type
|
|
* @postprocessMask : post-proccess feature mask
|
|
* @isType : type of image stabilization required on the stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::addStream(cam_stream_type_t streamType,
|
|
cam_format_t streamFormat,
|
|
cam_dimension_t streamDim,
|
|
cam_rotation_t streamRotation,
|
|
uint8_t minStreamBufNum,
|
|
cam_feature_mask_t postprocessMask,
|
|
cam_is_type_t isType,
|
|
uint32_t batchSize,
|
|
bool bNeedStreamCb,
|
|
bool bNeedBundling)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
bool isSecure = isSecureMode() && (streamType != CAM_STREAM_TYPE_METADATA);
|
|
|
|
if (m_numStreams >= 1) {
|
|
LOGE("Only one stream per channel supported in v3 Hal");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (m_numStreams >= MAX_STREAM_NUM_IN_BUNDLE) {
|
|
LOGE("stream number (%d) exceeds max limit (%d)",
|
|
m_numStreams, MAX_STREAM_NUM_IN_BUNDLE);
|
|
return BAD_VALUE;
|
|
}
|
|
QCamera3Stream *pStream = new QCamera3Stream(m_camHandle,
|
|
m_handle,
|
|
m_camOps,
|
|
&mPaddingInfo,
|
|
this);
|
|
if (pStream == NULL) {
|
|
LOGE("No mem for Stream");
|
|
return NO_MEMORY;
|
|
}
|
|
LOGD("batch size is %d", batchSize);
|
|
|
|
hal3_stream_cb_routine stream_cb =
|
|
bNeedStreamCb ? (hal3_stream_cb_routine)streamCbRoutine : NULL;
|
|
|
|
rc = pStream->init(streamType, streamFormat, streamDim, streamRotation,
|
|
NULL, minStreamBufNum, postprocessMask, isType, batchSize,
|
|
stream_cb, this, isSecure, bNeedBundling);
|
|
if (rc == 0) {
|
|
mStreams[m_numStreams] = pStream;
|
|
m_numStreams++;
|
|
} else {
|
|
delete pStream;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : start
|
|
*
|
|
* DESCRIPTION: start channel, which will start all streams belong to this channel
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::start()
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_CH_START);
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if (m_numStreams > 1) {
|
|
LOGW("bundle not supported");
|
|
} else if (m_numStreams == 0) {
|
|
return NO_INIT;
|
|
}
|
|
|
|
if(m_bIsActive) {
|
|
LOGW("Attempt to start active channel");
|
|
return rc;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (mStreams[i] != NULL) {
|
|
mStreams[i]->start();
|
|
}
|
|
}
|
|
|
|
m_bIsActive = true;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : stop
|
|
*
|
|
* DESCRIPTION: stop a channel, which will stop all streams belong to this channel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::stop()
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_CH_STOP);
|
|
int32_t rc = NO_ERROR;
|
|
if(!m_bIsActive) {
|
|
LOGE("Attempt to stop inactive channel");
|
|
return rc;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (mStreams[i] != NULL) {
|
|
mStreams[i]->stop();
|
|
}
|
|
}
|
|
|
|
m_bIsActive = false;
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setBatchSize
|
|
*
|
|
* DESCRIPTION: Set batch size for the channel. This is a dummy implementation
|
|
* for the base class
|
|
*
|
|
* PARAMETERS :
|
|
* @batchSize : Number of image buffers in a batch
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success always
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::setBatchSize(uint32_t batchSize)
|
|
{
|
|
LOGD("Dummy method. batchSize: %d unused ", batchSize);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : queueBatchBuf
|
|
*
|
|
* DESCRIPTION: This is a dummy implementation for the base class
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success always
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::queueBatchBuf()
|
|
{
|
|
LOGD("Dummy method. Unused ");
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setPerFrameMapUnmap
|
|
*
|
|
* DESCRIPTION: Sets internal enable flag
|
|
*
|
|
* PARAMETERS :
|
|
* @enable : Bool value for the enable flag
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success always
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::setPerFrameMapUnmap(bool enable)
|
|
{
|
|
mPerFrameMapUnmapEnable = enable;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : flush
|
|
*
|
|
* DESCRIPTION: flush a channel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::flush()
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_CH_FLUSH);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : bufDone
|
|
*
|
|
* DESCRIPTION: return a stream buf back to kernel
|
|
*
|
|
* PARAMETERS :
|
|
* @recvd_frame : stream buf frame to be returned
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::bufDone(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
|
|
if (recvd_frame->bufs[i] != NULL) {
|
|
for (uint32_t j = 0; j < m_numStreams; j++) {
|
|
if (mStreams[j] != NULL &&
|
|
validate_handle(mStreams[j]->getMyHandle(), recvd_frame->bufs[i]->stream_id)) {
|
|
rc = mStreams[j]->bufDone(recvd_frame->bufs[i]->buf_idx);
|
|
break; // break loop j
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setBundleInfo
|
|
*
|
|
* DESCRIPTION: setting bundle information in stream params
|
|
*
|
|
* PARAMETERS :
|
|
* @bundleInfo : stream bundle information.
|
|
* @cam_type : MAIN or AUX.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::setBundleInfo(const cam_bundle_config_t &bundleInfo, uint32_t cam_type)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
cam_stream_parm_buffer_t param;
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_SET_BUNDLE_INFO;
|
|
param.bundleInfo = bundleInfo;
|
|
if (m_numStreams > 0 && mStreams[0]) {
|
|
rc = mStreams[0]->setParameter(param, cam_type);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("stream setParameter for set bundle failed");
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamSize
|
|
*
|
|
* DESCRIPTION: get the size from the camera3_stream_t for the channel
|
|
*
|
|
* PARAMETERS :
|
|
* @dim : Return the size of the stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3Channel::getStreamSize(cam_dimension_t &dim)
|
|
{
|
|
if (mStreams[0]) {
|
|
return mStreams[0]->getFrameDimension(dim);
|
|
} else {
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamTypeMask
|
|
*
|
|
* DESCRIPTION: Get bit mask of all stream types in this channel
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : Bit mask of all stream types in this channel
|
|
*==========================================================================*/
|
|
uint32_t QCamera3Channel::getStreamTypeMask()
|
|
{
|
|
uint32_t mask = 0;
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
mask |= (1U << mStreams[i]->getMyType());
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamID
|
|
*
|
|
* DESCRIPTION: Get StreamID of requested stream type
|
|
*
|
|
* PARAMETERS : streamMask
|
|
*
|
|
* RETURN : Stream ID
|
|
*==========================================================================*/
|
|
uint32_t QCamera3Channel::getStreamID(uint32_t streamMask)
|
|
{
|
|
uint32_t streamID = 0;
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (streamMask == (uint32_t )(0x1 << mStreams[i]->getMyType())) {
|
|
streamID = mStreams[i]->getMyServerID();
|
|
break;
|
|
}
|
|
}
|
|
return streamID;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamByHandle
|
|
*
|
|
* DESCRIPTION: return stream object by stream handle
|
|
*
|
|
* PARAMETERS :
|
|
* @streamHandle : stream handle
|
|
*
|
|
* RETURN : stream object. NULL if not found
|
|
*==========================================================================*/
|
|
QCamera3Stream *QCamera3Channel::getStreamByHandle(uint32_t streamHandle)
|
|
{
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (mStreams[i] != NULL && validate_handle(mStreams[i]->getMyHandle(), streamHandle)) {
|
|
return mStreams[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamByIndex
|
|
*
|
|
* DESCRIPTION: return stream object by index
|
|
*
|
|
* PARAMETERS :
|
|
* @streamHandle : stream handle
|
|
*
|
|
* RETURN : stream object. NULL if not found
|
|
*==========================================================================*/
|
|
QCamera3Stream *QCamera3Channel::getStreamByIndex(uint32_t index)
|
|
{
|
|
if (index < m_numStreams) {
|
|
return mStreams[index];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getPaddingInfo
|
|
*
|
|
* DESCRIPTION: return stream padding info
|
|
*
|
|
* RETURN : ptr to padding info structure
|
|
*==========================================================================*/
|
|
cam_padding_info_t* QCamera3Channel::getPaddingInfo() {
|
|
return &mPaddingInfo;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : streamCbRoutine
|
|
*
|
|
* DESCRIPTION: callback routine for stream
|
|
*
|
|
* PARAMETERS :
|
|
* @streamHandle : stream handle
|
|
*
|
|
* RETURN : stream object. NULL if not found
|
|
*==========================================================================*/
|
|
void QCamera3Channel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream, void *userdata)
|
|
{
|
|
QCamera3Channel *channel = (QCamera3Channel *)userdata;
|
|
if (channel == NULL) {
|
|
LOGE("invalid channel pointer");
|
|
return;
|
|
}
|
|
channel->streamCbRoutine(super_frame, stream);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : dumpYUV
|
|
*
|
|
* DESCRIPTION: function to dump the YUV data from ISP/pproc
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : frame to be dumped
|
|
* @dim : dimension of the stream
|
|
* @offset : offset of the data
|
|
* @name : 1 if it is ISP output/pproc input, 2 if it is pproc output
|
|
*
|
|
* RETURN :
|
|
*==========================================================================*/
|
|
void QCamera3Channel::dumpYUV(mm_camera_buf_def_t *frame, cam_dimension_t dim,
|
|
cam_frame_len_offset_t offset, uint8_t dump_type)
|
|
{
|
|
char buf[FILENAME_MAX];
|
|
memset(buf, 0, sizeof(buf));
|
|
static int counter = 0;
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
property_get("persist.vendor.camera.dumpimg", prop, "0");
|
|
mYUVDump = (uint32_t)atoi(prop);
|
|
if (mYUVDump & dump_type) {
|
|
mFrmNum = ((mYUVDump & 0xffff0000) >> 16);
|
|
if (mFrmNum == 0) {
|
|
mFrmNum = 10;
|
|
}
|
|
mSkipMode = ((mYUVDump & 0x0000ff00) >> 8);
|
|
if (mSkipMode == 0) {
|
|
mSkipMode = 1;
|
|
}
|
|
if (mDumpSkipCnt == 0) {
|
|
mDumpSkipCnt = 1;
|
|
}
|
|
if (mDumpSkipCnt % mSkipMode == 0) {
|
|
if (mDumpFrmCnt < mFrmNum) {
|
|
/* Note that the image dimension will be the unrotated stream dimension.
|
|
* If you feel that the image would have been rotated during reprocess
|
|
* then swap the dimensions while opening the file
|
|
* */
|
|
switch (dump_type) {
|
|
case QCAMERA_DUMP_FRM_PREVIEW:
|
|
snprintf(buf, sizeof(buf), QCAMERA_DUMP_FRM_LOCATION"p_%d_%d_%dx%d.yuv",
|
|
counter, frame->frame_idx, dim.width, dim.height);
|
|
break;
|
|
case QCAMERA_DUMP_FRM_VIDEO:
|
|
snprintf(buf, sizeof(buf), QCAMERA_DUMP_FRM_LOCATION"v_%d_%d_%dx%d.yuv",
|
|
counter, frame->frame_idx, dim.width, dim.height);
|
|
break;
|
|
case QCAMERA_DUMP_FRM_INPUT_JPEG:
|
|
snprintf(buf, sizeof(buf), QCAMERA_DUMP_FRM_LOCATION"s_%d_%d_%dx%d.yuv",
|
|
counter, frame->frame_idx, dim.width, dim.height);
|
|
break;
|
|
case QCAMERA_DUMP_FRM_INPUT_REPROCESS:
|
|
snprintf(buf, sizeof(buf), QCAMERA_DUMP_FRM_LOCATION"ir_%d_%d_%dx%d.yuv",
|
|
counter, frame->frame_idx, dim.width, dim.height);
|
|
break;
|
|
case QCAMERA_DUMP_FRM_CALLBACK:
|
|
snprintf(buf, sizeof(buf), QCAMERA_DUMP_FRM_LOCATION"c_%d_%d_%dx%d.yuv",
|
|
counter, frame->frame_idx, dim.width, dim.height);
|
|
break;
|
|
case QCAMERA_DUMP_FRM_OUTPUT_JPEG:
|
|
snprintf(buf, sizeof(buf), QCAMERA_DUMP_FRM_LOCATION"j_%d_%d_%dx%d.jpg",
|
|
counter, frame->frame_idx, dim.width, dim.height);
|
|
break;
|
|
default :
|
|
LOGE("dumping not enabled for stream type %d",dump_type);
|
|
break;
|
|
}
|
|
counter++;
|
|
int file_fd = open(buf, O_RDWR | O_CREAT, 0777);
|
|
ssize_t written_len = 0;
|
|
if (file_fd >= 0) {
|
|
void *data = NULL;
|
|
fchmod(file_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
|
|
if( dump_type == QCAMERA_DUMP_FRM_OUTPUT_JPEG ) {
|
|
written_len = write(file_fd, frame->buffer, frame->frame_len);
|
|
}
|
|
else {
|
|
for (uint32_t i = 0; i < offset.num_planes; i++) {
|
|
uint32_t index = offset.mp[i].offset;
|
|
if (i > 0) {
|
|
index += offset.mp[i-1].len;
|
|
}
|
|
for (int j = 0; j < offset.mp[i].height; j++) {
|
|
data = (void *)((uint8_t *)frame->buffer + index);
|
|
written_len += write(file_fd, data,
|
|
(size_t)offset.mp[i].width);
|
|
index += (uint32_t)offset.mp[i].stride;
|
|
}
|
|
}
|
|
}
|
|
LOGH("written number of bytes %ld\n", written_len);
|
|
mDumpFrmCnt++;
|
|
frame->cache_flags |= CPU_HAS_READ;
|
|
close(file_fd);
|
|
} else {
|
|
LOGE("failed to open file to dump image");
|
|
}
|
|
}
|
|
} else {
|
|
mDumpSkipCnt++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : isUBWCEnabled
|
|
*
|
|
* DESCRIPTION: Function to get UBWC hardware support.
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : TRUE -- UBWC format supported
|
|
* FALSE -- UBWC is not supported.
|
|
*==========================================================================*/
|
|
bool QCamera3Channel::isUBWCEnabled()
|
|
{
|
|
#ifdef UBWC_PRESENT
|
|
char value[PROPERTY_VALUE_MAX];
|
|
int prop_value = 0;
|
|
memset(value, 0, sizeof(value));
|
|
property_get("debug.gralloc.gfx_ubwc_disable", value, "0");
|
|
prop_value = atoi(value);
|
|
if (prop_value) {
|
|
return FALSE;
|
|
}
|
|
|
|
//Disable UBWC if Eztune is enabled
|
|
//EzTune process CPP output frame and cannot understand UBWC.
|
|
memset(value, 0, sizeof(value));
|
|
property_get("persist.vendor.camera.eztune.enable", value, "0");
|
|
prop_value = atoi(value);
|
|
if (prop_value) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setUBWCEnabled
|
|
*
|
|
* DESCRIPTION: set UBWC enable
|
|
*
|
|
* PARAMETERS : UBWC enable value
|
|
*
|
|
* RETURN : none
|
|
*
|
|
*==========================================================================*/
|
|
void QCamera3Channel::setUBWCEnabled(bool val)
|
|
{
|
|
m_bUBWCenable = val;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamDefaultFormat
|
|
*
|
|
* DESCRIPTION: return default buffer format for the stream
|
|
*
|
|
* PARAMETERS : type : Stream type
|
|
*
|
|
** RETURN : format for stream type
|
|
*
|
|
*==========================================================================*/
|
|
cam_format_t QCamera3Channel::getStreamDefaultFormat(cam_stream_type_t type,
|
|
uint32_t width, uint32_t height, __unused uint32_t usage)
|
|
{
|
|
cam_format_t streamFormat;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
|
|
switch (type) {
|
|
case CAM_STREAM_TYPE_PREVIEW:
|
|
if (isUBWCEnabled()) {
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
int pFormat;
|
|
memset(prop, 0, sizeof(prop));
|
|
property_get("persist.vendor.camera.preview.ubwc", prop, "1");
|
|
pFormat = atoi(prop);
|
|
if (pFormat == 1 && (m_bUBWCenable)) {
|
|
streamFormat = CAM_FORMAT_YUV_420_NV12_UBWC;
|
|
} else {
|
|
/* Changed to macro to ensure format sent to gralloc for preview
|
|
is also changed if the preview format is changed at camera HAL */
|
|
streamFormat = PREVIEW_STREAM_FORMAT;
|
|
}
|
|
} else {
|
|
/* Changed to macro to ensure format sent to gralloc for preview
|
|
is also changed if the preview format is changed at camera HAL */
|
|
streamFormat = PREVIEW_STREAM_FORMAT;
|
|
}
|
|
break;
|
|
case CAM_STREAM_TYPE_VIDEO:
|
|
{
|
|
/* Disable UBWC for smaller video resolutions due to CPP downscale
|
|
limits. Refer cpp_hw_params.h::CPP_DOWNSCALE_LIMIT_UBWC */
|
|
if (isUBWCEnabled() && (width >= 640) && (height >= 480)) {
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if ((hal_obj->mCommon.isVideoUBWCEnabled())) {
|
|
streamFormat = CAM_FORMAT_YUV_420_NV12_UBWC;
|
|
} else {
|
|
streamFormat = CAM_FORMAT_YUV_420_NV12_VENUS;
|
|
}
|
|
} else {
|
|
#if VENUS_PRESENT
|
|
streamFormat = CAM_FORMAT_YUV_420_NV12_VENUS;
|
|
#else
|
|
streamFormat = CAM_FORMAT_YUV_420_NV12;
|
|
#endif
|
|
}
|
|
|
|
#if VIDEO_EXPLICIT_UBWC
|
|
bool isUBWCBitSet = (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC);
|
|
if (!isUBWCBitSet) {
|
|
streamFormat = CAM_FORMAT_YUV_420_NV12_VENUS;
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
case CAM_STREAM_TYPE_SNAPSHOT:
|
|
streamFormat = CAM_FORMAT_YUV_420_NV21;
|
|
break;
|
|
case CAM_STREAM_TYPE_CALLBACK:
|
|
/* Changed to macro to ensure format sent to gralloc for callback
|
|
is also changed if the preview format is changed at camera HAL */
|
|
streamFormat = CALLBACK_STREAM_FORMAT;
|
|
break;
|
|
case CAM_STREAM_TYPE_RAW:
|
|
streamFormat = hal_obj->mRdiModeFmt;
|
|
break;
|
|
case CAM_STREAM_TYPE_OFFLINE_PROC:
|
|
if (hal_obj->isQuadCfaSensor() && hal_obj->getReprocChannelCnt() > 1) {
|
|
if (hal_obj->mRdiModeFmt == CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG) {
|
|
streamFormat = CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GBRG;
|
|
} else if (hal_obj->mRdiModeFmt == CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GRBG) {
|
|
streamFormat = CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GRBG;
|
|
} else if (hal_obj->mRdiModeFmt == CAM_FORMAT_BAYER_MIPI_RAW_10BPP_RGGB) {
|
|
streamFormat = CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_RGGB;
|
|
} else if (hal_obj->mRdiModeFmt == CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR) {
|
|
streamFormat = CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR;
|
|
} else {
|
|
LOGW("unkown rdi format, use default one for offline proc stream");
|
|
streamFormat = CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR;
|
|
}
|
|
} else {
|
|
streamFormat = CAM_FORMAT_YUV_420_NV21;
|
|
}
|
|
break;
|
|
default:
|
|
streamFormat = CAM_FORMAT_YUV_420_NV21;
|
|
break;
|
|
}
|
|
LOGH("stream type %d, usage 0x%x stream format %d",type,usage,streamFormat);
|
|
return streamFormat;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : switchMaster
|
|
*
|
|
* DESCRIPTION: switch master camera in all the channels
|
|
*
|
|
* PARAMETERS : master camera
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3Channel::switchMaster(uint32_t masterCam)
|
|
{
|
|
mMasterCam = masterCam;
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (mStreams[i] != NULL) {
|
|
mStreams[i]->switchMaster(masterCam);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QCamera3Channel::overridePPConfig(cam_feature_mask_t pp_mask)
|
|
{
|
|
LOGD("overriding ppmask to %" PRIx64, pp_mask);
|
|
mPostProcMask = pp_mask;
|
|
}
|
|
|
|
/* QCamera3ProcessingChannel methods */
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3ProcessingChannel
|
|
*
|
|
* DESCRIPTION: constructor of QCamera3ProcessingChannel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : camera handle
|
|
* @cam_ops : ptr to camera ops table
|
|
* @cb_routine : callback routine to frame aggregator
|
|
* @paddingInfo: stream padding info
|
|
* @userData : HWI handle
|
|
* @stream : camera3_stream_t structure
|
|
* @stream_type: Channel stream type
|
|
* @postprocess_mask: the postprocess mask for streams of this channel
|
|
* @metadataChannel: handle to the metadataChannel
|
|
* @numBuffers : number of max dequeued buffers
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3ProcessingChannel::QCamera3ProcessingChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buffer_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
camera3_stream_t *stream,
|
|
cam_stream_type_t stream_type,
|
|
cam_feature_mask_t postprocess_mask,
|
|
QCamera3Channel *metadataChannel,
|
|
uint32_t numBuffers) :
|
|
QCamera3Channel(cam_handle, channel_handle, cam_ops, cb_routine,
|
|
cb_buffer_err, paddingInfo, postprocess_mask, userData, numBuffers),
|
|
m_postprocessor(this),
|
|
mFrameCount(0),
|
|
mLastFrameCount(0),
|
|
mLastFpsTime(0),
|
|
mMemory(numBuffers, true, isSecureMode()),
|
|
mNumBufs(CAM_MAX_NUM_BUFS_PER_STREAM),
|
|
mStreamType(stream_type),
|
|
mPostProcStarted(false),
|
|
mInputBufferConfig(false),
|
|
m_pMetaChannel(metadataChannel),
|
|
mMetaFrame(NULL),
|
|
mOfflineMemory(0, true, isSecureMode()),
|
|
mOfflineMetaMemory(numBuffers + (MAX_REPROCESS_PIPELINE_STAGES - 1),
|
|
false, false),
|
|
m_bZSL(FALSE),
|
|
m_zslType(CAM_HAL3_ZSL_TYPE_NONE),
|
|
mSourceZSLChannel(NULL),
|
|
mSinkZSLChannel(NULL),
|
|
mJpegMemory(numBuffers, true, isSecureMode()),
|
|
mCamera3Stream(stream),
|
|
mAllocDone(FALSE),
|
|
m_bSkipConfig(false),
|
|
m_bQuadraChannel(false)
|
|
{
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
property_get("persist.vendor.debug.sf.showfps", prop, "0");
|
|
mDebugFPS = (uint8_t) atoi(prop);
|
|
mReqFrameNumList.clear();
|
|
mAllocThread = 0;
|
|
|
|
int32_t rc = m_postprocessor.init(&mMemory);
|
|
if (rc != 0) {
|
|
LOGE("Init Postprocessor failed");
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCamera3ProcessingChannel
|
|
*
|
|
* DESCRIPTION: destructor of QCamera3ProcessingChannel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3ProcessingChannel::~QCamera3ProcessingChannel()
|
|
{
|
|
destroy();
|
|
|
|
int32_t rc = m_postprocessor.deinit();
|
|
if (rc != 0) {
|
|
LOGE("De-init Postprocessor failed");
|
|
}
|
|
|
|
if (0 < mOfflineMetaMemory.getCnt()) {
|
|
mOfflineMetaMemory.deallocate();
|
|
}
|
|
if (0 < mOfflineMemory.getCnt()) {
|
|
mOfflineMemory.unregisterBuffers();
|
|
}
|
|
|
|
mReqFrameNumList.clear();
|
|
mAllocDone = FALSE;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : cancelFramePProc
|
|
*
|
|
* DESCRIPTION: cancel FramePost Processing request.
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : frame number for which postproc request need to be cancel.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::cancelFramePProc(uint32_t framenum,
|
|
__unused cam_sync_type_t cam)
|
|
{
|
|
int rc = NO_ERROR;
|
|
rc = m_postprocessor.cancelFramePProc(framenum);
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : streamCbRoutine
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS :
|
|
* @super_frame : the super frame with filled buffer
|
|
* @stream : stream on which the buffer was requested and filled
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3ProcessingChannel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream)
|
|
{
|
|
if (mStreamType == CAM_STREAM_TYPE_PREVIEW) {
|
|
KPI_ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PREVIEW_STRM_CB);
|
|
} else {
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PROC_CH_STRM_CB);
|
|
}
|
|
//FIXME Q Buf back in case of error?
|
|
uint8_t frameIndex;
|
|
buffer_handle_t *resultBuffer;
|
|
int32_t resultFrameNumber;
|
|
camera3_stream_buffer_t result;
|
|
cam_dimension_t dim;
|
|
cam_frame_len_offset_t offset;
|
|
|
|
memset(&dim, 0, sizeof(dim));
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
if (checkStreamCbErrors(super_frame, stream) != NO_ERROR) {
|
|
LOGE("Error with the stream callback");
|
|
return;
|
|
}
|
|
|
|
frameIndex = (uint8_t)super_frame->bufs[0]->buf_idx;
|
|
if(frameIndex >= mNumBufs) {
|
|
LOGE("Error, Invalid index for buffer");
|
|
stream->bufDone(frameIndex);
|
|
return;
|
|
}
|
|
|
|
if (mDebugFPS) {
|
|
showDebugFPS(stream->getMyType());
|
|
}
|
|
stream->getFrameDimension(dim);
|
|
stream->getFrameOffset(offset);
|
|
if (stream->getMyType() == CAM_STREAM_TYPE_PREVIEW) {
|
|
dumpYUV(super_frame->bufs[0], dim, offset, QCAMERA_DUMP_FRM_PREVIEW);
|
|
} else if (stream->getMyType() == CAM_STREAM_TYPE_VIDEO) {
|
|
dumpYUV(super_frame->bufs[0], dim, offset, QCAMERA_DUMP_FRM_VIDEO);
|
|
} else if (stream->getMyType() == CAM_STREAM_TYPE_CALLBACK) {
|
|
dumpYUV(super_frame->bufs[0], dim, offset, QCAMERA_DUMP_FRM_CALLBACK);
|
|
}
|
|
|
|
if(super_frame->bufs[0]->cache_flags != 0)
|
|
{
|
|
mMemory.cleanInvalidateCache(super_frame->bufs[0]->buf_idx);
|
|
super_frame->bufs[0]->cache_flags = 0;
|
|
}
|
|
|
|
do {
|
|
//Use below data to issue framework callback
|
|
resultBuffer = (buffer_handle_t *)mMemory.getBufferHandle(frameIndex);
|
|
resultFrameNumber = mMemory.getFrameNumber(frameIndex);
|
|
uint32_t oldestBufIndex;
|
|
int32_t lowestFrameNumber = mMemory.getOldestFrameNumber(oldestBufIndex);
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if ((lowestFrameNumber != -1 ) && (lowestFrameNumber < resultFrameNumber) &&
|
|
hal_obj->mOpMode != CAMERA3_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE) {
|
|
LOGE("Error buffer dropped for framenumber:%d with bufidx:%d",
|
|
lowestFrameNumber, oldestBufIndex);
|
|
if (mOutOfSequenceBuffers.empty()) {
|
|
stream->cancelBuffer(oldestBufIndex);
|
|
}
|
|
|
|
//push in order!
|
|
auto itr = mOutOfSequenceBuffers.begin();
|
|
for (; itr != mOutOfSequenceBuffers.end(); itr++) {
|
|
mm_camera_super_buf_t *super_buf = *itr;
|
|
uint32_t buf_idx = super_buf->bufs[0]->buf_idx;
|
|
int32_t frame_num = mMemory.getFrameNumber(buf_idx);
|
|
if (resultFrameNumber < frame_num) {
|
|
LOGE("Out of order frame!! set buffer status error flag!");
|
|
mOutOfSequenceBuffers.insert(itr, super_frame);
|
|
super_buf->bufs[0]->flags |= V4L2_BUF_FLAG_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (itr == mOutOfSequenceBuffers.end()) {
|
|
LOGE("Add the frame to the end of mOutOfSequenceBuffers");
|
|
// add the buffer
|
|
mOutOfSequenceBuffers.push_back(super_frame);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(hal_obj->mStreamConfig == true) {
|
|
switch (stream->getMyType()) {
|
|
case CAM_STREAM_TYPE_PREVIEW:
|
|
LOGI("[KPI Perf] : PROFILE_FIRST_PREVIEW_FRAME camera id %d",
|
|
hal_obj->getCameraID());
|
|
break;
|
|
case CAM_STREAM_TYPE_VIDEO:
|
|
LOGI("[KPI Perf] : PROFILE_FIRST_VIDEO_FRAME camera id %d ",
|
|
hal_obj->getCameraID());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
hal_obj->mStreamConfig = false;
|
|
}
|
|
|
|
result.stream = mCamera3Stream;
|
|
result.buffer = resultBuffer;
|
|
if (IS_BUFFER_ERROR(super_frame->bufs[0]->flags)) {
|
|
result.status = CAMERA3_BUFFER_STATUS_ERROR;
|
|
LOGW("CAMERA3_BUFFER_STATUS_ERROR for stream_type: %d",
|
|
mStreams[0]->getMyType());
|
|
mChannelCbBufErr(this, resultFrameNumber, CAMERA3_BUFFER_STATUS_ERROR, mUserData);
|
|
} else {
|
|
result.status = CAMERA3_BUFFER_STATUS_OK;
|
|
}
|
|
result.acquire_fence = -1;
|
|
result.release_fence = -1;
|
|
if(mPerFrameMapUnmapEnable) {
|
|
int32_t rc = stream->bufRelease(frameIndex);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d releasing stream buffer %d",
|
|
rc, frameIndex);
|
|
}
|
|
|
|
rc = mMemory.unregisterBuffer(frameIndex);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d unregistering stream buffer %d",
|
|
rc, frameIndex);
|
|
}
|
|
}
|
|
|
|
if (0 <= resultFrameNumber) {
|
|
if (mChannelCB) {
|
|
mChannelCB(NULL, &result, (uint32_t)resultFrameNumber, false, mUserData);
|
|
}
|
|
} else {
|
|
LOGE("Bad frame number");
|
|
}
|
|
free(super_frame);
|
|
super_frame = NULL;
|
|
if (mOutOfSequenceBuffers.empty()) {
|
|
break;
|
|
} else {
|
|
auto itr = mOutOfSequenceBuffers.begin();
|
|
super_frame = *itr;
|
|
frameIndex = super_frame->bufs[0]->buf_idx;
|
|
resultFrameNumber = mMemory.getFrameNumber(frameIndex);
|
|
lowestFrameNumber = mMemory.getOldestFrameNumber(oldestBufIndex);
|
|
LOGE("Attempting to recover next frame: result Frame#: %d, resultIdx: %d, "
|
|
"Lowest Frame#: %d, oldestBufIndex: %d",
|
|
resultFrameNumber, frameIndex, lowestFrameNumber, oldestBufIndex);
|
|
if ((lowestFrameNumber != -1) && (lowestFrameNumber < resultFrameNumber)) {
|
|
int32_t ret = NO_ERROR;
|
|
LOGE("Multiple frame dropped requesting cancel for frame %d, idx:%d",
|
|
lowestFrameNumber, oldestBufIndex);
|
|
ret = stream->cancelBuffer(oldestBufIndex);
|
|
if (NO_ERROR == ret) {
|
|
return;
|
|
} else {
|
|
//check if the buffer already exists in the out of sequence list
|
|
auto it = mOutOfSequenceBuffers.begin();
|
|
for (;it != mOutOfSequenceBuffers.end(); it++) {
|
|
mm_camera_super_buf_t *frame = *it;
|
|
if (frame->bufs[0]->buf_idx == oldestBufIndex) {
|
|
LOGE("buffer already in mOutOfSequenceBuffers list");
|
|
frameIndex = oldestBufIndex;
|
|
super_frame = *it;
|
|
mOutOfSequenceBuffers.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
if (it == mOutOfSequenceBuffers.end()) {
|
|
LOGE("SHOULD NOT BE HERE, BUFFER LOST !!!");
|
|
return;
|
|
}
|
|
}
|
|
} else if (lowestFrameNumber == resultFrameNumber) {
|
|
LOGE("Time to flush out head of list continue loop with this new super frame");
|
|
itr = mOutOfSequenceBuffers.erase(itr);
|
|
} else {
|
|
LOGE("Unexpected condition head of list is not the lowest frame number");
|
|
itr = mOutOfSequenceBuffers.erase(itr);
|
|
}
|
|
}
|
|
} while (1);
|
|
return;
|
|
}
|
|
|
|
int32_t QCamera3ProcessingChannel::requestZSLBuf(uint32_t cam_handle,
|
|
uint32_t channel_handle, uint32_t frameNumber,
|
|
uint32_t numBuf)
|
|
{
|
|
LOGH("requestZSLBuf with frameNumber %d",frameNumber);
|
|
mm_camera_req_buf_t buf;
|
|
memset(&buf, 0x0, sizeof(buf));
|
|
buf.type = MM_CAMERA_REQ_SUPER_BUF;
|
|
buf.num_buf_requested = numBuf;
|
|
buf.frame_idx = frameNumber;
|
|
return m_camOps->request_super_buf(cam_handle, channel_handle, &buf);
|
|
}
|
|
|
|
int QCamera3ProcessingChannel::createAllocThread()
|
|
{
|
|
int rc = NO_ERROR;
|
|
|
|
if (mAllocThread != 0) {
|
|
pthread_join(mAllocThread,NULL);
|
|
mAllocThread = 0;
|
|
}
|
|
|
|
rc = pthread_create(&mAllocThread, NULL, buffer_alloc_thread, (void *) this);
|
|
if (!rc) {
|
|
pthread_setname_np(mAllocThread, "CAM_BufferAlloc");
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3ProcessingChannel::setSourceZSLChannel(QCamera3ProcessingChannel *srcZsl,
|
|
zsl_stream_type_t zslType,
|
|
bool isSkipChannelConfig)
|
|
{
|
|
if(IS_VALID_PTR(mSourceZSLChannel) && IS_VALID_PTR(srcZsl))
|
|
{
|
|
if(IS_EQUAL(mSourceZSLChannel,srcZsl)) {
|
|
return;
|
|
}
|
|
else {
|
|
LOGW("Resetting source zsl channel !!!");
|
|
}
|
|
}
|
|
|
|
mSourceZSLChannel = srcZsl;
|
|
m_zslType = zslType;
|
|
m_bSkipConfig = isSkipChannelConfig;
|
|
mSourceZSLChannel->setSinkZSLChannel(this, zslType);
|
|
}
|
|
|
|
void* QCamera3ProcessingChannel::buffer_alloc_thread (void* data)
|
|
{
|
|
QCamera3ProcessingChannel *channelObj = reinterpret_cast<QCamera3ProcessingChannel *>(data);
|
|
if (!channelObj) {
|
|
return (void *)BAD_VALUE;
|
|
}
|
|
channelObj->allocateZSLBuffers();
|
|
return (void* )NULL;
|
|
}
|
|
|
|
void QCamera3ProcessingChannel::setSinkZSLChannel(QCamera3ProcessingChannel *sinkZsl,
|
|
zsl_stream_type_t zslType)
|
|
{
|
|
if(IS_VALID_PTR(mSinkZSLChannel) && IS_VALID_PTR(sinkZsl))
|
|
{
|
|
if(IS_EQUAL(mSinkZSLChannel,sinkZsl)) {
|
|
return;
|
|
}
|
|
else {
|
|
LOGW("Resetting source zsl channel !!!");
|
|
}
|
|
}
|
|
mSinkZSLChannel = sinkZsl;
|
|
m_zslType = zslType;
|
|
}
|
|
|
|
int32_t QCamera3ProcessingChannel::getFrameNumber(uint32_t frameIndex)
|
|
{
|
|
return mMemory.getFrameNumber(frameIndex);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : timeoutFrame
|
|
*
|
|
* DESCRIPTION: Method to indicate to channel that a given frame has take too
|
|
* long to be generated
|
|
*
|
|
* PARAMETERS : framenumber indicating the framenumber of the buffer timingout
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::timeoutFrame(uint32_t frameNumber)
|
|
{
|
|
int32_t bufIdx;
|
|
|
|
bufIdx = mMemory.getBufferIndex(frameNumber);
|
|
|
|
if (bufIdx < 0) {
|
|
LOGE("Buffer not found for frame:%d", frameNumber);
|
|
return -1;
|
|
}
|
|
|
|
mStreams[0]->timeoutFrame(bufIdx);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void QCamera3ProcessingChannel::setQuadraMetaBuffer(metadata_buffer_t *meta,
|
|
__unused metadata_buffer_t *framemeta)
|
|
{
|
|
(void)meta;
|
|
}
|
|
|
|
void QCamera3ProcessingChannel::getQuadraMetaBuffer(metadata_buffer_t **meta)
|
|
{
|
|
(void)meta;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : request
|
|
*
|
|
* DESCRIPTION: handle the request - either with an input buffer or a direct
|
|
* output request
|
|
*
|
|
* PARAMETERS :
|
|
* @buffer : pointer to the output buffer
|
|
* @frameNumber : frame number of the request
|
|
* @pInputBuffer : pointer to input buffer if an input request
|
|
* @metadata : parameters associated with the request
|
|
* @internalreq : boolean to indicate if this is purely internal request
|
|
* needing internal buffer allocation
|
|
* @meteringonly : boolean indicating metering only frame subset of internal
|
|
* not consumed by postprocessor
|
|
*
|
|
* RETURN : 0 on a success start of capture
|
|
* -EINVAL on invalid input
|
|
* -ENODEV on serious error
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::request(buffer_handle_t *buffer,
|
|
uint32_t frameNumber,
|
|
camera3_stream_buffer_t* pInputBuffer,
|
|
metadata_buffer_t* metadata,
|
|
int &indexUsed,
|
|
__unused bool internalRequest,
|
|
__unused bool meteringOnly,
|
|
__unused bool isZSL)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
int index;
|
|
|
|
if (NULL == buffer || NULL == metadata) {
|
|
LOGE("Invalid buffer/metadata in channel request");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (pInputBuffer) {
|
|
//need to send to reprocessing
|
|
LOGD("Got a request with input buffer, output streamType = %d", mStreamType);
|
|
reprocess_config_t reproc_cfg;
|
|
cam_dimension_t dim;
|
|
memset(&reproc_cfg, 0, sizeof(reprocess_config_t));
|
|
memset(&dim, 0, sizeof(dim));
|
|
setReprocConfig(reproc_cfg, pInputBuffer, metadata, mStreamFormat, dim);
|
|
startPostProc(reproc_cfg);
|
|
|
|
qcamera_fwk_input_pp_data_t *src_frame = NULL;
|
|
src_frame = (qcamera_fwk_input_pp_data_t *)calloc(1,
|
|
sizeof(qcamera_fwk_input_pp_data_t));
|
|
if (src_frame == NULL) {
|
|
LOGE("No memory for src frame");
|
|
return NO_MEMORY;
|
|
}
|
|
rc = setFwkInputPPData(src_frame, pInputBuffer, &reproc_cfg, metadata, buffer, frameNumber);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d while setting framework input PP data", rc);
|
|
free(src_frame);
|
|
return rc;
|
|
}
|
|
LOGH("Post-process started");
|
|
m_postprocessor.processData(src_frame);
|
|
} else {
|
|
//need to fill output buffer with new data and return
|
|
if(!m_bIsActive) {
|
|
rc = registerBuffer(buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
rc = start();
|
|
if (NO_ERROR != rc)
|
|
return rc;
|
|
} else {
|
|
LOGD("Request on an existing stream");
|
|
}
|
|
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if(index < 0) {
|
|
rc = registerBuffer(buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if (index < 0) {
|
|
LOGE("Could not find object among registered buffers");
|
|
return DEAD_OBJECT;
|
|
}
|
|
}
|
|
rc = mMemory.markFrameNumber(index, frameNumber);
|
|
if(rc != NO_ERROR) {
|
|
LOGE("Error marking frame number:%d for index %d", frameNumber,
|
|
index);
|
|
return rc;
|
|
}
|
|
rc = mStreams[0]->bufDone(index);
|
|
if(rc != NO_ERROR) {
|
|
LOGE("Failed to Q new buffer to stream");
|
|
mMemory.markFrameNumber(index, -1);
|
|
return rc;
|
|
}
|
|
indexUsed = index;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : initialize
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS : isType : type of image stabilization on the buffer
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::initialize(__unused cam_is_type_t isType)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
rc = mOfflineMetaMemory.allocateAll(sizeof(metadata_buffer_t));
|
|
if (rc == NO_ERROR) {
|
|
Mutex::Autolock lock(mFreeOfflineMetaBuffersLock);
|
|
mFreeOfflineMetaBuffersList.clear();
|
|
for (uint32_t i = 0; i < mNumBuffers + (MAX_REPROCESS_PIPELINE_STAGES - 1);
|
|
i++) {
|
|
mFreeOfflineMetaBuffersList.push_back(i);
|
|
}
|
|
} else {
|
|
LOGE("Could not allocate offline meta buffers for input reprocess");
|
|
}
|
|
mOutOfSequenceBuffers.clear();
|
|
mReprocDropBufferList.clear();
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : registerBuffer
|
|
*
|
|
* DESCRIPTION: register streaming buffer to the channel object
|
|
*
|
|
* PARAMETERS :
|
|
* @buffer : buffer to be registered
|
|
* @isType : image stabilization type on the stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::registerBuffer(buffer_handle_t *buffer,
|
|
cam_is_type_t isType)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PROC_CH_REG_BUF);
|
|
int rc = 0;
|
|
mIsType = isType;
|
|
cam_stream_type_t streamType;
|
|
|
|
if ((uint32_t)mMemory.getCnt() > (mNumBufs - 1)) {
|
|
LOGE("Trying to register more buffers than initially requested");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (0 == m_numStreams) {
|
|
rc = initialize(mIsType);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Couldn't initialize camera stream %d", rc);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
streamType = mStreams[0]->getMyType();
|
|
rc = mMemory.registerBuffer(buffer, streamType);
|
|
if (ALREADY_EXISTS == rc) {
|
|
return NO_ERROR;
|
|
} else if (NO_ERROR != rc) {
|
|
LOGE("Buffer %p couldn't be registered %d", buffer, rc);
|
|
return rc;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setFwkInputPPData
|
|
*
|
|
* DESCRIPTION: fill out the framework src frame information for reprocessing
|
|
*
|
|
* PARAMETERS :
|
|
* @src_frame : input pp data to be filled out
|
|
* @pInputBuffer : input buffer for reprocessing
|
|
* @reproc_cfg : pointer to the reprocess config
|
|
* @metadata : pointer to the metadata buffer
|
|
* @output_buffer : output buffer for reprocessing; could be NULL if not
|
|
* framework allocated
|
|
* @frameNumber : frame number of the request
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::setFwkInputPPData(qcamera_fwk_input_pp_data_t *src_frame,
|
|
camera3_stream_buffer_t *pInputBuffer, reprocess_config_t *reproc_cfg,
|
|
metadata_buffer_t *metadata, buffer_handle_t *output_buffer,
|
|
uint32_t frameNumber)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
int input_index = mOfflineMemory.getMatchBufIndex((void*)pInputBuffer->buffer);
|
|
if(input_index < 0) {
|
|
rc = mOfflineMemory.registerBuffer(pInputBuffer->buffer, mStreamType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly input buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
input_index = mOfflineMemory.getMatchBufIndex((void*)pInputBuffer->buffer);
|
|
if (input_index < 0) {
|
|
LOGE("Could not find object among registered buffers");
|
|
return DEAD_OBJECT;
|
|
}
|
|
}
|
|
mOfflineMemory.markFrameNumber(input_index, frameNumber);
|
|
|
|
src_frame->src_frame = *pInputBuffer;
|
|
rc = mOfflineMemory.getBufDef(reproc_cfg->input_stream_plane_info.plane_info,
|
|
src_frame->input_buffer, input_index);
|
|
if (rc != 0) {
|
|
return rc;
|
|
}
|
|
dumpYUV(&src_frame->input_buffer, reproc_cfg->input_stream_dim,
|
|
reproc_cfg->input_stream_plane_info.plane_info, QCAMERA_DUMP_FRM_INPUT_REPROCESS);
|
|
cam_dimension_t dim = {sizeof(metadata_buffer_t), 1};
|
|
cam_stream_buf_plane_info_t meta_planes;
|
|
rc = mm_stream_calc_offset_metadata(&dim, &mPaddingInfo, &meta_planes);
|
|
if (rc != 0) {
|
|
LOGE("Metadata stream plane info calculation failed!");
|
|
return rc;
|
|
}
|
|
uint32_t metaBufIdx;
|
|
{
|
|
Mutex::Autolock lock(mFreeOfflineMetaBuffersLock);
|
|
if (mFreeOfflineMetaBuffersList.empty()) {
|
|
LOGE("mFreeOfflineMetaBuffersList is null. Fatal");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
metaBufIdx = *(mFreeOfflineMetaBuffersList.begin());
|
|
mFreeOfflineMetaBuffersList.erase(mFreeOfflineMetaBuffersList.begin());
|
|
LOGD("erasing %d, mFreeOfflineMetaBuffersList.size %d", metaBufIdx,
|
|
mFreeOfflineMetaBuffersList.size());
|
|
}
|
|
|
|
mOfflineMetaMemory.markFrameNumber(metaBufIdx, frameNumber);
|
|
|
|
mm_camera_buf_def_t meta_buf;
|
|
cam_frame_len_offset_t offset = meta_planes.plane_info;
|
|
rc = mOfflineMetaMemory.getBufDef(offset, meta_buf, metaBufIdx);
|
|
if (NO_ERROR != rc) {
|
|
return rc;
|
|
}
|
|
memcpy(meta_buf.buffer, metadata, sizeof(metadata_buffer_t));
|
|
src_frame->metadata_buffer = meta_buf;
|
|
src_frame->reproc_config = *reproc_cfg;
|
|
src_frame->output_buffer = output_buffer;
|
|
src_frame->frameNumber = frameNumber;
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : checkStreamCbErrors
|
|
*
|
|
* DESCRIPTION: check the stream callback for errors
|
|
*
|
|
* PARAMETERS :
|
|
* @super_frame : the super frame with filled buffer
|
|
* @stream : stream on which the buffer was requested and filled
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::checkStreamCbErrors(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream)
|
|
{
|
|
if (NULL == stream) {
|
|
LOGE("Invalid stream");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if(NULL == super_frame) {
|
|
LOGE("Invalid Super buffer");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if(super_frame->num_bufs != 1) {
|
|
LOGE("Multiple streams are not supported");
|
|
return BAD_VALUE;
|
|
}
|
|
if(NULL == super_frame->bufs[0]) {
|
|
LOGE("Error, Super buffer frame does not contain valid buffer");
|
|
return BAD_VALUE;
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamSize
|
|
*
|
|
* DESCRIPTION: get the size from the camera3_stream_t for the channel
|
|
*
|
|
* PARAMETERS :
|
|
* @dim : Return the size of the stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::getStreamSize(cam_dimension_t &dim)
|
|
{
|
|
if (mCamera3Stream) {
|
|
dim.width = mCamera3Stream->width;
|
|
dim.height = mCamera3Stream->height;
|
|
return NO_ERROR;
|
|
} else {
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamBufs
|
|
*
|
|
* DESCRIPTION: get the buffers allocated to the stream
|
|
*
|
|
* PARAMETERS :
|
|
* @len : buffer length
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
QCamera3StreamMem* QCamera3ProcessingChannel::getStreamBufs(uint32_t /*len*/)
|
|
{
|
|
KPI_ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_GETSTREAMBUFS);
|
|
return &mMemory;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : putStreamBufs
|
|
*
|
|
* DESCRIPTION: release the buffers allocated to the stream
|
|
*
|
|
* PARAMETERS : NONE
|
|
*
|
|
* RETURN : NONE
|
|
*==========================================================================*/
|
|
void QCamera3ProcessingChannel::putStreamBufs()
|
|
{
|
|
mMemory.unregisterBuffers();
|
|
|
|
/* Reclaim all the offline metabuffers and push them to free list */
|
|
{
|
|
Mutex::Autolock lock(mFreeOfflineMetaBuffersLock);
|
|
mFreeOfflineMetaBuffersList.clear();
|
|
for (uint32_t i = 0; i < mOfflineMetaMemory.getCnt(); i++) {
|
|
mFreeOfflineMetaBuffersList.push_back(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QCamera3ProcessingChannel::ZSLChannelCb(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
(void) recvd_frame;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : stop
|
|
*
|
|
* DESCRIPTION: stop processing channel, which will stop all streams within,
|
|
* including the reprocessing channel in postprocessor.
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::stop()
|
|
{
|
|
if (mStreamType == CAM_STREAM_TYPE_PREVIEW) {
|
|
KPI_ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_STOP_PREVIEW);
|
|
}
|
|
int32_t rc = NO_ERROR;
|
|
if(!m_bIsActive) {
|
|
LOGE("Attempt to stop inactive channel");
|
|
return rc;
|
|
}
|
|
|
|
if (mAllocThread != 0) {
|
|
pthread_join(mAllocThread,NULL);
|
|
mAllocThread = 0;
|
|
}
|
|
|
|
m_postprocessor.stop();
|
|
mPostProcStarted = false;
|
|
rc |= QCamera3Channel::stop();
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : startPostProc
|
|
*
|
|
* DESCRIPTION: figure out if the postprocessor needs to be restarted and if yes
|
|
* start it
|
|
*
|
|
* PARAMETERS :
|
|
* @inputBufExists : whether there is an input buffer for post processing
|
|
* @config : reprocessing configuration
|
|
* @metadata : metadata associated with the reprocessing request
|
|
*
|
|
* RETURN : NONE
|
|
*==========================================================================*/
|
|
void QCamera3ProcessingChannel::startPostProc(const reprocess_config_t &config)
|
|
{
|
|
if(!mPostProcStarted) {
|
|
m_postprocessor.start(config);
|
|
mPostProcStarted = true;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : queueReprocMetadata
|
|
*
|
|
* DESCRIPTION: queue the reprocess metadata to the postprocessor
|
|
*
|
|
* PARAMETERS : metadata : the metadata corresponding to the pp frame
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::queueReprocMetadata(mm_camera_super_buf_t *metadata,
|
|
uint32_t framenum, bool dropframe)
|
|
{
|
|
Mutex::Autolock lock(mDropReprocBuffersLock);
|
|
List<uint32_t>::iterator dropInfo;
|
|
if(mReprocDropBufferList.size()) {
|
|
for (dropInfo = mReprocDropBufferList.begin();
|
|
dropInfo != mReprocDropBufferList.end(); dropInfo++) {
|
|
if (*dropInfo == framenum) {
|
|
mReprocDropBufferList.erase(dropInfo);
|
|
return metadataBufDone(metadata);
|
|
} else if (*dropInfo < framenum) {
|
|
if(m_postprocessor.releaseReprocMetaBuffer(*dropInfo)) {
|
|
mReprocDropBufferList.erase(dropInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return m_postprocessor.processPPMetadata(metadata, framenum, dropframe);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : metadataBufDone
|
|
*
|
|
* DESCRIPTION: Buffer done method for a metadata buffer
|
|
*
|
|
* PARAMETERS :
|
|
* @recvd_frame : received metadata frame
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::metadataBufDone(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
int32_t rc = NO_ERROR;;
|
|
if ((NULL == m_pMetaChannel) || (NULL == recvd_frame)) {
|
|
LOGE("Metadata channel or metadata buffer invalid");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
rc = ((QCamera3MetadataChannel*)m_pMetaChannel)->bufDone(recvd_frame);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : translateStreamTypeAndFormat
|
|
*
|
|
* DESCRIPTION: translates the framework stream format into HAL stream type
|
|
* and format
|
|
*
|
|
* PARAMETERS :
|
|
* @streamType : translated stream type
|
|
* @streamFormat : translated stream format
|
|
* @stream : fwk stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::translateStreamTypeAndFormat(camera3_stream_t *stream,
|
|
cam_stream_type_t &streamType, cam_format_t &streamFormat)
|
|
{
|
|
switch (stream->format) {
|
|
case HAL_PIXEL_FORMAT_YCbCr_420_888:
|
|
if(stream->stream_type == CAMERA3_STREAM_INPUT){
|
|
streamType = CAM_STREAM_TYPE_SNAPSHOT;
|
|
streamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_SNAPSHOT,
|
|
stream->width, stream->height);
|
|
} else {
|
|
streamType = CAM_STREAM_TYPE_CALLBACK;
|
|
streamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_CALLBACK,
|
|
stream->width, stream->height);
|
|
}
|
|
break;
|
|
case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
|
|
if (stream->usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
|
|
streamType = CAM_STREAM_TYPE_VIDEO;
|
|
streamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_VIDEO,
|
|
stream->width, stream->height, stream->usage);
|
|
} else if(stream->stream_type == CAMERA3_STREAM_INPUT ||
|
|
stream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL ||
|
|
IS_USAGE_ZSL(stream->usage)){
|
|
streamType = CAM_STREAM_TYPE_SNAPSHOT;
|
|
streamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_SNAPSHOT,
|
|
stream->width, stream->height);
|
|
} else {
|
|
streamType = CAM_STREAM_TYPE_PREVIEW;
|
|
streamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_PREVIEW,
|
|
stream->width, stream->height);
|
|
}
|
|
break;
|
|
case HAL_PIXEL_FORMAT_RAW_OPAQUE:
|
|
case HAL_PIXEL_FORMAT_RAW16:
|
|
case HAL_PIXEL_FORMAT_RAW10:
|
|
streamType = CAM_STREAM_TYPE_RAW;
|
|
streamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_RAW,
|
|
stream->width, stream->height);
|
|
break;
|
|
case HAL_PIXEL_FORMAT_RAW8:
|
|
streamType = CAM_STREAM_TYPE_RAW;
|
|
streamFormat = CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG;
|
|
break;
|
|
case HAL_PIXEL_FORMAT_BLOB:
|
|
if (stream->data_space == HAL_DATASPACE_DEPTH) {
|
|
streamType = CAM_STREAM_TYPE_DEPTH;
|
|
streamFormat = CAM_FORMAT_DEPTH_POINT_CLOUD;
|
|
}
|
|
break;
|
|
case HAL_PIXEL_FORMAT_Y16:
|
|
if (stream->data_space == HAL_DATASPACE_DEPTH) {
|
|
streamType = CAM_STREAM_TYPE_DEPTH;
|
|
streamFormat = CAM_FORMAT_DEPTH16;
|
|
}
|
|
break;
|
|
case HAL_PIXEL_FORMAT_Y8:
|
|
if (stream->data_space == HAL_DATASPACE_DEPTH) {
|
|
streamType = CAM_STREAM_TYPE_DEPTH;
|
|
streamFormat = CAM_FORMAT_DEPTH8;
|
|
}
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
LOGD("fwk_format = %d, streamType = %d, streamFormat = %d",
|
|
stream->format, streamType, streamFormat);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setReprocConfig
|
|
*
|
|
* DESCRIPTION: sets the reprocessing parameters for the input buffer
|
|
*
|
|
* PARAMETERS :
|
|
* @reproc_cfg : the configuration to be set
|
|
* @pInputBuffer : pointer to the input buffer
|
|
* @metadata : pointer to the reprocessing metadata buffer
|
|
* @streamFormat : format of the input stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::setReprocConfig(reprocess_config_t &reproc_cfg,
|
|
camera3_stream_buffer_t *pInputBuffer,
|
|
__unused metadata_buffer_t *metadata,
|
|
cam_format_t streamFormat, cam_dimension_t dim, bool bNeedUpScale)
|
|
{
|
|
int32_t rc = 0;
|
|
reproc_cfg.padding = &mPaddingInfo;
|
|
//to ensure a big enough buffer size set the height and width
|
|
//padding to max(height padding, width padding)
|
|
if (reproc_cfg.padding->height_padding > reproc_cfg.padding->width_padding) {
|
|
reproc_cfg.padding->width_padding = reproc_cfg.padding->height_padding;
|
|
} else {
|
|
reproc_cfg.padding->height_padding = reproc_cfg.padding->width_padding;
|
|
}
|
|
|
|
if (NULL != pInputBuffer && !bNeedUpScale) {
|
|
reproc_cfg.input_stream_dim.width = (int32_t)pInputBuffer->stream->width;
|
|
reproc_cfg.input_stream_dim.height = (int32_t)pInputBuffer->stream->height;
|
|
} else {
|
|
reproc_cfg.input_stream_dim.width = (int32_t)dim.width;
|
|
reproc_cfg.input_stream_dim.height = (int32_t)dim.height;
|
|
}
|
|
reproc_cfg.src_channel = this;
|
|
|
|
QCamera3HardwareInterface *hal_obj = (QCamera3HardwareInterface *)mUserData;
|
|
//In bokeh mode: upscaling will be done by jpeg in asymetric mode.
|
|
if((hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH ) && bNeedUpScale)
|
|
{
|
|
reproc_cfg.output_stream_dim.width = (int32_t)dim.width;
|
|
reproc_cfg.output_stream_dim.height = (int32_t)dim.height;
|
|
}else {
|
|
reproc_cfg.output_stream_dim.width = mCamera3Stream->width;
|
|
reproc_cfg.output_stream_dim.height = mCamera3Stream->height;
|
|
}
|
|
reproc_cfg.reprocess_type = getReprocessType();
|
|
reproc_cfg.output_stream_format = streamFormat;
|
|
//offset calculation
|
|
if (NULL != pInputBuffer) {
|
|
rc = translateStreamTypeAndFormat(pInputBuffer->stream,
|
|
reproc_cfg.stream_type, reproc_cfg.stream_format);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Stream format %d is not supported",
|
|
pInputBuffer->stream->format);
|
|
return rc;
|
|
}
|
|
} else {
|
|
reproc_cfg.stream_type = mStreamType;
|
|
reproc_cfg.stream_format = streamFormat;
|
|
}
|
|
|
|
if (getStreamByIndex(0) == NULL) {
|
|
LOGE("Could not find stream");
|
|
rc = -1;
|
|
return rc;
|
|
}
|
|
|
|
switch (reproc_cfg.stream_type) {
|
|
case CAM_STREAM_TYPE_PREVIEW:
|
|
rc = mm_stream_calc_offset_preview(
|
|
getStreamByIndex(0)->getStreamInfo(),
|
|
&reproc_cfg.input_stream_dim,
|
|
reproc_cfg.padding,
|
|
&reproc_cfg.input_stream_plane_info);
|
|
break;
|
|
case CAM_STREAM_TYPE_VIDEO:
|
|
rc = mm_stream_calc_offset_video(getStreamByIndex(0)->getStreamInfo(),
|
|
reproc_cfg.padding,
|
|
&reproc_cfg.input_stream_plane_info);
|
|
break;
|
|
case CAM_STREAM_TYPE_RAW:
|
|
rc = mm_stream_calc_offset_raw(reproc_cfg.stream_format,
|
|
&reproc_cfg.input_stream_dim,
|
|
reproc_cfg.padding, &reproc_cfg.input_stream_plane_info);
|
|
break;
|
|
case CAM_STREAM_TYPE_SNAPSHOT:
|
|
case CAM_STREAM_TYPE_CALLBACK:
|
|
default:
|
|
rc = mm_stream_calc_offset_snapshot(streamFormat, &reproc_cfg.input_stream_dim,
|
|
reproc_cfg.padding, &reproc_cfg.input_stream_plane_info);
|
|
break;
|
|
}
|
|
if (rc != 0) {
|
|
LOGE("Stream %d plane info calculation failed!", mStreamType);
|
|
return rc;
|
|
}
|
|
LOGD("reprocess input dim %dx%d output dim %dx%d", reproc_cfg.input_stream_dim.width,
|
|
reproc_cfg.input_stream_dim.height,
|
|
reproc_cfg.output_stream_dim.width,
|
|
reproc_cfg.output_stream_dim.height);
|
|
IF_META_AVAILABLE(cam_hdr_param_t, hdr_info, CAM_INTF_PARM_HAL_BRACKETING_HDR, metadata) {
|
|
reproc_cfg.hdr_param = *hdr_info;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : reprocessCbRoutine
|
|
*
|
|
* DESCRIPTION: callback function for the reprocessed frame. This frame now
|
|
* should be returned to the framework
|
|
*
|
|
* PARAMETERS :
|
|
* @resultBuffer : buffer containing the reprocessed data
|
|
* @resultFrameNumber : frame number on which the buffer was requested
|
|
*
|
|
* RETURN : NONE
|
|
*
|
|
*==========================================================================*/
|
|
void QCamera3ProcessingChannel::reprocessCbRoutine(buffer_handle_t *resultBuffer,
|
|
uint32_t resultFrameNumber)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PROC_CH_REPROC_CB);
|
|
int rc = NO_ERROR;
|
|
|
|
LOGD("E resultFrameNumber: %d", resultFrameNumber);
|
|
rc = releaseOfflineMemory(resultFrameNumber);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error releasing offline memory %d", rc);
|
|
}
|
|
/* Since reprocessing is done, send the callback to release the input buffer */
|
|
if (mChannelCB) {
|
|
mChannelCB(NULL, NULL, resultFrameNumber, true, mUserData);
|
|
}
|
|
issueChannelCb(resultBuffer, resultFrameNumber);
|
|
|
|
return;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : issueChannelCb
|
|
*
|
|
* DESCRIPTION: function to set the result and issue channel callback
|
|
*
|
|
* PARAMETERS :
|
|
* @resultBuffer : buffer containing the data
|
|
* @resultFrameNumber : frame number on which the buffer was requested
|
|
*
|
|
* RETURN : NONE
|
|
*
|
|
*
|
|
*==========================================================================*/
|
|
void QCamera3ProcessingChannel::issueChannelCb(buffer_handle_t *resultBuffer,
|
|
uint32_t resultFrameNumber)
|
|
{
|
|
camera3_stream_buffer_t result;
|
|
//Use below data to issue framework callback
|
|
result.stream = mCamera3Stream;
|
|
result.buffer = resultBuffer;
|
|
result.status = CAMERA3_BUFFER_STATUS_OK;
|
|
result.acquire_fence = -1;
|
|
result.release_fence = -1;
|
|
|
|
if (mChannelCB) {
|
|
mChannelCB(NULL, &result, resultFrameNumber, false, mUserData);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : showDebugFPS
|
|
*
|
|
* DESCRIPTION: Function to log the fps for preview, video, callback and raw
|
|
* streams
|
|
*
|
|
* PARAMETERS : Stream type
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCamera3ProcessingChannel::showDebugFPS(int32_t streamType)
|
|
{
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
int cameraId = -1;
|
|
if (hal_obj != NULL) {
|
|
cameraId = hal_obj->getCameraId();
|
|
} else {
|
|
LOGE("Failed to get hal obj for cameraId");
|
|
}
|
|
|
|
double fps = 0;
|
|
mFrameCount++;
|
|
nsecs_t now = systemTime();
|
|
nsecs_t diff = now - mLastFpsTime;
|
|
if (diff > ms2ns(250)) {
|
|
fps = (((double)(mFrameCount - mLastFrameCount)) *
|
|
(double)(s2ns(1))) / (double)diff;
|
|
switch(streamType) {
|
|
case CAM_STREAM_TYPE_PREVIEW:
|
|
LOGH("PROFILE_PREVIEW_FRAMES_PER_SECOND CAMERA %d: %.4f: mFrameCount=%d",
|
|
cameraId, fps, mFrameCount);
|
|
break;
|
|
case CAM_STREAM_TYPE_VIDEO:
|
|
LOGH("PROFILE_VIDEO_FRAMES_PER_SECOND CAMERA %d: %.4f",
|
|
cameraId, fps);
|
|
break;
|
|
case CAM_STREAM_TYPE_CALLBACK:
|
|
LOGH("PROFILE_CALLBACK_FRAMES_PER_SECOND CAMERA %d: %.4f",
|
|
cameraId, fps);
|
|
break;
|
|
case CAM_STREAM_TYPE_RAW:
|
|
LOGH("PROFILE_RAW_FRAMES_PER_SECOND CAMERA %d: %.4f",
|
|
cameraId, fps);
|
|
break;
|
|
default:
|
|
LOGH("logging not supported for the stream");
|
|
break;
|
|
}
|
|
mLastFpsTime = now;
|
|
mLastFrameCount = mFrameCount;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseOfflineMemory
|
|
*
|
|
* DESCRIPTION: function to clean up the offline memory used for input reprocess
|
|
*
|
|
* PARAMETERS :
|
|
* @resultFrameNumber : frame number on which the buffer was requested
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* non-zero failure code
|
|
*
|
|
*
|
|
*==========================================================================*/
|
|
int32_t QCamera3ProcessingChannel::releaseOfflineMemory(uint32_t resultFrameNumber)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
int32_t inputBufIndex =
|
|
mOfflineMemory.getGrallocBufferIndex(resultFrameNumber);
|
|
if (0 <= inputBufIndex) {
|
|
rc = mOfflineMemory.unregisterBuffer(inputBufIndex);
|
|
} else {
|
|
LOGW("Could not find offline input buffer, resultFrameNumber %d",
|
|
resultFrameNumber);
|
|
}
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Failed to unregister offline input buffer");
|
|
}
|
|
|
|
int32_t metaBufIndex =
|
|
mOfflineMetaMemory.getHeapBufferIndex(resultFrameNumber);
|
|
if (0 <= metaBufIndex) {
|
|
Mutex::Autolock lock(mFreeOfflineMetaBuffersLock);
|
|
mFreeOfflineMetaBuffersList.push_back((uint32_t)metaBufIndex);
|
|
} else {
|
|
LOGW("Could not find offline meta buffer, resultFrameNumber %d",
|
|
resultFrameNumber);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3ProcessingChannel::releaseInputBuffer(uint32_t resultFrameNumber)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
int32_t inputBufIndex =
|
|
mOfflineMemory.getGrallocBufferIndex(resultFrameNumber);
|
|
if (0 <= inputBufIndex) {
|
|
rc = mOfflineMemory.unregisterBuffer(inputBufIndex);
|
|
} else {
|
|
LOGW("Could not find offline input buffer, resultFrameNumber %d",
|
|
resultFrameNumber);
|
|
}
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Failed to unregister offline input buffer");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
bool QCamera3ProcessingChannel::isFwkInputBuffer(uint32_t resultFrameNumber)
|
|
{
|
|
int32_t inputBufIndex =
|
|
mOfflineMemory.getGrallocBufferIndex(resultFrameNumber);
|
|
if (0 <= inputBufIndex)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
/* Regular Channel methods */
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3RegularChannel
|
|
*
|
|
* DESCRIPTION: constructor of QCamera3RegularChannel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : camera handle
|
|
* @cam_ops : ptr to camera ops table
|
|
* @cb_routine : callback routine to frame aggregator
|
|
* @stream : camera3_stream_t structure
|
|
* @stream_type: Channel stream type
|
|
* @postprocess_mask: feature mask for postprocessing
|
|
* @metadataChannel : metadata channel for the session
|
|
* @numBuffers : number of max dequeued buffers
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3RegularChannel::QCamera3RegularChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buffer_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
camera3_stream_t *stream,
|
|
cam_stream_type_t stream_type,
|
|
cam_feature_mask_t postprocess_mask,
|
|
QCamera3Channel *metadataChannel,
|
|
uint32_t numBuffers) :
|
|
QCamera3ProcessingChannel(cam_handle, channel_handle, cam_ops,
|
|
cb_routine, cb_buffer_err, paddingInfo, userData, stream, stream_type,
|
|
postprocess_mask, metadataChannel, numBuffers),
|
|
mBatchSize(0),
|
|
mRotation(ROTATE_0),
|
|
mAuxChannel(NULL)
|
|
{
|
|
cam_dimension_t dim = {0,0};
|
|
dim.width = stream->width;
|
|
dim.height = stream->height;
|
|
|
|
QCamera3HardwareInterface *hal_obj = (QCamera3HardwareInterface *)mUserData;
|
|
if(is_dual_camera_by_handle(cam_handle)
|
|
&& (!hal_obj->isPPMaskSetForScaling(postprocess_mask))
|
|
&& hal_obj->isAsymetricDim(dim)
|
|
&& (stream_type != CAM_STREAM_TYPE_RAW))
|
|
{
|
|
m_camHandle = get_main_camera_handle(cam_handle);
|
|
m_handle = get_main_camera_handle(channel_handle);
|
|
mAuxChannel = new QCamera3RegularChannel(get_aux_camera_handle(cam_handle),
|
|
get_aux_camera_handle(channel_handle),cam_ops, cb_routine,
|
|
cb_buffer_err, paddingInfo, userData, stream, stream_type,
|
|
postprocess_mask, metadataChannel, numBuffers);
|
|
setDualChannelMode(true);
|
|
}
|
|
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCamera3RegularChannel
|
|
*
|
|
* DESCRIPTION: destructor of QCamera3RegularChannel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3RegularChannel::~QCamera3RegularChannel()
|
|
{
|
|
destroy();
|
|
if(NULL != mAuxChannel)
|
|
{
|
|
delete mAuxChannel;
|
|
mAuxChannel = NULL;
|
|
}
|
|
}
|
|
|
|
void QCamera3RegularChannel::setDualChannelMode(bool bMode)
|
|
{
|
|
QCamera3Channel::setDualChannelMode(bMode);
|
|
if(NULL != mAuxChannel)
|
|
{
|
|
mAuxChannel->setDualChannelMode(bMode);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : initialize
|
|
*
|
|
* DESCRIPTION: Initialize and add camera channel & stream
|
|
*
|
|
* PARAMETERS :
|
|
* @isType : type of image stabilization required on this stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
|
|
int32_t QCamera3RegularChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_REG_CH_INIT);
|
|
int32_t rc = NO_ERROR;
|
|
|
|
cam_dimension_t streamDim;
|
|
|
|
if (NULL == mCamera3Stream) {
|
|
LOGE("Camera stream uninitialized");
|
|
return NO_INIT;
|
|
}
|
|
|
|
if (1 <= m_numStreams) {
|
|
// Only one stream per channel supported in v3 Hal
|
|
return NO_ERROR;
|
|
}
|
|
|
|
mIsType = isType;
|
|
|
|
rc = translateStreamTypeAndFormat(mCamera3Stream, mStreamType,
|
|
mStreamFormat);
|
|
if (rc != NO_ERROR) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
|
|
if ((mStreamType == CAM_STREAM_TYPE_VIDEO) ||
|
|
(mStreamType == CAM_STREAM_TYPE_PREVIEW)) {
|
|
if ((mCamera3Stream->rotation != CAMERA3_STREAM_ROTATION_0) &&
|
|
((mPostProcMask & CAM_QCOM_FEATURE_ROTATION) == 0)) {
|
|
LOGE("attempting rotation %d when rotation is disabled",
|
|
mCamera3Stream->rotation);
|
|
return -EINVAL;
|
|
}
|
|
|
|
switch (mCamera3Stream->rotation) {
|
|
case CAMERA3_STREAM_ROTATION_0:
|
|
mRotation = ROTATE_0;
|
|
break;
|
|
case CAMERA3_STREAM_ROTATION_90: {
|
|
mRotation = ROTATE_90;
|
|
break;
|
|
}
|
|
case CAMERA3_STREAM_ROTATION_180:
|
|
mRotation = ROTATE_180;
|
|
break;
|
|
case CAMERA3_STREAM_ROTATION_270: {
|
|
mRotation = ROTATE_270;
|
|
break;
|
|
}
|
|
default:
|
|
LOGE("Unknown rotation: %d",
|
|
mCamera3Stream->rotation);
|
|
return -EINVAL;
|
|
}
|
|
|
|
// Camera3/HAL3 spec expecting counter clockwise rotation but CPP HW is
|
|
// doing Clockwise rotation and so swap it.
|
|
if (mRotation == ROTATE_90) {
|
|
mRotation = ROTATE_270;
|
|
} else if (mRotation == ROTATE_270) {
|
|
mRotation = ROTATE_90;
|
|
}
|
|
|
|
} else if (mCamera3Stream->rotation != CAMERA3_STREAM_ROTATION_0) {
|
|
LOGE("Rotation %d is not supported by stream type %d",
|
|
mCamera3Stream->rotation,
|
|
mStreamType);
|
|
return -EINVAL;
|
|
}
|
|
|
|
streamDim.width = mCamera3Stream->width;
|
|
streamDim.height = mCamera3Stream->height;
|
|
|
|
//In DualCamera usecase for Asymetric mode
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if(m_bDualChannel && (mStreamType != CAM_STREAM_TYPE_RAW))
|
|
{
|
|
//if 2 channels are configure with different dimensions
|
|
//for low configuration don't change the stream dimension.
|
|
bool needUpScale;
|
|
hal_obj->rectifyStreamDimIfNeeded(
|
|
streamDim, (mAuxChannel != NULL) ? CAM_TYPE_MAIN: CAM_TYPE_AUX, needUpScale);
|
|
}
|
|
|
|
LOGD("batch size is %d", mBatchSize);
|
|
rc = QCamera3Channel::addStream(mStreamType,
|
|
mStreamFormat,
|
|
streamDim,
|
|
mRotation,
|
|
mNumBufs,
|
|
mPostProcMask,
|
|
mIsType,
|
|
mBatchSize);
|
|
|
|
if(NULL != mAuxChannel)
|
|
{
|
|
mAuxChannel->initialize(isType);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setBatchSize
|
|
*
|
|
* DESCRIPTION: Set batch size for the channel.
|
|
*
|
|
* PARAMETERS :
|
|
* @batchSize : Number of image buffers in a batch
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success always
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3RegularChannel::setBatchSize(uint32_t batchSize)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
mBatchSize = batchSize;
|
|
LOGD("Batch size set: %d", mBatchSize);
|
|
if(NULL != mAuxChannel) {
|
|
mAuxChannel->setBatchSize(batchSize);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3RegularChannel::overridePPConfig(cam_feature_mask_t pp_mask)
|
|
{
|
|
LOGD("overriding ppmask to %" PRIx64, pp_mask);
|
|
mPostProcMask = pp_mask;
|
|
if(NULL != mAuxChannel)
|
|
{
|
|
mAuxChannel->overridePPConfig(pp_mask);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamTypeMask
|
|
*
|
|
* DESCRIPTION: Get bit mask of all stream types in this channel.
|
|
* If stream is not initialized, then generate mask based on
|
|
* local streamType
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : Bit mask of all stream types in this channel
|
|
*==========================================================================*/
|
|
uint32_t QCamera3RegularChannel::getStreamTypeMask()
|
|
{
|
|
if (mStreams[0]) {
|
|
return QCamera3Channel::getStreamTypeMask();
|
|
} else {
|
|
return (1U << mStreamType);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : queueBatchBuf
|
|
*
|
|
* DESCRIPTION: queue batch container to downstream
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success always
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3RegularChannel::queueBatchBuf()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if (mStreams[0]) {
|
|
rc = mStreams[0]->queueBatchBuf();
|
|
}
|
|
if (rc != NO_ERROR) {
|
|
LOGE("stream->queueBatchContainer failed");
|
|
}
|
|
|
|
if(NULL != mAuxChannel)
|
|
rc = mAuxChannel->queueBatchBuf();
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : request
|
|
*
|
|
* DESCRIPTION: process a request from camera service. Stream on if ncessary.
|
|
*
|
|
* PARAMETERS :
|
|
* @buffer : buffer to be filled for this request
|
|
*
|
|
* RETURN : 0 on a success start of capture
|
|
* -EINVAL on invalid input
|
|
* -ENODEV on serious error
|
|
*==========================================================================*/
|
|
int32_t QCamera3RegularChannel::request(buffer_handle_t *buffer, uint32_t frameNumber, int &indexUsed)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_REG_CH_REQ);
|
|
//FIX ME: Return buffer back in case of failures below.
|
|
|
|
int32_t rc = NO_ERROR;
|
|
int index;
|
|
|
|
if (NULL == buffer) {
|
|
LOGE("Invalid buffer in channel request");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
bool bIsMaster = true;
|
|
if(m_bDualChannel)
|
|
{
|
|
bIsMaster = (mAuxChannel != NULL) ? (mMasterCam == CAM_TYPE_MAIN)
|
|
: (mMasterCam == CAM_TYPE_AUX);
|
|
}
|
|
if(bIsMaster)
|
|
{
|
|
if(!m_bIsActive) {
|
|
rc = registerBuffer(buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
rc = start();
|
|
if (NO_ERROR != rc) {
|
|
return rc;
|
|
}
|
|
} else {
|
|
LOGD("Request on an existing stream");
|
|
}
|
|
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if(index < 0) {
|
|
rc = registerBuffer(buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if (index < 0) {
|
|
LOGE("Could not find object among registered buffers");
|
|
return DEAD_OBJECT;
|
|
}
|
|
}
|
|
|
|
rc = mMemory.markFrameNumber((uint32_t)index, frameNumber);
|
|
if(rc != NO_ERROR) {
|
|
LOGE("Failed to mark FrameNumber:%d,idx:%d",frameNumber,index);
|
|
return rc;
|
|
}
|
|
rc = mStreams[0]->bufDone((uint32_t)index);
|
|
if(rc != NO_ERROR) {
|
|
LOGE("Failed to Q new buffer to stream");
|
|
mMemory.markFrameNumber(index, -1);
|
|
return rc;
|
|
}
|
|
|
|
indexUsed = index;
|
|
} else if(NULL != mAuxChannel) {
|
|
mAuxChannel->request(buffer, frameNumber, indexUsed);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getReprocessType
|
|
*
|
|
* DESCRIPTION: get the type of reprocess output supported by this channel
|
|
*
|
|
* PARAMETERS : NONE
|
|
*
|
|
* RETURN : reprocess_type_t : type of reprocess
|
|
*==========================================================================*/
|
|
reprocess_type_t QCamera3RegularChannel::getReprocessType()
|
|
{
|
|
return REPROCESS_TYPE_PRIVATE;
|
|
}
|
|
|
|
void QCamera3RegularChannel::switchMaster(uint32_t masterCam)
|
|
{
|
|
if(m_bDualChannel)
|
|
{
|
|
mMasterCam = masterCam;
|
|
if(NULL != mAuxChannel)
|
|
mAuxChannel->switchMaster(masterCam);
|
|
} else {
|
|
QCamera3Channel::switchMaster(masterCam);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setBundleInfo
|
|
*
|
|
* DESCRIPTION: setting bundle information in stream params
|
|
*
|
|
* PARAMETERS :
|
|
* @bundleInfo : stream bundle information.
|
|
* @cam_type : MAIN or AUX.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3RegularChannel::setBundleInfo(
|
|
const cam_bundle_config_t &bundleInfo, uint32_t cam_type)
|
|
{
|
|
if(m_bDualChannel)
|
|
{
|
|
if ((cam_type == CAM_TYPE_AUX) && (NULL != mAuxChannel)) {
|
|
return mAuxChannel->setBundleInfo(bundleInfo);
|
|
}
|
|
int32_t rc = NO_ERROR;
|
|
cam_stream_parm_buffer_t param;
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_SET_BUNDLE_INFO;
|
|
param.bundleInfo = bundleInfo;
|
|
if (m_numStreams > 0 && mStreams[0]) {
|
|
rc = mStreams[0]->setParameter(param, cam_type);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("stream setParameter for set bundle failed");
|
|
}
|
|
}
|
|
return rc;
|
|
}else {
|
|
return QCamera3Channel::setBundleInfo(bundleInfo, cam_type);
|
|
}
|
|
|
|
}
|
|
|
|
QCamera3MetadataChannel::QCamera3MetadataChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buffer_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
cam_feature_mask_t postprocess_mask,
|
|
void *userData, uint32_t numBuffers) :
|
|
QCamera3Channel(cam_handle, channel_handle, cam_ops,
|
|
cb_routine, cb_buffer_err, paddingInfo, postprocess_mask,
|
|
userData, numBuffers),
|
|
mMemory(NULL)
|
|
{
|
|
}
|
|
|
|
QCamera3MetadataChannel::~QCamera3MetadataChannel()
|
|
{
|
|
destroy();
|
|
|
|
if (mMemory) {
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
}
|
|
|
|
int32_t QCamera3MetadataChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_METADATA_CH_INIT);
|
|
int32_t rc;
|
|
cam_dimension_t streamDim;
|
|
|
|
if (mMemory || m_numStreams > 0) {
|
|
LOGE("metadata channel already initialized");
|
|
return -EINVAL;
|
|
}
|
|
|
|
streamDim.width = (int32_t)sizeof(metadata_buffer_t),
|
|
streamDim.height = 1;
|
|
|
|
mIsType = isType;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
bool needBundledMeta = hal_obj->isHALZSLEnabled();
|
|
rc = QCamera3Channel::addStream(CAM_STREAM_TYPE_METADATA, CAM_FORMAT_MAX,
|
|
streamDim, ROTATE_0, (uint8_t)mNumBuffers, mPostProcMask, mIsType, 0, true, needBundledMeta);
|
|
if (rc < 0) {
|
|
LOGE("addStream failed");
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3MetadataChannel::request(buffer_handle_t * /*buffer*/,
|
|
uint32_t /*frameNumber*/,
|
|
int& /*indexUsed*/)
|
|
{
|
|
if (!m_bIsActive) {
|
|
return start();
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
void QCamera3MetadataChannel::streamCbRoutine(
|
|
mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream * /*stream*/)
|
|
{
|
|
ATRACE_NAME("metadata_stream_cb_routine");
|
|
uint32_t requestNumber = 0;
|
|
if (super_frame == NULL || super_frame->num_bufs != 1) {
|
|
LOGE("super_frame is not valid");
|
|
return;
|
|
}
|
|
if (mChannelCB) {
|
|
mChannelCB(super_frame, NULL, requestNumber, false, mUserData);
|
|
}
|
|
}
|
|
|
|
QCamera3StreamMem* QCamera3MetadataChannel::getStreamBufs(uint32_t len)
|
|
{
|
|
int rc;
|
|
if (len < sizeof(metadata_buffer_t)) {
|
|
LOGE("Metadata buffer size less than structure %d vs %d",
|
|
len,
|
|
sizeof(metadata_buffer_t));
|
|
return NULL;
|
|
}
|
|
|
|
uint32_t numBufs = MIN_STREAMING_BUFFER_NUM;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if (hal_obj && hal_obj->isDualCamera()) {
|
|
//Allocate equal no. of meta buffers for aux session
|
|
numBufs += MIN_STREAMING_BUFFER_NUM;
|
|
}
|
|
|
|
mMemory = new QCamera3StreamMem(numBufs);
|
|
if (!mMemory) {
|
|
LOGE("unable to create metadata memory");
|
|
return NULL;
|
|
}
|
|
rc = mMemory->allocateAll(len);
|
|
if (rc < 0) {
|
|
LOGE("unable to allocate metadata memory");
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
return NULL;
|
|
}
|
|
clear_metadata_buffer((metadata_buffer_t*)mMemory->getPtr(0));
|
|
return mMemory;
|
|
}
|
|
|
|
void QCamera3MetadataChannel::putStreamBufs()
|
|
{
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
|
|
/*************************************************************************************/
|
|
// DEPTH Channel related functions
|
|
QCamera3DepthChannel::QCamera3DepthChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buffer_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
camera3_stream_t *stream,
|
|
cam_feature_mask_t postprocess_mask,
|
|
QCamera3Channel *metadataChannel,
|
|
int32_t numDepthPoints, uint32_t numBuffers) :
|
|
QCamera3RegularChannel(cam_handle, channel_handle, cam_ops,
|
|
cb_routine, cb_buffer_err, paddingInfo, userData, stream,
|
|
CAM_STREAM_TYPE_DEPTH, postprocess_mask,
|
|
metadataChannel, numBuffers)
|
|
{
|
|
mNumDepthPoints = numDepthPoints;
|
|
}
|
|
|
|
QCamera3DepthChannel::~QCamera3DepthChannel()
|
|
{
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : initialize
|
|
*
|
|
* DESCRIPTION: Initialize and add camera channel & stream
|
|
*
|
|
* PARAMETERS :
|
|
* @isType : image stabilization type on the stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
|
|
int32_t QCamera3DepthChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
return QCamera3RegularChannel::initialize(isType);
|
|
}
|
|
|
|
void QCamera3DepthChannel::streamCbRoutine(
|
|
mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream * stream)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_RAW_CH_STRM_CB);
|
|
QCamera3RegularChannel::streamCbRoutine(super_frame, stream);
|
|
return;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getReprocessType
|
|
*
|
|
* DESCRIPTION: get the type of reprocess output supported by this channel
|
|
*
|
|
* PARAMETERS : NONE
|
|
*
|
|
* RETURN : reprocess_type_t : type of reprocess
|
|
*==========================================================================*/
|
|
reprocess_type_t QCamera3DepthChannel::getReprocessType()
|
|
{
|
|
return REPROCESS_TYPE_NONE;
|
|
}
|
|
|
|
/*************************************************************************************/
|
|
// RAW Channel related functions
|
|
QCamera3RawChannel::QCamera3RawChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buffer_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
camera3_stream_t *stream,
|
|
cam_feature_mask_t postprocess_mask,
|
|
QCamera3Channel *metadataChannel,
|
|
bool raw_16, uint32_t numBuffers) :
|
|
QCamera3RegularChannel(cam_handle, channel_handle, cam_ops,
|
|
cb_routine, cb_buffer_err, paddingInfo, userData, stream,
|
|
CAM_STREAM_TYPE_RAW, postprocess_mask,
|
|
metadataChannel, numBuffers),
|
|
mIsRaw16(raw_16)
|
|
{
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
property_get("persist.vendor.camera.raw.debug.dump", prop, "0");
|
|
mRawDump = atoi(prop);
|
|
}
|
|
|
|
QCamera3RawChannel::~QCamera3RawChannel()
|
|
{
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : initialize
|
|
*
|
|
* DESCRIPTION: Initialize and add camera channel & stream
|
|
*
|
|
* PARAMETERS :
|
|
* @isType : image stabilization type on the stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3RawChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
return QCamera3RegularChannel::initialize(isType);
|
|
}
|
|
|
|
void QCamera3RawChannel::streamCbRoutine(
|
|
mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream * stream)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_RAW_CH_STRM_CB);
|
|
/* Move this back down once verified */
|
|
if (mRawDump)
|
|
dumpRawSnapshot(super_frame->bufs[0]);
|
|
|
|
if (mIsRaw16) {
|
|
cam_format_t streamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_RAW,
|
|
mCamera3Stream->width, mCamera3Stream->height);
|
|
if (streamFormat >= CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG &&
|
|
streamFormat <= CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR)
|
|
convertMipiToRaw16(super_frame->bufs[0]);
|
|
else
|
|
convertLegacyToRaw16(super_frame->bufs[0]);
|
|
//Make sure cache coherence because extra processing is done
|
|
mMemory.cleanInvalidateCache(super_frame->bufs[0]->buf_idx);
|
|
}
|
|
|
|
QCamera3RegularChannel::streamCbRoutine(super_frame, stream);
|
|
return;
|
|
}
|
|
|
|
void QCamera3RawChannel::dumpRawSnapshot(mm_camera_buf_def_t *frame)
|
|
{
|
|
QCamera3Stream *stream = getStreamByIndex(0);
|
|
if (stream != NULL) {
|
|
char buf[FILENAME_MAX];
|
|
memset(buf, 0, sizeof(buf));
|
|
cam_dimension_t dim;
|
|
memset(&dim, 0, sizeof(dim));
|
|
stream->getFrameDimension(dim);
|
|
|
|
cam_frame_len_offset_t offset;
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
stream->getFrameOffset(offset);
|
|
snprintf(buf, sizeof(buf), QCAMERA_DUMP_FRM_LOCATION"r_%d_%dx%d.raw",
|
|
frame->frame_idx, offset.mp[0].stride, offset.mp[0].scanline);
|
|
|
|
int file_fd = open(buf, O_RDWR| O_CREAT, 0644);
|
|
if (file_fd >= 0) {
|
|
ssize_t written_len = write(file_fd, frame->buffer, frame->frame_len);
|
|
LOGD("written number of bytes %zd", written_len);
|
|
frame->cache_flags |= CPU_HAS_READ;
|
|
close(file_fd);
|
|
} else {
|
|
LOGE("failed to open file to dump image");
|
|
}
|
|
} else {
|
|
LOGE("Could not find stream");
|
|
}
|
|
|
|
if(frame->cache_flags != 0)
|
|
{
|
|
//Make sure cache coherence because extra processing is done
|
|
mMemory.cleanInvalidateCache(frame->buf_idx);
|
|
frame->cache_flags = 0;
|
|
}
|
|
|
|
}
|
|
|
|
void QCamera3RawChannel::convertLegacyToRaw16(mm_camera_buf_def_t *frame)
|
|
{
|
|
// Convert image buffer from Opaque raw format to RAW16 format
|
|
// 10bit Opaque raw is stored in the format of:
|
|
// 0000 - p5 - p4 - p3 - p2 - p1 - p0
|
|
// where p0 to p5 are 6 pixels (each is 10bit)_and most significant
|
|
// 4 bits are 0s. Each 64bit word contains 6 pixels.
|
|
|
|
QCamera3Stream *stream = getStreamByIndex(0);
|
|
if (stream != NULL) {
|
|
cam_dimension_t dim;
|
|
memset(&dim, 0, sizeof(dim));
|
|
stream->getFrameDimension(dim);
|
|
|
|
cam_frame_len_offset_t offset;
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
stream->getFrameOffset(offset);
|
|
|
|
uint32_t raw16_stride = ((uint32_t)dim.width + 15U) & ~15U;
|
|
uint16_t* raw16_buffer = (uint16_t *)frame->buffer;
|
|
|
|
// In-place format conversion.
|
|
// Raw16 format always occupy more memory than opaque raw10.
|
|
// Convert to Raw16 by iterating through all pixels from bottom-right
|
|
// to top-left of the image.
|
|
// One special notes:
|
|
// 1. Cross-platform raw16's stride is 16 pixels.
|
|
// 2. Opaque raw10's stride is 6 pixels, and aligned to 16 bytes.
|
|
for (int32_t ys = dim.height - 1; ys >= 0; ys--) {
|
|
uint32_t y = (uint32_t)ys;
|
|
uint64_t* row_start = (uint64_t *)frame->buffer +
|
|
y * (uint32_t)offset.mp[0].stride_in_bytes / 8;
|
|
for (int32_t xs = dim.width - 1; xs >= 0; xs--) {
|
|
uint32_t x = (uint32_t)xs;
|
|
uint16_t raw16_pixel = 0x3FF & (row_start[x/6] >> (10*(x%6)));
|
|
raw16_buffer[y*raw16_stride+x] = raw16_pixel;
|
|
}
|
|
}
|
|
} else {
|
|
LOGE("Could not find stream");
|
|
}
|
|
|
|
}
|
|
|
|
void QCamera3RawChannel::convertMipiToRaw16(mm_camera_buf_def_t *frame)
|
|
{
|
|
// Convert image buffer from mipi10 raw format to RAW16 format
|
|
// mipi10 opaque raw is stored in the format of:
|
|
// P3(1:0) P2(1:0) P1(1:0) P0(1:0) P3(9:2) P2(9:2) P1(9:2) P0(9:2)
|
|
// 4 pixels occupy 5 bytes, no padding needed
|
|
|
|
QCamera3Stream *stream = getStreamByIndex(0);
|
|
if (stream != NULL) {
|
|
cam_dimension_t dim;
|
|
memset(&dim, 0, sizeof(dim));
|
|
stream->getFrameDimension(dim);
|
|
|
|
cam_frame_len_offset_t offset;
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
stream->getFrameOffset(offset);
|
|
|
|
uint32_t raw16_stride = ((uint32_t)dim.width + 15U) & ~15U;
|
|
uint16_t* raw16_buffer = (uint16_t *)frame->buffer;
|
|
uint8_t first_quintuple[5];
|
|
memcpy(first_quintuple, raw16_buffer, sizeof(first_quintuple));
|
|
|
|
// In-place format conversion.
|
|
// Raw16 format always occupy more memory than opaque raw10.
|
|
// Convert to Raw16 by iterating through all pixels from bottom-right
|
|
// to top-left of the image.
|
|
// One special notes:
|
|
// 1. Cross-platform raw16's stride is 16 pixels.
|
|
// 2. mipi raw10's stride is 4 pixels, and aligned to 16 bytes.
|
|
for (int32_t ys = dim.height - 1; ys >= 0; ys--) {
|
|
uint32_t y = (uint32_t)ys;
|
|
uint8_t* row_start = (uint8_t *)frame->buffer +
|
|
y * (uint32_t)offset.mp[0].stride_in_bytes;
|
|
for (int32_t xs = dim.width - 1; xs >= 0; xs--) {
|
|
uint32_t x = (uint32_t)xs;
|
|
uint8_t upper_8bit = row_start[5*(x/4)+x%4];
|
|
uint8_t lower_2bit = ((row_start[5*(x/4)+4] >> ((x%4) << 1)) & 0x3);
|
|
uint16_t raw16_pixel =
|
|
(uint16_t)(((uint16_t)upper_8bit)<<2 |
|
|
(uint16_t)lower_2bit);
|
|
raw16_buffer[y*raw16_stride+x] = raw16_pixel;
|
|
}
|
|
}
|
|
|
|
// Re-convert the first 2 pixels of the buffer because the loop above messes
|
|
// them up by reading the first quintuple while modifying it.
|
|
raw16_buffer[0] = ((uint16_t)first_quintuple[0]<<2) | (first_quintuple[4] & 0x3);
|
|
raw16_buffer[1] = ((uint16_t)first_quintuple[1]<<2) | ((first_quintuple[4] >> 2) & 0x3);
|
|
|
|
} else {
|
|
LOGE("Could not find stream");
|
|
}
|
|
|
|
}
|
|
|
|
int32_t QCamera3RawChannel::start()
|
|
{
|
|
int32_t ret = NO_ERROR;
|
|
ret = QCamera3Channel::start();
|
|
if(mAuxChannel && ret == NO_ERROR)
|
|
ret = mAuxChannel->start();
|
|
return ret;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getReprocessType
|
|
*
|
|
* DESCRIPTION: get the type of reprocess output supported by this channel
|
|
*
|
|
* PARAMETERS : NONE
|
|
*
|
|
* RETURN : reprocess_type_t : type of reprocess
|
|
*==========================================================================*/
|
|
reprocess_type_t QCamera3RawChannel::getReprocessType()
|
|
{
|
|
return REPROCESS_TYPE_RAW;
|
|
}
|
|
|
|
|
|
/*************************************************************************************/
|
|
// RAW Dump Channel related functions
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3RawDumpChannel
|
|
*
|
|
* DESCRIPTION: Constructor for RawDumpChannel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : Handle for Camera
|
|
* @cam_ops : Function pointer table
|
|
* @rawDumpSize : Dimensions for the Raw stream
|
|
* @paddinginfo : Padding information for stream
|
|
* @userData : Cookie for parent
|
|
* @pp mask : PP feature mask for this stream
|
|
* @numBuffers : number of max dequeued buffers
|
|
*
|
|
* RETURN : NA
|
|
*==========================================================================*/
|
|
QCamera3RawDumpChannel::QCamera3RawDumpChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
cam_dimension_t rawDumpSize,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
cam_feature_mask_t postprocess_mask, uint32_t numBuffers) :
|
|
QCamera3Channel(cam_handle, channel_handle, cam_ops, NULL,
|
|
NULL, paddingInfo, postprocess_mask,
|
|
userData, numBuffers),
|
|
mDim(rawDumpSize),
|
|
mMemory(NULL)
|
|
{
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
property_get("persist.vendor.camera.raw.dump", prop, "0");
|
|
mRawDump = atoi(prop);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3RawDumpChannel
|
|
*
|
|
* DESCRIPTION: Destructor for RawDumpChannel
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : NA
|
|
*==========================================================================*/
|
|
|
|
QCamera3RawDumpChannel::~QCamera3RawDumpChannel()
|
|
{
|
|
destroy();
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : dumpRawSnapshot
|
|
*
|
|
* DESCRIPTION: Helper function to dump Raw frames
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : stream buf frame to be dumped
|
|
*
|
|
* RETURN : NA
|
|
*==========================================================================*/
|
|
void QCamera3RawDumpChannel::dumpRawSnapshot(mm_camera_buf_def_t *frame)
|
|
{
|
|
QCamera3Stream *stream = getStreamByIndex(0);
|
|
if (stream != NULL) {
|
|
char buf[FILENAME_MAX];
|
|
struct timeval tv;
|
|
struct tm timeinfo_data;
|
|
struct tm *timeinfo;
|
|
|
|
cam_dimension_t dim;
|
|
memset(&dim, 0, sizeof(dim));
|
|
stream->getFrameDimension(dim);
|
|
|
|
cam_frame_len_offset_t offset;
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
stream->getFrameOffset(offset);
|
|
|
|
gettimeofday(&tv, NULL);
|
|
timeinfo = localtime_r(&tv.tv_sec, &timeinfo_data);
|
|
|
|
if (NULL != timeinfo) {
|
|
memset(buf, 0, sizeof(buf));
|
|
snprintf(buf, sizeof(buf),
|
|
QCAMERA_DUMP_FRM_LOCATION
|
|
"%04d-%02d-%02d-%02d-%02d-%02d-%06ld_%d_%dx%d.raw",
|
|
timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
|
|
timeinfo->tm_mday, timeinfo->tm_hour,
|
|
timeinfo->tm_min, timeinfo->tm_sec,tv.tv_usec,
|
|
frame->frame_idx, dim.width, dim.height);
|
|
|
|
int file_fd = open(buf, O_RDWR| O_CREAT, 0777);
|
|
if (file_fd >= 0) {
|
|
ssize_t written_len =
|
|
write(file_fd, frame->buffer, offset.frame_len);
|
|
LOGD("written number of bytes %zd", written_len);
|
|
frame->cache_flags |= CPU_HAS_READ;
|
|
close(file_fd);
|
|
} else {
|
|
LOGE("failed to open file to dump image");
|
|
}
|
|
} else {
|
|
LOGE("localtime_r() error");
|
|
}
|
|
} else {
|
|
LOGE("Could not find stream");
|
|
}
|
|
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : streamCbRoutine
|
|
*
|
|
* DESCRIPTION: Callback routine invoked for each frame generated for
|
|
* Rawdump channel
|
|
*
|
|
* PARAMETERS :
|
|
* @super_frame : stream buf frame generated
|
|
* @stream : Underlying Stream object cookie
|
|
*
|
|
* RETURN : NA
|
|
*==========================================================================*/
|
|
void QCamera3RawDumpChannel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
__unused QCamera3Stream *stream)
|
|
{
|
|
LOGD("E");
|
|
if (super_frame == NULL || super_frame->num_bufs != 1) {
|
|
LOGE("super_frame is not valid");
|
|
return;
|
|
}
|
|
|
|
if (mRawDump)
|
|
dumpRawSnapshot(super_frame->bufs[0]);
|
|
|
|
bufDone(super_frame);
|
|
free(super_frame);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamBufs
|
|
*
|
|
* DESCRIPTION: Callback function provided to interface to get buffers.
|
|
*
|
|
* PARAMETERS :
|
|
* @len : Length of each buffer to be allocated
|
|
*
|
|
* RETURN : NULL on buffer allocation failure
|
|
* QCamera3StreamMem object on sucess
|
|
*==========================================================================*/
|
|
QCamera3StreamMem* QCamera3RawDumpChannel::getStreamBufs(uint32_t len)
|
|
{
|
|
int rc;
|
|
uint32_t numBufs = mNumBuffers;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if (hal_obj && hal_obj->isDualCamera()) {
|
|
//Allocate equal no. of buffers for aux session
|
|
numBufs += mNumBuffers;
|
|
}
|
|
mMemory = new QCamera3StreamMem(numBufs, true, isSecureMode());
|
|
|
|
if (!mMemory) {
|
|
LOGE("unable to create heap memory");
|
|
return NULL;
|
|
}
|
|
rc = mMemory->allocateAll((size_t)len);
|
|
if (rc < 0) {
|
|
LOGE("unable to allocate heap memory");
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
return NULL;
|
|
}
|
|
return mMemory;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : putStreamBufs
|
|
*
|
|
* DESCRIPTION: Callback function provided to interface to return buffers.
|
|
* Although no handles are actually returned, implicitl assumption
|
|
* that interface will no longer use buffers and channel can
|
|
* deallocated if necessary.
|
|
*
|
|
* PARAMETERS : NA
|
|
*
|
|
* RETURN : NA
|
|
*==========================================================================*/
|
|
void QCamera3RawDumpChannel::putStreamBufs()
|
|
{
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : request
|
|
*
|
|
* DESCRIPTION: Request function used as trigger
|
|
*
|
|
* PARAMETERS :
|
|
* @recvd_frame : buffer- this will be NULL since this is internal channel
|
|
* @frameNumber : Undefined again since this is internal stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3RawDumpChannel::request(buffer_handle_t * /*buffer*/,
|
|
uint32_t /*frameNumber*/,
|
|
int & /*indexUsed*/)
|
|
{
|
|
if (!m_bIsActive) {
|
|
return QCamera3Channel::start();
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : intialize
|
|
*
|
|
* DESCRIPTION: Initializes channel params and creates underlying stream
|
|
*
|
|
* PARAMETERS :
|
|
* @isType : type of image stabilization required on this stream
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3RawDumpChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
int32_t rc;
|
|
|
|
mIsType = isType;
|
|
rc = QCamera3Channel::addStream(CAM_STREAM_TYPE_RAW,
|
|
CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG, mDim, ROTATE_0, (uint8_t)mNumBuffers,
|
|
mPostProcMask, mIsType);
|
|
if (rc < 0) {
|
|
LOGE("addStream failed");
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*************************************************************************************/
|
|
// Quadra CFA Raw Channel related functions
|
|
|
|
QCamera3QCfaCaptureChannel::QCamera3QCfaCaptureChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
cam_dimension_t snapshotSize,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
cam_feature_mask_t postprocess_mask, bool inSensorQcfa, uint32_t numBuffers) :
|
|
QCamera3Channel(cam_handle, channel_handle, cam_ops, NULL,
|
|
NULL, paddingInfo, postprocess_mask,
|
|
userData, numBuffers),
|
|
mDim(snapshotSize),
|
|
mMemory(NULL),
|
|
m_metaMem(NULL),
|
|
m_frameNumber(0),
|
|
m_bInSensorQcfa(inSensorQcfa)
|
|
|
|
{
|
|
svr_stream_id = 0;
|
|
|
|
data_received = false;
|
|
memset(&capture_frame, 0, sizeof(mm_camera_super_buf_t));
|
|
|
|
meta_received = false;
|
|
memset(&meta_frame, 0, sizeof(mm_camera_super_buf_t));
|
|
|
|
cam_sem_init(&m_syncSem, 0);
|
|
}
|
|
|
|
QCamera3QCfaCaptureChannel::~QCamera3QCfaCaptureChannel()
|
|
{
|
|
destroy();
|
|
if (mMemory != NULL) {
|
|
LOGD("deallocate stream buffers");
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
if (m_metaMem != NULL) {
|
|
LOGD("deallocate local meta buffer");
|
|
m_metaMem->deallocate();
|
|
delete m_metaMem;
|
|
m_metaMem = NULL;
|
|
}
|
|
|
|
cam_sem_destroy(&m_syncSem);
|
|
}
|
|
|
|
void QCamera3QCfaCaptureChannel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream)
|
|
{
|
|
LOGD("E");
|
|
if (super_frame == NULL || super_frame->num_bufs != 1) {
|
|
LOGE("super_frame is not valid");
|
|
return;
|
|
}
|
|
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if (hal_obj->m_bQuadraCfaRequest) {
|
|
LOGH("store quadra cfa raw frame");
|
|
capture_frame = *super_frame;
|
|
capture_buf_def = *(super_frame->bufs[0]);
|
|
capture_frame.bufs[0] = &capture_buf_def;
|
|
data_received = true;
|
|
|
|
if (data_received && meta_received) {
|
|
notifyCaptureDone();
|
|
}
|
|
if(m_bInSensorQcfa) {
|
|
cam_dimension_t dim;
|
|
cam_frame_len_offset_t offset;
|
|
stream->getFrameDimension(dim);
|
|
stream->getFrameOffset(offset);
|
|
dumpYUV(super_frame->bufs[0], dim, offset, QCAMERA_DUMP_FRM_INPUT_REPROCESS);
|
|
}
|
|
} else {
|
|
bufDone(super_frame);
|
|
}
|
|
|
|
free(super_frame);
|
|
}
|
|
|
|
QCamera3StreamMem* QCamera3QCfaCaptureChannel::getStreamBufs(uint32_t len)
|
|
{
|
|
int rc;
|
|
mMemory = new QCamera3StreamMem(mNumBuffers, true, isSecureMode());
|
|
if (!mMemory) {
|
|
LOGE("unable to create heap memory");
|
|
return NULL;
|
|
}
|
|
rc = mMemory->allocateAll((size_t)len);
|
|
if (rc < 0) {
|
|
LOGE("unable to allocate heap memory");
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
return mMemory;
|
|
}
|
|
|
|
void QCamera3QCfaCaptureChannel::putStreamBufs()
|
|
{
|
|
LOGD("E. don't release the memory.");
|
|
}
|
|
|
|
int32_t QCamera3QCfaCaptureChannel::request(buffer_handle_t *, uint32_t frameNumber, int &)
|
|
{
|
|
int32_t rc = 0;
|
|
if (!m_bIsActive) {
|
|
rc = QCamera3Channel::start();
|
|
}
|
|
|
|
LOGD("frame number:%d", frameNumber);
|
|
m_frameNumber = frameNumber;
|
|
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3QCfaCaptureChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
int32_t rc;
|
|
|
|
mIsType = isType;
|
|
|
|
cam_format_t StreamFormat;
|
|
cam_stream_type_t StreamType;
|
|
if(m_bInSensorQcfa) {
|
|
StreamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_SNAPSHOT,mDim.width, mDim.height);
|
|
StreamType = CAM_STREAM_TYPE_SNAPSHOT;
|
|
} else {
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
StreamFormat = hal_obj->mRdiModeFmt;
|
|
StreamType = CAM_STREAM_TYPE_RAW;
|
|
}
|
|
|
|
rc = QCamera3Channel::addStream(StreamType,StreamFormat, mDim, ROTATE_0, (uint8_t)mNumBuffers, mPostProcMask, mIsType);
|
|
if (rc < 0) {
|
|
LOGE("addStream failed");
|
|
}
|
|
|
|
svr_stream_id = mStreams[0]->getMyServerID();
|
|
LOGD("stream server id:%d", svr_stream_id);
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3QCfaCaptureChannel::queueReprocMetadata(mm_camera_super_buf_t *metadata,
|
|
cam_frame_len_offset_t &offset, bool urgent)
|
|
{
|
|
LOGD("E. urgen meta:%d", urgent);
|
|
metadata_buffer_t *p_metadata = (metadata_buffer_t *)(metadata->bufs[0]->buffer);
|
|
uint32_t *p_frame_number = POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER, p_metadata);
|
|
|
|
if (urgent) {
|
|
uint32_t *p_urgent_frame_number =
|
|
POINTER_OF_META(CAM_INTF_META_URGENT_FRAME_NUMBER, p_metadata);
|
|
if (p_urgent_frame_number == NULL || *p_urgent_frame_number != m_frameNumber) {
|
|
LOGE("frame number not match!");
|
|
return -1;
|
|
}
|
|
memcpy(&urgent_meta, p_metadata, sizeof(metadata_buffer_t));
|
|
} else {
|
|
if (p_frame_number == NULL || *p_frame_number != m_frameNumber) {
|
|
return -1;
|
|
}
|
|
|
|
/* allocate meta buffre here and copy the content of metadata,
|
|
* as the original meta channel will be deleted
|
|
*/
|
|
m_metaMem = new QCamera3StreamMem(1);
|
|
if (!m_metaMem) {
|
|
LOGE("unable to create memory for meta");
|
|
return -1;
|
|
}
|
|
m_metaMem->allocateAll((size_t)metadata->bufs[0]->frame_len);
|
|
m_metaMem->getBufDef(offset, meta_buf, 0);
|
|
memcpy(meta_buf.buffer, metadata->bufs[0]->buffer, sizeof(metadata_buffer_t));
|
|
|
|
meta_frame = *metadata;
|
|
meta_frame.bufs[0] = &meta_buf;
|
|
|
|
meta_received = true;
|
|
if (data_received && meta_received) {
|
|
notifyCaptureDone();
|
|
}
|
|
}
|
|
|
|
LOGD("X");
|
|
return 0;
|
|
}
|
|
|
|
void QCamera3QCfaCaptureChannel::notifyCaptureDone()
|
|
{
|
|
cam_sem_post(&m_syncSem);
|
|
}
|
|
|
|
void QCamera3QCfaCaptureChannel::waitCaptureDone()
|
|
{
|
|
cam_sem_wait(&m_syncSem);
|
|
}
|
|
|
|
|
|
QCamera3MultiRawChannel::QCamera3MultiRawChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
cam_dimension_t rawDumpSize,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
cam_feature_mask_t postprocess_mask, uint32_t numBuffers) :
|
|
QCamera3Channel(cam_handle, channel_handle, cam_ops, NULL,
|
|
NULL, paddingInfo, postprocess_mask,
|
|
userData, numBuffers),
|
|
mDim(rawDumpSize),
|
|
mMemory(NULL),
|
|
m_metaMem(NULL),
|
|
m_frameNumber(0)
|
|
{
|
|
svr_stream_id = 0;
|
|
|
|
raw_received = false;
|
|
memset(&raw_frame, 0, sizeof(mm_camera_super_buf_t));
|
|
|
|
meta_received = false;
|
|
memset(&meta_frame, 0, sizeof(mm_camera_super_buf_t));
|
|
|
|
cam_sem_init(&m_syncSem, 0);
|
|
}
|
|
|
|
QCamera3MultiRawChannel::~QCamera3MultiRawChannel()
|
|
{
|
|
destroy();
|
|
if (mMemory != NULL) {
|
|
LOGD("deallocate stream buffers");
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
if (m_metaMem != NULL) {
|
|
LOGD("deallocate local meta buffer");
|
|
m_metaMem->deallocate();
|
|
delete m_metaMem;
|
|
m_metaMem = NULL;
|
|
}
|
|
if (mOutputMemory != NULL) {
|
|
LOGD("deallocate output stream buffers");
|
|
mOutputMemory->deallocate();
|
|
delete mOutputMemory;
|
|
mOutputMemory = NULL;
|
|
}
|
|
|
|
cam_sem_destroy(&m_syncSem);
|
|
}
|
|
|
|
void QCamera3MultiRawChannel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream)
|
|
{
|
|
LOGD("E");
|
|
if (super_frame == NULL || super_frame->num_bufs != 1) {
|
|
LOGE("super_frame is not valid");
|
|
return;
|
|
}
|
|
|
|
mm_camera_super_buf_t* frame = NULL;
|
|
frame = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
*frame = *super_frame;
|
|
|
|
inputRawQ.push_back(frame);
|
|
|
|
if (inputRawQ.size() == mNumBuffers) {
|
|
notifyCaptureDone(stream);
|
|
}
|
|
|
|
free(super_frame);
|
|
}
|
|
|
|
QCamera3StreamMem* QCamera3MultiRawChannel::getStreamBufs(uint32_t len)
|
|
{
|
|
int rc;
|
|
mMemory = new QCamera3StreamMem(mNumBuffers);
|
|
if (!mMemory) {
|
|
LOGE("unable to create heap memory");
|
|
return NULL;
|
|
}
|
|
rc = mMemory->allocateAll((size_t)len);
|
|
if (rc < 0) {
|
|
LOGE("unable to allocate heap memory");
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
|
|
mOutputMemory = new QCamera3StreamMem(1);
|
|
if (!mOutputMemory) {
|
|
LOGE("unable to create heap memory");
|
|
return NULL;
|
|
}
|
|
rc = mOutputMemory->allocateOne((size_t)mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("unable to allocate heap memory");
|
|
delete mOutputMemory;
|
|
mOutputMemory = NULL;
|
|
} else {
|
|
mBufIdx = (uint32_t)rc;
|
|
}
|
|
|
|
return mMemory;
|
|
}
|
|
|
|
void QCamera3MultiRawChannel::putStreamBufs()
|
|
{
|
|
LOGD("E. don't release the memory.");
|
|
}
|
|
|
|
int32_t QCamera3MultiRawChannel::request(buffer_handle_t *, uint32_t frameNumber, int &)
|
|
{
|
|
int32_t rc = 0;
|
|
if (!m_bIsActive) {
|
|
rc = QCamera3Channel::start();
|
|
}
|
|
|
|
LOGD("frame number:%d", frameNumber);
|
|
m_frameNumber = frameNumber;
|
|
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3MultiRawChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
int32_t rc;
|
|
|
|
mIsType = isType;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
rc = QCamera3Channel::addStream(CAM_STREAM_TYPE_RAW,
|
|
hal_obj->mRdiModeFmt, mDim, ROTATE_0, (uint8_t)mNumBuffers,
|
|
mPostProcMask, mIsType);
|
|
if (rc < 0) {
|
|
LOGE("addStream failed");
|
|
}
|
|
|
|
svr_stream_id = mStreams[0]->getMyServerID();
|
|
LOGD("stream server id:%d", svr_stream_id);
|
|
|
|
cam_stream_buf_plane_info_t buf_planes;
|
|
cam_padding_info_t paddingInfo = mPaddingInfo;
|
|
|
|
memset(&buf_planes, 0, sizeof(buf_planes));
|
|
//to ensure a big enough buffer size set the height and width
|
|
//padding to max(height padding, width padding)
|
|
paddingInfo.width_padding = MAX(paddingInfo.width_padding, paddingInfo.height_padding);
|
|
paddingInfo.height_padding = paddingInfo.width_padding;
|
|
|
|
rc = mm_stream_calc_offset_raw(hal_obj->mRdiModeFmt, &mDim, &paddingInfo,
|
|
&buf_planes);
|
|
if (rc < 0) {
|
|
LOGE("mm_stream_calc_offset_preview failed");
|
|
return rc;
|
|
}
|
|
|
|
mFrameLen = buf_planes.plane_info.frame_len;
|
|
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3MultiRawChannel::notifyCaptureDone(QCamera3Stream* stream)
|
|
{
|
|
int32_t rc = 0;
|
|
//cam_sem_post(&m_syncSem);
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
QCamera3PicChannel * picChannel = hal_obj->getPicChannel();
|
|
|
|
memcpy(mOutputMemory->getPtr(mBufIdx), inputRawQ[0]->bufs[0]->buffer, mFrameLen);
|
|
|
|
cam_frame_len_offset_t offset;
|
|
stream->getFrameOffset(offset);
|
|
|
|
mBufDef = (mm_camera_buf_def_t *)malloc(sizeof(mm_camera_buf_def_t));
|
|
memcpy(mBufDef, inputRawQ[0]->bufs[0], sizeof(mm_camera_buf_def_t));
|
|
|
|
rc = mOutputMemory->getBufDef(offset, *mBufDef, mBufIdx);
|
|
if (rc != 0) {
|
|
LOGE("getBufDef failed");
|
|
}
|
|
|
|
mm_camera_super_buf_t* frame = NULL;
|
|
frame = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (frame == NULL) {
|
|
LOGE("frame alloc failed");
|
|
}
|
|
frame->num_bufs = 1;
|
|
frame->bufs[0] = mBufDef;
|
|
frame->ch_id = getMyHandle();
|
|
frame->camera_handle = getMyCamHandle();
|
|
|
|
picChannel->queueReprocFrame(frame, m_frameNumber);
|
|
}
|
|
|
|
void QCamera3MultiRawChannel::waitCaptureDone()
|
|
{
|
|
cam_sem_wait(&m_syncSem);
|
|
}
|
|
|
|
void QCamera3MultiRawChannel::finishCapture()
|
|
{
|
|
Vector<mm_camera_super_buf_t*>::iterator itr;
|
|
|
|
for (itr = inputRawQ.begin(); itr != inputRawQ.end(); itr++) {
|
|
bufDone(*itr);
|
|
free(*itr);
|
|
}
|
|
inputRawQ.clear();
|
|
}
|
|
|
|
|
|
/*************************************************************************************/
|
|
|
|
/* QCamera3YUVChannel methods */
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3YUVChannel
|
|
*
|
|
* DESCRIPTION: constructor of QCamera3YUVChannel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : camera handle
|
|
* @cam_ops : ptr to camera ops table
|
|
* @cb_routine : callback routine to frame aggregator
|
|
* @paddingInfo : padding information for the stream
|
|
* @stream : camera3_stream_t structure
|
|
* @stream_type: Channel stream type
|
|
* @postprocess_mask: the postprocess mask for streams of this channel
|
|
* @metadataChannel: handle to the metadataChannel
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3YUVChannel::QCamera3YUVChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buf_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
camera3_stream_t *stream,
|
|
cam_stream_type_t stream_type,
|
|
cam_feature_mask_t postprocess_mask,
|
|
QCamera3Channel *metadataChannel,
|
|
uint32_t numBuffers,
|
|
bool appConfigAux,
|
|
cam_sync_type_t camType):
|
|
QCamera3ProcessingChannel(cam_handle, channel_handle, cam_ops,
|
|
cb_routine, cb_buf_err, paddingInfo, userData, stream, stream_type,
|
|
postprocess_mask, metadataChannel, numBuffers),
|
|
mAuxYUVChannel(NULL),
|
|
mNeedPPUpscale(false)
|
|
{
|
|
|
|
mBypass = (postprocess_mask == CAM_QCOM_FEATURE_NONE);
|
|
mFrameLen = 0;
|
|
mEdgeMode.edge_mode = CAM_EDGE_MODE_OFF;
|
|
mEdgeMode.sharpness = 0;
|
|
mNoiseRedMode = CAM_NOISE_REDUCTION_MODE_OFF;
|
|
lastReturnedFrame = 0;
|
|
memset(&mCropRegion, 0, sizeof(mCropRegion));
|
|
cam_dimension_t dim = {0,0};
|
|
dim.width = stream->width;
|
|
dim.height = stream->height;
|
|
mCompositeHandle = channel_handle;
|
|
mInternalDim = dim;
|
|
m_bUpdatedDimensions = false;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
m_bCtrlAux = !appConfigAux;
|
|
if (is_dual_camera_by_handle(cam_handle)
|
|
&& !(hal_obj->isPPMaskSetForScaling(postprocess_mask))
|
|
&& hal_obj->isAsymetricDim(dim)
|
|
&& !appConfigAux) {
|
|
m_camHandle = get_main_camera_handle(cam_handle);
|
|
m_handle = get_main_camera_handle(channel_handle);
|
|
mAuxYUVChannel = new QCamera3YUVChannel(get_aux_camera_handle(cam_handle),
|
|
get_aux_camera_handle(channel_handle), cam_ops,
|
|
cb_routine, cb_buf_err,
|
|
paddingInfo, userData,
|
|
stream, stream_type,
|
|
postprocess_mask,
|
|
metadataChannel);
|
|
|
|
setDualChannelMode(true);
|
|
}
|
|
|
|
if(appConfigAux && is_dual_camera_by_handle(cam_handle))
|
|
{
|
|
if(IS_EQUAL(camType,CAM_TYPE_MAIN))
|
|
{
|
|
m_camHandle = get_main_camera_handle(cam_handle);
|
|
m_handle = get_main_camera_handle(channel_handle);
|
|
}else if(IS_EQUAL(camType,CAM_TYPE_AUX))
|
|
{
|
|
m_camHandle = get_aux_camera_handle(cam_handle);
|
|
m_handle = get_aux_camera_handle(channel_handle);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCamera3YUVChannel
|
|
*
|
|
* DESCRIPTION: destructor of QCamera3YUVChannel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3YUVChannel::~QCamera3YUVChannel()
|
|
{
|
|
// Deallocation of heap buffers allocated in mMemory is freed
|
|
// automatically by its destructor
|
|
if((m_zslType == CAM_HAL3_ZSL_TYPE_CALLBACK) && !m_bCtrlAux)
|
|
{
|
|
//only of dual camera aux yuv will be true and since
|
|
//aux yuv handle is used for direct request.Skipping
|
|
//Aux handle delete.
|
|
mAuxYUVChannel = NULL;
|
|
}
|
|
if(NULL != mAuxYUVChannel)
|
|
{
|
|
delete mAuxYUVChannel;
|
|
mAuxYUVChannel = NULL;
|
|
}
|
|
|
|
if(NULL != m_QuadraMeta)
|
|
{
|
|
free(m_QuadraMeta);
|
|
m_QuadraMeta = NULL;
|
|
}
|
|
}
|
|
|
|
void QCamera3YUVChannel::setDualChannelMode(bool bMode)
|
|
{
|
|
QCamera3Channel::setDualChannelMode(bMode);
|
|
if(NULL != mAuxYUVChannel)
|
|
{
|
|
mAuxYUVChannel->setDualChannelMode(bMode);
|
|
}
|
|
}
|
|
|
|
void QCamera3YUVChannel::overrideStreamDim(uint32_t width, uint32_t height)
|
|
{
|
|
m_bUpdatedDimensions = true;
|
|
mInternalDim.width = width;
|
|
mInternalDim.height = height;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : putStreamBufs
|
|
*
|
|
* DESCRIPTION: release the buffers allocated to the stream
|
|
*
|
|
* PARAMETERS : NONE
|
|
*
|
|
* RETURN : NONE
|
|
*==========================================================================*/
|
|
void QCamera3YUVChannel::putStreamBufs()
|
|
{
|
|
QCamera3ProcessingChannel::putStreamBufs();
|
|
|
|
// Free allocated heap buffer.
|
|
mMemory.deallocate();
|
|
// Clear free heap buffer list.
|
|
mFreeHeapBufferList.clear();
|
|
// Clear offlinePpInfoList
|
|
mOfflinePpInfoList.clear();
|
|
// Clear offlineMemory
|
|
mOfflineMemory.clear();
|
|
}
|
|
|
|
void QCamera3YUVChannel::setZSLMode(bool mode)
|
|
{
|
|
if(mAuxYUVChannel)
|
|
{
|
|
mAuxYUVChannel->setZSLMode(mode);
|
|
}
|
|
LOGD("YUV stream zsl mode:%s", mode?"TRUE":"FALSE");
|
|
m_bZSL = mode;
|
|
}
|
|
|
|
void QCamera3YUVChannel::setChannelQuadraMode(bool mode)
|
|
{
|
|
m_bQuadraChannel = mode;
|
|
LOGD("QUADRA MODE : %s", m_bQuadraChannel?"Enabled":"Disabled");
|
|
}
|
|
|
|
QCamera3Channel *QCamera3YUVChannel::getAuxHandle()
|
|
{
|
|
if(mAuxYUVChannel) return mAuxYUVChannel;
|
|
return NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : initialize
|
|
*
|
|
* DESCRIPTION: Initialize and add camera channel & stream
|
|
*
|
|
* PARAMETERS :
|
|
* @isType : the image stabilization type
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3YUVChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_YUV_CH_INIT);
|
|
int32_t rc = NO_ERROR;
|
|
cam_dimension_t streamDim;
|
|
|
|
if (NULL == mCamera3Stream) {
|
|
LOGE("Camera stream uninitialized");
|
|
return NO_INIT;
|
|
}
|
|
|
|
if (1 <= m_numStreams) {
|
|
// Only one stream per channel supported in v3 Hal
|
|
return NO_ERROR;
|
|
}
|
|
|
|
mIsType = isType;
|
|
mStreamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_CALLBACK,
|
|
mCamera3Stream->width, mCamera3Stream->height);
|
|
|
|
streamDim.width = mCamera3Stream->width;
|
|
streamDim.height = mCamera3Stream->height;
|
|
|
|
if(m_bUpdatedDimensions)
|
|
{
|
|
streamDim.width = mInternalDim.width;
|
|
streamDim.height = mInternalDim.height;
|
|
}
|
|
|
|
//In DualCamera usecase for Asymetric mode
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if(m_bDualChannel)
|
|
{
|
|
//for low configuration don't change the stream dimension.
|
|
hal_obj->rectifyStreamDimIfNeeded(
|
|
streamDim, (mAuxYUVChannel != NULL) ? CAM_TYPE_MAIN: CAM_TYPE_AUX, mNeedPPUpscale);
|
|
}
|
|
|
|
rc = QCamera3Channel::addStream(mStreamType,
|
|
mStreamFormat,
|
|
streamDim,
|
|
ROTATE_0,
|
|
mNumBufs,
|
|
mPostProcMask,
|
|
mIsType,
|
|
0,
|
|
!isZSLChannel(),
|
|
isZSLChannel());
|
|
if (rc < 0) {
|
|
LOGE("addStream failed");
|
|
return rc;
|
|
}
|
|
|
|
cam_stream_buf_plane_info_t buf_planes;
|
|
cam_padding_info_t paddingInfo = mPaddingInfo;
|
|
|
|
memset(&buf_planes, 0, sizeof(buf_planes));
|
|
//to ensure a big enough buffer size set the height and width
|
|
//padding to max(height padding, width padding)
|
|
paddingInfo.width_padding = MAX(paddingInfo.width_padding, paddingInfo.height_padding);
|
|
paddingInfo.height_padding = paddingInfo.width_padding;
|
|
|
|
rc = mm_stream_calc_offset_snapshot(mStreamFormat, &streamDim, &paddingInfo,
|
|
&buf_planes);
|
|
if (rc < 0) {
|
|
LOGE("mm_stream_calc_offset_preview failed");
|
|
return rc;
|
|
}
|
|
|
|
mFrameLen = buf_planes.plane_info.frame_len;
|
|
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Initialize failed, rc = %d", rc);
|
|
return rc;
|
|
}
|
|
|
|
/* initialize offline meta memory for input reprocess */
|
|
rc = QCamera3ProcessingChannel::initialize(isType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Processing Channel initialize failed, rc = %d",
|
|
rc);
|
|
}
|
|
|
|
if(NULL != mAuxYUVChannel)
|
|
{
|
|
mAuxYUVChannel->initialize(isType);
|
|
}
|
|
|
|
m_bInitDone = true;
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3YUVChannel::setQuadraMetaBuffer(metadata_buffer_t *frameMeta,
|
|
__unused metadata_buffer_t* reproParam)
|
|
{
|
|
QCamera3HardwareInterface *hal_obj = (QCamera3HardwareInterface *)mUserData;
|
|
|
|
m_QuadraMeta = (metadata_buffer_t *)calloc(sizeof(metadata_buffer_t),1);
|
|
if(m_QuadraMeta != NULL)
|
|
{
|
|
LOGH("cache meta buffer");
|
|
memcpy(m_QuadraMeta, frameMeta, sizeof(metadata_buffer_t));
|
|
}
|
|
|
|
if(hal_obj)
|
|
{
|
|
if(hal_obj->updateFrameMetaWithParams(m_QuadraMeta) == NO_ERROR) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void QCamera3YUVChannel::getQuadraMetaBuffer(metadata_buffer_t **meta)
|
|
{
|
|
if(!(*meta)) return;
|
|
|
|
if(!(m_QuadraMeta)) return;
|
|
|
|
**meta = *m_QuadraMeta;
|
|
|
|
free(m_QuadraMeta);
|
|
m_QuadraMeta = NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : queueReprocMetadata
|
|
*
|
|
* DESCRIPTION: queue the reprocess metadata to the postprocessor
|
|
*
|
|
* PARAMETERS : metadata : the metadata corresponding to the pp frame
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3YUVChannel::queueReprocMetadata(mm_camera_super_buf_t *metadata,
|
|
uint32_t framenum, bool dropFrame)
|
|
{
|
|
if((NULL != mAuxYUVChannel) && (metadata->camera_handle != m_camHandle))
|
|
{
|
|
return mAuxYUVChannel->queueReprocMetadata(metadata, framenum, dropFrame);
|
|
} else {
|
|
return QCamera3ProcessingChannel::queueReprocMetadata(metadata, framenum, dropFrame);
|
|
}
|
|
LOGE("Should never be here");
|
|
return -1;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : request
|
|
*
|
|
* DESCRIPTION: entry function for a request on a YUV stream. This function
|
|
* has the logic to service a request based on its type
|
|
*
|
|
* PARAMETERS :
|
|
* @buffer : pointer to the output buffer
|
|
* @frameNumber : frame number of the request
|
|
* @pInputBuffer : pointer to input buffer if an input request
|
|
* @metadata : parameters associated with the request
|
|
* @internalreq : boolean to indicate if this is purely internal request
|
|
* needing internal buffer allocation
|
|
* @meteringonly : boolean indicating metering only frame subset of internal
|
|
* not consumed by postprocessor
|
|
*
|
|
* RETURN : 0 on a success start of capture
|
|
* -EINVAL on invalid input
|
|
* -ENODEV on serious error
|
|
*==========================================================================*/
|
|
int32_t QCamera3YUVChannel::request(buffer_handle_t *buffer,
|
|
uint32_t frameNumber,
|
|
camera3_stream_buffer_t* pInputBuffer,
|
|
metadata_buffer_t* metadata, bool &needMetadata,
|
|
int &indexUsed,
|
|
__unused bool internalRequest,
|
|
__unused bool meteringOnly,
|
|
__unused bool isZSL,
|
|
__unused bool dualSyncBuf,
|
|
__unused bool skipRequest)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
Mutex::Autolock lock(mOfflinePpLock);
|
|
|
|
LOGD("pInputBuffer is %p frame number %d", pInputBuffer, frameNumber);
|
|
if (NULL == buffer || NULL == metadata) {
|
|
LOGE("Invalid buffer/metadata in channel request");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
bool bIsMaster = true;
|
|
if(m_bDualChannel && !m_bZSL)
|
|
{
|
|
bIsMaster = (mAuxYUVChannel != NULL) ? (mMasterCam == CAM_TYPE_MAIN)
|
|
: (mMasterCam == CAM_TYPE_AUX);
|
|
}
|
|
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
|
|
if(bIsMaster)
|
|
{
|
|
PpInfo ppInfo;
|
|
memset(&ppInfo, 0, sizeof(ppInfo));
|
|
ppInfo.frameNumber = frameNumber;
|
|
ppInfo.offlinePpFlag = false;
|
|
if ((mBypass) && !pInputBuffer &&
|
|
!(hal_obj->m_bQuadraCfaRequest && m_bQuadraChannel)) {
|
|
if (QCAMERA3_VENDOR_STREAM_CONFIGURATION_PP_DISABLED_MODE == hal_obj->mOpMode)
|
|
{
|
|
ppInfo.offlinePpFlag = false;
|
|
}
|
|
else
|
|
{
|
|
ppInfo.offlinePpFlag = needsFramePostprocessing(metadata) || m_bZSL;
|
|
}
|
|
ppInfo.output = buffer;
|
|
mOfflinePpInfoList.push_back(ppInfo);
|
|
}
|
|
|
|
if ((pInputBuffer == NULL) && (hal_obj->m_bQuadraCfaRequest && m_bQuadraChannel)) {
|
|
LOGI("trigger reprocess for quadra cfa");
|
|
|
|
QCamera3QCfaCaptureChannel *pChannel = hal_obj->mQCFACaptureChannel;
|
|
if (pChannel == NULL || !pChannel->meta_received || !pChannel->data_received) {
|
|
LOGE("request failed!");
|
|
return -1;
|
|
}
|
|
|
|
int index = -1;
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
|
|
if(index < 0) {
|
|
rc = registerBuffer(buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if (index < 0) {
|
|
LOGE("Could not find object among registered buffers");
|
|
return DEAD_OBJECT;
|
|
}
|
|
}
|
|
LOGD("buffer index %d, frameNumber: %u", index, frameNumber);
|
|
|
|
rc = mMemory.markFrameNumber((uint32_t)index, frameNumber);
|
|
|
|
/* Configure and start postproc if necessary */
|
|
reprocess_config_t reproc_cfg;
|
|
cam_dimension_t dim;
|
|
memset(&reproc_cfg, 0, sizeof(reprocess_config_t));
|
|
memset(&dim, 0, sizeof(dim));
|
|
mStreams[0]->getFrameDimension(dim);
|
|
|
|
//reset the input dimension with actual dimension.
|
|
//note: only using in QuadraMode.
|
|
if(m_bUpdatedDimensions)
|
|
{
|
|
dim.width= mCamera3Stream->width;
|
|
dim.height = mCamera3Stream->height;
|
|
}
|
|
|
|
if (hal_obj->m_bInSensorQCFA && hal_obj->m_bQuadraCfaRequest) {
|
|
dim = hal_obj->getQuadraCfaDim();
|
|
}
|
|
|
|
setReprocConfig(reproc_cfg, NULL, metadata, mStreamFormat, dim, mNeedPPUpscale);
|
|
|
|
if (!hal_obj->m_bInSensorQCFA && hal_obj->m_bQuadraCfaRequest) {
|
|
LOGI("override reprocess input config for quadra cfa");
|
|
reproc_cfg.input_stream_dim = hal_obj->getQuadraCfaDim();
|
|
reproc_cfg.stream_format = hal_obj->mRdiModeFmt;
|
|
reproc_cfg.stream_type = CAM_STREAM_TYPE_RAW;
|
|
mm_stream_calc_offset_raw(reproc_cfg.stream_format, &reproc_cfg.input_stream_dim,
|
|
reproc_cfg.padding, &reproc_cfg.input_stream_plane_info);
|
|
}
|
|
// Start postprocessor without input buffer
|
|
startPostProc(reproc_cfg);
|
|
|
|
mm_camera_super_buf_t *super_buf =
|
|
(mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (super_buf == NULL) {
|
|
LOGE("fail to allocate memory");
|
|
return -1;
|
|
}
|
|
memcpy(super_buf, &(pChannel->meta_frame), sizeof(mm_camera_super_buf_t));
|
|
setQuadraMetaBuffer((metadata_buffer_t *)pChannel->meta_frame.bufs[0]->buffer,
|
|
metadata);
|
|
m_postprocessor.processPPMetadata(super_buf, frameNumber, false);
|
|
|
|
super_buf = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (super_buf == NULL) {
|
|
LOGE("fail to allocate memory");
|
|
return -1;
|
|
}
|
|
memcpy(super_buf, &(pChannel->capture_frame), sizeof(mm_camera_super_buf_t));
|
|
m_postprocessor.processData(super_buf, NULL, frameNumber);
|
|
} else if(pInputBuffer == NULL && m_bZSL) {
|
|
/* Configure and start postproc if necessary */
|
|
reprocess_config_t reproc_cfg;
|
|
cam_dimension_t dim;
|
|
memset(&reproc_cfg, 0, sizeof(reprocess_config_t));
|
|
memset(&dim, 0, sizeof(dim));
|
|
mStreams[0]->getFrameDimension(dim);
|
|
setReprocConfig(reproc_cfg, NULL, metadata, mStreamFormat, dim, mNeedPPUpscale);
|
|
|
|
// Start postprocessor without input buffer
|
|
startPostProc(reproc_cfg);
|
|
|
|
if (mAllocThread != 0) {
|
|
pthread_join(mAllocThread, NULL);
|
|
mAllocThread = 0;
|
|
}
|
|
|
|
{
|
|
zsl_req_t req;
|
|
memset(&req,0,sizeof(zsl_req_t));
|
|
req.reqStreamType = mStreamType;
|
|
Mutex::Autolock lock(mReqFrameListLock);
|
|
if (meteringOnly) {
|
|
req.frameNum = 0xFFFFFFFF;
|
|
} else {
|
|
req.frameNum = frameNumber;
|
|
}
|
|
mReqFrameNumList.push_back(req);
|
|
}
|
|
uint32_t handle = m_handle;
|
|
uint32_t camHandle = m_camHandle;
|
|
if(dualSyncBuf)
|
|
{
|
|
handle = mCompositeHandle;
|
|
camHandle = m_pMetaChannel->getMyCamHandle();
|
|
}
|
|
//skip request zsl buffer in yuvzsl for main if requested sync buf.
|
|
if(!(m_bDualChannel && m_bZSL && dualSyncBuf && skipRequest))
|
|
{
|
|
if (isZSL) {
|
|
requestZSLBuf(camHandle, handle);
|
|
} else {
|
|
requestZSLBuf(camHandle, handle, frameNumber);
|
|
}
|
|
}
|
|
indexUsed = CAM_FREERUN_IDX;
|
|
} else {
|
|
cam_dimension_t dim;
|
|
memset(&dim, 0, sizeof(dim));
|
|
mStreams[0]->getFrameDimension(dim);
|
|
LOGD("offlinePpFlag %d and mbypass is %d, dim %dx%d",
|
|
ppInfo.offlinePpFlag, mBypass, dim.width,dim.height);
|
|
needMetadata = ppInfo.offlinePpFlag;
|
|
if (!ppInfo.offlinePpFlag) {
|
|
// regular request
|
|
return QCamera3ProcessingChannel::request(buffer, frameNumber,
|
|
pInputBuffer, metadata, indexUsed);
|
|
} else {
|
|
if(!m_bIsActive) {
|
|
rc = start();
|
|
if (NO_ERROR != rc)
|
|
return rc;
|
|
} else {
|
|
LOGD("Request on an existing stream");
|
|
}
|
|
|
|
//we need to send this frame through the CPP
|
|
//Allocate heap memory, then buf done on the buffer
|
|
uint32_t bufIdx;
|
|
if (mFreeHeapBufferList.empty()) {
|
|
rc = mMemory.allocateOne(mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("Failed allocating heap buffer. Fatal");
|
|
return BAD_VALUE;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
}
|
|
} else {
|
|
bufIdx = *(mFreeHeapBufferList.begin());
|
|
mFreeHeapBufferList.erase(mFreeHeapBufferList.begin());
|
|
}
|
|
|
|
/* Configure and start postproc if necessary */
|
|
reprocess_config_t reproc_cfg;
|
|
cam_dimension_t dim;
|
|
memset(&reproc_cfg, 0, sizeof(reprocess_config_t));
|
|
memset(&dim, 0, sizeof(dim));
|
|
mStreams[0]->getFrameDimension(dim);
|
|
setReprocConfig(reproc_cfg, NULL, metadata, mStreamFormat, dim, mNeedPPUpscale);
|
|
|
|
// Start postprocessor without input buffer
|
|
startPostProc(reproc_cfg);
|
|
|
|
LOGD("erasing %d", bufIdx);
|
|
|
|
mMemory.markFrameNumber(bufIdx, frameNumber);
|
|
indexUsed = bufIdx;
|
|
mStreams[0]->bufDone(bufIdx);
|
|
}
|
|
}
|
|
}
|
|
if (mAuxYUVChannel && (!bIsMaster || hal_obj->needHALPP())) {
|
|
mAuxYUVChannel->request(buffer, frameNumber, pInputBuffer, metadata, needMetadata,
|
|
indexUsed, dualSyncBuf, !skipRequest);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3YUVChannel::startDeferredAllocation() {
|
|
createAllocThread();
|
|
if(mAuxYUVChannel)
|
|
{
|
|
mAuxYUVChannel->createAllocThread();
|
|
}
|
|
}
|
|
|
|
void QCamera3YUVChannel::setAuxChannel(QCamera3Channel *pAuxChannel,
|
|
bool mDualChMode)
|
|
{
|
|
mAuxYUVChannel = (QCamera3YUVChannel *)pAuxChannel;
|
|
setDualChannelMode(mDualChMode);
|
|
}
|
|
|
|
int QCamera3YUVChannel::allocateZSLBuffers()
|
|
{
|
|
LOGH(": E numbufs %d", mCamera3Stream->max_buffers);
|
|
int rc = NO_ERROR;
|
|
uint32_t bufIdx;
|
|
if (m_bZSL) {
|
|
for (size_t i = 0; i < mCamera3Stream->max_buffers; i++) {
|
|
rc = mMemory.allocateOne(mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("Failed allocating heap buffer. Fatal");
|
|
return BAD_VALUE;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
mStreams[0]->bufDone(bufIdx);
|
|
}
|
|
}
|
|
mAllocDone = true;
|
|
}
|
|
LOGH(": X");
|
|
return rc;
|
|
}
|
|
|
|
uint32_t QCamera3YUVChannel::getStreamTypeMask()
|
|
{
|
|
if(mStreams[0])
|
|
{
|
|
return QCamera3Channel::getStreamTypeMask();
|
|
}
|
|
return (1U << mStreamType);
|
|
}
|
|
|
|
void QCamera3YUVChannel::switchMaster(uint32_t masterCam)
|
|
{
|
|
if(m_bDualChannel)
|
|
{
|
|
mMasterCam = masterCam;
|
|
if(NULL != mAuxYUVChannel)
|
|
mAuxYUVChannel->switchMaster(masterCam);
|
|
} else {
|
|
QCamera3Channel::switchMaster(masterCam);
|
|
}
|
|
}
|
|
|
|
void QCamera3YUVChannel::overridePPConfig(cam_feature_mask_t pp_mask)
|
|
{
|
|
LOGD("overriding ppmask to %" PRIx64, pp_mask);
|
|
mPostProcMask = pp_mask;
|
|
if(NULL != mAuxYUVChannel)
|
|
{
|
|
mAuxYUVChannel->overridePPConfig(pp_mask);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setBundleInfo
|
|
*
|
|
* DESCRIPTION: setting bundle information in stream params
|
|
*
|
|
* PARAMETERS :
|
|
* @bundleInfo : stream bundle information.
|
|
* @cam_type : MAIN or AUX.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3YUVChannel::setBundleInfo(
|
|
const cam_bundle_config_t &bundleInfo, uint32_t cam_type)
|
|
{
|
|
if ((cam_type == CAM_TYPE_AUX) && (NULL != mAuxYUVChannel)) {
|
|
return mAuxYUVChannel->setBundleInfo(bundleInfo);
|
|
}
|
|
int32_t rc = NO_ERROR;
|
|
cam_stream_parm_buffer_t param;
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_SET_BUNDLE_INFO;
|
|
param.bundleInfo = bundleInfo;
|
|
if (m_numStreams > 0 && mStreams[0]) {
|
|
rc = mStreams[0]->setParameter(param, cam_type);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("stream setParameter for set bundle failed");
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : streamCbRoutine
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS :
|
|
* @super_frame : the super frame with filled buffer
|
|
* @stream : stream on which the buffer was requested and filled
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3YUVChannel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_YUV_CH_STRM_CB);
|
|
Mutex::Autolock lock(mYuvCbBufferLock);
|
|
uint8_t frameIndex;
|
|
uint32_t resultFrameNumber;
|
|
bool cancelledBuffer = false, isReturnFrame = false;
|
|
bool reprocNeeded = false;
|
|
buffer_handle_t *output;
|
|
uint32_t frameNum;
|
|
List<PpInfo>::iterator ppInfo;
|
|
if (checkStreamCbErrors(super_frame, stream) != NO_ERROR) {
|
|
LOGE("Error with the stream callback");
|
|
return;
|
|
}
|
|
|
|
frameIndex = (uint8_t)super_frame->bufs[0]->buf_idx;
|
|
if(frameIndex >= mNumBufs) {
|
|
LOGE("Error, Invalid index for buffer");
|
|
stream->bufDone(frameIndex);
|
|
return;
|
|
}
|
|
|
|
if (mBypass) {
|
|
List<PpInfo>::iterator ppInfoPending;
|
|
List<uint32_t>::iterator ppDropInfo;
|
|
int32_t index;
|
|
resultFrameNumber = mMemory.getFrameNumber(frameIndex);
|
|
if (IS_BUFFER_ERROR(super_frame->bufs[0]->flags)) {
|
|
/* TODO Sending notify to framework - need to send before corresponding full Meta */
|
|
cancelledBuffer = true;
|
|
mChannelCbBufErr(this, resultFrameNumber,
|
|
CAMERA3_BUFFER_STATUS_ERROR, mUserData);
|
|
}
|
|
Mutex::Autolock lock(mOfflinePpLock);
|
|
LOGD("mBypass result frame num %d and pplist start frame :%d",
|
|
resultFrameNumber, mOfflinePpInfoList.begin()->frameNumber);
|
|
reprocNeeded = false; isReturnFrame = false;
|
|
for (ppInfo = mOfflinePpInfoList.begin();
|
|
ppInfo != mOfflinePpInfoList.end(); ppInfo++) {
|
|
if (ppInfo->frameNumber == (uint32_t)resultFrameNumber) {
|
|
break;
|
|
}
|
|
}
|
|
LOGD("frame index %d, frame number %d ", frameIndex, resultFrameNumber);
|
|
//check the reprocessing required flag against the frame number
|
|
if (ppInfo == mOfflinePpInfoList.end()) {
|
|
LOGE("Error, request for frame number is a reprocess.");
|
|
stream->bufDone(frameIndex);
|
|
free(super_frame);
|
|
return;
|
|
}
|
|
if(lastReturnedFrame == 0) {
|
|
lastReturnedFrame = resultFrameNumber;
|
|
}
|
|
if (IS_BUFFER_ERROR(super_frame->bufs[0]->flags)) {
|
|
LOGD("Cancelled Buffer ");
|
|
if(ppInfo->offlinePpFlag == true) {
|
|
ppInfo->isReturnBuffer = true;
|
|
int32_t bufferIndex =
|
|
mMemory.getHeapBufferIndex(resultFrameNumber);
|
|
if(bufferIndex != -1) {
|
|
mMemory.markFrameNumber(bufferIndex, -1);
|
|
mFreeHeapBufferList.push_back(bufferIndex);
|
|
free(super_frame);
|
|
{
|
|
Mutex::Autolock lock(mDropReprocBuffersLock);
|
|
if(m_postprocessor.releaseReprocMetaBuffer(resultFrameNumber)) {
|
|
LOGD(" Meta has been released");
|
|
} else {
|
|
LOGD("Meta hasnt been received for Cancelled buffer");
|
|
mReprocDropBufferList.push_back(ppInfo->frameNumber);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(resultFrameNumber > lastReturnedFrame + 1) {
|
|
LOGD(" Detecting out of order %d and %d",
|
|
lastReturnedFrame, resultFrameNumber);
|
|
for (ppInfoPending = mOfflinePpInfoList.begin();
|
|
(ppInfoPending != mOfflinePpInfoList.end()); ppInfoPending++) {
|
|
if(ppInfoPending->frameNumber == lastReturnedFrame)
|
|
break;
|
|
}
|
|
for (ppInfoPending++;
|
|
(ppInfoPending != mOfflinePpInfoList.end()) &&
|
|
(ppInfoPending->frameNumber < resultFrameNumber); ppInfoPending++) {
|
|
LOGH(" Detecting out of order in Filed list:%d and %d",
|
|
ppInfoPending->frameNumber,resultFrameNumber);
|
|
index = mMemory.getBufferIndex(ppInfoPending->frameNumber);
|
|
mStreams[0]->cancelBuffer(index);
|
|
}
|
|
}
|
|
if(lastReturnedFrame < resultFrameNumber) {
|
|
lastReturnedFrame = resultFrameNumber;
|
|
}
|
|
if (ppInfo->offlinePpFlag && !cancelledBuffer) {
|
|
mm_camera_super_buf_t *frame =
|
|
(mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (frame == NULL) {
|
|
LOGE("Error allocating memory to save received_frame structure.");
|
|
if(stream) {
|
|
stream->bufDone(frameIndex);
|
|
}
|
|
return;
|
|
}
|
|
|
|
*frame = *super_frame;
|
|
LOGD(" Sending Frame for Reprocessing : %d", resultFrameNumber);
|
|
m_postprocessor.processData(frame, ppInfo->output, resultFrameNumber);
|
|
free(super_frame);
|
|
return;
|
|
} else {
|
|
if (ppInfo != mOfflinePpInfoList.begin()) {
|
|
// There is pending reprocess buffer, cache current buffer
|
|
if (ppInfo->callback_buffer != NULL) {
|
|
LOGE("Fatal: cached callback_buffer is already present");
|
|
}
|
|
LOGD(" Caching Frame: %d", resultFrameNumber);
|
|
ppInfo->isReturnBuffer = true;
|
|
ppInfo->callback_buffer = super_frame;
|
|
return;
|
|
}
|
|
}
|
|
isReturnFrame = (ppInfo == mOfflinePpInfoList.begin());
|
|
if(isReturnFrame ) {
|
|
if(ppInfo->offlinePpFlag) {
|
|
reprocNeeded = true;
|
|
output = ppInfo->output;
|
|
frameNum = ppInfo->frameNumber;
|
|
}
|
|
mOfflinePpInfoList.erase(ppInfo);
|
|
}
|
|
}
|
|
if((mBypass == true) && (isReturnFrame)) {
|
|
if(reprocNeeded) {
|
|
issueChannelCb(output, frameNum);
|
|
} else {
|
|
QCamera3ProcessingChannel::streamCbRoutine(super_frame, stream);
|
|
}
|
|
while(getNextPendingCbBuffer());
|
|
}
|
|
if(mBypass == false) {
|
|
resultFrameNumber = mMemory.getFrameNumber(frameIndex);
|
|
LOGD(" Returning Non bypass Buffer : %d",resultFrameNumber );
|
|
QCamera3ProcessingChannel::streamCbRoutine(super_frame, stream);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : timeoutFrame
|
|
*
|
|
* DESCRIPTION: Method to indicate to channel that a given frame has take too
|
|
* long to be generated
|
|
*
|
|
* PARAMETERS : framenumber indicating the framenumber of the buffer timingout
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3YUVChannel::timeoutFrame(uint32_t frameNumber)
|
|
{
|
|
int32_t yuvbufIdx = 0;
|
|
int32_t rc = NO_ERROR;
|
|
|
|
LOGH("E, frameNumber: %d", frameNumber)
|
|
yuvbufIdx = mMemory.getBufferIndex(frameNumber);
|
|
if (yuvbufIdx < 0) {
|
|
LOGE("X: Buffer not found for frame:%d", frameNumber);
|
|
return -1;
|
|
}
|
|
|
|
if (mBypass) {
|
|
List<PpInfo>::iterator ppInfo;
|
|
|
|
Mutex::Autolock lock(mOfflinePpLock);
|
|
for (ppInfo = mOfflinePpInfoList.begin();
|
|
ppInfo != mOfflinePpInfoList.end(); ppInfo++) {
|
|
if (ppInfo->frameNumber == (uint32_t)frameNumber) {
|
|
break;
|
|
}
|
|
}
|
|
//check the reprocessing required flag against the frame number
|
|
if (ppInfo == mOfflinePpInfoList.end()) {
|
|
LOGD("No reprocess frame for this frame number.");
|
|
} else if (ppInfo->offlinePpFlag) {
|
|
// FixMe : timeout logic update for reprocess buffer
|
|
rc = m_postprocessor.timeoutFrame(frameNumber);
|
|
LOGH("X, calling reprocess timeoutFrame for frame: %d", frameNumber)
|
|
return rc;
|
|
}
|
|
}
|
|
QCamera3ProcessingChannel::timeoutFrame(frameNumber);
|
|
LOGH("X frameNumber: %d", frameNumber)
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getNextPendingCbBuffer
|
|
*
|
|
* DESCRIPTION: Returns the callback_buffer from the first entry of
|
|
* mOfflinePpInfoList
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : callback_buffer
|
|
*==========================================================================*/
|
|
bool QCamera3YUVChannel::getNextPendingCbBuffer() {
|
|
bool returned = false;
|
|
buffer_handle_t *output;
|
|
mm_camera_super_buf_t *callback_buffer = NULL;
|
|
uint32_t frameNum;
|
|
{
|
|
Mutex::Autolock lock(mOfflinePpLock);
|
|
if (mOfflinePpInfoList.size()) {
|
|
if(mOfflinePpInfoList.begin()->offlinePpFlag == true &&
|
|
mOfflinePpInfoList.begin()->isReturnBuffer == true) {
|
|
returned = true;
|
|
output = mOfflinePpInfoList.begin()->output;
|
|
frameNum = mOfflinePpInfoList.begin()->frameNumber;
|
|
mOfflinePpInfoList.erase(mOfflinePpInfoList.begin());
|
|
LOGD(" Sending the reprocess buffer :%d",frameNum);
|
|
} else if (mOfflinePpInfoList.begin()->callback_buffer) {
|
|
returned = true;
|
|
callback_buffer = mOfflinePpInfoList.begin()->callback_buffer;
|
|
mOfflinePpInfoList.erase(mOfflinePpInfoList.begin());
|
|
}
|
|
}
|
|
}
|
|
if(returned == true) {
|
|
if(callback_buffer != NULL) {
|
|
QCamera3ProcessingChannel::streamCbRoutine(
|
|
callback_buffer, mStreams[0]);
|
|
} else {
|
|
issueChannelCb(output, frameNum);
|
|
}
|
|
}
|
|
return returned;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : cancelFramePProc
|
|
*
|
|
* DESCRIPTION: cancel FramePost Processing request.
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : frame number for which postproc request need to be cancel.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
*==========================================================================*/
|
|
int32_t QCamera3YUVChannel::cancelFramePProc(uint32_t framenum,
|
|
__unused cam_sync_type_t cam)
|
|
{
|
|
int rc = NO_ERROR;
|
|
rc = QCamera3ProcessingChannel::cancelFramePProc(framenum);
|
|
if(mAuxYUVChannel != NULL){
|
|
return mAuxYUVChannel->cancelFramePProc(framenum);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : reprocessCbRoutine
|
|
*
|
|
* DESCRIPTION: callback function for the reprocessed frame. This frame now
|
|
* should be returned to the framework. This same callback is
|
|
* used during input reprocessing or offline postprocessing
|
|
*
|
|
* PARAMETERS :
|
|
* @resultBuffer : buffer containing the reprocessed data
|
|
* @resultFrameNumber : frame number on which the buffer was requested
|
|
*
|
|
* RETURN : NONE
|
|
*
|
|
*==========================================================================*/
|
|
void QCamera3YUVChannel::reprocessCbRoutine(buffer_handle_t *resultBuffer,
|
|
uint32_t resultFrameNumber)
|
|
{
|
|
LOGD("E: frame number %d", resultFrameNumber);
|
|
Vector<mm_camera_super_buf_t *> pendingCbs;
|
|
|
|
/* release the input buffer and input metadata buffer if used */
|
|
if (0 > mMemory.getHeapBufferIndex(resultFrameNumber)) {
|
|
/* mOfflineMemory and mOfflineMetaMemory used only for input reprocessing */
|
|
int32_t rc = releaseOfflineMemory(resultFrameNumber);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error releasing offline memory rc = %d", rc);
|
|
}
|
|
/* Since reprocessing is done, send the callback to release the input buffer */
|
|
if (mChannelCB) {
|
|
mChannelCB(NULL, NULL, resultFrameNumber, true, mUserData);
|
|
}
|
|
}
|
|
|
|
if (mBypass) {
|
|
int32_t rc = handleOfflinePpCallback(resultFrameNumber, pendingCbs);
|
|
if (rc != NO_ERROR) {
|
|
LOGI("X: Error!!! rc = %d", rc);
|
|
return;
|
|
}
|
|
}
|
|
Mutex::Autolock lock(mYuvCbBufferLock);
|
|
issueChannelCb(resultBuffer, resultFrameNumber);
|
|
// Call all pending callbacks to return buffers
|
|
while(getNextPendingCbBuffer());
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : needsFramePostprocessing
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN :
|
|
* TRUE if frame needs to be postprocessed
|
|
* FALSE is frame does not need to be postprocessed
|
|
*
|
|
*==========================================================================*/
|
|
bool QCamera3YUVChannel::needsFramePostprocessing(metadata_buffer_t *meta)
|
|
{
|
|
bool ppNeeded = false;
|
|
|
|
//sharpness
|
|
IF_META_AVAILABLE(cam_edge_application_t, edgeMode,
|
|
CAM_INTF_META_EDGE_MODE, meta) {
|
|
mEdgeMode = *edgeMode;
|
|
}
|
|
|
|
//wnr
|
|
IF_META_AVAILABLE(uint32_t, noiseRedMode,
|
|
CAM_INTF_META_NOISE_REDUCTION_MODE, meta) {
|
|
mNoiseRedMode = *noiseRedMode;
|
|
}
|
|
|
|
//crop region
|
|
IF_META_AVAILABLE(cam_crop_region_t, scalerCropRegion,
|
|
CAM_INTF_META_SCALER_CROP_REGION, meta) {
|
|
mCropRegion = *scalerCropRegion;
|
|
}
|
|
|
|
if ((CAM_EDGE_MODE_OFF != mEdgeMode.edge_mode) &&
|
|
(CAM_EDGE_MODE_ZERO_SHUTTER_LAG != mEdgeMode.edge_mode)) {
|
|
ppNeeded = true;
|
|
}
|
|
if ((CAM_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG != mNoiseRedMode) &&
|
|
(CAM_NOISE_REDUCTION_MODE_OFF != mNoiseRedMode) &&
|
|
(CAM_NOISE_REDUCTION_MODE_MINIMAL != mNoiseRedMode)) {
|
|
ppNeeded = true;
|
|
}
|
|
if ((mCropRegion.width < (int32_t)mCamera3Stream->width) ||
|
|
(mCropRegion.height < (int32_t)mCamera3Stream->height)) {
|
|
ppNeeded = true;
|
|
}
|
|
|
|
return ppNeeded;
|
|
}
|
|
|
|
void QCamera3YUVChannel::setAuxSourceZSLChannel(QCamera3ProcessingChannel *srcZsl,
|
|
zsl_stream_type_t zslType,
|
|
bool skipConfig)
|
|
{
|
|
if(IS_VALID_PTR(mAuxYUVChannel))
|
|
{
|
|
mAuxYUVChannel->setSourceZSLChannel(srcZsl,zslType,skipConfig);
|
|
}
|
|
}
|
|
|
|
int QCamera3YUVChannel::returnBufferError(uint32_t frameNumber)
|
|
{
|
|
int32_t bufIdx;
|
|
LOGH(": E numbufs %d", mCamera3Stream->max_buffers);
|
|
|
|
bufIdx = mMemory.getBufferIndex(frameNumber);
|
|
if(bufIdx < 0)
|
|
{
|
|
LOGE("X: Buffer not found for frame:%d", frameNumber);
|
|
return -1;
|
|
}
|
|
buffer_handle_t *buf = (buffer_handle_t *)mMemory.getBufferHandle(bufIdx);
|
|
mMemory.unregisterBuffer(bufIdx);
|
|
|
|
camera3_stream_buffer_t result_buffer;
|
|
memset(&result_buffer, 0, sizeof(camera3_stream_buffer_t));
|
|
|
|
result_buffer.stream = mCamera3Stream;
|
|
result_buffer.buffer = buf;
|
|
result_buffer.status = CAMERA3_BUFFER_STATUS_ERROR;
|
|
result_buffer.acquire_fence = -1;
|
|
result_buffer.release_fence = -1;
|
|
|
|
mChannelCB(NULL,
|
|
&result_buffer,
|
|
(uint32_t)frameNumber,
|
|
false,
|
|
mUserData);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void QCamera3YUVChannel::releaseSuperBuf(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
for(uint32_t i =0; i< recvd_frame->num_bufs; i++)
|
|
{
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_CALLBACK) {
|
|
mm_camera_super_buf_t *snap_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*snap_buf = *recvd_frame;
|
|
snap_buf->num_bufs = 1;
|
|
snap_buf->bufs[0] = recvd_frame->bufs[i];
|
|
bufDone(snap_buf);
|
|
free(snap_buf);
|
|
} else if(recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
mm_camera_super_buf_t *meta_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*meta_buf = *recvd_frame;
|
|
meta_buf->num_bufs = 1;
|
|
meta_buf->ch_id = m_pMetaChannel->getMyHandle();
|
|
meta_buf->bufs[0] = recvd_frame->bufs[i];
|
|
m_pMetaChannel->bufDone(meta_buf);
|
|
free(meta_buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QCamera3YUVChannel::ZSLChannelCb(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
if(mAuxYUVChannel) {
|
|
if (recvd_frame->ch_id == mAuxYUVChannel->getMyHandle()) {
|
|
return mAuxYUVChannel->ZSLChannelCb(recvd_frame);
|
|
}
|
|
}
|
|
|
|
LOGI("[KPI Perf]: superbuf frame_idx %d",
|
|
recvd_frame->bufs[0]->frame_idx);
|
|
|
|
uint32_t frameIndex;
|
|
uint32_t frameNum;
|
|
bool metaNeedPP = true;
|
|
cam_stream_type_t reqFrom = CAM_STREAM_TYPE_DEFAULT;
|
|
{
|
|
Mutex::Autolock lock(mReqFrameListLock);
|
|
if (!mReqFrameNumList.empty()) {
|
|
List<zsl_req_t>::iterator it = mReqFrameNumList.begin();
|
|
frameNum = (*it).frameNum;
|
|
reqFrom = (*it).reqStreamType;
|
|
mReqFrameNumList.erase(it);
|
|
if (frameNum == 0xFFFFFFFF) metaNeedPP = false;
|
|
LOGH("Processing ZSL superbuf for frame_number %d", frameNum);
|
|
} else {
|
|
releaseSuperBuf(recvd_frame);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//detect frame drop
|
|
for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
metadata_buffer_t *metadata = (metadata_buffer_t *)recvd_frame->bufs[i]->buffer;
|
|
uint32_t *p_frame_number = POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER, metadata);
|
|
IF_META_AVAILABLE(cam_stream_ID_t, p_cam_frame_drop, CAM_INTF_META_FRAME_DROPPED,
|
|
metadata) {
|
|
LOGH("Dropped frame info for frame_number %d", *p_frame_number);
|
|
for (uint32_t k = 0; k < p_cam_frame_drop->num_streams; k++) {
|
|
if (mStreams[0]->getMyServerID() ==
|
|
p_cam_frame_drop->stream_request[k].streamID) {
|
|
returnBufferError(frameNum);
|
|
releaseSuperBuf(recvd_frame);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_CALLBACK) {
|
|
frameIndex = (uint8_t)recvd_frame->bufs[i]->buf_idx;
|
|
mm_camera_super_buf_t *cb_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*cb_buf = *recvd_frame;
|
|
cb_buf->num_bufs = 1;
|
|
cb_buf->bufs[0] = recvd_frame->bufs[i];
|
|
|
|
LOGD("YUV buf_idx %d", cb_buf->bufs[0]->buf_idx);
|
|
mMemory.markFrameNumber(recvd_frame->bufs[i]->buf_idx, frameNum);
|
|
if((mSinkZSLChannel != NULL) && (reqFrom == mSinkZSLChannel->getMyType()))
|
|
{
|
|
mSinkZSLChannel->streamCbRoutine(cb_buf, mStreams[0]);
|
|
} else {
|
|
streamCbRoutine(cb_buf, mStreams[0]);
|
|
}
|
|
}
|
|
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
mm_camera_super_buf_t *meta_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*meta_buf = *recvd_frame;
|
|
meta_buf->num_bufs = 1;
|
|
meta_buf->ch_id = m_pMetaChannel->getMyHandle();
|
|
meta_buf->bufs[0] = recvd_frame->bufs[i];
|
|
|
|
metadata_buffer_t *metadata = (metadata_buffer_t *)meta_buf->bufs[0]->buffer;
|
|
uint32_t *p_frame_number = POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER, metadata);
|
|
if (p_frame_number) LOGD("meta frame_number : %d", *p_frame_number);
|
|
if (metaNeedPP) {
|
|
if((mSinkZSLChannel != NULL) && (reqFrom == mSinkZSLChannel->getMyType()))
|
|
{
|
|
mSinkZSLChannel->queueReprocMetadata(meta_buf, frameNum, false);
|
|
} else {
|
|
queueReprocMetadata(meta_buf, frameNum, false);
|
|
}
|
|
} else {
|
|
m_pMetaChannel->bufDone(meta_buf);
|
|
free(meta_buf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void QCamera3YUVChannel::stopPostProc()
|
|
{
|
|
if(mPostProcStarted) {
|
|
m_postprocessor.stop();
|
|
mPostProcStarted = false;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : handleOfflinePpCallback
|
|
*
|
|
* DESCRIPTION: callback function for the reprocessed frame from offline
|
|
* postprocessing.
|
|
*
|
|
* PARAMETERS :
|
|
* @resultFrameNumber : frame number on which the buffer was requested
|
|
* @pendingCbs : pending buffers to be returned first
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3YUVChannel::handleOfflinePpCallback(uint32_t resultFrameNumber,
|
|
Vector<mm_camera_super_buf_t *>& pendingCbs)
|
|
{
|
|
Mutex::Autolock lock(mOfflinePpLock);
|
|
List<PpInfo>::iterator ppInfo;
|
|
if(pendingCbs.size() == 0)
|
|
LOGD(" No Pending Call Back ");
|
|
for (ppInfo = mOfflinePpInfoList.begin();
|
|
ppInfo != mOfflinePpInfoList.end(); ppInfo++) {
|
|
if (ppInfo->frameNumber == resultFrameNumber) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ppInfo == mOfflinePpInfoList.end()) {
|
|
LOGI("Request of frame number %d is reprocessing",
|
|
resultFrameNumber);
|
|
return NO_ERROR;
|
|
} else if (ppInfo->offlinePpFlag) {
|
|
int32_t bufferIndex =
|
|
mMemory.getHeapBufferIndex(resultFrameNumber);
|
|
if (bufferIndex < 0) {
|
|
LOGE("Fatal %d: no buffer index for frame number %d",
|
|
bufferIndex, resultFrameNumber);
|
|
return BAD_VALUE;
|
|
}
|
|
LOGD(" Returned Reprocessed Buffer :%d ",resultFrameNumber );
|
|
mMemory.markFrameNumber(bufferIndex, -1);
|
|
if(m_bZSL) {
|
|
mStreams[0]->bufDone(bufferIndex);
|
|
}else {
|
|
mFreeHeapBufferList.push_back(bufferIndex);
|
|
}
|
|
}
|
|
else {
|
|
LOGE("Fatal: request of frame number %d doesn't need"
|
|
" offline postprocessing. However there is"
|
|
" reprocessing callback.",
|
|
resultFrameNumber);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (ppInfo != mOfflinePpInfoList.begin()) {
|
|
LOGD("callback for frame number %d should be head of list",
|
|
resultFrameNumber);
|
|
ppInfo->isReturnBuffer = true;
|
|
return BAD_VALUE;
|
|
} else {
|
|
LOGD(" Erasing Reprocessed Buffer :%d ",resultFrameNumber );
|
|
//Move heap buffer into free pool and invalidate the frame number
|
|
ppInfo = mOfflinePpInfoList.erase(ppInfo);
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getReprocessType
|
|
*
|
|
* DESCRIPTION: get the type of reprocess output supported by this channel
|
|
*
|
|
* PARAMETERS : NONE
|
|
*
|
|
* RETURN : reprocess_type_t : type of reprocess
|
|
*==========================================================================*/
|
|
reprocess_type_t QCamera3YUVChannel::getReprocessType()
|
|
{
|
|
return REPROCESS_TYPE_YUV;
|
|
}
|
|
|
|
void* QCamera3YUVChannel::getQuadraOutputBuffer(uint32_t frameNumber, bool free)
|
|
{
|
|
uint32_t bufIdx = UINT32_MAX;
|
|
|
|
bufIdx = mMemory.getBufferIndex(frameNumber);
|
|
|
|
if(bufIdx == UINT32_MAX)
|
|
{
|
|
LOGE("Could not get output buffer. Unexpected case");
|
|
return NULL;
|
|
}
|
|
void *buffer = mMemory.getBufferHandle(bufIdx);
|
|
if(buffer == NULL)
|
|
{
|
|
LOGE("Could not get output buffer. Unexpected case");
|
|
return NULL;
|
|
}
|
|
|
|
if(free)
|
|
{
|
|
mMemory.unregisterBuffer(bufIdx);
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getMpoOutputBuffer
|
|
*
|
|
* DESCRIPTION: get the output mpo buffer of BOKEH snapshot request (received
|
|
* in PCR).
|
|
*
|
|
* PARAMETERS : (output)pointer to mm_jpeg_output_t structure to get the
|
|
* buffer details.
|
|
*
|
|
* RETURN : BAD_VALUE in case of error else NO_ERROR (int32_t).
|
|
*==========================================================================*/
|
|
int32_t QCamera3PicChannel::getMpoOutputBuffer(mm_jpeg_output_t *output)
|
|
{
|
|
mm_jpeg_output_t buf;
|
|
int32_t bufIdx = getMpoBufferIndex();
|
|
|
|
memset(&buf, 0, sizeof(mm_jpeg_output_t));
|
|
|
|
if(bufIdx < 0)
|
|
{
|
|
LOGE("Error: could not find output buffer index");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
buf.buf_filled_len = mMemory.getSize(bufIdx);
|
|
buf.buf_vaddr = (uint8_t *)mMemory.getPtr(bufIdx);
|
|
buf.fd = mMemory.getFd(bufIdx);
|
|
|
|
*output = buf;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseSnapshotBuffer
|
|
*
|
|
* DESCRIPTION: Release snapshot buffer for next snapshot request. Adding
|
|
* snapshot index to mFreeBufferList so that it can be reused
|
|
* in next request.
|
|
*
|
|
* PARAMETERS :
|
|
* @src_frame : src_frame need to released.
|
|
*
|
|
* RETURN : none.
|
|
*==========================================================================*/
|
|
void QCamera3PicChannel::releaseSnapshotBuffer (mm_camera_super_buf_t*
|
|
src_frame)
|
|
{
|
|
int32_t snapshotIdx = -1;
|
|
if(src_frame == NULL)
|
|
{
|
|
LOGD("Calling release of NULL frame");
|
|
return;
|
|
}
|
|
|
|
if (src_frame) {
|
|
if (mStreams[0]->getMyHandle() ==
|
|
src_frame->bufs[0]->stream_id) {
|
|
snapshotIdx = (int32_t)src_frame->bufs[0]->buf_idx;
|
|
} else {
|
|
LOGD("Snapshot stream id %d and framework"
|
|
"source frame streamid %d don't match!",
|
|
mStreams[0]->getMyHandle(),
|
|
src_frame->bufs[0]->stream_id);
|
|
}
|
|
}
|
|
|
|
if (0 <= snapshotIdx) {
|
|
if (m_bZSL) {
|
|
mStreams[0]->bufDone((uint32_t)snapshotIdx);
|
|
} else {
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
mFreeBufferList.push_back((uint32_t)snapshotIdx);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : mpoEvtHandle
|
|
*
|
|
* DESCRIPTION: Function registerd to postProcessor to handle MPO events.
|
|
*
|
|
* PARAMETERS :
|
|
* @status : status of jpeg job.
|
|
* @p_output : ptr to jpeg output result struct.
|
|
* @userdata : user data ptr.
|
|
*
|
|
* RETURN : none.
|
|
*==========================================================================*/
|
|
void QCamera3PicChannel::mpoEvtHandle(jpeg_job_status_t status,
|
|
mm_jpeg_output_t *p_output,
|
|
void *userdata)
|
|
{
|
|
LOGH("E");
|
|
buffer_handle_t *resultBuffer = NULL;
|
|
buffer_handle_t *jpegBufferHandle = NULL;
|
|
QCamera3PicChannel *obj = (QCamera3PicChannel *)userdata;
|
|
camera3_jpeg_blob_t jpegHeader;
|
|
camera3_stream_buffer_t result;
|
|
int resultStatus = CAMERA3_BUFFER_STATUS_OK;
|
|
|
|
if(status == JPEG_JOB_STATUS_ERROR)
|
|
{
|
|
resultStatus = CAMERA3_BUFFER_STATUS_ERROR;
|
|
}
|
|
|
|
if(obj)
|
|
{
|
|
//create jpeg header
|
|
uint32_t bufIdx = obj->getMpoBufferIndex();
|
|
int32_t resultFrameNumber = obj->mMemory.getFrameNumber(bufIdx);
|
|
jpegHeader.jpeg_blob_id = CAMERA3_JPEG_BLOB_ID;
|
|
if(status == JPEG_JOB_STATUS_DONE)
|
|
{
|
|
char* jpeg_buf = (char *)p_output->buf_vaddr;
|
|
jpegHeader.jpeg_size = p_output->buf_filled_len;
|
|
{
|
|
//dumping mpo output
|
|
cam_frame_len_offset_t offset;
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
mm_camera_buf_def_t *jpeg_dump_buffer = NULL;
|
|
cam_dimension_t dim;
|
|
dim.width = obj->mCamera3Stream->width;
|
|
dim.height = obj->mCamera3Stream->height;
|
|
jpeg_dump_buffer = (mm_camera_buf_def_t *)malloc(sizeof(mm_camera_buf_def_t));
|
|
if(!jpeg_dump_buffer) {
|
|
LOGE("Could not allocate jpeg dump buffer");
|
|
} else {
|
|
jpeg_dump_buffer->buffer = jpeg_buf;
|
|
jpeg_dump_buffer->frame_len = p_output->buf_filled_len;
|
|
jpeg_dump_buffer->frame_idx = obj->mMemory.getFrameNumber(bufIdx);
|
|
obj->dumpYUV(jpeg_dump_buffer, dim, offset, QCAMERA_DUMP_FRM_OUTPUT_JPEG);
|
|
free(jpeg_dump_buffer);
|
|
}
|
|
}
|
|
|
|
ssize_t maxJpegSize = -1;
|
|
|
|
// Gralloc buffer may have additional padding for 4K page size
|
|
// Follow size guidelines based on spec since framework relies
|
|
// on that to reach end of buffer and with it the header
|
|
//Handle same as resultBuffer, but for readablity
|
|
jpegBufferHandle =
|
|
(buffer_handle_t *)obj->mMemory.getBufferHandle(bufIdx);
|
|
if (NULL != jpegBufferHandle) {
|
|
maxJpegSize = ((private_handle_t*)(*jpegBufferHandle))->width;
|
|
if (maxJpegSize <= 0 || maxJpegSize > obj->mMemory.getSize(bufIdx)) {
|
|
maxJpegSize = obj->mMemory.getSize(bufIdx);
|
|
}
|
|
|
|
size_t jpeg_eof_offset =
|
|
(size_t)(maxJpegSize - (ssize_t)sizeof(jpegHeader));
|
|
char *jpeg_eof = &jpeg_buf[jpeg_eof_offset];
|
|
memcpy(jpeg_eof, &jpegHeader, sizeof(jpegHeader));
|
|
obj->mMemory.cleanInvalidateCache(bufIdx);
|
|
} else {
|
|
LOGE("JPEG buffer not found and index: %d",
|
|
bufIdx);
|
|
resultStatus = CAMERA3_BUFFER_STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
////Use below data to issue framework callback
|
|
resultBuffer =
|
|
(buffer_handle_t *)obj->mMemory.getBufferHandle(bufIdx);
|
|
int rc = obj->mMemory.unregisterBuffer(bufIdx);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d unregistering stream buffer %d",
|
|
rc, bufIdx);
|
|
}
|
|
|
|
result.stream = obj->mCamera3Stream;
|
|
result.buffer = resultBuffer;
|
|
result.status = resultStatus;
|
|
result.acquire_fence = -1;
|
|
result.release_fence = -1;
|
|
if (obj->mChannelCB) {
|
|
LOGI("Issue Jpeg Callback frameNumber = %d status = %d",
|
|
resultFrameNumber, resultStatus);
|
|
obj->mChannelCB(NULL,
|
|
&result,
|
|
(uint32_t)resultFrameNumber,
|
|
false,
|
|
obj->mUserData);
|
|
}
|
|
obj->clearMpoBufferIndex();
|
|
} else {
|
|
LOGE("ERROR: NULL MPO USERDATA");
|
|
}
|
|
LOGH("X");
|
|
}
|
|
|
|
/* QCamera3PicChannel methods */
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : jpegEvtHandle
|
|
*
|
|
* DESCRIPTION: Function registerd to mm-jpeg-interface to handle jpeg events.
|
|
Construct result payload and call mChannelCb to deliver buffer
|
|
to framework.
|
|
*
|
|
* PARAMETERS :
|
|
* @status : status of jpeg job
|
|
* @client_hdl: jpeg client handle
|
|
* @jobId : jpeg job Id
|
|
* @p_ouput : ptr to jpeg output result struct
|
|
* @userdata : user data ptr
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3PicChannel::jpegEvtHandle(jpeg_job_status_t status,
|
|
uint32_t /*client_hdl*/,
|
|
uint32_t jobId,
|
|
mm_jpeg_output_t *p_output,
|
|
void *userdata)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PIC_CH_JPEG_EVT_HANDLE);
|
|
buffer_handle_t *resultBuffer = NULL;
|
|
buffer_handle_t *jpegBufferHandle = NULL;
|
|
int resultStatus = CAMERA3_BUFFER_STATUS_OK;
|
|
bool isHDR = false;
|
|
bool isMFCapture = false;
|
|
bool isMFCRaw = false;
|
|
camera3_stream_buffer_t result;
|
|
camera3_jpeg_blob_t jpegHeader;
|
|
|
|
KPI_ATRACE_CAMSCOPE_INT("SNAPSHOT", CAMSCOPE_HAL3_SNAPSHOT, 0);
|
|
QCamera3PicChannel *obj = (QCamera3PicChannel *)userdata;
|
|
if (obj) {
|
|
//Construct payload for process_capture_result. Call mChannelCb
|
|
|
|
qcamera_hal3_jpeg_data_t *job = obj->m_postprocessor.findJpegJobByJobId(jobId);
|
|
|
|
if ((job == NULL) || (status == JPEG_JOB_STATUS_ERROR)) {
|
|
LOGE("Error in jobId: (%d) with status: %d", jobId, status);
|
|
resultStatus = CAMERA3_BUFFER_STATUS_ERROR;
|
|
}
|
|
|
|
if (NULL != job) {
|
|
uint32_t bufIdx = (uint32_t)job->jpeg_settings->out_buf_index;
|
|
LOGD("jpeg out_buf_index: %d and if HDR :%d", bufIdx, job->jpeg_settings->hdr_snapshot);
|
|
isHDR = job->jpeg_settings->hdr_snapshot;
|
|
isMFCapture = job->jpeg_settings->multiframe_snapshot;
|
|
isMFCRaw = job->jpeg_settings->raw_mfc_snapshot;
|
|
//Construct jpeg transient header of type camera3_jpeg_blob_t
|
|
//Append at the end of jpeg image of buf_filled_len size
|
|
|
|
jpegHeader.jpeg_blob_id = CAMERA3_JPEG_BLOB_ID;
|
|
if (JPEG_JOB_STATUS_DONE == status) {
|
|
jpegHeader.jpeg_size = (uint32_t)p_output->buf_filled_len;
|
|
char* jpeg_buf = (char *)p_output->buf_vaddr;
|
|
cam_frame_len_offset_t offset;
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
mm_camera_buf_def_t *jpeg_dump_buffer = NULL;
|
|
cam_dimension_t dim;
|
|
dim.width = obj->mCamera3Stream->width;
|
|
dim.height = obj->mCamera3Stream->height;
|
|
jpeg_dump_buffer = (mm_camera_buf_def_t *)malloc(sizeof(mm_camera_buf_def_t));
|
|
if(!jpeg_dump_buffer) {
|
|
LOGE("Could not allocate jpeg dump buffer");
|
|
} else {
|
|
jpeg_dump_buffer->buffer = p_output->buf_vaddr;
|
|
jpeg_dump_buffer->frame_len = p_output->buf_filled_len;
|
|
jpeg_dump_buffer->frame_idx = obj->mMemory.getFrameNumber(bufIdx);
|
|
obj->dumpYUV(jpeg_dump_buffer, dim, offset, QCAMERA_DUMP_FRM_OUTPUT_JPEG);
|
|
free(jpeg_dump_buffer);
|
|
}
|
|
|
|
ssize_t maxJpegSize = -1;
|
|
|
|
// Gralloc buffer may have additional padding for 4K page size
|
|
// Follow size guidelines based on spec since framework relies
|
|
// on that to reach end of buffer and with it the header
|
|
|
|
//Handle same as resultBuffer, but for readablity
|
|
jpegBufferHandle =
|
|
(buffer_handle_t *)obj->mMemory.getBufferHandle(bufIdx);
|
|
|
|
if (NULL != jpegBufferHandle) {
|
|
maxJpegSize = ((private_handle_t*)(*jpegBufferHandle))->width;
|
|
if (maxJpegSize <= 0 || maxJpegSize > obj->mMemory.getSize(bufIdx)) {
|
|
maxJpegSize = obj->mMemory.getSize(bufIdx);
|
|
}
|
|
|
|
size_t jpeg_eof_offset =
|
|
(size_t)(maxJpegSize - (ssize_t)sizeof(jpegHeader));
|
|
char *jpeg_eof = &jpeg_buf[jpeg_eof_offset];
|
|
memcpy(jpeg_eof, &jpegHeader, sizeof(jpegHeader));
|
|
obj->mMemory.cleanInvalidateCache(bufIdx);
|
|
} else {
|
|
LOGE("JPEG buffer not found and index: %d",
|
|
bufIdx);
|
|
resultStatus = CAMERA3_BUFFER_STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
////Use below data to issue framework callback
|
|
resultBuffer =
|
|
(buffer_handle_t *)obj->mMemory.getBufferHandle(bufIdx);
|
|
int32_t resultFrameNumber = obj->mMemory.getFrameNumber(bufIdx);
|
|
int32_t rc = obj->mMemory.unregisterBuffer(bufIdx);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d unregistering stream buffer %d",
|
|
rc, bufIdx);
|
|
}
|
|
|
|
result.stream = obj->mCamera3Stream;
|
|
result.buffer = resultBuffer;
|
|
result.status = resultStatus;
|
|
result.acquire_fence = -1;
|
|
result.release_fence = -1;
|
|
|
|
// Release any snapshot buffers before calling
|
|
// the user callback. The callback can potentially
|
|
// unblock pending requests to snapshot stream.
|
|
int32_t snapshotIdx = -1;
|
|
mm_camera_super_buf_t* src_frame = NULL;
|
|
|
|
if (job->src_reproc_frame)
|
|
src_frame = job->src_reproc_frame;
|
|
else
|
|
src_frame = job->src_frame;
|
|
|
|
if (src_frame) {
|
|
if ((is_dual_camera_by_handle(obj->mStreams[0]->getMyHandle())
|
|
&& ((get_main_camera_handle(obj->mStreams[0]->getMyHandle()))
|
|
|| (get_aux_camera_handle(obj->mStreams[0]->getMyHandle()))))
|
|
|| (obj->mStreams[0]->getMyHandle() ==
|
|
src_frame->bufs[0]->stream_id)) {
|
|
snapshotIdx = (int32_t)src_frame->bufs[0]->buf_idx;
|
|
} else {
|
|
LOGD("Snapshot stream id %d and framework"
|
|
"source frame streamid %d don't match!",
|
|
obj->mStreams[0]->getMyHandle(),
|
|
src_frame->bufs[0]->stream_id);
|
|
}
|
|
}
|
|
if (0 <= snapshotIdx) {
|
|
LOGD("Pushing snapshot buf idx %d to freebuf list", snapshotIdx);
|
|
|
|
if (obj->m_bZSL) {
|
|
obj->mStreams[0]->bufDone(snapshotIdx);
|
|
} else {
|
|
Mutex::Autolock lock(obj->mFreeBuffersLock);
|
|
obj->mFreeBufferList.push_back((uint32_t)snapshotIdx);
|
|
}
|
|
}
|
|
|
|
if (isMFCRaw) {
|
|
QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)obj->mUserData;
|
|
hw->mMultiRawChannel->finishCapture();
|
|
}
|
|
|
|
if(isHDR || isMFCRaw || isMFCapture) {
|
|
obj->mPostProcStarted = false;
|
|
obj->m_postprocessor.mChannelStop = false;
|
|
} else {
|
|
LOGI("Issue Jpeg Callback frameNumber = %d status = %d and %d",
|
|
resultFrameNumber, resultStatus, isHDR);
|
|
if (obj->mChannelCB) {
|
|
obj->mChannelCB(NULL,
|
|
&result,
|
|
(uint32_t)resultFrameNumber,
|
|
false,
|
|
obj->mUserData);
|
|
}
|
|
}
|
|
|
|
// release internal data for jpeg job
|
|
if ((NULL != job->fwk_frame) || (NULL != job->fwk_src_buffer)) {
|
|
/* unregister offline input buffer */
|
|
int32_t inputBufIndex =
|
|
obj->mOfflineMemory.getGrallocBufferIndex((uint32_t)resultFrameNumber);
|
|
if (0 <= inputBufIndex) {
|
|
rc = obj->mOfflineMemory.unregisterBuffer(inputBufIndex);
|
|
} else {
|
|
LOGE("could not find the input buf index, frame number %d",
|
|
resultFrameNumber);
|
|
}
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d unregistering input buffer %d",
|
|
rc, bufIdx);
|
|
}
|
|
|
|
/* unregister offline meta buffer */
|
|
int32_t metaBufIndex =
|
|
obj->mOfflineMetaMemory.getHeapBufferIndex((uint32_t)resultFrameNumber);
|
|
if (0 <= metaBufIndex) {
|
|
Mutex::Autolock lock(obj->mFreeOfflineMetaBuffersLock);
|
|
obj->mFreeOfflineMetaBuffersList.push_back((uint32_t)metaBufIndex);
|
|
} else {
|
|
LOGE("could not find the input meta buf index, frame number %d",
|
|
resultFrameNumber);
|
|
}
|
|
}else {
|
|
obj->m_postprocessor.releaseOfflineBuffers(false);
|
|
}
|
|
obj->m_postprocessor.releaseJpegJobData(job);
|
|
free(job);
|
|
if(isHDR || isMFCapture || isMFCRaw) {
|
|
LOGD("Calling PostProc Stopped sending ");
|
|
if (obj->mChannelCB) {
|
|
obj->mChannelCB(NULL,
|
|
&result,
|
|
(uint32_t)resultFrameNumber,
|
|
false,
|
|
obj->mUserData);
|
|
}
|
|
obj->m_postprocessor.stop(true);
|
|
}
|
|
|
|
QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)obj->mUserData;
|
|
if (hw->isQuadCfaSensor()) {
|
|
hw->deleteQCFACaptureChannel();
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
// }
|
|
} else {
|
|
LOGE("Null userdata in jpeg callback");
|
|
}
|
|
}
|
|
|
|
QCamera3PicChannel::QCamera3PicChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buf_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
void *userData,
|
|
camera3_stream_t *stream,
|
|
cam_feature_mask_t postprocess_mask,
|
|
__unused bool is4KVideo,
|
|
bool isInputStreamConfigured,
|
|
QCamera3Channel *metadataChannel,
|
|
uint32_t numBuffers, bool isZSL, bool isLiveshot) :
|
|
QCamera3ProcessingChannel(cam_handle, channel_handle,
|
|
cam_ops, cb_routine, cb_buf_err, paddingInfo, userData,
|
|
stream, CAM_STREAM_TYPE_SNAPSHOT,
|
|
postprocess_mask, metadataChannel, numBuffers),
|
|
mNumSnapshotBufs(0),
|
|
mInputBufferHint(isInputStreamConfigured),
|
|
mYuvMemory(NULL),
|
|
mFrameLen(0),
|
|
mAuxPicChannel(NULL),
|
|
mNeedPPUpscale(false),
|
|
m_bMpoEnabled(true)
|
|
{
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
m_max_pic_dim = hal_obj->calcMaxJpegDim();
|
|
mYuvWidth = stream->width;
|
|
mYuvHeight = stream->height;
|
|
mStreamType = CAM_STREAM_TYPE_SNAPSHOT;
|
|
// Use same pixelformat for 4K video case
|
|
mStreamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_SNAPSHOT,
|
|
stream->width, stream->height);
|
|
setZSLMode(isZSL);
|
|
mLiveShot = isLiveshot;
|
|
m_bStarted = false;
|
|
mInit = false;
|
|
LOGH("Configuring picchannel in %s mode", isZSL ? "ZSL" : "psuedo-ZSL");
|
|
int32_t rc = m_postprocessor.initJpeg(jpegEvtHandle, mpoEvtHandle, &m_max_pic_dim, this);
|
|
if (rc != 0) {
|
|
LOGE("Init Postprocessor failed");
|
|
}
|
|
mCompositeHandle = channel_handle;
|
|
if (is_dual_camera_by_handle(cam_handle)) {
|
|
m_camHandle = get_main_camera_handle(cam_handle);
|
|
m_handle = get_main_camera_handle(channel_handle);
|
|
mAuxPicChannel = new QCamera3PicChannel(get_aux_camera_handle(cam_handle),
|
|
get_aux_camera_handle(channel_handle),
|
|
cam_ops, cb_routine, cb_buf_err,
|
|
paddingInfo, userData, stream,
|
|
postprocess_mask, is4KVideo,
|
|
isInputStreamConfigured,
|
|
metadataChannel, numBuffers, isZSL, isLiveshot);
|
|
setDualChannelMode(true);
|
|
}
|
|
mAllocDone = false;
|
|
mAllocThread = 0;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : flush
|
|
*
|
|
* DESCRIPTION: flush pic channel, which will stop all processing within, including
|
|
* the reprocessing channel in postprocessor and YUV stream.
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3PicChannel::flush()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if(!m_bIsActive && !m_bSkipConfig) {
|
|
LOGE("Attempt to flush inactive channel");
|
|
return NO_INIT;
|
|
}
|
|
|
|
rc = m_postprocessor.flush();
|
|
if (rc == 0) {
|
|
LOGE("Postprocessor flush failed, rc = %d", rc);
|
|
return rc;
|
|
}
|
|
|
|
if (0 < mOfflineMetaMemory.getCnt()) {
|
|
mOfflineMetaMemory.deallocate();
|
|
}
|
|
if (0 < mOfflineMemory.getCnt()) {
|
|
mOfflineMemory.unregisterBuffers();
|
|
}
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
mFreeBufferList.clear();
|
|
|
|
if (!m_bZSL) {
|
|
for (uint32_t i = 0; i < mCamera3Stream->max_buffers; i++) {
|
|
mFreeBufferList.push_back(i);
|
|
}
|
|
}
|
|
|
|
{
|
|
Mutex::Autolock lock(mFreeJpegBufferLock);
|
|
mFreeJpegBufferList.clear();
|
|
}
|
|
|
|
if (mAuxPicChannel) {
|
|
rc = mAuxPicChannel->flush();
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
QCamera3PicChannel::~QCamera3PicChannel()
|
|
{
|
|
if(m_bSkipConfig)
|
|
{
|
|
//reset stream added from source
|
|
//stream deletion will be taken care by
|
|
//source channel
|
|
if(IS_VALID_PTR(mSourceZSLChannel)
|
|
&& IS_VALID_PTR(mStreams[0]))
|
|
{
|
|
mStreams[0] = NULL;
|
|
m_numStreams--;
|
|
}
|
|
}
|
|
|
|
if(mInit)
|
|
{
|
|
deleteChannel();
|
|
mInit = false;
|
|
}
|
|
if(0 < mJpegMemory.getCnt())
|
|
{
|
|
mJpegMemory.deallocate();
|
|
Mutex::Autolock lock(mFreeJpegBufferLock);
|
|
mFreeJpegBufferList.clear();
|
|
}
|
|
if (mAuxPicChannel) {
|
|
delete mAuxPicChannel;
|
|
mAuxPicChannel = NULL;
|
|
}
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::start()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if(m_bSkipConfig)
|
|
{
|
|
if(!IS_VALID_PTR(mStreams[0]) && IS_VALID_PTR(mSourceZSLChannel))
|
|
{
|
|
mStreams[0] = mSourceZSLChannel->getStreamByIndex(0);
|
|
if(mStreams[0] != NULL)
|
|
{
|
|
m_numStreams++;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
mAllocDone = false;
|
|
mAllocThread = 0;
|
|
|
|
if(m_bIsActive) {
|
|
LOGE("Attempt to start active channel");
|
|
return rc;
|
|
}
|
|
|
|
QCamera3Channel::start();
|
|
}
|
|
|
|
if (mAuxPicChannel) {
|
|
rc = mAuxPicChannel->start();
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::stop()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if(!m_bSkipConfig)
|
|
{
|
|
if(!m_bIsActive) {
|
|
LOGE("Attempt to stop inactive channel");
|
|
return rc;
|
|
}
|
|
|
|
if (mAllocThread != 0) {
|
|
pthread_join(mAllocThread,NULL);
|
|
mAllocThread = 0;
|
|
}
|
|
QCamera3ProcessingChannel::stop();
|
|
|
|
stopChannel();
|
|
} else {
|
|
m_postprocessor.stop();
|
|
mPostProcStarted = false;
|
|
}
|
|
|
|
if (mAuxPicChannel) {
|
|
rc = mAuxPicChannel->stop();
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::stopChannel()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if (!mLiveShot) return NO_ERROR;
|
|
|
|
if(!m_bStarted) {
|
|
LOGD("Attempt to stop inactive channel");
|
|
if(mAuxPicChannel)
|
|
{
|
|
return mAuxPicChannel->stopChannel();
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
LOGD("QCamera3PicChannel::stopChannel");
|
|
|
|
rc = m_camOps->stop_channel(m_camHandle, m_handle);
|
|
if(rc == NO_ERROR){
|
|
m_bStarted = false;
|
|
}
|
|
|
|
if(mAuxPicChannel){
|
|
mAuxPicChannel->stopChannel();
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::startChannel()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if(m_bStarted) {
|
|
LOGD("Attempt to start active channel");
|
|
return rc;
|
|
}
|
|
|
|
if (!mLiveShot) return NO_ERROR;
|
|
LOGD("QCamera3PicChannel::startChannel");
|
|
|
|
QCamera3HardwareInterface *hal_obj= (QCamera3HardwareInterface *)mUserData;
|
|
if(m_bDualChannel)
|
|
{
|
|
bool isMaster = mAuxPicChannel ?
|
|
(mMasterCam == CAM_TYPE_MAIN): (mMasterCam == CAM_TYPE_AUX);
|
|
if(mAuxPicChannel && (!isMaster || hal_obj->needHALPP())){
|
|
mAuxPicChannel->startChannel();
|
|
}
|
|
}
|
|
|
|
rc = m_camOps->start_channel(m_camHandle, m_handle);
|
|
if(rc == NO_ERROR){
|
|
m_bStarted = true;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3PicChannel::setDualChannelMode(bool bMode)
|
|
{
|
|
QCamera3Channel::setDualChannelMode(bMode);
|
|
if(NULL != mAuxPicChannel)
|
|
{
|
|
mAuxPicChannel->setDualChannelMode(bMode);
|
|
}
|
|
}
|
|
|
|
void QCamera3PicChannel::setZSLMode(bool mode)
|
|
{
|
|
if(mAuxPicChannel)
|
|
{
|
|
mAuxPicChannel->setZSLMode(mode);
|
|
}
|
|
LOGD("snapshot stream zsl mode:%s", mode?"TRUE":"FALSE");
|
|
m_bZSL = mode;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::addChannel()
|
|
{
|
|
if (!mLiveShot) return NO_ERROR;
|
|
int32_t rc = NO_ERROR;
|
|
uint32_t handle = 0;
|
|
|
|
handle = m_camOps->add_channel(m_camHandle, NULL, NULL, this);
|
|
|
|
if(!m_bDualChannel || (mAuxPicChannel != NULL))
|
|
{
|
|
m_handle = get_main_camera_handle(handle);
|
|
} else {
|
|
m_handle = get_aux_camera_handle(handle);
|
|
}
|
|
if (m_handle == 0) {
|
|
LOGE("Add channel failed");
|
|
rc = UNKNOWN_ERROR;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::deleteChannel()
|
|
{
|
|
if (!mLiveShot) return NO_ERROR;
|
|
destroy();
|
|
|
|
int32_t rc = NO_ERROR;
|
|
if (m_handle) {
|
|
rc = m_camOps->delete_channel(m_camHandle, m_handle);
|
|
LOGD("deleting channel %d", m_handle);
|
|
m_handle = 0;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
cam_dimension_t streamDim;
|
|
cam_stream_type_t streamType;
|
|
cam_format_t streamFormat;
|
|
|
|
if (NULL == mCamera3Stream) {
|
|
LOGE("Camera stream uninitialized");
|
|
return NO_INIT;
|
|
}
|
|
|
|
if (1 <= m_numStreams) {
|
|
// Only one stream per channel supported in v3 Hal
|
|
return NO_ERROR;
|
|
}
|
|
|
|
mIsType = isType;
|
|
streamType = mStreamType;
|
|
streamFormat = mStreamFormat;
|
|
streamDim.width = (int32_t)mYuvWidth;
|
|
streamDim.height = (int32_t)mYuvHeight;
|
|
|
|
addChannel();
|
|
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
|
|
if(m_bDualChannel)
|
|
{
|
|
//if 2 channels are configure with different dimensions
|
|
//for low configuration don't change the stream dimension.
|
|
hal_obj->rectifyStreamDimIfNeeded(
|
|
streamDim, (mAuxPicChannel != NULL) ? CAM_TYPE_MAIN: CAM_TYPE_AUX, mNeedPPUpscale);
|
|
mYuvWidth = streamDim.width;
|
|
mYuvHeight = streamDim.height;
|
|
}
|
|
|
|
mNumSnapshotBufs = mCamera3Stream->max_buffers;
|
|
if(!m_bSkipConfig)
|
|
{
|
|
rc = QCamera3Channel::addStream(streamType, streamFormat, streamDim,
|
|
ROTATE_0, (uint8_t)mCamera3Stream->max_buffers, mPostProcMask,
|
|
mIsType, 0 , !m_bZSL, m_bZSL);
|
|
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Initialize failed, rc = %d", rc);
|
|
return rc;
|
|
}
|
|
}else {
|
|
LOGD("Skipped adding stream to channel.hint:YUV ZSL mode");
|
|
}
|
|
|
|
/* initialize offline meta memory for input reprocess */
|
|
rc = QCamera3ProcessingChannel::initialize(isType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Processing Channel initialize failed, rc = %d",
|
|
rc);
|
|
}
|
|
|
|
if (mAuxPicChannel) {
|
|
mAuxPicChannel->initialize(isType);
|
|
}
|
|
configureMpo();
|
|
mInit = true;
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3PicChannel::configureMpo()
|
|
{
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
property_get("persist.vendor.camera.mpo.disabled",prop,"0");
|
|
m_bMpoEnabled = atoi(prop)?FALSE:TRUE;
|
|
m_postprocessor.setMpoMode(m_bMpoEnabled);
|
|
}
|
|
void QCamera3PicChannel::stopPostProc()
|
|
{
|
|
if(mPostProcStarted) {
|
|
m_postprocessor.stop();
|
|
mPostProcStarted = false;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : cancelFramePProc
|
|
*
|
|
* DESCRIPTION: cancel FramePost Processing request.
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : frame number for which postproc request need to be cancel.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
*==========================================================================*/
|
|
int32_t QCamera3PicChannel::cancelFramePProc(uint32_t framenum,
|
|
cam_sync_type_t cam)
|
|
{
|
|
int rc = NO_ERROR;
|
|
if(mAuxPicChannel != NULL){
|
|
return mAuxPicChannel->cancelFramePProc(framenum,cam);
|
|
}
|
|
rc = QCamera3ProcessingChannel::cancelFramePProc(framenum);
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : request
|
|
*
|
|
* DESCRIPTION: handle the request - either with an input buffer or a direct
|
|
* output request
|
|
*
|
|
* PARAMETERS :
|
|
* @buffer : pointer to the output buffer
|
|
* @frameNumber : frame number of the request
|
|
* @pInputBuffer : pointer to input buffer if an input request
|
|
* @metadata : parameters associated with the request
|
|
* @internalreq : boolean to indicate if this is purely internal request
|
|
* needing internal buffer allocation
|
|
* @meteringonly : boolean indicating metering only frame subset of internal
|
|
* not consumed by postprocessor
|
|
*
|
|
* RETURN : 0 on a success start of capture
|
|
* -EINVAL on invalid input
|
|
* -ENODEV on serious error
|
|
*==========================================================================*/
|
|
int32_t QCamera3PicChannel::request(buffer_handle_t *buffer,
|
|
uint32_t frameNumber,
|
|
camera3_stream_buffer_t *pInputBuffer,
|
|
metadata_buffer_t *metadata, int &indexUsed,
|
|
bool internalRequest, bool meteringOnly, bool isZSL)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PIC_CH_REQ);
|
|
//FIX ME: Return buffer back in case of failures below.
|
|
|
|
int32_t rc = NO_ERROR;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
|
|
reprocess_config_t reproc_cfg;
|
|
cam_dimension_t dim;
|
|
memset(&reproc_cfg, 0, sizeof(reprocess_config_t));
|
|
//make sure to set the correct input stream dim in case of YUV size override
|
|
//and recalculate the plane info
|
|
dim.width = (int32_t)mYuvWidth;
|
|
dim.height = (int32_t)mYuvHeight;
|
|
|
|
if (hal_obj->m_bInSensorQCFA && hal_obj->m_bQuadraCfaRequest) {
|
|
dim = hal_obj->getQuadraCfaDim();
|
|
}
|
|
|
|
if((mSourceZSLChannel != NULL) && (pInputBuffer == NULL))
|
|
{
|
|
mSourceZSLChannel->getStreamSize(dim);
|
|
}
|
|
|
|
setReprocConfig(reproc_cfg, pInputBuffer, metadata, mStreamFormat, dim, mNeedPPUpscale);
|
|
|
|
if (!hal_obj->m_bInSensorQCFA && hal_obj->m_bQuadraCfaRequest) {
|
|
LOGI("override reprocess input config for quadra cfa");
|
|
reproc_cfg.input_stream_dim = hal_obj->getQuadraCfaDim();
|
|
reproc_cfg.stream_format = hal_obj->mRdiModeFmt;
|
|
reproc_cfg.stream_type = CAM_STREAM_TYPE_RAW;
|
|
mm_stream_calc_offset_raw(reproc_cfg.stream_format, &reproc_cfg.input_stream_dim,
|
|
reproc_cfg.padding, &reproc_cfg.input_stream_plane_info);
|
|
}
|
|
|
|
if (hal_obj->m_bMultiRawRequest) {
|
|
LOGI("override reprocess input config for raw");
|
|
reproc_cfg.input_stream_dim = hal_obj->getMaxRawSize(hal_obj->getCameraId());
|
|
reproc_cfg.stream_format = hal_obj->mRdiModeFmt;
|
|
reproc_cfg.stream_type = CAM_STREAM_TYPE_RAW;
|
|
reproc_cfg.src_channel = hal_obj->mMultiRawChannel;
|
|
mm_stream_calc_offset_raw(reproc_cfg.stream_format, &reproc_cfg.input_stream_dim,
|
|
reproc_cfg.padding, &reproc_cfg.input_stream_plane_info);
|
|
}
|
|
|
|
// Picture stream has already been started before any request comes in
|
|
if (!m_bIsActive && !m_bSkipConfig) {
|
|
LOGE("Channel not started!!");
|
|
return NO_INIT;
|
|
}
|
|
|
|
if (m_bZSL && (mAllocThread != 0)) {
|
|
pthread_join(mAllocThread, NULL);
|
|
mAllocThread = 0;
|
|
}
|
|
|
|
// Start postprocessor
|
|
LOGD(" Starting Postproc Channel");
|
|
startPostProc(reproc_cfg);
|
|
|
|
//B+M DualCam mode: Main channel will always be Bayre.
|
|
// mAuxPicChannel will always be Mono.
|
|
//W+T DualCam mode: Main channel will always be Wide.
|
|
// mAuxPicChannel will always be Tele.
|
|
//bIsMaster will be true if current pic channel is mMasterCam.
|
|
bool bIsMaster = true;
|
|
if(m_bDualChannel)
|
|
{
|
|
bIsMaster = mAuxPicChannel ? (mMasterCam == CAM_TYPE_MAIN) : (mMasterCam == CAM_TYPE_AUX);
|
|
}
|
|
|
|
//if needHALPP() is false then take snapshot from mMaster channel,
|
|
// else request on both channels.
|
|
if(hal_obj->needHALPP() || bIsMaster)
|
|
{
|
|
if (!internalRequest) {
|
|
if(hal_obj->needHALPP()
|
|
&& (hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH)
|
|
&& isMpoEnabled())
|
|
{ //BOKEH MODE
|
|
//Master channel: allocate 2 jpeg settings one for main image
|
|
//and other for bokeh with respective output buffer index.
|
|
//Non Master will allocate buffer for depth image.
|
|
int index = -1;
|
|
int numOfJpegSettings = 1;
|
|
if(bIsMaster)
|
|
{
|
|
numOfJpegSettings = 2;
|
|
}
|
|
for (int i =0; i < numOfJpegSettings; i++)
|
|
{
|
|
Mutex::Autolock lock(mFreeJpegBufferLock);
|
|
if (mFreeJpegBufferList.empty()) {
|
|
if(bIsMaster)
|
|
{
|
|
index = mJpegMemory.allocateOne(mCamera3Stream->width *
|
|
mCamera3Stream->height);
|
|
} else {
|
|
cam_dimension_t dim = {0,0};
|
|
#ifdef ENABLE_QC_BOKEH
|
|
qrcp::getDepthMapSize(mCamera3Stream->width,
|
|
mCamera3Stream->height,
|
|
dim.width, dim.height);
|
|
#else
|
|
dim.width = mCamera3Stream->width;
|
|
dim.height = mCamera3Stream->height;
|
|
#endif //ENABLE_QC_BOKEH
|
|
index = mJpegMemory.allocateOne(dim.width * dim.height);
|
|
}
|
|
if(index < 0)
|
|
{
|
|
LOGE("Could not allocate HEAP Memory");
|
|
return index;
|
|
}
|
|
} else{
|
|
auto it = mFreeJpegBufferList.begin();
|
|
index = *it;
|
|
mFreeJpegBufferList.erase(it);
|
|
}
|
|
LOGD("buffer index %d, frameNumber: %u %p", index, frameNumber, &mJpegMemory);
|
|
|
|
rc = mJpegMemory.markFrameNumber((uint32_t)index, frameNumber);
|
|
|
|
// Queue jpeg settings
|
|
if (bIsMaster) {
|
|
rc = queueJpegSetting((uint32_t)index, frameNumber, metadata, (i==0)?
|
|
CAM_HAL3_JPEG_TYPE_MAIN : CAM_HAL3_JPEG_TYPE_BOKEH);
|
|
} else {
|
|
rc = queueJpegSetting((uint32_t)index, frameNumber, metadata,
|
|
CAM_HAL3_JPEG_TYPE_DEPTH);
|
|
}
|
|
}
|
|
if(bIsMaster)
|
|
{
|
|
//Get the index of framework allocated buffer, will be required while composeMpo
|
|
int index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if(index < 0) {
|
|
rc = registerBuffer(buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d", rc);
|
|
return rc;
|
|
}
|
|
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if (index < 0) {
|
|
LOGE("Could not find object among registered buffers");
|
|
return DEAD_OBJECT;
|
|
}
|
|
}
|
|
|
|
mMpoOutBufIndex = (uint32_t) index;
|
|
|
|
rc = mMemory.markFrameNumber((uint32_t)index, frameNumber);
|
|
}
|
|
}
|
|
else {
|
|
// For FUSION usecase i.e. needHALPP is true in non-BOKEH mode:
|
|
// jpeg_setting for slave is only required for overideMetadata
|
|
// so setting invalid index.
|
|
int index = -1;
|
|
if(bIsMaster)
|
|
{
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
|
|
if(index < 0) {
|
|
rc = registerBuffer(buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
index = mMemory.getMatchBufIndex((void*)buffer);
|
|
if (index < 0) {
|
|
LOGE("Could not find object among registered buffers");
|
|
return DEAD_OBJECT;
|
|
}
|
|
}
|
|
LOGD("buffer index %d, frameNumber: %u", index, frameNumber);
|
|
|
|
rc = mMemory.markFrameNumber((uint32_t)index, frameNumber);
|
|
}
|
|
// Queue jpeg settings
|
|
if(hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_DUAL_FOV)
|
|
{
|
|
rc = queueJpegSetting((uint32_t)index, frameNumber, metadata, bIsMaster ?
|
|
CAM_HAL3_JPEG_TYPE_FUSION : CAM_HAL3_JPEG_TYPE_AUX);
|
|
} else if ((hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH)
|
|
&& bIsMaster && hal_obj->needHALPP()){
|
|
rc = queueJpegSetting((uint32_t)index, frameNumber, metadata,
|
|
CAM_HAL3_JPEG_TYPE_BOKEH);
|
|
} else {
|
|
rc = queueJpegSetting((uint32_t)index, frameNumber, metadata, bIsMaster ?
|
|
CAM_HAL3_JPEG_TYPE_MAIN : CAM_HAL3_JPEG_TYPE_AUX);
|
|
}
|
|
}
|
|
} else {
|
|
LOGD("Internal request @ Picchannel");
|
|
}
|
|
|
|
if (hal_obj->m_bMultiRawRequest) {
|
|
LOGH("nothing needed here for multi raw capture");
|
|
return rc;
|
|
}
|
|
|
|
|
|
if (pInputBuffer == NULL && hal_obj->m_bQuadraCfaRequest) {
|
|
LOGI("trigger reprocess for quadra cfa");
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
QCamera3QCfaCaptureChannel *pChannel = hal_obj->mQCFACaptureChannel;
|
|
if (pChannel == NULL || !pChannel->meta_received || !pChannel->data_received) {
|
|
LOGE("request failed!");
|
|
return -1;
|
|
}
|
|
|
|
mm_camera_super_buf_t *super_buf =
|
|
(mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (super_buf == NULL) {
|
|
LOGE("fail to allocate memory");
|
|
return -1;
|
|
}
|
|
memcpy(super_buf, &(pChannel->meta_frame), sizeof(mm_camera_super_buf_t));
|
|
m_postprocessor.processPPMetadata(super_buf, frameNumber, false);
|
|
|
|
super_buf = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (super_buf == NULL) {
|
|
LOGE("fail to allocate memory");
|
|
return -1;
|
|
}
|
|
memcpy(super_buf, &(pChannel->capture_frame), sizeof(mm_camera_super_buf_t));
|
|
m_postprocessor.processData(super_buf, NULL, frameNumber);
|
|
} else if ((pInputBuffer == NULL) && m_bZSL) {
|
|
QCamera3ProcessingChannel *zslChannel = (QCamera3ProcessingChannel *)this;
|
|
uint32_t handle = zslChannel->getMyHandle();
|
|
if(IS_VALID_PTR(mSourceZSLChannel))
|
|
{
|
|
zslChannel = mSourceZSLChannel;
|
|
handle = zslChannel->getCompositeHandle();
|
|
}
|
|
{
|
|
zsl_req_t req;
|
|
memset(&req,0,sizeof(zsl_req_t));
|
|
req.reqStreamType = mStreamType;
|
|
Mutex::Autolock lock(zslChannel->mReqFrameListLock);
|
|
if (meteringOnly) {
|
|
req.frameNum = 0xFFFFFFFF;
|
|
} else {
|
|
req.frameNum = frameNumber;
|
|
}
|
|
zslChannel->mReqFrameNumList.push_back(req);
|
|
}
|
|
|
|
if (isZSL) {
|
|
zslChannel->requestZSLBuf(m_camHandle, handle);
|
|
} else {
|
|
zslChannel->requestZSLBuf(m_camHandle, handle,frameNumber);
|
|
}
|
|
indexUsed = CAM_FREERUN_IDX;
|
|
} else if (pInputBuffer == NULL) {
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
uint32_t bufIdx;
|
|
if (mFreeBufferList.empty()) {
|
|
rc = mYuvMemory->allocateOne(mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("Failed to allocate heap buffer. Fatal");
|
|
return rc;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
}
|
|
} else {
|
|
List<uint32_t>::iterator it = mFreeBufferList.begin();
|
|
bufIdx = *it;
|
|
mFreeBufferList.erase(it);
|
|
}
|
|
if (meteringOnly) {
|
|
mYuvMemory->markFrameNumber(bufIdx, 0xFFFFFFFF);
|
|
} else {
|
|
mYuvMemory->markFrameNumber(bufIdx, frameNumber);
|
|
}
|
|
mStreams[0]->bufDone(bufIdx);
|
|
indexUsed = bufIdx;
|
|
} else {
|
|
qcamera_fwk_input_pp_data_t *src_frame = NULL;
|
|
src_frame = (qcamera_fwk_input_pp_data_t *)calloc(1,
|
|
sizeof(qcamera_fwk_input_pp_data_t));
|
|
if (src_frame == NULL) {
|
|
LOGE("No memory for src frame");
|
|
return NO_MEMORY;
|
|
}
|
|
rc = setFwkInputPPData(src_frame, pInputBuffer, &reproc_cfg, metadata,
|
|
NULL /*fwk output buffer*/, frameNumber);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d while setting framework input PP data", rc);
|
|
free(src_frame);
|
|
return rc;
|
|
}
|
|
LOGH("Post-process started");
|
|
m_postprocessor.processData(src_frame);
|
|
}
|
|
}
|
|
|
|
if (mAuxPicChannel && (!bIsMaster || hal_obj->needHALPP()) ) {
|
|
int AuxIndexUsed = 0;
|
|
rc = mAuxPicChannel->request(buffer, frameNumber,
|
|
pInputBuffer, metadata, AuxIndexUsed,
|
|
internalRequest, meteringOnly, isZSL);
|
|
//Only mMasterCam indexUsed is required, slave is in freeRunIdx
|
|
if((rc != -1) && (!bIsMaster))
|
|
{
|
|
indexUsed = AuxIndexUsed;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3PicChannel::setAuxSourceZSLChannel(QCamera3ProcessingChannel *srcZsl,
|
|
zsl_stream_type_t zslType,
|
|
bool skipConfig)
|
|
{
|
|
if(IS_VALID_PTR(mAuxPicChannel))
|
|
{
|
|
mAuxPicChannel->setSourceZSLChannel(srcZsl,zslType,skipConfig);
|
|
}
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::requestZSLBuf(uint32_t camera_handle,
|
|
uint32_t ch_handle, uint32_t frameNumber, uint32_t numBuf)
|
|
{
|
|
uint32_t cam_handle = camera_handle;
|
|
uint32_t channel_handle = ch_handle;
|
|
LOGH("frameNumber %d", frameNumber);
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if((hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH) && hal_obj->needHALPP()) {
|
|
if (mAuxPicChannel) {
|
|
return NO_ERROR;
|
|
} else {
|
|
//derive composite handles from metadata channel
|
|
channel_handle = m_pMetaChannel->getMyHandle();
|
|
cam_handle = m_pMetaChannel->getMyCamHandle();
|
|
}
|
|
}
|
|
|
|
mm_camera_req_buf_t buf;
|
|
memset(&buf, 0x0, sizeof(buf));
|
|
buf.type = MM_CAMERA_REQ_SUPER_BUF;
|
|
buf.num_buf_requested = numBuf;
|
|
buf.frame_idx = frameNumber;
|
|
return m_camOps->request_super_buf(cam_handle, channel_handle, &buf);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : dataNotifyCB
|
|
*
|
|
* DESCRIPTION: Channel Level callback used for super buffer data notify.
|
|
* This function is registered with mm-camera-interface to handle
|
|
* data notify
|
|
*
|
|
* PARAMETERS :
|
|
* @recvd_frame : stream frame received
|
|
* userdata : user data ptr
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3PicChannel::dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
|
|
void *userdata)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_PIC_CH_DATA_NOTIFY_CB);
|
|
LOGD("E\n");
|
|
QCamera3PicChannel *channel = (QCamera3PicChannel *)userdata;
|
|
|
|
if (channel == NULL) {
|
|
LOGE("invalid channel pointer");
|
|
return;
|
|
}
|
|
|
|
if(channel->m_numStreams != 1) {
|
|
LOGE("Error: Bug: This callback assumes one stream per channel");
|
|
return;
|
|
}
|
|
|
|
|
|
if(channel->mStreams[0] == NULL) {
|
|
LOGE("Error: Invalid Stream object");
|
|
return;
|
|
}
|
|
|
|
channel->QCamera3PicChannel::streamCbRoutine(recvd_frame, channel->mStreams[0]);
|
|
|
|
LOGD("X\n");
|
|
return;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::releaseOfflineMemory(uint32_t resultFrameNumber)
|
|
{
|
|
return QCamera3ProcessingChannel::releaseOfflineMemory(resultFrameNumber);
|
|
}
|
|
|
|
void QCamera3PicChannel::freeBufferForFrame(mm_camera_super_buf_t *frame)
|
|
{
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
LOGD(" Freeing the Buffer %d", frame->bufs[0]->buf_idx);
|
|
if (m_bZSL) {
|
|
mStreams[0]->bufDone(frame->bufs[0]->buf_idx);
|
|
} else {
|
|
mFreeBufferList.push_back(frame->bufs[0]->buf_idx);
|
|
}
|
|
}
|
|
|
|
void QCamera3PicChannel::freeBufferForJpeg(int& index)
|
|
{
|
|
Mutex::Autolock lock(mFreeJpegBufferLock);
|
|
mFreeJpegBufferList.push_back(index);
|
|
}
|
|
|
|
void QCamera3PicChannel::queueReprocFrame(mm_camera_super_buf_t *super_frame, uint32_t frame_number)
|
|
{
|
|
mm_camera_super_buf_t* frame = NULL;
|
|
frame = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
*frame = *super_frame;
|
|
m_postprocessor.processData(frame, NULL, frame_number);
|
|
free(super_frame);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : streamCbRoutine
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS :
|
|
* @super_frame : the super frame with filled buffer
|
|
* @stream : stream on which the buffer was requested and filled
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3PicChannel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream)
|
|
{
|
|
KPI_ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_CAPTURE_CH_CB);
|
|
//TODO
|
|
//Used only for getting YUV. Jpeg callback will be sent back from channel
|
|
//directly to HWI. Refer to func jpegEvtHandle
|
|
|
|
//Got the yuv callback. Calling yuv callback handler in PostProc
|
|
uint8_t frameIndex;
|
|
mm_camera_super_buf_t* frame = NULL;
|
|
cam_dimension_t dim;
|
|
cam_frame_len_offset_t offset;
|
|
|
|
memset(&dim, 0, sizeof(dim));
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
|
|
if (checkStreamCbErrors(super_frame, stream) != NO_ERROR) {
|
|
LOGE("Error with the stream callback");
|
|
return;
|
|
}
|
|
|
|
frameIndex = (uint8_t)super_frame->bufs[0]->buf_idx;
|
|
LOGD("recvd buf_idx: %u for further processing",
|
|
(uint32_t)frameIndex);
|
|
if(frameIndex >= mNumSnapshotBufs) {
|
|
LOGE("Error, Invalid index for buffer");
|
|
if(stream) {
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
mFreeBufferList.push_back(frameIndex);
|
|
stream->bufDone(frameIndex);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ((mSourceZSLChannel == NULL) &&
|
|
(uint32_t)mYuvMemory->getFrameNumber(frameIndex) == EMPTY_FRAMEWORK_FRAME_NUMBER) {
|
|
LOGD("Internal Request recycle frame");
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
if (m_bZSL) {
|
|
stream->bufDone(frameIndex);
|
|
} else {
|
|
mFreeBufferList.push_back(frameIndex);
|
|
}
|
|
free(super_frame);
|
|
return;
|
|
}
|
|
|
|
frame = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (frame == NULL) {
|
|
LOGE("Error allocating memory to save received_frame structure.");
|
|
if(stream) {
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
mFreeBufferList.push_back(frameIndex);
|
|
stream->bufDone(frameIndex);
|
|
}
|
|
return;
|
|
}
|
|
*frame = *super_frame;
|
|
stream->getFrameDimension(dim);
|
|
stream->getFrameOffset(offset);
|
|
dumpYUV(frame->bufs[0], dim, offset, QCAMERA_DUMP_FRM_INPUT_REPROCESS);
|
|
|
|
if (IS_BUFFER_ERROR(super_frame->bufs[0]->flags)) {
|
|
mChannelCbBufErr(this, mYuvMemory->getFrameNumber(frameIndex),
|
|
CAMERA3_BUFFER_STATUS_ERROR, mUserData);
|
|
}
|
|
int32_t frameNum = ((IS_VALID_PTR(mSourceZSLChannel))?
|
|
mSourceZSLChannel->getFrameNumber(frameIndex):
|
|
mYuvMemory->getFrameNumber(frameIndex));
|
|
LOGD(" Sending frame :%d ",frameNum);
|
|
m_postprocessor.processData(frame, NULL, frameNum);
|
|
free(super_frame);
|
|
return;
|
|
}
|
|
|
|
QCamera3StreamMem* QCamera3PicChannel::getStreamBufs(uint32_t len)
|
|
{
|
|
mYuvMemory = new QCamera3StreamMem(mCamera3Stream->max_buffers, false, isSecureMode());
|
|
if (!mYuvMemory) {
|
|
LOGE("unable to create metadata memory");
|
|
return NULL;
|
|
}
|
|
mFrameLen = len;
|
|
return mYuvMemory;
|
|
}
|
|
|
|
void QCamera3PicChannel::startDeferredAllocation() {
|
|
createAllocThread();
|
|
if(mAuxPicChannel) {
|
|
mAuxPicChannel->createAllocThread();
|
|
}
|
|
}
|
|
|
|
int QCamera3PicChannel::allocateZSLBuffers()
|
|
{
|
|
LOGH(": E numbufs %d", mCamera3Stream->max_buffers);
|
|
int rc = NO_ERROR;
|
|
uint32_t bufIdx;
|
|
if (m_bZSL && (mYuvMemory != NULL)) {
|
|
for (size_t i = 0; i < mCamera3Stream->max_buffers; i++) {
|
|
rc = mYuvMemory->allocateOne(mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("Failed allocating heap buffer. Fatal");
|
|
return BAD_VALUE;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
mStreams[0]->bufDone(bufIdx);
|
|
}
|
|
}
|
|
mAllocDone = true;
|
|
}
|
|
LOGH(": X");
|
|
return rc;
|
|
}
|
|
|
|
int QCamera3PicChannel::returnBufferError(uint32_t frameNumber)
|
|
{
|
|
int32_t bufIdx;
|
|
LOGH(": E numbufs %d", mCamera3Stream->max_buffers);
|
|
|
|
bufIdx = mMemory.getBufferIndex(frameNumber);
|
|
if(bufIdx < 0)
|
|
{
|
|
LOGE("X: Buffer not found for frame:%d", frameNumber);
|
|
return -1;
|
|
}
|
|
buffer_handle_t *buf = (buffer_handle_t *)mMemory.getBufferHandle(bufIdx);
|
|
mMemory.unregisterBuffer(bufIdx);
|
|
|
|
camera3_stream_buffer_t result_buffer;
|
|
memset(&result_buffer, 0, sizeof(camera3_stream_buffer_t));
|
|
|
|
result_buffer.stream = mCamera3Stream;
|
|
result_buffer.buffer = buf;
|
|
result_buffer.status = CAMERA3_BUFFER_STATUS_ERROR;
|
|
result_buffer.acquire_fence = -1;
|
|
result_buffer.release_fence = -1;
|
|
|
|
mChannelCB(NULL,
|
|
&result_buffer,
|
|
(uint32_t)frameNumber,
|
|
false,
|
|
mUserData);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void QCamera3PicChannel::releaseSuperBuf(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
for(uint32_t i =0; i< recvd_frame->num_bufs; i++)
|
|
{
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_SNAPSHOT) {
|
|
mm_camera_super_buf_t *snap_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*snap_buf = *recvd_frame;
|
|
snap_buf->num_bufs = 1;
|
|
snap_buf->bufs[0] = recvd_frame->bufs[i];
|
|
bufDone(snap_buf);
|
|
free(snap_buf);
|
|
} else if(recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
mm_camera_super_buf_t *meta_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*meta_buf = *recvd_frame;
|
|
meta_buf->num_bufs = 1;
|
|
meta_buf->ch_id = m_pMetaChannel->getMyHandle();
|
|
meta_buf->bufs[0] = recvd_frame->bufs[i];
|
|
m_pMetaChannel->bufDone(meta_buf);
|
|
free(meta_buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void* buffer_alloc_thread (void* data)
|
|
{
|
|
QCamera3PicChannel *channelObj = reinterpret_cast<QCamera3PicChannel *>(data);
|
|
if (!channelObj) {
|
|
return (void *)BAD_VALUE;
|
|
}
|
|
channelObj->allocateZSLBuffers();
|
|
return (void* )NULL;
|
|
}
|
|
|
|
void QCamera3PicChannel::putStreamBufs()
|
|
{
|
|
QCamera3ProcessingChannel::putStreamBufs();
|
|
|
|
mYuvMemory->deallocate();
|
|
delete mYuvMemory;
|
|
mYuvMemory = NULL;
|
|
mAllocDone = false;
|
|
mFreeBufferList.clear();
|
|
// Clear offlineMemory
|
|
mOfflineMemory.clear();
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::queueJpegSetting(uint32_t index, uint32_t frame_number,
|
|
metadata_buffer_t *metadata,
|
|
cam_hal3_JPEG_type_t imagetype)
|
|
{
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
jpeg_settings_t *settings =
|
|
(jpeg_settings_t *)malloc(sizeof(jpeg_settings_t));
|
|
|
|
if (!settings) {
|
|
LOGE("out of memory allocating jpeg_settings");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
memset(settings, 0, sizeof(jpeg_settings_t));
|
|
|
|
settings->out_buf_index = index;
|
|
settings->image_type = imagetype;
|
|
settings->frame_number = frame_number;
|
|
|
|
settings->jpeg_orientation = 0;
|
|
IF_META_AVAILABLE(int32_t, orientation, CAM_INTF_META_JPEG_ORIENTATION, metadata) {
|
|
settings->jpeg_orientation = *orientation;
|
|
}
|
|
|
|
settings->jpeg_quality = 85;
|
|
IF_META_AVAILABLE(uint32_t, quality1, CAM_INTF_META_JPEG_QUALITY, metadata) {
|
|
settings->jpeg_quality = (uint8_t) *quality1;
|
|
}
|
|
|
|
if((hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH && hal_obj->needHALPP())?
|
|
(imagetype == CAM_HAL3_JPEG_TYPE_BOKEH) : true)
|
|
{
|
|
IF_META_AVAILABLE(uint32_t, quality2, CAM_INTF_META_JPEG_THUMB_QUALITY, metadata) {
|
|
settings->jpeg_thumb_quality = (uint8_t) *quality2;
|
|
}
|
|
|
|
IF_META_AVAILABLE(cam_dimension_t, dimension, CAM_INTF_META_JPEG_THUMB_SIZE, metadata) {
|
|
settings->thumbnail_size = *dimension;
|
|
}
|
|
}
|
|
|
|
if(hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH && hal_obj->needHALPP() && isMpoEnabled())
|
|
{
|
|
settings->encode_type = MM_JPEG_TYPE_MPO;
|
|
} else {
|
|
settings->encode_type = MM_JPEG_TYPE_JPEG;
|
|
}
|
|
|
|
settings->is_dim_valid = false;
|
|
if((hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH) &&
|
|
(imagetype != CAM_HAL3_JPEG_TYPE_DEPTH))
|
|
{
|
|
settings->output_dim.width = mCamera3Stream->width;
|
|
settings->output_dim.height = mCamera3Stream->height;
|
|
settings->is_dim_valid = true;
|
|
}
|
|
|
|
settings->gps_timestamp_valid = 0;
|
|
IF_META_AVAILABLE(int64_t, timestamp, CAM_INTF_META_JPEG_GPS_TIMESTAMP, metadata) {
|
|
settings->gps_timestamp = *timestamp;
|
|
settings->gps_timestamp_valid = 1;
|
|
}
|
|
|
|
settings->gps_coordinates_valid = 0;
|
|
IF_META_AVAILABLE(double, coordinates, CAM_INTF_META_JPEG_GPS_COORDINATES, metadata) {
|
|
memcpy(settings->gps_coordinates, coordinates, 3*sizeof(double));
|
|
settings->gps_coordinates_valid = 1;
|
|
}
|
|
|
|
IF_META_AVAILABLE(uint8_t, proc_methods, CAM_INTF_META_JPEG_GPS_PROC_METHODS, metadata) {
|
|
memset(settings->gps_processing_method, 0,
|
|
sizeof(settings->gps_processing_method));
|
|
strlcpy(settings->gps_processing_method, (const char *)proc_methods,
|
|
sizeof(settings->gps_processing_method));
|
|
}
|
|
|
|
settings->hdr_snapshot = 0;
|
|
IF_META_AVAILABLE(cam_hdr_param_t, hdr_info, CAM_INTF_PARM_HAL_BRACKETING_HDR, metadata) {
|
|
if (hdr_info->hdr_enable) {
|
|
settings->hdr_snapshot = 1;
|
|
}
|
|
}
|
|
|
|
settings->multiframe_snapshot = 0;
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
property_get("persist.vendor.camera.multiframe.capture.enable", prop, "0");
|
|
bool bIsMultiFrameCapture = atoi(prop) ? TRUE : FALSE;
|
|
if(bIsMultiFrameCapture || hal_obj->mbIsSWMFNRCapture) {
|
|
settings->multiframe_snapshot = 1;
|
|
LOGD("multi frame snapshot is enabled");
|
|
}
|
|
// Image description
|
|
const char *eepromVersion = hal_obj->getEepromVersionInfo();
|
|
const uint32_t *ldafCalib = hal_obj->getLdafCalib();
|
|
if ((eepromVersion && strlen(eepromVersion)) ||
|
|
ldafCalib) {
|
|
int len = 0;
|
|
settings->image_desc_valid = true;
|
|
if (eepromVersion && strlen(eepromVersion)) {
|
|
len = snprintf(settings->image_desc, sizeof(settings->image_desc),
|
|
"M:%s ", eepromVersion);
|
|
}
|
|
if (ldafCalib) {
|
|
snprintf(settings->image_desc + len,
|
|
sizeof(settings->image_desc) - len, "L:%u-%u",
|
|
ldafCalib[0], ldafCalib[1]);
|
|
}
|
|
}
|
|
|
|
if (m_bZSL && !hal_obj->m_bQuadraCfaRequest && !m_bSkipConfig) {
|
|
settings->zsl_snapshot = true;
|
|
}
|
|
if (hal_obj->m_bMultiRawRequest) {
|
|
settings->raw_mfc_snapshot = 1;
|
|
}
|
|
|
|
return m_postprocessor.processJpegSettingData(settings);
|
|
}
|
|
|
|
|
|
void QCamera3PicChannel::overrideYuvSize(uint32_t width, uint32_t height)
|
|
{
|
|
LOGH("override Yuv size to: %d x %d", width, height);
|
|
mYuvWidth = width;
|
|
mYuvHeight = height;
|
|
if(mAuxPicChannel)
|
|
mAuxPicChannel->overrideYuvSize(width,height);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getReprocessType
|
|
*
|
|
* DESCRIPTION: get the type of reprocess output supported by this channel
|
|
*
|
|
* PARAMETERS : NONE
|
|
*
|
|
* RETURN : reprocess_type_t : type of reprocess
|
|
*==========================================================================*/
|
|
reprocess_type_t QCamera3PicChannel::getReprocessType()
|
|
{
|
|
/* a picture channel could either use the postprocessor for reprocess+jpeg
|
|
or only for reprocess */
|
|
reprocess_type_t expectedReprocess;
|
|
if (mPostProcMask == CAM_QCOM_FEATURE_NONE || mInputBufferHint) {
|
|
expectedReprocess = REPROCESS_TYPE_JPEG;
|
|
} else {
|
|
expectedReprocess = REPROCESS_TYPE_NONE;
|
|
}
|
|
LOGH("expectedReprocess from Pic Channel is %d", expectedReprocess);
|
|
return expectedReprocess;
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : timeoutFrame
|
|
*
|
|
* DESCRIPTION: Method to indicate to channel that a given frame has take too
|
|
* long to be generated
|
|
*
|
|
* PARAMETERS : framenumber indicating the framenumber of the buffer timingout
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3PicChannel::timeoutFrame(uint32_t frameNumber)
|
|
{
|
|
int32_t bufIdx;
|
|
LOGH("frameNumber %d", frameNumber);
|
|
QCamera3StreamMem *streamMemory = &this->mMemory;
|
|
|
|
if(m_bZSL)
|
|
{
|
|
//postprocess timeout if, we have received zslchannelcb
|
|
bufIdx = mYuvMemory->getBufferIndex(frameNumber);
|
|
if(bufIdx >= 0)
|
|
{
|
|
LOGE("Calling repocess channel frame timeout!!!");
|
|
return m_postprocessor.timeoutFrame(frameNumber);
|
|
}
|
|
|
|
//return output_buffer if no zslchannel callback received.
|
|
bufIdx = streamMemory->getBufferIndex(frameNumber);
|
|
if(bufIdx < 0)
|
|
{
|
|
if(mAuxPicChannel)
|
|
{
|
|
return mAuxPicChannel->timeoutFrame(frameNumber);
|
|
}
|
|
LOGE("X: Buffer not found for frame:%d", frameNumber);
|
|
return -1;
|
|
}
|
|
buffer_handle_t *buf = (buffer_handle_t *)streamMemory->getBufferHandle(bufIdx);
|
|
streamMemory->unregisterBuffer(bufIdx);
|
|
notifyDropForPendingBuffer(frameNumber,buf);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
if(IS_VALID_PTR(mSourceZSLChannel))
|
|
{
|
|
streamMemory = mSourceZSLChannel->getStreamBufs(0);
|
|
if(streamMemory == NULL)
|
|
{
|
|
LOGE("Stream Memory not found!!!.should never be here.");
|
|
return NO_ERROR;
|
|
}
|
|
bufIdx = streamMemory->getBufferIndex(frameNumber);
|
|
} else {
|
|
bufIdx = mYuvMemory->getBufferIndex(frameNumber);
|
|
}
|
|
|
|
if(bufIdx < 0)
|
|
{
|
|
if(mAuxPicChannel)
|
|
{
|
|
return mAuxPicChannel->timeoutFrame(frameNumber);
|
|
}
|
|
LOGE("X: Buffer not found for frame:%d", frameNumber);
|
|
return -1;
|
|
}
|
|
|
|
mStreams[0]->timeoutFrame(bufIdx);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
int32_t QCamera3PicChannel::notifyDropForPendingBuffer(uint32_t frameNumber,
|
|
buffer_handle_t *buf)
|
|
{
|
|
LOGH("frameNumber %d", frameNumber);
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
bool found = false;
|
|
for (auto &req : hal_obj->mPendingBuffersMap.mPendingBuffersInRequest) {
|
|
if(req.frame_number == frameNumber) {
|
|
for (auto &info : req.mPendingBufferList)
|
|
{
|
|
if(info.buffer == buf)
|
|
{
|
|
camera3_capture_result_t result;
|
|
memset(&result, 0, sizeof(camera3_capture_result_t));
|
|
camera3_stream_buffer_t result_buffer;
|
|
memset(&result_buffer, 0, sizeof(camera3_stream_buffer_t));
|
|
|
|
result_buffer.stream = mCamera3Stream;
|
|
result_buffer.buffer = buf;
|
|
result_buffer.status = CAMERA3_BUFFER_STATUS_ERROR;
|
|
result_buffer.acquire_fence = -1;
|
|
result_buffer.release_fence = -1;
|
|
|
|
result.result = NULL;
|
|
result.frame_number = req.frame_number;
|
|
result.num_output_buffers = 1;
|
|
result.output_buffers = &result_buffer;
|
|
hal_obj->orchestrateResult(&result);
|
|
hal_obj->mPendingBuffersMap.removeBuf(buf);
|
|
|
|
Mutex::Autolock lock(mReqFrameListLock);
|
|
if (!mReqFrameNumList.empty()) {
|
|
List<zsl_req_t>::iterator it = mReqFrameNumList.begin();
|
|
do {
|
|
if(frameNumber == (*it).frameNum)
|
|
{
|
|
mReqFrameNumList.erase(it);
|
|
break;
|
|
}
|
|
++it;
|
|
}while(it != mReqFrameNumList.end());
|
|
}
|
|
found = true;
|
|
m_postprocessor.eraseJpegSetting(frameNumber);
|
|
break;
|
|
}
|
|
}
|
|
if(!found)
|
|
LOGE("X:buffer not found in the list %d", frameNumber);
|
|
break;
|
|
}
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : queueReprocMetadata
|
|
*
|
|
* DESCRIPTION: queue the reprocess metadata to the postprocessor
|
|
*
|
|
* PARAMETERS : metadata : the metadata corresponding to the pp frame
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3PicChannel::queueReprocMetadata(mm_camera_super_buf_t *metadata,
|
|
uint32_t framenum, bool dropFrame)
|
|
{
|
|
if(mAuxPicChannel && metadata->camera_handle != m_camHandle)
|
|
{
|
|
return mAuxPicChannel->queueReprocMetadata(metadata, framenum, dropFrame);
|
|
} else {
|
|
metadata_buffer_t* meta = (metadata_buffer_t *)metadata->bufs[0]->buffer;
|
|
IF_META_AVAILABLE(cam_crop_data_t, crop_data, CAM_INTF_META_CROP_DATA, meta) {
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if(hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH)
|
|
{
|
|
if(hal_obj->needHALPP())
|
|
{
|
|
crop_data->ignore_crop = 1; // CPP ignores the crop in this special zone
|
|
// Set the margins to 0.
|
|
crop_data->margins.widthMargins = 0.0f;
|
|
crop_data->margins.heightMargins = 0.0f;
|
|
} else {
|
|
crop_data->ignore_crop = 0;
|
|
// Get the frame margin data for the master camera and copy to the metadata
|
|
crop_data->margins = hal_obj->m_pFovControl->getFrameMargins(mMasterCam);
|
|
}
|
|
}
|
|
}
|
|
return QCamera3ProcessingChannel::queueReprocMetadata(metadata, framenum, dropFrame);
|
|
}
|
|
LOGE("Should never be here");
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : switchMaster
|
|
*
|
|
* DESCRIPTION: Set the current master in pic channel.
|
|
*
|
|
* PARAMETERS : masterCam : MAIN or AUX cam type
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
void QCamera3PicChannel::switchMaster(uint32_t masterCam)
|
|
{
|
|
mMasterCam = masterCam;
|
|
if(mAuxPicChannel)
|
|
mAuxPicChannel->switchMaster(masterCam);
|
|
}
|
|
|
|
void QCamera3PicChannel::overridePPConfig(cam_feature_mask_t pp_mask)
|
|
{
|
|
LOGD("overriding ppmask to %" PRIx64, pp_mask);
|
|
mPostProcMask = pp_mask;
|
|
if(NULL != mAuxPicChannel)
|
|
{
|
|
mAuxPicChannel->overridePPConfig(pp_mask);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setBundleInfo
|
|
*
|
|
* DESCRIPTION: setting bundle information in stream params
|
|
*
|
|
* PARAMETERS :
|
|
* @bundleInfo : stream bundle information.
|
|
* @cam_type : MAIN or AUX.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3PicChannel::setBundleInfo(const cam_bundle_config_t &bundleInfo, uint32_t cam_type)
|
|
{
|
|
if ((cam_type == CAM_TYPE_AUX) && (NULL != mAuxPicChannel)) {
|
|
return mAuxPicChannel->setBundleInfo(bundleInfo);
|
|
}
|
|
int32_t rc = NO_ERROR;
|
|
cam_stream_parm_buffer_t param;
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_SET_BUNDLE_INFO;
|
|
param.bundleInfo = bundleInfo;
|
|
if (m_numStreams > 0 && mStreams[0]) {
|
|
rc = mStreams[0]->setParameter(param, cam_type);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("stream setParameter for set bundle failed");
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
void QCamera3PicChannel::ZSLChannelCb(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
|
|
if(mAuxPicChannel) {
|
|
if (recvd_frame->ch_id == mAuxPicChannel->getMyHandle()) {
|
|
return mAuxPicChannel->ZSLChannelCb(recvd_frame);
|
|
}
|
|
}
|
|
|
|
LOGI("[KPI Perf]: superbuf frame_idx %d",
|
|
recvd_frame->bufs[0]->frame_idx);
|
|
|
|
uint32_t frameIndex;
|
|
uint32_t frameNum;
|
|
bool metaNeedPP = true;
|
|
|
|
{
|
|
Mutex::Autolock lock(mReqFrameListLock);
|
|
if (!mReqFrameNumList.empty()) {
|
|
List<zsl_req_t>::iterator it = mReqFrameNumList.begin();
|
|
frameNum = (*it).frameNum;
|
|
mReqFrameNumList.erase(it);
|
|
if (frameNum == 0xFFFFFFFF) metaNeedPP = false;
|
|
LOGH("Processing ZSL superbuf for frame_number %d", frameNum);
|
|
} else {
|
|
LOGE("Error ! Received zsl callback without corresponding request entry");
|
|
releaseSuperBuf(recvd_frame);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//detect frame drop
|
|
for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
metadata_buffer_t *metadata = (metadata_buffer_t *)recvd_frame->bufs[i]->buffer;
|
|
uint32_t *p_frame_number = POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER, metadata);
|
|
IF_META_AVAILABLE(cam_stream_ID_t, p_cam_frame_drop, CAM_INTF_META_FRAME_DROPPED,
|
|
metadata) {
|
|
LOGH("Dropped frame info for frame_number %d", *p_frame_number);
|
|
for (uint32_t k = 0; k < p_cam_frame_drop->num_streams; k++) {
|
|
if (mStreams[0]->getMyServerID() ==
|
|
p_cam_frame_drop->stream_request[k].streamID) {
|
|
m_postprocessor.eraseJpegSetting(frameNum);
|
|
returnBufferError(frameNum);
|
|
releaseSuperBuf(recvd_frame);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_SNAPSHOT) {
|
|
frameIndex = (uint8_t)recvd_frame->bufs[i]->buf_idx;
|
|
mm_camera_super_buf_t *snap_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*snap_buf = *recvd_frame;
|
|
snap_buf->num_bufs = 1;
|
|
snap_buf->bufs[0] = recvd_frame->bufs[i];
|
|
|
|
LOGD("Snapshot buf_idx %d", snap_buf->bufs[0]->buf_idx);
|
|
mYuvMemory->markFrameNumber(recvd_frame->bufs[i]->buf_idx, frameNum);
|
|
streamCbRoutine(snap_buf, mStreams[0]);
|
|
}
|
|
|
|
if (recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
mm_camera_super_buf_t *meta_buf =
|
|
(mm_camera_super_buf_t *) malloc(sizeof(mm_camera_super_buf_t));
|
|
*meta_buf = *recvd_frame;
|
|
meta_buf->num_bufs = 1;
|
|
meta_buf->ch_id = m_pMetaChannel->getMyHandle();
|
|
meta_buf->bufs[0] = recvd_frame->bufs[i];
|
|
|
|
metadata_buffer_t *metadata = (metadata_buffer_t *)meta_buf->bufs[0]->buffer;
|
|
uint32_t *p_frame_number = POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER, metadata);
|
|
if (p_frame_number) LOGD("meta frame_number : %d", *p_frame_number);
|
|
if (metaNeedPP) {
|
|
queueReprocMetadata(meta_buf, frameNum, false);
|
|
} else {
|
|
m_pMetaChannel->bufDone(meta_buf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3ReprocessChannel
|
|
*
|
|
* DESCRIPTION: constructor of QCamera3ReprocessChannel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : camera handle
|
|
* @cam_ops : ptr to camera ops table
|
|
* @pp_mask : post-proccess feature mask
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3ReprocessChannel::QCamera3ReprocessChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
channel_cb_routine cb_routine,
|
|
channel_cb_buffer_err cb_buf_err,
|
|
cam_padding_info_t *paddingInfo,
|
|
cam_feature_mask_t postprocess_mask,
|
|
void *userData, void *ch_hdl) :
|
|
/* In case of framework reprocessing, pproc and jpeg operations could be
|
|
* parallelized by allowing 1 extra buffer for reprocessing output:
|
|
* ch_hdl->getNumBuffers() + 1 */
|
|
QCamera3Channel(cam_handle, channel_handle, cam_ops, cb_routine, cb_buf_err, paddingInfo,
|
|
postprocess_mask, userData,
|
|
((QCamera3Channel *)ch_hdl)->getNumBuffers()
|
|
+ (MAX_REPROCESS_PIPELINE_STAGES - 1) + MAX_REPROCESS_POSTCPP_BUFCNT),
|
|
inputChHandle(ch_hdl),
|
|
mOfflineBuffersIndex(-1),
|
|
mFrameLen(0),
|
|
mFrameLenMeta(0),
|
|
mReprocessType(REPROCESS_TYPE_NONE),
|
|
m_pSrcChannel(NULL),
|
|
m_pMetaChannel(NULL),
|
|
mMemory(NULL),
|
|
mMemoryMeta(NULL),
|
|
mGrallocMemory(0),
|
|
mReprocessPerfMode(false),
|
|
m_bOfflineIsp(false),
|
|
m_bMultiFrameCapture(false),
|
|
m_ppIndex(0)
|
|
{
|
|
memset(mSrcStreamHandles, 0, sizeof(mSrcStreamHandles));
|
|
mOfflineBuffersIndex = mNumBuffers -1;
|
|
mOfflineMetaIndex = (int32_t) (2*mNumBuffers -1);
|
|
memset(&m_processedMetaBuf, 0, sizeof(mm_camera_buf_def_t));
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3ReprocessChannel
|
|
*
|
|
* DESCRIPTION: constructor of QCamera3ReprocessChannel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : camera handle
|
|
* @cam_ops : ptr to camera ops table
|
|
* @pp_mask : post-proccess feature mask
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
mm_camera_channel_attr_t attr;
|
|
|
|
memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
|
|
attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
|
|
attr.max_unmatched_frames = 1;
|
|
|
|
m_handle = m_camOps->add_channel(m_camHandle,
|
|
&attr,
|
|
NULL,
|
|
this);
|
|
if (m_handle == 0) {
|
|
LOGE("Add channel failed");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
mIsType = isType;
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : registerBuffer
|
|
*
|
|
* DESCRIPTION: register streaming buffer to the channel object
|
|
*
|
|
* PARAMETERS :
|
|
* @buffer : buffer to be registered
|
|
* @isType : the image stabilization type for the buffer
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::registerBuffer(buffer_handle_t *buffer,
|
|
cam_is_type_t isType)
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_REPROC_CH_REG_BUF);
|
|
int rc = 0;
|
|
mIsType = isType;
|
|
cam_stream_type_t streamType;
|
|
|
|
if (buffer == NULL) {
|
|
LOGE("Error: Cannot register a NULL buffer");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if ((uint32_t)mGrallocMemory.getCnt() > (mNumBuffers - 1)) {
|
|
LOGE("Trying to register more buffers than initially requested");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (0 == m_numStreams) {
|
|
rc = initialize(mIsType);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Couldn't initialize camera stream %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
streamType = mStreams[0]->getMyType();
|
|
rc = mGrallocMemory.registerBuffer(buffer, streamType);
|
|
if (ALREADY_EXISTS == rc) {
|
|
return NO_ERROR;
|
|
} else if (NO_ERROR != rc) {
|
|
LOGE("Buffer %p couldn't be registered %d", buffer, rc);
|
|
return rc;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
int QCamera3ReprocessChannel::releaseOutputBuffer(buffer_handle_t * output_buffer,
|
|
uint32_t frame_number)
|
|
{
|
|
int rc = NO_ERROR;
|
|
QCamera3ProcessingChannel *obj = (QCamera3ProcessingChannel *)inputChHandle;
|
|
if(mReprocessType == REPROCESS_TYPE_YUV)
|
|
{
|
|
obj->reprocessCbRoutine(output_buffer, frame_number);
|
|
}else if(mReprocessType == REPROCESS_TYPE_JPEG) {
|
|
QCamera3PicChannel *pic_channel = (QCamera3PicChannel *)obj;
|
|
pic_channel->returnBufferError(frame_number);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCamera3ReprocessChannel
|
|
*
|
|
* DESCRIPTION: constructor of QCamera3ReprocessChannel
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_handle : camera handle
|
|
* @cam_ops : ptr to camera ops table
|
|
* @pp_mask : post-proccess feature mask
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
void QCamera3ReprocessChannel::streamCbRoutine(mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream *stream)
|
|
{
|
|
//Got the pproc data callback. Now send to jpeg encoding
|
|
uint8_t frameIndex;
|
|
uint32_t resultFrameNumber;
|
|
mm_camera_super_buf_t* frame = NULL;
|
|
LOGD("E. current reproc ch idx:%d", m_ppIndex);
|
|
|
|
// input channel is the pic/yuv channel (processing channel) for all reprocess channels
|
|
QCamera3ProcessingChannel *obj = (QCamera3ProcessingChannel *)inputChHandle;
|
|
QCamera3HardwareInterface *hal_obj= (QCamera3HardwareInterface *)obj->mUserData;
|
|
|
|
cam_dimension_t dim;
|
|
cam_frame_len_offset_t offset;
|
|
|
|
// TODO: here assume meta always comes befofe raw reprocess stream
|
|
if (m_bOfflineIsp && isMetaReprocStream(stream)) {
|
|
m_processedMetaBuf = *(super_frame->bufs[0]);
|
|
// as we cached the meta reproc output,
|
|
// we can deallocate original meta reproc stream buffers here
|
|
// righ now, deallocate buffer in QCamera3ReprocessChannel::bufDone()/putStreamBufs()
|
|
return;
|
|
}
|
|
|
|
memset(&dim, 0, sizeof(dim));
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
if(!super_frame) {
|
|
LOGE("Invalid Super buffer");
|
|
return;
|
|
}
|
|
|
|
if(super_frame->num_bufs != 1) {
|
|
LOGE("Multiple streams are not supported");
|
|
return;
|
|
}
|
|
if(super_frame->bufs[0] == NULL ) {
|
|
LOGE("Error, Super buffer frame does not contain valid buffer");
|
|
return;
|
|
}
|
|
frameIndex = (uint8_t)super_frame->bufs[0]->buf_idx;
|
|
|
|
|
|
if (mReprocessType == REPROCESS_TYPE_JPEG) {
|
|
resultFrameNumber = mMemory->getFrameNumber(frameIndex);
|
|
frame = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (frame == NULL) {
|
|
LOGE("Error allocating memory to save received_frame structure.");
|
|
if(stream) {
|
|
stream->bufDone(frameIndex);
|
|
}
|
|
return;
|
|
}
|
|
LOGI("bufIndex: %u recvd from post proc",
|
|
(uint32_t)frameIndex);
|
|
*frame = *super_frame;
|
|
|
|
stream->getFrameDimension(dim);
|
|
stream->getFrameOffset(offset);
|
|
dumpYUV(frame->bufs[0], dim, offset, QCAMERA_DUMP_FRM_INPUT_JPEG);
|
|
bool isInputBuf = obj->isFwkInputBuffer((uint32_t)resultFrameNumber);
|
|
if (isInputBuf) {
|
|
obj->m_postprocessor.releaseOfflineBuffers(false);
|
|
obj->releaseInputBuffer(resultFrameNumber);
|
|
}
|
|
if (mChannelCB && m_ppIndex == 0) {
|
|
mChannelCB(NULL, NULL, resultFrameNumber, true, mUserData);
|
|
}
|
|
|
|
obj->m_postprocessor.processPPData(frame,
|
|
m_bOfflineIsp ? ((const metadata_buffer_t*)m_processedMetaBuf.buffer) : NULL);
|
|
} else if((mReprocessType == REPROCESS_TYPE_YUV) &&
|
|
(hal_obj->m_bPreSnapQuadraCfaRequest) && (m_ppIndex == 0)) {
|
|
resultFrameNumber = mMemory->getFrameNumber(frameIndex);
|
|
frame = (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if(frame == NULL) {
|
|
LOGE("Error allocating memory to save received frame structure");
|
|
if(stream) {
|
|
stream->bufDone(frameIndex);
|
|
}
|
|
return;
|
|
}
|
|
LOGI("bufIndex: %u recvd from post proc", (uint32_t) frameIndex);
|
|
*frame = *super_frame;
|
|
|
|
stream->getFrameDimension(dim);
|
|
stream->getFrameOffset(offset);
|
|
obj->getQuadraMetaBuffer((metadata_buffer_t **)&m_processedMetaBuf.buffer);
|
|
|
|
obj->m_postprocessor.processPPData(frame,
|
|
m_bOfflineIsp ? ((const metadata_buffer_t*)m_processedMetaBuf.buffer) : NULL);
|
|
}else {
|
|
buffer_handle_t *resultBuffer;
|
|
frameIndex = (uint8_t)super_frame->bufs[0]->buf_idx;
|
|
resultBuffer = (buffer_handle_t *)mGrallocMemory.getBufferHandle(frameIndex);
|
|
resultFrameNumber = mGrallocMemory.getFrameNumber(frameIndex);
|
|
LOGD(" Reprocessed Frame Number is : %d",resultFrameNumber);
|
|
int32_t rc = stream->bufRelease(frameIndex);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d releasing stream buffer %d",
|
|
rc, frameIndex);
|
|
}
|
|
rc = mGrallocMemory.unregisterBuffer(frameIndex);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error %d unregistering stream buffer %d",
|
|
rc, frameIndex);
|
|
}
|
|
obj->m_postprocessor.releaseOfflineBuffers(false);
|
|
obj->reprocessCbRoutine(resultBuffer, resultFrameNumber);
|
|
qcamera_hal3_pp_data_t *pp_job = obj->m_postprocessor.dequeuePPJob(resultFrameNumber);
|
|
if (pp_job != NULL) {
|
|
obj->m_postprocessor.releasePPJobData(pp_job);
|
|
}
|
|
free(pp_job);
|
|
QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)obj->mUserData;
|
|
if (hw->isQuadCfaSensor()) {
|
|
hw->deleteQCFACaptureChannel();
|
|
}
|
|
resetToCamPerfNormal(resultFrameNumber);
|
|
}
|
|
free(super_frame);
|
|
return;
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : resetToCamPerfNormal
|
|
*
|
|
* DESCRIPTION: Set the perf mode to normal if all the priority frames
|
|
* have been reprocessed
|
|
*
|
|
* PARAMETERS :
|
|
* @frameNumber: Frame number of the reprocess completed frame
|
|
*
|
|
* RETURN : QCamera3StreamMem *
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::resetToCamPerfNormal(uint32_t frameNumber)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
bool resetToPerfNormal = false;
|
|
{
|
|
Mutex::Autolock lock(mPriorityFramesLock);
|
|
/* remove the priority frame number from the list */
|
|
for (size_t i = 0; i < mPriorityFrames.size(); i++) {
|
|
if (mPriorityFrames[i] == frameNumber) {
|
|
mPriorityFrames.removeAt(i);
|
|
}
|
|
}
|
|
/* reset the perf mode if pending priority frame list is empty */
|
|
if (mReprocessPerfMode && mPriorityFrames.empty()) {
|
|
resetToPerfNormal = true;
|
|
}
|
|
}
|
|
if (resetToPerfNormal) {
|
|
QCamera3Stream *pStream = mStreams[0];
|
|
cam_stream_parm_buffer_t param;
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
|
|
param.type = CAM_STREAM_PARAM_TYPE_REQUEST_OPS_MODE;
|
|
param.perf_mode = CAM_PERF_NORMAL;
|
|
rc = pStream->setParameter(param);
|
|
{
|
|
Mutex::Autolock lock(mPriorityFramesLock);
|
|
mReprocessPerfMode = false;
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getOfflineMetaStreamBufs
|
|
*
|
|
* DESCRIPTION: register the buffers of the meta reprocess stream
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : QCamera3StreamMem *
|
|
*==========================================================================*/
|
|
QCamera3StreamMem* QCamera3ReprocessChannel::getMetaStreamBufs(uint32_t len)
|
|
{
|
|
LOGD("E. len:%d", len);
|
|
mMemoryMeta = new QCamera3StreamMem(mNumBuffers, false);
|
|
mFrameLenMeta = len;
|
|
if (!mMemoryMeta) {
|
|
LOGE("unable to create meta reproc memory");
|
|
return NULL;
|
|
}
|
|
|
|
return mMemoryMeta;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamBufs
|
|
*
|
|
* DESCRIPTION: register the buffers of the reprocess channel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : QCamera3StreamMem *
|
|
*==========================================================================*/
|
|
QCamera3StreamMem* QCamera3ReprocessChannel::getStreamBufs(uint32_t len)
|
|
{
|
|
QCamera3ProcessingChannel *obj = (QCamera3ProcessingChannel *)inputChHandle;
|
|
if ((mReprocessType == REPROCESS_TYPE_JPEG)
|
|
|| ((mReprocessType == REPROCESS_TYPE_YUV)
|
|
&& obj->m_bQuadraChannel
|
|
&& (m_ppIndex == 0))) {
|
|
mMemory = new QCamera3StreamMem(mNumBuffers, false, isSecureMode());
|
|
if (!mMemory) {
|
|
LOGE("unable to create reproc memory");
|
|
return NULL;
|
|
}
|
|
mFrameLen = len;
|
|
return mMemory;
|
|
}
|
|
return &mGrallocMemory;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : putStreamBufs
|
|
*
|
|
* DESCRIPTION: release the reprocess channel buffers
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN :
|
|
*==========================================================================*/
|
|
void QCamera3ReprocessChannel::putStreamBufs()
|
|
{
|
|
if (mReprocessType == REPROCESS_TYPE_JPEG) {
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
mFreeBufferList.clear();
|
|
} else {
|
|
mGrallocMemory.unregisterBuffers();
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : putMetaStreamBufs
|
|
*
|
|
* DESCRIPTION: release the reprocess channel buffers
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN :
|
|
*==========================================================================*/
|
|
void QCamera3ReprocessChannel::putMetaStreamBufs()
|
|
{
|
|
LOGD("put stream bufs for offline meta");
|
|
if (mMemoryMeta != NULL) {
|
|
mMemoryMeta->deallocate();
|
|
delete mMemoryMeta;
|
|
mMemoryMeta = NULL;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCamera3ReprocessChannel
|
|
*
|
|
* DESCRIPTION: destructor of QCamera3ReprocessChannel
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : none
|
|
*==========================================================================*/
|
|
QCamera3ReprocessChannel::~QCamera3ReprocessChannel()
|
|
{
|
|
destroy();
|
|
|
|
if (m_handle) {
|
|
m_camOps->delete_channel(m_camHandle, m_handle);
|
|
LOGD("deleting channel %d", m_handle);
|
|
m_handle = 0;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : start
|
|
*
|
|
* DESCRIPTION: start reprocess channel.
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::start()
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_REPROC_CH_START);
|
|
int32_t rc = NO_ERROR;
|
|
|
|
rc = QCamera3Channel::start();
|
|
|
|
if (rc == NO_ERROR) {
|
|
rc = m_camOps->start_channel(m_camHandle, m_handle);
|
|
|
|
// Check failure
|
|
if (rc != NO_ERROR) {
|
|
LOGE("start_channel failed %d", rc);
|
|
QCamera3Channel::stop();
|
|
}
|
|
}
|
|
|
|
if (m_bMultiFrameCapture) {
|
|
uint32_t bufIdx;
|
|
rc = mMemory->allocateOne(mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("Failed allocating heap buffer. Fatal");
|
|
return BAD_VALUE;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
}
|
|
rc = mStreams[0]->bufDone(bufIdx);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Failed to queue new buffer to stream");
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : stop
|
|
*
|
|
* DESCRIPTION: stop reprocess channel.
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::stop()
|
|
{
|
|
ATRACE_CAMSCOPE_CALL(CAMSCOPE_HAL3_REPROC_CH_STOP);
|
|
int32_t rc = NO_ERROR;
|
|
rc = QCamera3Channel::stop();
|
|
rc |= m_camOps->stop_channel(m_camHandle, m_handle);
|
|
// Unmapping the buffers
|
|
unmapOfflineBuffers(true);
|
|
m_bMultiFrameCapture = FALSE;
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getStreamBySrcHandle
|
|
*
|
|
* DESCRIPTION: find reprocess stream by its source stream handle
|
|
*
|
|
* PARAMETERS :
|
|
* @srcHandle : source stream handle
|
|
*
|
|
* RETURN : ptr to reprocess stream if found. NULL if not found
|
|
*==========================================================================*/
|
|
QCamera3Stream * QCamera3ReprocessChannel::getStreamBySrcHandle(uint32_t srcHandle)
|
|
{
|
|
QCamera3Stream *pStream = NULL;
|
|
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (mSrcStreamHandles[i] == srcHandle) {
|
|
pStream = mStreams[i];
|
|
break;
|
|
}
|
|
}
|
|
return pStream;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getSrcStreamBySrcHandle
|
|
*
|
|
* DESCRIPTION: find source stream by source stream handle
|
|
*
|
|
* PARAMETERS :
|
|
* @srcHandle : source stream handle
|
|
*
|
|
* RETURN : ptr to reprocess stream if found. NULL if not found
|
|
*==========================================================================*/
|
|
QCamera3Stream * QCamera3ReprocessChannel::getSrcStreamBySrcHandle(uint32_t srcHandle)
|
|
{
|
|
QCamera3Stream *pStream = NULL;
|
|
|
|
if (NULL == m_pSrcChannel) {
|
|
return NULL;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
if (mSrcStreamHandles[i] == srcHandle) {
|
|
pStream = m_pSrcChannel->getStreamByIndex(i);
|
|
break;
|
|
}
|
|
}
|
|
return pStream;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : unmapOfflineBuffers
|
|
*
|
|
* DESCRIPTION: Unmaps offline buffers
|
|
*
|
|
* PARAMETERS : none
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::unmapOfflineBuffers(bool all)
|
|
{
|
|
LOGD("E. all = %d, m_numStreams:%d", all, m_numStreams);
|
|
int unmap_cnt = m_numStreams;
|
|
int rc = NO_ERROR;
|
|
{
|
|
Mutex::Autolock lock(mOfflineBuffersLock);
|
|
if (!mOfflineBuffers.empty()) {
|
|
QCamera3Stream *stream = NULL;
|
|
List<OfflineBuffer>::iterator it = mOfflineBuffers.begin();
|
|
for (; it != mOfflineBuffers.end(); it++) {
|
|
stream = (*it).stream;
|
|
if (NULL != stream) {
|
|
rc = stream->unmapBuf((*it).type,
|
|
(*it).index,
|
|
-1);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error during offline buffer unmap %d",
|
|
rc);
|
|
}
|
|
LOGD("Unmapped buffer with index %d", (*it).index);
|
|
}
|
|
if (!all) {
|
|
it = mOfflineBuffers.erase(it);
|
|
unmap_cnt--;
|
|
if (unmap_cnt == 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (all) {
|
|
mOfflineBuffers.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
Mutex::Autolock lock(mOfflineMetaBuffersLock);
|
|
if (!mOfflineMetaBuffers.empty()) {
|
|
unmap_cnt = m_numStreams;
|
|
QCamera3Stream *stream = NULL;
|
|
List<OfflineBuffer>::iterator it = mOfflineMetaBuffers.begin();
|
|
for (; it != mOfflineMetaBuffers.end(); it++) {
|
|
stream = (*it).stream;
|
|
if (NULL != stream) {
|
|
rc = stream->unmapBuf((*it).type,
|
|
(*it).index,
|
|
-1);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("Error during offline buffer unmap %d",
|
|
rc);
|
|
}
|
|
LOGD("Unmapped meta buffer with index %d", (*it).index);
|
|
}
|
|
if (!all) {
|
|
it = mOfflineMetaBuffers.erase(it);
|
|
unmap_cnt--;
|
|
if (unmap_cnt == 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (all) {
|
|
mOfflineMetaBuffers.clear();
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : bufDone
|
|
*
|
|
* DESCRIPTION: Return reprocess stream buffer to free buffer list.
|
|
* Note that this function doesn't queue buffer back to kernel.
|
|
* It's up to doReprocessOffline to do that instead.
|
|
* PARAMETERS :
|
|
* @recvd_frame : stream buf frame to be returned
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::bufDone(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
int rc = NO_ERROR;
|
|
if (recvd_frame && recvd_frame->num_bufs == 1) {
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
uint32_t buf_idx = recvd_frame->bufs[0]->buf_idx;
|
|
mFreeBufferList.push_back(buf_idx);
|
|
|
|
if (m_bOfflineIsp && mMemoryMeta != NULL) {
|
|
LOGD("deallocate memory for meta reproc stream");
|
|
mMemoryMeta->deallocate();
|
|
}
|
|
} else {
|
|
LOGE("Fatal. Not supposed to be here");
|
|
rc = BAD_VALUE;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : overrideMetadata
|
|
*
|
|
* DESCRIPTION: Override metadata entry such as rotation, crop, and CDS info.
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : input frame from source stream
|
|
* meta_buffer: metadata buffer
|
|
* @metadata : corresponding metadata
|
|
* @fwk_frame :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::overrideMetadata(qcamera_hal3_pp_buffer_t *pp_buffer,
|
|
mm_camera_buf_def_t *meta_buffer, jpeg_settings_t *jpeg_settings,
|
|
qcamera_fwk_input_pp_data_t &fwk_frame)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if ((NULL == meta_buffer) || (NULL == pp_buffer) || (NULL == pp_buffer->input) ||
|
|
(NULL == hal_obj)) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
metadata_buffer_t *meta = (metadata_buffer_t *)meta_buffer->buffer;
|
|
mm_camera_super_buf_t *frame = pp_buffer->input;
|
|
if (NULL == meta) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < frame->num_bufs; i++) {
|
|
QCamera3Stream *pSrcStream = getSrcStreamBySrcHandle(frame->bufs[i]->stream_id);
|
|
|
|
if (pSrcStream != NULL) {
|
|
if (jpeg_settings) {
|
|
// Find rotation info for reprocess stream
|
|
cam_rotation_info_t rotation_info;
|
|
memset(&rotation_info, 0, sizeof(rotation_info));
|
|
if (jpeg_settings->jpeg_orientation == 0) {
|
|
rotation_info.rotation = ROTATE_0;
|
|
} else if (jpeg_settings->jpeg_orientation == 90) {
|
|
rotation_info.rotation = ROTATE_90;
|
|
} else if (jpeg_settings->jpeg_orientation == 180) {
|
|
rotation_info.rotation = ROTATE_180;
|
|
} else if (jpeg_settings->jpeg_orientation == 270) {
|
|
rotation_info.rotation = ROTATE_270;
|
|
}
|
|
if (jpeg_settings->hdr_snapshot ||
|
|
hal_obj->getHalPPType() == CAM_HAL_PP_TYPE_BOKEH) {
|
|
rotation_info.rotation = ROTATE_0;
|
|
}
|
|
rotation_info.streamId = mStreams[0]->getMyServerID();
|
|
ADD_SET_PARAM_ENTRY_TO_BATCH(meta, CAM_INTF_PARM_ROTATION, rotation_info);
|
|
LOGD("rotation_info.rotation: %d", rotation_info.rotation);
|
|
}
|
|
|
|
// Find and insert crop info for reprocess stream
|
|
IF_META_AVAILABLE(cam_crop_data_t, crop_data, CAM_INTF_META_CROP_DATA, meta) {
|
|
if (MAX_NUM_STREAMS > crop_data->num_of_streams) {
|
|
for (int j = 0; j < crop_data->num_of_streams; j++) {
|
|
if (crop_data->crop_info[j].stream_id ==
|
|
pSrcStream->getMyServerID()) {
|
|
|
|
// Store crop/roi information for offline reprocess
|
|
// in the reprocess stream slot
|
|
crop_data->crop_info[crop_data->num_of_streams].crop =
|
|
crop_data->crop_info[j].crop;
|
|
crop_data->crop_info[crop_data->num_of_streams].roi_map =
|
|
crop_data->crop_info[j].roi_map;
|
|
crop_data->crop_info[crop_data->num_of_streams].stream_id =
|
|
mStreams[0]->getMyServerID();
|
|
crop_data->num_of_streams++;
|
|
|
|
LOGD("Reprocess stream server id: %d",
|
|
mStreams[0]->getMyServerID());
|
|
LOGD("Found offline reprocess crop %dx%d %dx%d",
|
|
crop_data->crop_info[j].crop.left,
|
|
crop_data->crop_info[j].crop.top,
|
|
crop_data->crop_info[j].crop.width,
|
|
crop_data->crop_info[j].crop.height);
|
|
LOGD("Found offline reprocess roimap %dx%d %dx%d",
|
|
crop_data->crop_info[j].roi_map.left,
|
|
crop_data->crop_info[j].roi_map.top,
|
|
crop_data->crop_info[j].roi_map.width,
|
|
crop_data->crop_info[j].roi_map.height);
|
|
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
LOGE("No space to add reprocess stream crop/roi information");
|
|
}
|
|
}
|
|
|
|
IF_META_AVAILABLE(cam_cds_data_t, cdsInfo, CAM_INTF_META_CDS_DATA, meta) {
|
|
uint8_t cnt = cdsInfo->num_of_streams;
|
|
if (cnt <= MAX_NUM_STREAMS) {
|
|
cam_stream_cds_info_t repro_cds_info;
|
|
memset(&repro_cds_info, 0, sizeof(repro_cds_info));
|
|
repro_cds_info.stream_id = mStreams[0]->getMyServerID();
|
|
for (size_t i = 0; i < cnt; i++) {
|
|
if (cdsInfo->cds_info[i].stream_id ==
|
|
pSrcStream->getMyServerID()) {
|
|
repro_cds_info.cds_enable =
|
|
cdsInfo->cds_info[i].cds_enable;
|
|
break;
|
|
}
|
|
}
|
|
cdsInfo->num_of_streams = 1;
|
|
cdsInfo->cds_info[0] = repro_cds_info;
|
|
} else {
|
|
LOGE("No space to add reprocess stream cds information");
|
|
}
|
|
}
|
|
|
|
fwk_frame.input_buffer = *frame->bufs[i];
|
|
fwk_frame.metadata_buffer = *meta_buffer;
|
|
fwk_frame.output_buffer = pp_buffer->output;
|
|
break;
|
|
} else {
|
|
LOGE("Source/Re-process streams are invalid");
|
|
rc |= BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3ReprocessChannel::overrideMetadata(metadata_buffer_t *meta_buffer,
|
|
jpeg_settings_t *jpeg_settings, uint32_t input_stream_svr_id)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if ((NULL == meta_buffer) || (NULL == hal_obj) || input_stream_svr_id == 0) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
LOGD("E, input stream id:%d", input_stream_svr_id);
|
|
|
|
if (jpeg_settings != NULL) {
|
|
// Find rotation info for reprocess stream
|
|
cam_rotation_info_t rotation_info;
|
|
memset(&rotation_info, 0, sizeof(rotation_info));
|
|
if (jpeg_settings->jpeg_orientation == 0) {
|
|
rotation_info.rotation = ROTATE_0;
|
|
} else if (jpeg_settings->jpeg_orientation == 90) {
|
|
rotation_info.rotation = ROTATE_90;
|
|
} else if (jpeg_settings->jpeg_orientation == 180) {
|
|
rotation_info.rotation = ROTATE_180;
|
|
} else if (jpeg_settings->jpeg_orientation == 270) {
|
|
rotation_info.rotation = ROTATE_270;
|
|
}
|
|
if (jpeg_settings->hdr_snapshot) {
|
|
rotation_info.rotation = ROTATE_0;
|
|
}
|
|
rotation_info.streamId = mStreams[0]->getMyServerID();
|
|
LOGD("roration:%d, stream id:%d", rotation_info.rotation, rotation_info.streamId);
|
|
ADD_SET_PARAM_ENTRY_TO_BATCH(meta_buffer, CAM_INTF_PARM_ROTATION, rotation_info);
|
|
}
|
|
|
|
// Find and insert crop info for reprocess stream
|
|
IF_META_AVAILABLE(cam_crop_data_t, crop_data, CAM_INTF_META_CROP_DATA, meta_buffer) {
|
|
if (MAX_NUM_STREAMS > crop_data->num_of_streams) {
|
|
for (int j = 0; j < crop_data->num_of_streams; j++) {
|
|
if (crop_data->crop_info[j].stream_id == input_stream_svr_id) {
|
|
// Store crop/roi information for offline reprocess
|
|
// in the reprocess stream slot
|
|
crop_data->crop_info[crop_data->num_of_streams].crop =
|
|
crop_data->crop_info[j].crop;
|
|
crop_data->crop_info[crop_data->num_of_streams].roi_map =
|
|
crop_data->crop_info[j].roi_map;
|
|
crop_data->crop_info[crop_data->num_of_streams].stream_id =
|
|
mStreams[0]->getMyServerID();
|
|
crop_data->num_of_streams++;
|
|
|
|
LOGD("Reprocess stream server id: %d",
|
|
mStreams[0]->getMyServerID());
|
|
LOGD("Found offline reprocess crop %dx%d %dx%d",
|
|
crop_data->crop_info[j].crop.left,
|
|
crop_data->crop_info[j].crop.top,
|
|
crop_data->crop_info[j].crop.width,
|
|
crop_data->crop_info[j].crop.height);
|
|
LOGD("Found offline reprocess roimap %dx%d %dx%d",
|
|
crop_data->crop_info[j].roi_map.left,
|
|
crop_data->crop_info[j].roi_map.top,
|
|
crop_data->crop_info[j].roi_map.width,
|
|
crop_data->crop_info[j].roi_map.height);
|
|
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
LOGE("No space to add reprocess stream crop/roi information");
|
|
}
|
|
}
|
|
|
|
|
|
IF_META_AVAILABLE(cam_cds_data_t, cdsInfo, CAM_INTF_META_CDS_DATA, meta_buffer) {
|
|
uint8_t cnt = cdsInfo->num_of_streams;
|
|
LOGD("num of streams in cdsInfo:%d", cnt);
|
|
if (cnt <= MAX_NUM_STREAMS) {
|
|
cam_stream_cds_info_t repro_cds_info;
|
|
memset(&repro_cds_info, 0, sizeof(repro_cds_info));
|
|
repro_cds_info.stream_id = mStreams[0]->getMyServerID();
|
|
for (size_t i = 0; i < cnt; i++) {
|
|
if (cdsInfo->cds_info[i].stream_id == input_stream_svr_id) {
|
|
repro_cds_info.cds_enable = cdsInfo->cds_info[i].cds_enable;
|
|
break;
|
|
}
|
|
}
|
|
cdsInfo->num_of_streams = 1;
|
|
cdsInfo->cds_info[0] = repro_cds_info;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : overrideFwkMetadata
|
|
*
|
|
* DESCRIPTION: Override frameworks metadata such as rotation, crop, and CDS data.
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : input frame for reprocessing
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::overrideFwkMetadata(
|
|
qcamera_fwk_input_pp_data_t *frame)
|
|
{
|
|
if (NULL == frame) {
|
|
LOGE("Incorrect input frame");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (NULL == frame->metadata_buffer.buffer) {
|
|
LOGE("No metadata available");
|
|
return BAD_VALUE;
|
|
}
|
|
metadata_buffer_t *meta = (metadata_buffer_t *) frame->metadata_buffer.buffer;
|
|
|
|
// Not doing rotation at all for YUV to YUV reprocess
|
|
if (mReprocessType != REPROCESS_TYPE_JPEG) {
|
|
LOGD("Override rotation to 0 for channel reprocess type %d",
|
|
mReprocessType);
|
|
cam_rotation_info_t rotation_info;
|
|
memset(&rotation_info, 0, sizeof(rotation_info));
|
|
rotation_info.rotation = ROTATE_0;
|
|
rotation_info.streamId = mStreams[0]->getMyServerID();
|
|
ADD_SET_PARAM_ENTRY_TO_BATCH(meta, CAM_INTF_PARM_ROTATION, rotation_info);
|
|
}
|
|
|
|
// Find and insert crop info for reprocess stream
|
|
IF_META_AVAILABLE(cam_crop_data_t, crop_data, CAM_INTF_META_CROP_DATA, meta) {
|
|
if (1 == crop_data->num_of_streams) {
|
|
// Store crop/roi information for offline reprocess
|
|
// in the reprocess stream slot
|
|
crop_data->crop_info[crop_data->num_of_streams].crop =
|
|
crop_data->crop_info[0].crop;
|
|
crop_data->crop_info[crop_data->num_of_streams].roi_map =
|
|
crop_data->crop_info[0].roi_map;
|
|
crop_data->crop_info[crop_data->num_of_streams].stream_id =
|
|
mStreams[0]->getMyServerID();
|
|
crop_data->num_of_streams++;
|
|
|
|
LOGD("Reprocess stream server id: %d",
|
|
mStreams[0]->getMyServerID());
|
|
LOGD("Found offline reprocess crop %dx%d %dx%d",
|
|
crop_data->crop_info[0].crop.left,
|
|
crop_data->crop_info[0].crop.top,
|
|
crop_data->crop_info[0].crop.width,
|
|
crop_data->crop_info[0].crop.height);
|
|
LOGD("Found offline reprocess roi map %dx%d %dx%d",
|
|
crop_data->crop_info[0].roi_map.left,
|
|
crop_data->crop_info[0].roi_map.top,
|
|
crop_data->crop_info[0].roi_map.width,
|
|
crop_data->crop_info[0].roi_map.height);
|
|
} else {
|
|
LOGE("Incorrect number of offline crop data entries %d",
|
|
crop_data->num_of_streams);
|
|
return BAD_VALUE;
|
|
}
|
|
} else {
|
|
LOGW("Crop data not present");
|
|
}
|
|
|
|
IF_META_AVAILABLE(cam_cds_data_t, cdsInfo, CAM_INTF_META_CDS_DATA, meta) {
|
|
if (1 == cdsInfo->num_of_streams) {
|
|
cdsInfo->cds_info[0].stream_id = mStreams[0]->getMyServerID();
|
|
} else {
|
|
LOGE("Incorrect number of offline cds info entries %d",
|
|
cdsInfo->num_of_streams);
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : doMetaReprocessOffline
|
|
*
|
|
* DESCRIPTION: request to do a reprocess on meta frame
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : input frame for reprocessing
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::doMetaReprocessOffline(
|
|
qcamera_fwk_input_pp_data_t *frame)
|
|
{
|
|
int32_t rc = 0;
|
|
OfflineBuffer mappedBuffer;
|
|
LOGD("E");
|
|
|
|
if (!m_bOfflineIsp) {
|
|
LOGE("meta reprocess is not allowed when m_bOfflineIsp is not set");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
uint32_t i;
|
|
for (i = 0; i < m_numStreams; i++) {
|
|
if (isMetaReprocStream(mStreams[i])) {
|
|
LOGD("found meta reproc stream idx:%d, src stream handle:%x", i, mSrcStreamHandles[i]);
|
|
break;
|
|
}
|
|
}
|
|
if (i >= m_numStreams) {
|
|
LOGE("can't find meta reproc stream!");
|
|
return BAD_VALUE;
|
|
}
|
|
QCamera3Stream* pMetaReprocStream = mStreams[i];
|
|
|
|
if (mMemoryMeta == NULL) {
|
|
LOGE("mMemoryMeta shouldn't be NULL.");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
uint32_t bufIdx = 0;
|
|
rc = mMemoryMeta->allocateOne(mFrameLenMeta);
|
|
if (rc < 0) {
|
|
LOGE("Failed allocating heap buffer. Fatal");
|
|
return BAD_VALUE;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
}
|
|
|
|
LOGD("allocate one buffer, len:%d, idx:%d", mFrameLenMeta, bufIdx);
|
|
mMemoryMeta->markFrameNumber(bufIdx, frame->frameNumber);
|
|
rc = pMetaReprocStream->bufDone(bufIdx);
|
|
|
|
// map offline buffers
|
|
uint32_t buf_idx = mOfflineBuffersIndex;
|
|
|
|
//Do cache ops before sending for reprocess
|
|
mMemoryMeta->cleanInvalidateCache(buf_idx);
|
|
|
|
rc = pMetaReprocStream->mapBuf(
|
|
CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF,
|
|
buf_idx, -1,
|
|
frame->metadata_buffer.fd, frame->metadata_buffer.buffer,
|
|
frame->metadata_buffer.frame_len);
|
|
if (NO_ERROR == rc) {
|
|
mappedBuffer.index = buf_idx;
|
|
mappedBuffer.stream = pMetaReprocStream;
|
|
mappedBuffer.type = CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF;
|
|
mOfflineBuffers.push_back(mappedBuffer);
|
|
LOGD("Mapped buffer with index %d", buf_idx);
|
|
}
|
|
|
|
uint32_t meta_buf_idx = mOfflineMetaIndex;
|
|
rc |= pMetaReprocStream->mapBuf(
|
|
CAM_MAPPING_BUF_TYPE_OFFLINE_META_BUF,
|
|
meta_buf_idx, -1,
|
|
frame->metadata_buffer.fd, frame->metadata_buffer.buffer,
|
|
frame->metadata_buffer.frame_len);
|
|
if (NO_ERROR == rc) {
|
|
mappedBuffer.index = meta_buf_idx;
|
|
mappedBuffer.stream = pMetaReprocStream;
|
|
mappedBuffer.type = CAM_MAPPING_BUF_TYPE_OFFLINE_META_BUF;
|
|
mOfflineMetaBuffers.push_back(mappedBuffer);
|
|
LOGD("Mapped meta buffer with index %d", meta_buf_idx);
|
|
}
|
|
|
|
cam_stream_parm_buffer_t param;
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_DO_REPROCESS;
|
|
param.reprocess.buf_index = buf_idx;
|
|
param.reprocess.frame_idx = frame->input_buffer.frame_idx;
|
|
param.reprocess.meta_present = 1;
|
|
param.reprocess.meta_buf_index = meta_buf_idx;
|
|
|
|
LOGI("Offline reprocessing id = %d buf Id = %d meta index = %d",
|
|
param.reprocess.frame_idx, param.reprocess.buf_index,
|
|
param.reprocess.meta_buf_index);
|
|
rc = pMetaReprocStream->setParameter(param);
|
|
|
|
LOGE("X, rc = %d", rc);
|
|
return rc;
|
|
}
|
|
|
|
|
|
int32_t QCamera3ReprocessChannel::timeoutFrame(uint32_t frameNumber)
|
|
{
|
|
int32_t index = -1, ret = NO_ERROR;
|
|
LOGH("E, frameNumber: %d", frameNumber)
|
|
|
|
if (mReprocessType == REPROCESS_TYPE_JPEG) {
|
|
index = mMemory->getFrameNumber(frameNumber);
|
|
} else {
|
|
index = mGrallocMemory.getGrallocBufferIndex(frameNumber);
|
|
}
|
|
|
|
if (index < 0) {
|
|
LOGH("Error!! X, frameNumber: %d index(%d) not found", frameNumber, index)
|
|
return BAD_VALUE;
|
|
}
|
|
ret = mStreams[0]->cancelBuffer(index);
|
|
LOGH("X, frameNumber: %d", frameNumber)
|
|
return ret;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : doReprocessOffline
|
|
*
|
|
* DESCRIPTION: request to do a reprocess on the frame
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : input frame for reprocessing
|
|
* @isPriorityFrame: Hint that this frame is of priority, equivalent to
|
|
* real time, even though it is processed in offline mechanism
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::doReprocessOffline(
|
|
qcamera_fwk_input_pp_data_t *frame, bool isPriorityFrame)
|
|
{
|
|
int32_t rc = 0;
|
|
int index;
|
|
OfflineBuffer mappedBuffer;
|
|
|
|
QCamera3ProcessingChannel *obj = (QCamera3ProcessingChannel *)inputChHandle;
|
|
|
|
if (m_numStreams < 1) {
|
|
LOGE("No reprocess stream is created");
|
|
return -1;
|
|
}
|
|
|
|
if (NULL == frame) {
|
|
LOGE("Incorrect input frame");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (NULL == frame->metadata_buffer.buffer) {
|
|
LOGE("No metadata available");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (NULL == frame->input_buffer.buffer) {
|
|
LOGE("No input buffer available");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if ((0 == m_numStreams) || (NULL == mStreams[0])) {
|
|
LOGE("Reprocess stream not initialized!");
|
|
return NO_INIT;
|
|
}
|
|
|
|
if (m_bOfflineIsp) {
|
|
LOGH("do meta offline reprocess first");
|
|
rc = doMetaReprocessOffline(frame);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("meta stream setParameter for reprocess failed");
|
|
}
|
|
}
|
|
|
|
QCamera3Stream *pStream = mStreams[0];
|
|
|
|
//qbuf the output buffer if it was allocated by the framework
|
|
if (mReprocessType != REPROCESS_TYPE_JPEG && ((frame->output_buffer != NULL)
|
|
|| (obj->m_bQuadraChannel
|
|
&& (m_ppIndex == 1)))) {
|
|
|
|
if(obj->m_bQuadraChannel && (frame->output_buffer == NULL)) {
|
|
frame->output_buffer = (buffer_handle_t *)
|
|
((QCamera3YUVChannel *)obj)->getQuadraOutputBuffer(frame->frameNumber);
|
|
}
|
|
if(!m_bIsActive) {
|
|
rc = registerBuffer(frame->output_buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
rc = start();
|
|
if (NO_ERROR != rc) {
|
|
return rc;
|
|
}
|
|
}
|
|
index = mGrallocMemory.getMatchBufIndex((void*)frame->output_buffer);
|
|
if(index < 0) {
|
|
rc = registerBuffer(frame->output_buffer, mIsType);
|
|
if (NO_ERROR != rc) {
|
|
LOGE("On-the-fly buffer registration failed %d",
|
|
rc);
|
|
return rc;
|
|
}
|
|
|
|
index = mGrallocMemory.getMatchBufIndex((void*)frame->output_buffer);
|
|
if (index < 0) {
|
|
LOGE("Could not find object among registered buffers");
|
|
return DEAD_OBJECT;
|
|
}
|
|
}
|
|
rc = mGrallocMemory.markFrameNumber(index, frame->frameNumber);
|
|
LOGD("Offline Reprocessing Starting for Buf Index : %d and frame number :%d ",
|
|
index, frame->frameNumber);
|
|
if(rc != NO_ERROR) {
|
|
LOGE("Failed to mark frame#:%d, index:%d",frame->frameNumber,index);
|
|
return rc;
|
|
}
|
|
rc = pStream->bufDone(index);
|
|
if(rc != NO_ERROR) {
|
|
LOGE("Failed to Q new buffer to stream");
|
|
mGrallocMemory.markFrameNumber(index, -1);
|
|
return rc;
|
|
}
|
|
|
|
} else if (mReprocessType == REPROCESS_TYPE_JPEG) {
|
|
Mutex::Autolock lock(mFreeBuffersLock);
|
|
uint32_t bufIdx;
|
|
if (mFreeBufferList.empty()) {
|
|
rc = mMemory->allocateOne(mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("Failed allocating heap buffer. Fatal");
|
|
return BAD_VALUE;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
}
|
|
} else {
|
|
bufIdx = *(mFreeBufferList.begin());
|
|
mFreeBufferList.erase(mFreeBufferList.begin());
|
|
}
|
|
|
|
mMemory->markFrameNumber(bufIdx, frame->frameNumber);
|
|
rc = pStream->bufDone(bufIdx);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Failed to queue new buffer to stream");
|
|
return rc;
|
|
}
|
|
}else if(mReprocessType == REPROCESS_TYPE_YUV && (frame->output_buffer == NULL)) {
|
|
uint32_t bufIdx;
|
|
rc = mMemory->allocateOne(mFrameLen);
|
|
if (rc < 0) {
|
|
LOGE("Failed allocating heap buffer. Fatal");
|
|
return BAD_VALUE;
|
|
} else {
|
|
bufIdx = (uint32_t)rc;
|
|
}
|
|
|
|
mMemory->markFrameNumber(bufIdx, frame->frameNumber);
|
|
rc = pStream->bufDone(bufIdx);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("Failed to queue new buffer to stream");
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
int32_t max_idx = (int32_t) (mNumBuffers - 1);
|
|
//loop back the indices if max burst count reached
|
|
if (mOfflineBuffersIndex == max_idx) {
|
|
mOfflineBuffersIndex = -1;
|
|
}
|
|
uint32_t buf_idx = (uint32_t)(mOfflineBuffersIndex + 1);
|
|
|
|
rc = pStream->mapBuf(
|
|
CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF,
|
|
buf_idx, -1,
|
|
frame->input_buffer.fd, frame->input_buffer.buffer,
|
|
frame->input_buffer.frame_len);
|
|
if (NO_ERROR == rc) {
|
|
mappedBuffer.index = buf_idx;
|
|
mappedBuffer.stream = pStream;
|
|
mappedBuffer.type = CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF;
|
|
Mutex::Autolock lock(mOfflineBuffersLock);
|
|
mOfflineBuffers.push_back(mappedBuffer);
|
|
mOfflineBuffersIndex = (int32_t)buf_idx;
|
|
LOGD("Mapped buffer with index %d", mOfflineBuffersIndex);
|
|
}
|
|
|
|
max_idx = (int32_t) ((mNumBuffers * 2) - 1);
|
|
//loop back the indices if max burst count reached
|
|
if (mOfflineMetaIndex == max_idx) {
|
|
mOfflineMetaIndex = (int32_t) (mNumBuffers - 1);
|
|
}
|
|
uint32_t meta_buf_idx = (uint32_t)(mOfflineMetaIndex + 1);
|
|
rc |= pStream->mapBuf(
|
|
CAM_MAPPING_BUF_TYPE_OFFLINE_META_BUF,
|
|
meta_buf_idx, -1,
|
|
frame->metadata_buffer.fd, frame->metadata_buffer.buffer,
|
|
frame->metadata_buffer.frame_len);
|
|
if (NO_ERROR == rc) {
|
|
mappedBuffer.index = meta_buf_idx;
|
|
mappedBuffer.stream = pStream;
|
|
mappedBuffer.type = CAM_MAPPING_BUF_TYPE_OFFLINE_META_BUF;
|
|
Mutex::Autolock lock(mOfflineMetaBuffersLock);
|
|
mOfflineMetaBuffers.push_back(mappedBuffer);
|
|
mOfflineMetaIndex = (int32_t)meta_buf_idx;
|
|
LOGD("Mapped meta buffer with index %d", mOfflineMetaIndex);
|
|
}
|
|
|
|
if (rc == NO_ERROR) {
|
|
cam_stream_parm_buffer_t param;
|
|
uint32_t numPendingPriorityFrames = 0;
|
|
|
|
if(isPriorityFrame && (mReprocessType != REPROCESS_TYPE_JPEG)) {
|
|
Mutex::Autolock lock(mPriorityFramesLock);
|
|
/* read the length before pushing the frame number to check if
|
|
* vector is empty */
|
|
numPendingPriorityFrames = mPriorityFrames.size();
|
|
mPriorityFrames.push(frame->frameNumber);
|
|
}
|
|
|
|
if(isPriorityFrame && !numPendingPriorityFrames &&
|
|
(mReprocessType != REPROCESS_TYPE_JPEG)) {
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_REQUEST_OPS_MODE;
|
|
param.perf_mode = CAM_PERF_HIGH_PERFORMANCE;
|
|
rc = pStream->setParameter(param);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("%s: setParameter for CAM_PERF_HIGH_PERFORMANCE failed",
|
|
__func__);
|
|
}
|
|
{
|
|
Mutex::Autolock lock(mPriorityFramesLock);
|
|
mReprocessPerfMode = true;
|
|
}
|
|
}
|
|
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_DO_REPROCESS;
|
|
param.reprocess.buf_index = buf_idx;
|
|
param.reprocess.frame_idx = frame->input_buffer.frame_idx;
|
|
param.reprocess.meta_present = 1;
|
|
param.reprocess.meta_buf_index = meta_buf_idx;
|
|
|
|
LOGI("Offline reprocessing id = %d buf Id = %d meta index = %d",
|
|
param.reprocess.frame_idx, param.reprocess.buf_index,
|
|
param.reprocess.meta_buf_index);
|
|
rc = pStream->setParameter(param);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("stream setParameter for reprocess failed");
|
|
resetToCamPerfNormal(frame->frameNumber);
|
|
}
|
|
} else {
|
|
LOGE("Input buffer memory map failed: %d", rc);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : doReprocess
|
|
*
|
|
* DESCRIPTION: request to do a reprocess on the frame
|
|
*
|
|
* PARAMETERS :
|
|
* @buf_fd : fd to the input buffer that needs reprocess
|
|
* @buffer : Buffer ptr
|
|
* @buf_lenght : length of the input buffer
|
|
* @ret_val : result of reprocess.
|
|
* Example: Could be faceID in case of register face image.
|
|
* @meta_frame : metadata frame.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::doReprocess(int buf_fd, void *buffer, size_t buf_length,
|
|
int32_t &ret_val, mm_camera_super_buf_t *meta_frame)
|
|
{
|
|
int32_t rc = 0;
|
|
if (m_numStreams < 1) {
|
|
LOGE("No reprocess stream is created");
|
|
return -1;
|
|
}
|
|
if (meta_frame == NULL) {
|
|
LOGE("Did not get corresponding metadata in time");
|
|
return -1;
|
|
}
|
|
|
|
uint8_t buf_idx = 0;
|
|
for (uint32_t i = 0; i < m_numStreams; i++) {
|
|
rc = mStreams[i]->mapBuf(CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF,
|
|
buf_idx, -1,
|
|
buf_fd, buffer, buf_length);
|
|
|
|
if (rc == NO_ERROR) {
|
|
cam_stream_parm_buffer_t param;
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
param.type = CAM_STREAM_PARAM_TYPE_DO_REPROCESS;
|
|
param.reprocess.buf_index = buf_idx;
|
|
param.reprocess.meta_present = 1;
|
|
param.reprocess.meta_stream_handle = m_pMetaChannel->mStreams[0]->getMyServerID();
|
|
param.reprocess.meta_buf_index = meta_frame->bufs[0]->buf_idx;
|
|
|
|
LOGI("Online reprocessing id = %d buf Id = %d meta index = %d",
|
|
param.reprocess.frame_idx, param.reprocess.buf_index,
|
|
param.reprocess.meta_buf_index);
|
|
rc = mStreams[i]->setParameter(param);
|
|
if (rc == NO_ERROR) {
|
|
ret_val = param.reprocess.ret_val;
|
|
}
|
|
mStreams[i]->unmapBuf(CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF,
|
|
buf_idx, -1);
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : addMetaReprocStream
|
|
*
|
|
* DESCRIPTION: add metadata reprocess stream from metadata channel
|
|
*
|
|
* PARAMETERS :
|
|
* @config : pp feature configuration
|
|
* @src_config : source reprocess configuration
|
|
* @isType : type of image stabilization required on this stream
|
|
* @pMetaChannel : ptr to metadata channel to get corresp. metadata
|
|
*
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::addMetaReprocStream(QCamera3Channel *pMetaChannel)
|
|
{
|
|
int32_t rc = 0;
|
|
cam_stream_reproc_config_t reproc_cfg;
|
|
cam_dimension_t meta_dim = {0, 0};
|
|
cam_format_t meta_stream_fmt = CAM_FORMAT_MAX;
|
|
|
|
LOGD("E");
|
|
|
|
QCamera3Stream *pMetaStream = pMetaChannel->getStreamByIndex(0);
|
|
if (pMetaStream == NULL) {
|
|
LOGE("fail to get metadata stream.");
|
|
return -1;
|
|
}
|
|
mSrcStreamHandles[m_numStreams] = pMetaStream->getMyHandle();
|
|
LOGD("meta stream:%p, handle:%p", pMetaStream, mSrcStreamHandles[m_numStreams]);
|
|
|
|
meta_dim.width = (int32_t)sizeof(metadata_buffer_t),
|
|
meta_dim.height = 1;
|
|
|
|
memset(&reproc_cfg, 0, sizeof(cam_stream_reproc_config_t));
|
|
reproc_cfg.pp_type = CAM_OFFLINE_REPROCESS_TYPE;
|
|
|
|
// input stream config
|
|
reproc_cfg.offline.input_fmt = meta_stream_fmt;
|
|
reproc_cfg.offline.input_dim = meta_dim;
|
|
mm_stream_calc_offset_metadata(&meta_dim, pMetaChannel->getPaddingInfo(),
|
|
&reproc_cfg.offline.input_buf_planes);
|
|
reproc_cfg.offline.num_of_bufs = mNumBuffers;
|
|
reproc_cfg.offline.input_type = CAM_STREAM_TYPE_METADATA;
|
|
|
|
reproc_cfg.pp_feature_config.feature_mask = CAM_QCOM_FEATURE_METADATA_PROCESSING;;
|
|
|
|
QCamera3Stream *pStream = new QCamera3Stream(m_camHandle,
|
|
m_handle,
|
|
m_camOps,
|
|
pMetaChannel->getPaddingInfo(),
|
|
(QCamera3Channel*)this);
|
|
|
|
rc = pStream->init(CAM_STREAM_TYPE_OFFLINE_PROC, meta_stream_fmt,
|
|
meta_dim, ROTATE_0, &reproc_cfg,
|
|
(uint8_t)mNumBuffers,
|
|
reproc_cfg.pp_feature_config.feature_mask,
|
|
IS_TYPE_NONE,
|
|
0,/* batchSize */
|
|
QCamera3Channel::streamCbRoutine, this, false);
|
|
|
|
if (rc == 0) {
|
|
mStreams[m_numStreams] = pStream;
|
|
m_numStreams++;
|
|
} else {
|
|
LOGE("failed to create reprocess stream");
|
|
delete pStream;
|
|
}
|
|
|
|
LOGD("X. rc = %d", rc);
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : addReprocStreamsFromSource
|
|
*
|
|
* DESCRIPTION: add reprocess streams from input source channel
|
|
*
|
|
* PARAMETERS :
|
|
* @config : pp feature configuration
|
|
* @src_config : source reprocess configuration
|
|
* @isType : type of image stabilization required on this stream
|
|
* @pMetaChannel : ptr to metadata channel to get corresp. metadata
|
|
*
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCamera3ReprocessChannel::addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config,
|
|
const reprocess_config_t &src_config , cam_is_type_t is_type,
|
|
QCamera3Channel *pMetaChannel)
|
|
{
|
|
int32_t rc = 0;
|
|
cam_stream_reproc_config_t reprocess_config;
|
|
cam_stream_type_t streamType;
|
|
|
|
cam_dimension_t streamDim = src_config.output_stream_dim;
|
|
cam_format_t streamFormat = src_config.output_stream_format;
|
|
|
|
if (NULL != src_config.src_channel) {
|
|
QCamera3Stream *pSrcStream = src_config.src_channel->getStreamByIndex(0);
|
|
if (pSrcStream == NULL) {
|
|
LOGE("source channel doesn't have a stream");
|
|
return BAD_VALUE;
|
|
}
|
|
mSrcStreamHandles[m_numStreams] = pSrcStream->getMyHandle();
|
|
}
|
|
|
|
streamType = CAM_STREAM_TYPE_OFFLINE_PROC;
|
|
reprocess_config.pp_type = CAM_OFFLINE_REPROCESS_TYPE;
|
|
|
|
reprocess_config.offline.input_fmt = src_config.stream_format;
|
|
reprocess_config.offline.input_dim = src_config.input_stream_dim;
|
|
reprocess_config.offline.input_buf_planes.plane_info =
|
|
src_config.input_stream_plane_info.plane_info;
|
|
reprocess_config.offline.num_of_bufs = (uint8_t)mNumBuffers;
|
|
reprocess_config.offline.input_type = src_config.stream_type;
|
|
|
|
//overwrite input/output stream foramt/type/frame_offset in multi pass reproc
|
|
QCamera3HardwareInterface* hal_obj = (QCamera3HardwareInterface*)mUserData;
|
|
if (hal_obj->getReprocChannelCnt() == 2) {
|
|
LOGI("modify input/output format for multi pass reprocess");
|
|
if (pp_config.feature_mask & CAM_QCOM_FEATURE_QUADRA_CFA) {
|
|
streamFormat = getStreamDefaultFormat(streamType, streamDim.width, streamDim.height);
|
|
LOGD("override output format from:%d to %d",
|
|
src_config.output_stream_format, streamFormat);
|
|
} else if (pp_config.feature_mask & CAM_QCOM_FEATURE_RAW_PROCESSING) {
|
|
reprocess_config.offline.input_fmt =
|
|
getStreamDefaultFormat(streamType, streamDim.width, streamDim.height);
|
|
LOGD("override input format from:%d to %d",
|
|
src_config.stream_format, reprocess_config.offline.input_fmt);
|
|
}
|
|
}
|
|
|
|
reprocess_config.pp_feature_config = pp_config;
|
|
QCamera3Stream *pStream = new QCamera3Stream(m_camHandle,
|
|
m_handle,
|
|
m_camOps,
|
|
&mPaddingInfo,
|
|
(QCamera3Channel*)this);
|
|
if (pStream == NULL) {
|
|
LOGE("No mem for Stream");
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
rc = pStream->init(streamType, streamFormat,
|
|
streamDim, ROTATE_0, &reprocess_config,
|
|
(uint8_t)mNumBuffers,
|
|
reprocess_config.pp_feature_config.feature_mask,
|
|
is_type,
|
|
0,/* batchSize */
|
|
QCamera3Channel::streamCbRoutine, this, isSecureMode());
|
|
|
|
if (rc == 0) {
|
|
mStreams[m_numStreams] = pStream;
|
|
m_numStreams++;
|
|
} else {
|
|
LOGE("failed to create reprocess stream");
|
|
delete pStream;
|
|
}
|
|
|
|
if (rc == NO_ERROR) {
|
|
m_pSrcChannel = src_config.src_channel;
|
|
m_pMetaChannel = pMetaChannel;
|
|
mReprocessType = src_config.reprocess_type;
|
|
LOGD("mReprocessType is %d", mReprocessType);
|
|
}
|
|
|
|
// meta reproc stream always appends as the last reproc stream
|
|
if (pp_config.feature_mask & CAM_QCOM_FEATURE_RAW_PROCESSING) {
|
|
LOGH("raw process mask is set, need offline isp and meta reprocess");
|
|
m_bOfflineIsp = TRUE;
|
|
addMetaReprocStream(pMetaChannel);
|
|
}
|
|
|
|
// meta reproc stream always appends as the last reproc stream
|
|
if ((pp_config.feature_mask & CAM_QTI_FEATURE_MFPROC_POSTCPP) ||
|
|
(pp_config.feature_mask & CAM_QCOM_FEATURE_STILLMORE )) {
|
|
LOGH("MultiFrame Postcpp Reprocess mask is set, need duplicate buffers");
|
|
m_bMultiFrameCapture = TRUE;
|
|
}
|
|
|
|
mm_camera_req_buf_t buf;
|
|
memset(&buf, 0x0, sizeof(buf));
|
|
buf.type = MM_CAMERA_REQ_SUPER_BUF;
|
|
buf.num_buf_requested = 1;
|
|
if(m_camOps->request_super_buf(m_camHandle,m_handle, &buf) < 0) {
|
|
LOGE("Request for super buffer failed");
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
bool QCamera3ReprocessChannel::isMetaReprocStream(QCamera3Stream *stream) {
|
|
return (stream->getStreamInfo()->reprocess_config.offline.input_type
|
|
== CAM_STREAM_TYPE_METADATA);
|
|
}
|
|
|
|
|
|
/* QCamera3SupportChannel methods */
|
|
|
|
cam_dimension_t QCamera3SupportChannel::kDim = {640, 480};
|
|
|
|
QCamera3SupportChannel::QCamera3SupportChannel(uint32_t cam_handle,
|
|
uint32_t channel_handle,
|
|
mm_camera_ops_t *cam_ops,
|
|
cam_padding_info_t *paddingInfo,
|
|
cam_feature_mask_t postprocess_mask,
|
|
cam_stream_type_t streamType,
|
|
cam_dimension_t *dim,
|
|
cam_format_t streamFormat,
|
|
cam_color_filter_arrangement_t color_arrangement,
|
|
void *userData, uint32_t numBuffers) :
|
|
QCamera3Channel(cam_handle, channel_handle, cam_ops,
|
|
NULL, NULL, paddingInfo, postprocess_mask,
|
|
userData, numBuffers),
|
|
mMemory(NULL)
|
|
{
|
|
memcpy(&mDim, dim, sizeof(cam_dimension_t));
|
|
mStreamType = streamType;
|
|
mStreamFormat = streamFormat;
|
|
// Make Analysis same as Preview format
|
|
if ((mStreamFormat != CAM_FORMAT_Y_ONLY) &&
|
|
(mStreamType == CAM_STREAM_TYPE_ANALYSIS) &&
|
|
(color_arrangement != CAM_FILTER_ARRANGEMENT_Y)) {
|
|
mStreamFormat = getStreamDefaultFormat(CAM_STREAM_TYPE_PREVIEW,
|
|
dim->width, dim->height);
|
|
}
|
|
}
|
|
|
|
QCamera3SupportChannel::~QCamera3SupportChannel()
|
|
{
|
|
destroy();
|
|
|
|
if (mMemory) {
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
}
|
|
|
|
int32_t QCamera3SupportChannel::initialize(cam_is_type_t isType)
|
|
{
|
|
int32_t rc;
|
|
|
|
if (mMemory || m_numStreams > 0) {
|
|
LOGE("metadata channel already initialized");
|
|
return -EINVAL;
|
|
}
|
|
|
|
mIsType = isType;
|
|
rc = QCamera3Channel::addStream(mStreamType,
|
|
mStreamFormat, mDim, ROTATE_0, MIN_STREAMING_BUFFER_NUM,
|
|
mPostProcMask, mIsType);
|
|
if (rc < 0) {
|
|
LOGE("addStream failed");
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int32_t QCamera3SupportChannel::request(buffer_handle_t * /*buffer*/,
|
|
uint32_t /*frameNumber*/,
|
|
int & /*indexUsed*/)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void QCamera3SupportChannel::streamCbRoutine(
|
|
mm_camera_super_buf_t *super_frame,
|
|
QCamera3Stream * /*stream*/)
|
|
{
|
|
if (super_frame == NULL || super_frame->num_bufs != 1) {
|
|
LOGE("super_frame is not valid");
|
|
return;
|
|
}
|
|
bufDone(super_frame);
|
|
free(super_frame);
|
|
}
|
|
|
|
QCamera3StreamMem* QCamera3SupportChannel::getStreamBufs(uint32_t len)
|
|
{
|
|
int rc;
|
|
mMemory = new QCamera3StreamMem(mNumBuffers, true, isSecureMode());
|
|
if (!mMemory) {
|
|
LOGE("unable to create heap memory");
|
|
return NULL;
|
|
}
|
|
rc = mMemory->allocateAll(len);
|
|
if (rc < 0) {
|
|
LOGE("unable to allocate heap memory");
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
return NULL;
|
|
}
|
|
return mMemory;
|
|
}
|
|
|
|
void QCamera3SupportChannel::putStreamBufs()
|
|
{
|
|
mMemory->deallocate();
|
|
delete mMemory;
|
|
mMemory = NULL;
|
|
}
|
|
|
|
}; // namespace qcamera
|