669d233045
CAF revision: AU_LINUX_ANDROID_LA.UM.5.1_RB1.06.00.01.192.038 Change-Id: I87589fea5e9c00c3bdc9c79cc6b2d6453c3d09b3
3631 lines
130 KiB
C++
3631 lines
130 KiB
C++
/* Copyright (c) 2012-2016, 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 "QCameraPostProc"
|
|
|
|
// System dependencies
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <utils/Errors.h>
|
|
|
|
// Camera dependencies
|
|
#include "QCamera2HWI.h"
|
|
#include "QCameraPostProc.h"
|
|
#include "QCameraTrace.h"
|
|
|
|
extern "C" {
|
|
#include "mm_camera_dbg.h"
|
|
}
|
|
|
|
namespace qcamera {
|
|
|
|
const char *QCameraPostProcessor::STORE_LOCATION = "/sdcard/img_%d.jpg";
|
|
|
|
#define FREE_JPEG_OUTPUT_BUFFER(ptr,cnt) \
|
|
int jpeg_bufs; \
|
|
for (jpeg_bufs = 0; jpeg_bufs < (int)cnt; jpeg_bufs++) { \
|
|
if (ptr[jpeg_bufs] != NULL) { \
|
|
free(ptr[jpeg_bufs]); \
|
|
ptr[jpeg_bufs] = NULL; \
|
|
} \
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCameraPostProcessor
|
|
*
|
|
* DESCRIPTION: constructor of QCameraPostProcessor.
|
|
*
|
|
* PARAMETERS :
|
|
* @cam_ctrl : ptr to HWI object
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraPostProcessor::QCameraPostProcessor(QCamera2HardwareInterface *cam_ctrl)
|
|
: m_parent(cam_ctrl),
|
|
mJpegCB(NULL),
|
|
mJpegUserData(NULL),
|
|
mJpegClientHandle(0),
|
|
mJpegSessionId(0),
|
|
m_pJpegExifObj(NULL),
|
|
m_bThumbnailNeeded(TRUE),
|
|
mPPChannelCount(0),
|
|
m_bInited(FALSE),
|
|
m_inputPPQ(releaseOngoingPPData, this),
|
|
m_ongoingPPQ(releaseOngoingPPData, this),
|
|
m_inputJpegQ(releaseJpegData, this),
|
|
m_ongoingJpegQ(releaseJpegData, this),
|
|
m_inputRawQ(releaseRawData, this),
|
|
mSaveFrmCnt(0),
|
|
mUseSaveProc(false),
|
|
mUseJpegBurst(false),
|
|
mJpegMemOpt(true),
|
|
m_JpegOutputMemCount(0),
|
|
mNewJpegSessionNeeded(true),
|
|
m_bufCountPPQ(0),
|
|
m_PPindex(0)
|
|
{
|
|
memset(&mJpegHandle, 0, sizeof(mJpegHandle));
|
|
memset(&mJpegMpoHandle, 0, sizeof(mJpegMpoHandle));
|
|
memset(&m_pJpegOutputMem, 0, sizeof(m_pJpegOutputMem));
|
|
memset(mPPChannels, 0, sizeof(mPPChannels));
|
|
m_DataMem = NULL;
|
|
mOfflineDataBufs = NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCameraPostProcessor
|
|
*
|
|
* DESCRIPTION: deconstructor of QCameraPostProcessor.
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraPostProcessor::~QCameraPostProcessor()
|
|
{
|
|
FREE_JPEG_OUTPUT_BUFFER(m_pJpegOutputMem,m_JpegOutputMemCount);
|
|
if (m_pJpegExifObj != NULL) {
|
|
delete m_pJpegExifObj;
|
|
m_pJpegExifObj = NULL;
|
|
}
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
QCameraChannel *pChannel = mPPChannels[i];
|
|
if ( pChannel != NULL ) {
|
|
pChannel->stop();
|
|
delete pChannel;
|
|
pChannel = NULL;
|
|
}
|
|
}
|
|
mPPChannelCount = 0;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setJpegHandle
|
|
*
|
|
* DESCRIPTION: set JPEG client handles
|
|
*
|
|
* PARAMETERS :
|
|
* @pJpegHandle : JPEG ops handle
|
|
* @pJpegMpoHandle : MPO JPEG ops handle
|
|
* @clientHandle : JPEG client handle
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::setJpegHandle(mm_jpeg_ops_t *pJpegHandle,
|
|
mm_jpeg_mpo_ops_t *pJpegMpoHandle, uint32_t clientHandle)
|
|
{
|
|
LOGH("E mJpegClientHandle: %d, clientHandle: %d",
|
|
mJpegClientHandle, clientHandle);
|
|
|
|
if(pJpegHandle) {
|
|
memcpy(&mJpegHandle, pJpegHandle, sizeof(mm_jpeg_ops_t));
|
|
}
|
|
|
|
if(pJpegMpoHandle) {
|
|
memcpy(&mJpegMpoHandle, pJpegMpoHandle, sizeof(mm_jpeg_mpo_ops_t));
|
|
}
|
|
mJpegClientHandle = clientHandle;
|
|
LOGH("X mJpegClientHandle: %d, clientHandle: %d",
|
|
mJpegClientHandle, clientHandle);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : init
|
|
*
|
|
* DESCRIPTION: initialization of postprocessor
|
|
*
|
|
* PARAMETERS :
|
|
* @jpeg_cb : callback to handle jpeg event from mm-camera-interface
|
|
* @user_data : user data ptr for jpeg callback
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::init(jpeg_encode_callback_t jpeg_cb, void *user_data)
|
|
{
|
|
mJpegCB = jpeg_cb;
|
|
mJpegUserData = user_data;
|
|
m_dataProcTh.launch(dataProcessRoutine, this);
|
|
m_saveProcTh.launch(dataSaveRoutine, this);
|
|
m_parent->mParameters.setReprocCount();
|
|
m_bInited = TRUE;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : deinit
|
|
*
|
|
* DESCRIPTION: de-initialization of postprocessor
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::deinit()
|
|
{
|
|
if (m_bInited == TRUE) {
|
|
m_dataProcTh.exit();
|
|
m_saveProcTh.exit();
|
|
m_bInited = FALSE;
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : start
|
|
*
|
|
* DESCRIPTION: start postprocessor. Data process thread and data notify thread
|
|
* will be launched.
|
|
*
|
|
* PARAMETERS :
|
|
* @pSrcChannel : source channel obj ptr that possibly needs reprocess
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : if any reprocess is needed, a reprocess channel/stream
|
|
* will be started.
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::start(QCameraChannel *pSrcChannel)
|
|
{
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
int32_t rc = NO_ERROR;
|
|
QCameraChannel *pInputChannel = pSrcChannel;
|
|
|
|
LOGH("E ");
|
|
if (m_bInited == FALSE) {
|
|
LOGE("postproc not initialized yet");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
if (m_DataMem != NULL) {
|
|
m_DataMem->release(m_DataMem);
|
|
m_DataMem = NULL;
|
|
}
|
|
|
|
if (pInputChannel == NULL) {
|
|
LOGE("Input Channel for pproc is NULL.");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
if ( m_parent->needReprocess() ) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
// Delete previous reproc channel
|
|
QCameraReprocessChannel *pChannel = mPPChannels[i];
|
|
if (pChannel != NULL) {
|
|
pChannel->stop();
|
|
delete pChannel;
|
|
pChannel = NULL;
|
|
}
|
|
}
|
|
mPPChannelCount = 0;
|
|
|
|
m_bufCountPPQ = 0;
|
|
if (!m_parent->isLongshotEnabled()) {
|
|
m_parent->mParameters.setReprocCount();
|
|
}
|
|
|
|
if (m_parent->mParameters.getManualCaptureMode() >=
|
|
CAM_MANUAL_CAPTURE_TYPE_3) {
|
|
mPPChannelCount = m_parent->mParameters.getReprocCount() - 1;
|
|
} else {
|
|
mPPChannelCount = m_parent->mParameters.getReprocCount();
|
|
}
|
|
|
|
// Create all reproc channels and start channel
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
mPPChannels[i] = m_parent->addReprocChannel(pInputChannel, i);
|
|
if (mPPChannels[i] == NULL) {
|
|
LOGE("cannot add multi reprocess channel i = %d", i);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
rc = mPPChannels[i]->start();
|
|
if (rc != 0) {
|
|
LOGE("cannot start multi reprocess channel i = %d", i);
|
|
delete mPPChannels[i];
|
|
mPPChannels[i] = NULL;
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
pInputChannel = static_cast<QCameraChannel *>(mPPChannels[i]);
|
|
}
|
|
}
|
|
|
|
property_get("persist.camera.longshot.save", prop, "0");
|
|
mUseSaveProc = atoi(prop) > 0 ? true : false;
|
|
|
|
m_PPindex = 0;
|
|
m_InputMetadata.clear();
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, TRUE, FALSE);
|
|
m_parent->m_cbNotifier.startSnapshots();
|
|
LOGH("X rc = %d", rc);
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : stop
|
|
*
|
|
* DESCRIPTION: stop postprocessor. Data process and notify thread will be stopped.
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : reprocess channel will be stopped and deleted if there is any
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::stop()
|
|
{
|
|
if (m_bInited == TRUE) {
|
|
m_parent->m_cbNotifier.stopSnapshots();
|
|
|
|
if (m_DataMem != NULL) {
|
|
m_DataMem->release(m_DataMem);
|
|
m_DataMem = NULL;
|
|
}
|
|
|
|
// dataProc Thread need to process "stop" as sync call because abort jpeg job should be a sync call
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, TRUE, TRUE);
|
|
}
|
|
// stop reproc channel if exists
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
QCameraReprocessChannel *pChannel = mPPChannels[i];
|
|
if (pChannel != NULL) {
|
|
pChannel->stop();
|
|
delete pChannel;
|
|
pChannel = NULL;
|
|
}
|
|
}
|
|
mPPChannelCount = 0;
|
|
m_PPindex = 0;
|
|
m_InputMetadata.clear();
|
|
|
|
if (mOfflineDataBufs != NULL) {
|
|
mOfflineDataBufs->deallocate();
|
|
delete mOfflineDataBufs;
|
|
mOfflineDataBufs = NULL;
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : createJpegSession
|
|
*
|
|
* DESCRIPTION: start JPEG session in parallel to reproces to reduce the KPI
|
|
*
|
|
* PARAMETERS :
|
|
* @pSrcChannel : source channel obj ptr that possibly needs reprocess
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::createJpegSession(QCameraChannel *pSrcChannel)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
LOGH("E ");
|
|
if (m_bInited == FALSE) {
|
|
LOGE("postproc not initialized yet");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
if (pSrcChannel == NULL) {
|
|
LOGE("Input Channel for pproc is NULL.");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
if ( !m_parent->mParameters.getRecordingHintValue() &&
|
|
!m_parent->isLongshotEnabled() && (mPPChannelCount > 0)) {
|
|
|
|
QCameraChannel *pChannel = NULL;
|
|
int ppChannel_idx = mPPChannelCount - 1;
|
|
pChannel = m_parent->needReprocess() ? mPPChannels[ppChannel_idx] :
|
|
pSrcChannel;
|
|
QCameraStream *pSnapshotStream = NULL;
|
|
QCameraStream *pThumbStream = NULL;
|
|
bool thumb_stream_needed = ((!m_parent->isZSLMode() ||
|
|
(m_parent->mParameters.getFlipMode(CAM_STREAM_TYPE_SNAPSHOT) ==
|
|
m_parent->mParameters.getFlipMode(CAM_STREAM_TYPE_PREVIEW))) &&
|
|
!m_parent->mParameters.generateThumbFromMain());
|
|
|
|
if (pChannel == NULL) {
|
|
LOGE("Input Channel for pproc is NULL for index %d.",
|
|
ppChannel_idx);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < pChannel->getNumOfStreams(); ++i) {
|
|
QCameraStream *pStream = pChannel->getStreamByIndex(i);
|
|
|
|
if ( NULL == pStream ) {
|
|
break;
|
|
}
|
|
|
|
if (pStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
|
|
pSnapshotStream = pStream;
|
|
}
|
|
|
|
if ((thumb_stream_needed) &&
|
|
(pStream->isTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
|
|
pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_POSTVIEW))) {
|
|
pThumbStream = pStream;
|
|
}
|
|
}
|
|
|
|
// If thumbnail is not part of the reprocess channel, then
|
|
// try to get it from the source channel
|
|
if ((thumb_stream_needed) && (NULL == pThumbStream) &&
|
|
(pChannel == mPPChannels[ppChannel_idx])) {
|
|
for (uint32_t i = 0; i < pSrcChannel->getNumOfStreams(); ++i) {
|
|
QCameraStream *pStream = pSrcChannel->getStreamByIndex(i);
|
|
|
|
if ( NULL == pStream ) {
|
|
break;
|
|
}
|
|
|
|
if (pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_POSTVIEW) ||
|
|
pStream->isTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_PREVIEW)) {
|
|
pThumbStream = pStream;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( NULL != pSnapshotStream ) {
|
|
mm_jpeg_encode_params_t encodeParam;
|
|
memset(&encodeParam, 0, sizeof(mm_jpeg_encode_params_t));
|
|
rc = getJpegEncodingConfig(encodeParam, pSnapshotStream, pThumbStream);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("error getting encoding config");
|
|
return rc;
|
|
}
|
|
LOGH("[KPI Perf] : call jpeg create_session");
|
|
|
|
rc = mJpegHandle.create_session(mJpegClientHandle,
|
|
&encodeParam,
|
|
&mJpegSessionId);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("error creating a new jpeg encoding session");
|
|
return rc;
|
|
}
|
|
mNewJpegSessionNeeded = false;
|
|
}
|
|
}
|
|
LOGH("X ");
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getJpegEncodingConfig
|
|
*
|
|
* DESCRIPTION: function to prepare encoding job information
|
|
*
|
|
* PARAMETERS :
|
|
* @encode_parm : param to be filled with encoding configuration
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::getJpegEncodingConfig(mm_jpeg_encode_params_t& encode_parm,
|
|
QCameraStream *main_stream,
|
|
QCameraStream *thumb_stream)
|
|
{
|
|
LOGD("E");
|
|
int32_t ret = NO_ERROR;
|
|
size_t out_size;
|
|
|
|
char prop[PROPERTY_VALUE_MAX];
|
|
property_get("persist.camera.jpeg_burst", prop, "0");
|
|
mUseJpegBurst = (atoi(prop) > 0) && !mUseSaveProc;
|
|
encode_parm.burst_mode = mUseJpegBurst;
|
|
|
|
cam_rect_t crop;
|
|
memset(&crop, 0, sizeof(cam_rect_t));
|
|
main_stream->getCropInfo(crop);
|
|
|
|
cam_dimension_t src_dim, dst_dim;
|
|
memset(&src_dim, 0, sizeof(cam_dimension_t));
|
|
memset(&dst_dim, 0, sizeof(cam_dimension_t));
|
|
main_stream->getFrameDimension(src_dim);
|
|
|
|
bool hdr_output_crop = m_parent->mParameters.isHDROutputCropEnabled();
|
|
if (hdr_output_crop && crop.height) {
|
|
dst_dim.height = crop.height;
|
|
} else {
|
|
dst_dim.height = src_dim.height;
|
|
}
|
|
if (hdr_output_crop && crop.width) {
|
|
dst_dim.width = crop.width;
|
|
} else {
|
|
dst_dim.width = src_dim.width;
|
|
}
|
|
|
|
// set rotation only when no online rotation or offline pp rotation is done before
|
|
if (!m_parent->needRotationReprocess()) {
|
|
encode_parm.rotation = m_parent->mParameters.getJpegRotation();
|
|
}
|
|
|
|
encode_parm.main_dim.src_dim = src_dim;
|
|
encode_parm.main_dim.dst_dim = dst_dim;
|
|
|
|
m_dst_dim = dst_dim;
|
|
|
|
encode_parm.jpeg_cb = mJpegCB;
|
|
encode_parm.userdata = mJpegUserData;
|
|
|
|
m_bThumbnailNeeded = TRUE; // need encode thumbnail by default
|
|
// system property to disable the thumbnail encoding in order to reduce the power
|
|
// by default thumbnail encoding is set to TRUE and explicitly set this property to
|
|
// disable the thumbnail encoding
|
|
property_get("persist.camera.tn.disable", prop, "0");
|
|
if (atoi(prop) == 1) {
|
|
m_bThumbnailNeeded = FALSE;
|
|
LOGH("m_bThumbnailNeeded is %d", m_bThumbnailNeeded);
|
|
}
|
|
cam_dimension_t thumbnailSize;
|
|
memset(&thumbnailSize, 0, sizeof(cam_dimension_t));
|
|
m_parent->getThumbnailSize(thumbnailSize);
|
|
if (thumbnailSize.width == 0 || thumbnailSize.height == 0) {
|
|
// (0,0) means no thumbnail
|
|
m_bThumbnailNeeded = FALSE;
|
|
}
|
|
encode_parm.encode_thumbnail = m_bThumbnailNeeded;
|
|
|
|
// get color format
|
|
cam_format_t img_fmt = CAM_FORMAT_YUV_420_NV12;
|
|
main_stream->getFormat(img_fmt);
|
|
encode_parm.color_format = getColorfmtFromImgFmt(img_fmt);
|
|
|
|
// get jpeg quality
|
|
uint32_t val = m_parent->getJpegQuality();
|
|
if (0U < val) {
|
|
encode_parm.quality = val;
|
|
} else {
|
|
LOGH("Using default JPEG quality");
|
|
encode_parm.quality = 85;
|
|
}
|
|
cam_frame_len_offset_t main_offset;
|
|
memset(&main_offset, 0, sizeof(cam_frame_len_offset_t));
|
|
main_stream->getFrameOffset(main_offset);
|
|
|
|
// src buf config
|
|
QCameraMemory *pStreamMem = main_stream->getStreamBufs();
|
|
if (pStreamMem == NULL) {
|
|
LOGE("cannot get stream bufs from main stream");
|
|
ret = BAD_VALUE;
|
|
goto on_error;
|
|
}
|
|
encode_parm.num_src_bufs = pStreamMem->getCnt();
|
|
for (uint32_t i = 0; i < encode_parm.num_src_bufs; i++) {
|
|
camera_memory_t *stream_mem = pStreamMem->getMemory(i, false);
|
|
if (stream_mem != NULL) {
|
|
encode_parm.src_main_buf[i].index = i;
|
|
encode_parm.src_main_buf[i].buf_size = stream_mem->size;
|
|
encode_parm.src_main_buf[i].buf_vaddr = (uint8_t *)stream_mem->data;
|
|
encode_parm.src_main_buf[i].fd = pStreamMem->getFd(i);
|
|
encode_parm.src_main_buf[i].format = MM_JPEG_FMT_YUV;
|
|
encode_parm.src_main_buf[i].offset = main_offset;
|
|
}
|
|
}
|
|
LOGI("Src Buffer cnt = %d, res = %dX%d len = %d rot = %d "
|
|
"src_dim = %dX%d dst_dim = %dX%d",
|
|
encode_parm.num_src_bufs,
|
|
main_offset.mp[0].width, main_offset.mp[0].height,
|
|
main_offset.frame_len, encode_parm.rotation,
|
|
src_dim.width, src_dim.height,
|
|
dst_dim.width, dst_dim.height);
|
|
|
|
if (m_bThumbnailNeeded == TRUE) {
|
|
uint32_t jpeg_rotation = m_parent->mParameters.getJpegRotation();
|
|
m_parent->getThumbnailSize(encode_parm.thumb_dim.dst_dim);
|
|
|
|
if (thumb_stream == NULL) {
|
|
thumb_stream = main_stream;
|
|
}
|
|
if (((90 == m_parent->mParameters.getJpegRotation())
|
|
|| (270 == m_parent->mParameters.getJpegRotation()))
|
|
&& (m_parent->needRotationReprocess())) {
|
|
// swap thumbnail dimensions
|
|
cam_dimension_t tmp_dim = encode_parm.thumb_dim.dst_dim;
|
|
encode_parm.thumb_dim.dst_dim.width = tmp_dim.height;
|
|
encode_parm.thumb_dim.dst_dim.height = tmp_dim.width;
|
|
}
|
|
pStreamMem = thumb_stream->getStreamBufs();
|
|
if (pStreamMem == NULL) {
|
|
LOGE("cannot get stream bufs from thumb stream");
|
|
ret = BAD_VALUE;
|
|
goto on_error;
|
|
}
|
|
cam_frame_len_offset_t thumb_offset;
|
|
memset(&thumb_offset, 0, sizeof(cam_frame_len_offset_t));
|
|
thumb_stream->getFrameOffset(thumb_offset);
|
|
encode_parm.num_tmb_bufs = pStreamMem->getCnt();
|
|
for (uint32_t i = 0; i < pStreamMem->getCnt(); i++) {
|
|
camera_memory_t *stream_mem = pStreamMem->getMemory(i, false);
|
|
if (stream_mem != NULL) {
|
|
encode_parm.src_thumb_buf[i].index = i;
|
|
encode_parm.src_thumb_buf[i].buf_size = stream_mem->size;
|
|
encode_parm.src_thumb_buf[i].buf_vaddr = (uint8_t *)stream_mem->data;
|
|
encode_parm.src_thumb_buf[i].fd = pStreamMem->getFd(i);
|
|
encode_parm.src_thumb_buf[i].format = MM_JPEG_FMT_YUV;
|
|
encode_parm.src_thumb_buf[i].offset = thumb_offset;
|
|
}
|
|
}
|
|
cam_format_t img_fmt_thumb = CAM_FORMAT_YUV_420_NV12;
|
|
thumb_stream->getFormat(img_fmt_thumb);
|
|
encode_parm.thumb_color_format = getColorfmtFromImgFmt(img_fmt_thumb);
|
|
|
|
// crop is the same if frame is the same
|
|
if (thumb_stream != main_stream) {
|
|
memset(&crop, 0, sizeof(cam_rect_t));
|
|
thumb_stream->getCropInfo(crop);
|
|
}
|
|
|
|
memset(&src_dim, 0, sizeof(cam_dimension_t));
|
|
thumb_stream->getFrameDimension(src_dim);
|
|
encode_parm.thumb_dim.src_dim = src_dim;
|
|
|
|
if (!m_parent->needRotationReprocess()) {
|
|
encode_parm.thumb_rotation = m_parent->mParameters.getJpegRotation();
|
|
}
|
|
encode_parm.thumb_dim.crop = crop;
|
|
encode_parm.thumb_from_postview =
|
|
!m_parent->mParameters.generateThumbFromMain() &&
|
|
(img_fmt_thumb != CAM_FORMAT_YUV_420_NV12_UBWC) &&
|
|
(m_parent->mParameters.useJpegExifRotation() ||
|
|
m_parent->mParameters.getJpegRotation() == 0);
|
|
LOGI("Src THUMB buf_cnt = %d, res = %dX%d len = %d rot = %d "
|
|
"src_dim = %dX%d, dst_dim = %dX%d",
|
|
encode_parm.num_tmb_bufs,
|
|
thumb_offset.mp[0].width, thumb_offset.mp[0].height,
|
|
thumb_offset.frame_len, encode_parm.thumb_rotation,
|
|
encode_parm.thumb_dim.src_dim.width,
|
|
encode_parm.thumb_dim.src_dim.height,
|
|
encode_parm.thumb_dim.dst_dim.width,
|
|
encode_parm.thumb_dim.dst_dim.height);
|
|
}
|
|
|
|
encode_parm.num_dst_bufs = 1;
|
|
if (mUseJpegBurst) {
|
|
encode_parm.num_dst_bufs = MAX_JPEG_BURST;
|
|
}
|
|
encode_parm.get_memory = NULL;
|
|
out_size = main_offset.frame_len;
|
|
if (mJpegMemOpt) {
|
|
encode_parm.get_memory = getJpegMemory;
|
|
encode_parm.put_memory = releaseJpegMemory;
|
|
out_size = sizeof(omx_jpeg_ouput_buf_t);
|
|
encode_parm.num_dst_bufs = encode_parm.num_src_bufs;
|
|
}
|
|
m_JpegOutputMemCount = (uint32_t)encode_parm.num_dst_bufs;
|
|
for (uint32_t i = 0; i < m_JpegOutputMemCount; i++) {
|
|
if (m_pJpegOutputMem[i] != NULL)
|
|
free(m_pJpegOutputMem[i]);
|
|
omx_jpeg_ouput_buf_t omx_out_buf;
|
|
omx_out_buf.handle = this;
|
|
// allocate output buf for jpeg encoding
|
|
m_pJpegOutputMem[i] = malloc(out_size);
|
|
|
|
if (NULL == m_pJpegOutputMem[i]) {
|
|
ret = NO_MEMORY;
|
|
LOGE("initHeapMem for jpeg, ret = NO_MEMORY");
|
|
goto on_error;
|
|
}
|
|
|
|
if (mJpegMemOpt) {
|
|
memcpy(m_pJpegOutputMem[i], &omx_out_buf, sizeof(omx_out_buf));
|
|
}
|
|
|
|
encode_parm.dest_buf[i].index = i;
|
|
encode_parm.dest_buf[i].buf_size = main_offset.frame_len;
|
|
encode_parm.dest_buf[i].buf_vaddr = (uint8_t *)m_pJpegOutputMem[i];
|
|
encode_parm.dest_buf[i].fd = -1;
|
|
encode_parm.dest_buf[i].format = MM_JPEG_FMT_YUV;
|
|
encode_parm.dest_buf[i].offset = main_offset;
|
|
}
|
|
|
|
LOGD("X");
|
|
return NO_ERROR;
|
|
|
|
on_error:
|
|
FREE_JPEG_OUTPUT_BUFFER(m_pJpegOutputMem, m_JpegOutputMemCount);
|
|
|
|
LOGD("X with error %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : sendEvtNotify
|
|
*
|
|
* DESCRIPTION: send event notify through notify callback registered by upper layer
|
|
*
|
|
* PARAMETERS :
|
|
* @msg_type: msg type of notify
|
|
* @ext1 : extension
|
|
* @ext2 : extension
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::sendEvtNotify(int32_t msg_type,
|
|
int32_t ext1,
|
|
int32_t ext2)
|
|
{
|
|
return m_parent->sendEvtNotify(msg_type, ext1, ext2);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : sendDataNotify
|
|
*
|
|
* DESCRIPTION: enqueue data into dataNotify thread
|
|
*
|
|
* PARAMETERS :
|
|
* @msg_type: data callback msg type
|
|
* @data : ptr to data memory struct
|
|
* @index : index to data buffer
|
|
* @metadata: ptr to meta data buffer if there is any
|
|
* @release_data : ptr to struct indicating if data need to be released
|
|
* after notify
|
|
* @super_buf_frame_idx : super buffer frame index
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::sendDataNotify(int32_t msg_type,
|
|
camera_memory_t *data,
|
|
uint8_t index,
|
|
camera_frame_metadata_t *metadata,
|
|
qcamera_release_data_t *release_data,
|
|
uint32_t super_buf_frame_idx)
|
|
{
|
|
qcamera_data_argm_t *data_cb = (qcamera_data_argm_t *)malloc(sizeof(qcamera_data_argm_t));
|
|
if (NULL == data_cb) {
|
|
LOGE("no mem for acamera_data_argm_t");
|
|
return NO_MEMORY;
|
|
}
|
|
memset(data_cb, 0, sizeof(qcamera_data_argm_t));
|
|
data_cb->msg_type = msg_type;
|
|
data_cb->data = data;
|
|
data_cb->index = index;
|
|
data_cb->metadata = metadata;
|
|
if (release_data != NULL) {
|
|
data_cb->release_data = *release_data;
|
|
}
|
|
|
|
qcamera_callback_argm_t cbArg;
|
|
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
|
|
cbArg.cb_type = QCAMERA_DATA_SNAPSHOT_CALLBACK;
|
|
cbArg.msg_type = msg_type;
|
|
cbArg.data = data;
|
|
cbArg.metadata = metadata;
|
|
cbArg.user_data = data_cb;
|
|
cbArg.cookie = this;
|
|
cbArg.release_cb = releaseNotifyData;
|
|
cbArg.frame_index = super_buf_frame_idx;
|
|
int rc = m_parent->m_cbNotifier.notifyCallback(cbArg);
|
|
if ( NO_ERROR != rc ) {
|
|
LOGE("Error enqueuing jpeg data into notify queue");
|
|
releaseNotifyData(data_cb, this, UNKNOWN_ERROR);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : validatePostProcess
|
|
*
|
|
* DESCRIPTION: Verify output buffer count of pp module
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : process frame received from mm-camera-interface
|
|
*
|
|
* RETURN : bool type of status
|
|
* TRUE -- success
|
|
* FALSE failure
|
|
*==========================================================================*/
|
|
bool QCameraPostProcessor::validatePostProcess(mm_camera_super_buf_t *frame)
|
|
{
|
|
bool status = TRUE;
|
|
QCameraChannel *pChannel = NULL;
|
|
QCameraReprocessChannel *m_pReprocChannel = NULL;
|
|
|
|
if (frame == NULL) {
|
|
return status;
|
|
}
|
|
|
|
pChannel = m_parent->getChannelByHandle(frame->ch_id);
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if (pChannel == mPPChannels[i]->getSrcChannel()) {
|
|
m_pReprocChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((m_pReprocChannel != NULL) && (pChannel == m_pReprocChannel->getSrcChannel())) {
|
|
QCameraStream *pStream = NULL;
|
|
for (uint8_t i = 0; i < m_pReprocChannel->getNumOfStreams(); i++) {
|
|
pStream = m_pReprocChannel->getStreamByIndex(i);
|
|
if (pStream && (m_inputPPQ.getCurrentSize() > 0) &&
|
|
(pStream->getNumQueuedBuf() <= 0)) {
|
|
LOGW("Out of PP Buffer PPQ = %d ongoingQ = %d Jpeg = %d onJpeg = %d",
|
|
m_inputPPQ.getCurrentSize(), m_inputPPQ.getCurrentSize(),
|
|
m_inputJpegQ.getCurrentSize(), m_ongoingJpegQ.getCurrentSize());
|
|
status = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getOfflinePPInputBuffer
|
|
*
|
|
* DESCRIPTION: Function to generate offline post proc buffer
|
|
*
|
|
* PARAMETERS :
|
|
* @src_frame : process frame received from mm-camera-interface
|
|
*
|
|
* RETURN : Buffer pointer if successfull
|
|
* : NULL in case of failures
|
|
*==========================================================================*/
|
|
mm_camera_buf_def_t *QCameraPostProcessor::getOfflinePPInputBuffer(
|
|
mm_camera_super_buf_t *src_frame)
|
|
{
|
|
mm_camera_buf_def_t *mBufDefs = NULL;
|
|
QCameraChannel *pChannel = NULL;
|
|
QCameraStream *src_pStream = NULL;
|
|
mm_camera_buf_def_t *data_frame = NULL;
|
|
mm_camera_buf_def_t *meta_frame = NULL;
|
|
|
|
if (mOfflineDataBufs == NULL) {
|
|
LOGE("Offline Buffer not allocated");
|
|
return NULL;
|
|
}
|
|
|
|
uint32_t num_bufs = mOfflineDataBufs->getCnt();
|
|
size_t bufDefsSize = num_bufs * sizeof(mm_camera_buf_def_t);
|
|
mBufDefs = (mm_camera_buf_def_t *)malloc(bufDefsSize);
|
|
if (mBufDefs == NULL) {
|
|
LOGE("No memory");
|
|
return NULL;
|
|
}
|
|
memset(mBufDefs, 0, bufDefsSize);
|
|
|
|
pChannel = m_parent->getChannelByHandle(src_frame->ch_id);
|
|
for (uint32_t i = 0; i < src_frame->num_bufs; i++) {
|
|
src_pStream = pChannel->getStreamByHandle(
|
|
src_frame->bufs[i]->stream_id);
|
|
if (src_pStream != NULL) {
|
|
if (src_pStream->getMyType() == CAM_STREAM_TYPE_RAW) {
|
|
LOGH("Found RAW input stream");
|
|
data_frame = src_frame->bufs[i];
|
|
} else if (src_pStream->getMyType() == CAM_STREAM_TYPE_METADATA){
|
|
LOGH("Found Metada input stream");
|
|
meta_frame = src_frame->bufs[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((src_pStream != NULL) && (data_frame != NULL)) {
|
|
cam_frame_len_offset_t offset;
|
|
memset(&offset, 0, sizeof(cam_frame_len_offset_t));
|
|
src_pStream->getFrameOffset(offset);
|
|
for (uint32_t i = 0; i < num_bufs; i++) {
|
|
mBufDefs[i] = *data_frame;
|
|
mOfflineDataBufs->getBufDef(offset, mBufDefs[i], i);
|
|
|
|
LOGD("Dumping RAW data on offline buffer");
|
|
/*Actual data memcpy just for verification*/
|
|
memcpy(mBufDefs[i].buffer, data_frame->buffer,
|
|
mBufDefs[i].frame_len);
|
|
}
|
|
releaseSuperBuf(src_frame, CAM_STREAM_TYPE_RAW);
|
|
} else {
|
|
free(mBufDefs);
|
|
mBufDefs = NULL;
|
|
}
|
|
|
|
LOGH("mBufDefs = %p", mBufDefs);
|
|
return mBufDefs;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : processData
|
|
*
|
|
* DESCRIPTION: enqueue data into dataProc thread
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : process frame received from mm-camera-interface
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : depends on if offline reprocess is needed, received frame will
|
|
* be sent to either input queue of postprocess or jpeg encoding
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::processData(mm_camera_super_buf_t *frame)
|
|
{
|
|
QCameraChannel *m_pReprocChannel = NULL;
|
|
|
|
if (m_bInited == FALSE) {
|
|
LOGE("postproc not initialized yet");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
if (frame == NULL) {
|
|
LOGE("Invalid parameter");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
mm_camera_buf_def_t *meta_frame = NULL;
|
|
for (uint32_t i = 0; i < frame->num_bufs; i++) {
|
|
// look through input superbuf
|
|
if (frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
meta_frame = frame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
if (meta_frame != NULL) {
|
|
//Function to upadte metadata for frame based parameter
|
|
m_parent->updateMetadata((metadata_buffer_t *)meta_frame->buffer);
|
|
}
|
|
|
|
if (m_parent->needReprocess()) {
|
|
if ((!m_parent->isLongshotEnabled() &&
|
|
!m_parent->m_stateMachine.isNonZSLCaptureRunning()) ||
|
|
(m_parent->isLongshotEnabled() &&
|
|
m_parent->isCaptureShutterEnabled())) {
|
|
//play shutter sound
|
|
m_parent->playShutter();
|
|
}
|
|
|
|
ATRACE_INT("Camera:Reprocess", 1);
|
|
LOGH("need reprocess");
|
|
|
|
// enqueu to post proc input queue
|
|
qcamera_pp_data_t *pp_request_job =
|
|
(qcamera_pp_data_t *)malloc(sizeof(qcamera_pp_data_t));
|
|
if (pp_request_job == NULL) {
|
|
LOGE("No memory for pproc job");
|
|
return NO_MEMORY;
|
|
}
|
|
memset(pp_request_job, 0, sizeof(qcamera_pp_data_t));
|
|
pp_request_job->src_frame = frame;
|
|
pp_request_job->src_reproc_frame = frame;
|
|
pp_request_job->reprocCount = 0;
|
|
pp_request_job->ppChannelIndex = 0;
|
|
|
|
if ((NULL != frame) &&
|
|
(0 < frame->num_bufs)
|
|
&& (m_parent->isRegularCapture())) {
|
|
/*Regular capture. Source stream will be deleted*/
|
|
mm_camera_buf_def_t *bufs = NULL;
|
|
uint32_t num_bufs = frame->num_bufs;
|
|
bufs = new mm_camera_buf_def_t[num_bufs];
|
|
if (NULL == bufs) {
|
|
LOGE("Unable to allocate cached buffers");
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < num_bufs; i++) {
|
|
bufs[i] = *frame->bufs[i];
|
|
frame->bufs[i] = &bufs[i];
|
|
}
|
|
pp_request_job->src_reproc_bufs = bufs;
|
|
|
|
// Don't release source frame after encoding
|
|
// at this point the source channel will not exist.
|
|
pp_request_job->reproc_frame_release = true;
|
|
}
|
|
|
|
if (mOfflineDataBufs != NULL) {
|
|
pp_request_job->offline_reproc_buf =
|
|
getOfflinePPInputBuffer(frame);
|
|
if (pp_request_job->offline_reproc_buf != NULL) {
|
|
pp_request_job->offline_buffer = true;
|
|
}
|
|
}
|
|
|
|
if (false == m_inputPPQ.enqueue((void *)pp_request_job)) {
|
|
LOGW("Input PP Q is not active!!!");
|
|
releaseSuperBuf(frame);
|
|
free(frame);
|
|
free(pp_request_job);
|
|
frame = NULL;
|
|
pp_request_job = NULL;
|
|
return NO_ERROR;
|
|
}
|
|
if (m_parent->mParameters.isAdvCamFeaturesEnabled()
|
|
&& (meta_frame != NULL)) {
|
|
m_InputMetadata.add(meta_frame);
|
|
}
|
|
} else if (m_parent->mParameters.isNV16PictureFormat() ||
|
|
m_parent->mParameters.isNV21PictureFormat()) {
|
|
//check if raw frame information is needed.
|
|
if(m_parent->mParameters.isYUVFrameInfoNeeded())
|
|
setYUVFrameInfo(frame);
|
|
|
|
processRawData(frame);
|
|
} else {
|
|
//play shutter sound
|
|
if(!m_parent->m_stateMachine.isNonZSLCaptureRunning() &&
|
|
!m_parent->mLongshotEnabled)
|
|
m_parent->playShutter();
|
|
|
|
LOGH("no need offline reprocess, sending to jpeg encoding");
|
|
qcamera_jpeg_data_t *jpeg_job =
|
|
(qcamera_jpeg_data_t *)malloc(sizeof(qcamera_jpeg_data_t));
|
|
if (jpeg_job == NULL) {
|
|
LOGE("No memory for jpeg job");
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
memset(jpeg_job, 0, sizeof(qcamera_jpeg_data_t));
|
|
jpeg_job->src_frame = frame;
|
|
|
|
if (meta_frame != NULL) {
|
|
// fill in meta data frame ptr
|
|
jpeg_job->metadata = (metadata_buffer_t *)meta_frame->buffer;
|
|
}
|
|
|
|
// enqueu to jpeg input queue
|
|
if (!m_inputJpegQ.enqueue((void *)jpeg_job)) {
|
|
LOGW("Input Jpeg Q is not active!!!");
|
|
releaseJpegJobData(jpeg_job);
|
|
free(jpeg_job);
|
|
jpeg_job = NULL;
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : processRawData
|
|
*
|
|
* DESCRIPTION: enqueue raw data into dataProc thread
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : process frame received from mm-camera-interface
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::processRawData(mm_camera_super_buf_t *frame)
|
|
{
|
|
if (m_bInited == FALSE) {
|
|
LOGE("postproc not initialized yet");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
// enqueu to raw input queue
|
|
if (m_inputRawQ.enqueue((void *)frame)) {
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
} else {
|
|
LOGW("m_inputRawQ is not active!!!");
|
|
releaseSuperBuf(frame);
|
|
free(frame);
|
|
frame = NULL;
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : processJpegEvt
|
|
*
|
|
* DESCRIPTION: process jpeg event from mm-jpeg-interface.
|
|
*
|
|
* PARAMETERS :
|
|
* @evt : payload of jpeg event, including information about jpeg encoding
|
|
* status, jpeg size and so on.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : This event will also trigger DataProc thread to move to next job
|
|
* processing (i.e., send a new jpeg encoding job to mm-jpeg-interface
|
|
* if there is any pending job in jpeg input queue)
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::processJpegEvt(qcamera_jpeg_evt_payload_t *evt)
|
|
{
|
|
if (m_bInited == FALSE) {
|
|
LOGE("postproc not initialized yet");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
int32_t rc = NO_ERROR;
|
|
camera_memory_t *jpeg_mem = NULL;
|
|
omx_jpeg_ouput_buf_t *jpeg_out = NULL;
|
|
void *jpegData = NULL;
|
|
if (mUseSaveProc && m_parent->isLongshotEnabled()) {
|
|
qcamera_jpeg_evt_payload_t *saveData = ( qcamera_jpeg_evt_payload_t * ) malloc(sizeof(qcamera_jpeg_evt_payload_t));
|
|
if ( NULL == saveData ) {
|
|
LOGE("Can not allocate save data message!");
|
|
return NO_MEMORY;
|
|
}
|
|
*saveData = *evt;
|
|
if (m_inputSaveQ.enqueue((void *) saveData)) {
|
|
m_saveProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
} else {
|
|
LOGD("m_inputSaveQ PP Q is not active!!!");
|
|
free(saveData);
|
|
saveData = NULL;
|
|
return rc;
|
|
}
|
|
} else {
|
|
/* To be removed later when ISP Frame sync feature is available
|
|
qcamera_jpeg_data_t *jpeg_job =
|
|
(qcamera_jpeg_data_t *)m_ongoingJpegQ.dequeue(matchJobId,
|
|
(void*)&evt->jobId);
|
|
uint32_t frame_idx = jpeg_job->src_frame->bufs[0]->frame_idx;*/
|
|
uint32_t frame_idx = 75;
|
|
LOGH("FRAME INDEX %d", frame_idx);
|
|
// Release jpeg job data
|
|
m_ongoingJpegQ.flushNodes(matchJobId, (void*)&evt->jobId);
|
|
|
|
if (m_inputPPQ.getCurrentSize() > 0) {
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
}
|
|
LOGH("[KPI Perf] : jpeg job %d", evt->jobId);
|
|
|
|
if ((false == m_parent->m_bIntJpegEvtPending) &&
|
|
(m_parent->mDataCb == NULL ||
|
|
m_parent->msgTypeEnabledWithLock(CAMERA_MSG_COMPRESSED_IMAGE) == 0 )) {
|
|
LOGW("No dataCB or CAMERA_MSG_COMPRESSED_IMAGE not enabled");
|
|
rc = NO_ERROR;
|
|
goto end;
|
|
}
|
|
|
|
if(evt->status == JPEG_JOB_STATUS_ERROR) {
|
|
LOGE("Error event handled from jpeg, status = %d",
|
|
evt->status);
|
|
rc = FAILED_TRANSACTION;
|
|
goto end;
|
|
}
|
|
if (!mJpegMemOpt) {
|
|
jpegData = evt->out_data.buf_vaddr;
|
|
}
|
|
else {
|
|
jpeg_out = (omx_jpeg_ouput_buf_t*) evt->out_data.buf_vaddr;
|
|
if (jpeg_out != NULL) {
|
|
jpeg_mem = (camera_memory_t *)jpeg_out->mem_hdl;
|
|
if (jpeg_mem != NULL) {
|
|
jpegData = jpeg_mem->data;
|
|
}
|
|
}
|
|
}
|
|
m_parent->dumpJpegToFile(jpegData,
|
|
evt->out_data.buf_filled_len,
|
|
evt->jobId);
|
|
LOGH("Dump jpeg_size=%d", evt->out_data.buf_filled_len);
|
|
if(true == m_parent->m_bIntJpegEvtPending) {
|
|
//Sending JPEG snapshot taken notification to HAL
|
|
pthread_mutex_lock(&m_parent->m_int_lock);
|
|
pthread_cond_signal(&m_parent->m_int_cond);
|
|
pthread_mutex_unlock(&m_parent->m_int_lock);
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
return rc;
|
|
}
|
|
if (!mJpegMemOpt) {
|
|
// alloc jpeg memory to pass to upper layer
|
|
jpeg_mem = m_parent->mGetMemory(-1, evt->out_data.buf_filled_len,
|
|
1, m_parent->mCallbackCookie);
|
|
if (NULL == jpeg_mem) {
|
|
rc = NO_MEMORY;
|
|
LOGE("getMemory for jpeg, ret = NO_MEMORY");
|
|
goto end;
|
|
}
|
|
memcpy(jpeg_mem->data, evt->out_data.buf_vaddr, evt->out_data.buf_filled_len);
|
|
}
|
|
LOGH("Calling upperlayer callback to store JPEG image");
|
|
qcamera_release_data_t release_data;
|
|
memset(&release_data, 0, sizeof(qcamera_release_data_t));
|
|
release_data.data = jpeg_mem;
|
|
LOGI("[KPI Perf]: PROFILE_JPEG_CB ");
|
|
rc = sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
|
|
jpeg_mem,
|
|
0,
|
|
NULL,
|
|
&release_data,
|
|
frame_idx);
|
|
m_parent->setOutputImageCount(m_parent->getOutputImageCount() + 1);
|
|
|
|
end:
|
|
if (rc != NO_ERROR) {
|
|
// send error msg to upper layer
|
|
LOGE("Jpeg Encoding failed. Notify Application");
|
|
sendEvtNotify(CAMERA_MSG_ERROR,
|
|
UNKNOWN_ERROR,
|
|
0);
|
|
|
|
if (NULL != jpeg_mem) {
|
|
jpeg_mem->release(jpeg_mem);
|
|
jpeg_mem = NULL;
|
|
}
|
|
}
|
|
|
|
/* check whether to send callback for depth map */
|
|
if (m_parent->mParameters.isUbiRefocus() &&
|
|
(m_parent->getOutputImageCount() + 1 ==
|
|
m_parent->mParameters.getRefocusOutputCount())) {
|
|
m_parent->setOutputImageCount(m_parent->getOutputImageCount() + 1);
|
|
|
|
jpeg_mem = m_DataMem;
|
|
release_data.data = jpeg_mem;
|
|
m_DataMem = NULL;
|
|
LOGH("[KPI Perf]: send jpeg callback for depthmap ");
|
|
rc = sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
|
|
jpeg_mem,
|
|
0,
|
|
NULL,
|
|
&release_data,
|
|
frame_idx);
|
|
if (rc != NO_ERROR) {
|
|
// send error msg to upper layer
|
|
sendEvtNotify(CAMERA_MSG_ERROR,
|
|
UNKNOWN_ERROR,
|
|
0);
|
|
if (NULL != jpeg_mem) {
|
|
jpeg_mem->release(jpeg_mem);
|
|
jpeg_mem = NULL;
|
|
}
|
|
}
|
|
m_DataMem = NULL;
|
|
}
|
|
}
|
|
|
|
// wait up data proc thread to do next job,
|
|
// if previous request is blocked due to ongoing jpeg job
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : processPPData
|
|
*
|
|
* DESCRIPTION: process received frame after reprocess.
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : received frame from reprocess channel.
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : The frame after reprocess need to send to jpeg encoding.
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::processPPData(mm_camera_super_buf_t *frame)
|
|
{
|
|
bool triggerEvent = TRUE;
|
|
|
|
LOGD("QCameraPostProcessor::processPPData");
|
|
bool needSuperBufMatch = m_parent->mParameters.generateThumbFromMain();
|
|
if (m_bInited == FALSE) {
|
|
LOGE("postproc not initialized yet");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
qcamera_pp_data_t *job = (qcamera_pp_data_t *)m_ongoingPPQ.dequeue();
|
|
if (NULL == job) {
|
|
LOGE("Cannot find reprocess job");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (!needSuperBufMatch && (job->src_frame == NULL
|
|
|| job->src_reproc_frame == NULL) ) {
|
|
LOGE("Invalid reprocess job");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (!needSuperBufMatch && (m_parent->mParameters.isNV16PictureFormat() ||
|
|
m_parent->mParameters.isNV21PictureFormat())) {
|
|
releaseOngoingPPData(job, this);
|
|
free(job);
|
|
|
|
if(m_parent->mParameters.isYUVFrameInfoNeeded())
|
|
setYUVFrameInfo(frame);
|
|
return processRawData(frame);
|
|
}
|
|
#ifdef TARGET_TS_MAKEUP
|
|
// find snapshot frame frame
|
|
mm_camera_buf_def_t *pReprocFrame = NULL;
|
|
QCameraStream * pSnapshotStream = NULL;
|
|
QCameraChannel *pChannel = m_parent->getChannelByHandle(frame->ch_id);
|
|
if (pChannel == NULL) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if ((mPPChannels[i] != NULL) &&
|
|
(mPPChannels[i]->getMyHandle() == frame->ch_id)) {
|
|
pChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (pChannel == NULL) {
|
|
LOGE("No corresponding channel (ch_id = %d) exist, return here",
|
|
frame->ch_id);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < frame->num_bufs; i++) {
|
|
pSnapshotStream = pChannel->getStreamByHandle(frame->bufs[i]->stream_id);
|
|
if (pSnapshotStream != NULL) {
|
|
if (pSnapshotStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
|
|
pReprocFrame = frame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (pReprocFrame != NULL && m_parent->mParameters.isFaceDetectionEnabled()) {
|
|
m_parent->TsMakeupProcess_Snapshot(pReprocFrame,pSnapshotStream);
|
|
} else {
|
|
LOGH("pReprocFrame == NULL || isFaceDetectionEnabled = %d",
|
|
m_parent->mParameters.isFaceDetectionEnabled());
|
|
}
|
|
#endif
|
|
if ((m_parent->isLongshotEnabled())
|
|
&& (!m_parent->isCaptureShutterEnabled())
|
|
&& (!m_parent->mCACDoneReceived)) {
|
|
// play shutter sound for longshot
|
|
// after reprocess is done
|
|
m_parent->playShutter();
|
|
}
|
|
m_parent->mCACDoneReceived = FALSE;
|
|
|
|
int8_t mCurReprocCount = job->reprocCount;
|
|
int8_t mCurChannelIndex = job->ppChannelIndex;
|
|
if ( mCurReprocCount > 1 ) {
|
|
//In case of pp 2nd pass, we can release input of 2nd pass
|
|
releaseSuperBuf(job->src_frame);
|
|
free(job->src_frame);
|
|
job->src_frame = NULL;
|
|
}
|
|
|
|
LOGD("mCurReprocCount = %d mCurChannelIndex = %d mTotalNumReproc = %d",
|
|
mCurReprocCount, mCurChannelIndex,
|
|
m_parent->mParameters.getReprocCount());
|
|
if (mCurReprocCount < m_parent->mParameters.getReprocCount()) {
|
|
//More pp pass needed. Push frame back to pp queue.
|
|
qcamera_pp_data_t *pp_request_job = job;
|
|
pp_request_job->src_frame = frame;
|
|
|
|
if ((mPPChannels[mCurChannelIndex]->getReprocCount()
|
|
== mCurReprocCount) &&
|
|
(mPPChannels[mCurChannelIndex + 1] != NULL)) {
|
|
pp_request_job->ppChannelIndex++;
|
|
}
|
|
|
|
// enqueu to post proc input queue
|
|
if (false == m_inputPPQ.enqueue((void *)pp_request_job)) {
|
|
LOGW("m_input PP Q is not active!!!");
|
|
releaseOngoingPPData(pp_request_job,this);
|
|
free(pp_request_job);
|
|
pp_request_job = NULL;
|
|
triggerEvent = FALSE;
|
|
}
|
|
} else {
|
|
//Done with post processing. Send frame to Jpeg
|
|
qcamera_jpeg_data_t *jpeg_job =
|
|
(qcamera_jpeg_data_t *)malloc(sizeof(qcamera_jpeg_data_t));
|
|
if (jpeg_job == NULL) {
|
|
LOGE("No memory for jpeg job");
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
memset(jpeg_job, 0, sizeof(qcamera_jpeg_data_t));
|
|
jpeg_job->src_frame = frame;
|
|
jpeg_job->src_reproc_frame = job ? job->src_reproc_frame : NULL;
|
|
jpeg_job->src_reproc_bufs = job ? job->src_reproc_bufs : NULL;
|
|
jpeg_job->reproc_frame_release = job ? job->reproc_frame_release : false;
|
|
jpeg_job->offline_reproc_buf = job ? job->offline_reproc_buf : NULL;
|
|
jpeg_job->offline_buffer = job ? job->offline_buffer : false;
|
|
|
|
// find meta data frame
|
|
mm_camera_buf_def_t *meta_frame = NULL;
|
|
if (m_parent->mParameters.isAdvCamFeaturesEnabled()) {
|
|
size_t meta_idx = m_parent->mParameters.getExifBufIndex(m_PPindex);
|
|
if (m_InputMetadata.size() >= (meta_idx + 1)) {
|
|
meta_frame = m_InputMetadata.itemAt(meta_idx);
|
|
} else {
|
|
LOGW("Input metadata vector contains %d entries, index required %d",
|
|
m_InputMetadata.size(), meta_idx);
|
|
}
|
|
m_PPindex++;
|
|
} else {
|
|
for (uint32_t i = 0; job && job->src_reproc_frame &&
|
|
(i < job->src_reproc_frame->num_bufs); i++) {
|
|
// look through input superbuf
|
|
if (job->src_reproc_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
meta_frame = job->src_reproc_frame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (meta_frame == NULL) {
|
|
// look through reprocess superbuf
|
|
for (uint32_t i = 0; i < frame->num_bufs; i++) {
|
|
if (frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
meta_frame = frame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (meta_frame != NULL) {
|
|
// fill in meta data frame ptr
|
|
jpeg_job->metadata = (metadata_buffer_t *)meta_frame->buffer;
|
|
}
|
|
|
|
// enqueu reprocessed frame to jpeg input queue
|
|
if (false == m_inputJpegQ.enqueue((void *)jpeg_job)) {
|
|
LOGW("Input Jpeg Q is not active!!!");
|
|
releaseJpegJobData(jpeg_job);
|
|
free(jpeg_job);
|
|
jpeg_job = NULL;
|
|
triggerEvent = FALSE;
|
|
}
|
|
|
|
// free pp job buf
|
|
if (job) {
|
|
free(job);
|
|
}
|
|
}
|
|
|
|
LOGD("");
|
|
// wait up data proc thread
|
|
|
|
if (triggerEvent) {
|
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : findJpegJobByJobId
|
|
*
|
|
* DESCRIPTION: find a jpeg job from ongoing Jpeg queue by its job ID
|
|
*
|
|
* PARAMETERS :
|
|
* @jobId : job Id of the job
|
|
*
|
|
* RETURN : ptr to a jpeg job struct. NULL if not found.
|
|
*
|
|
* NOTE : Currently only one job is sending to mm-jpeg-interface for jpeg
|
|
* encoding. Therefore simply dequeue from the ongoing Jpeg Queue
|
|
* will serve the purpose to find the jpeg job.
|
|
*==========================================================================*/
|
|
qcamera_jpeg_data_t *QCameraPostProcessor::findJpegJobByJobId(uint32_t jobId)
|
|
{
|
|
qcamera_jpeg_data_t * job = NULL;
|
|
if (jobId == 0) {
|
|
LOGE("not a valid jpeg jobId");
|
|
return NULL;
|
|
}
|
|
|
|
// currely only one jpeg job ongoing, so simply dequeue the head
|
|
job = (qcamera_jpeg_data_t *)m_ongoingJpegQ.dequeue();
|
|
return job;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releasePPInputData
|
|
*
|
|
* DESCRIPTION: callback function to release post process input data node
|
|
*
|
|
* PARAMETERS :
|
|
* @data : ptr to post process input data
|
|
* @user_data : user data ptr (QCameraReprocessor)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releasePPInputData(void *data, void *user_data)
|
|
{
|
|
QCameraPostProcessor *pme = (QCameraPostProcessor *)user_data;
|
|
if (NULL != pme) {
|
|
qcamera_pp_request_t *pp_job = (qcamera_pp_request_t *)data;
|
|
if (NULL != pp_job->src_frame) {
|
|
pme->releaseSuperBuf(pp_job->src_frame);
|
|
if (pp_job->src_frame == pp_job->src_reproc_frame)
|
|
pp_job->src_reproc_frame = NULL;
|
|
free(pp_job->src_frame);
|
|
pp_job->src_frame = NULL;
|
|
}
|
|
if (NULL != pp_job->src_reproc_frame) {
|
|
pme->releaseSuperBuf(pp_job->src_reproc_frame);
|
|
free(pp_job->src_reproc_frame);
|
|
pp_job->src_reproc_frame = NULL;
|
|
}
|
|
pp_job->reprocCount = 0;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseJpegData
|
|
*
|
|
* DESCRIPTION: callback function to release jpeg job node
|
|
*
|
|
* PARAMETERS :
|
|
* @data : ptr to ongoing jpeg job data
|
|
* @user_data : user data ptr (QCameraReprocessor)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseJpegData(void *data, void *user_data)
|
|
{
|
|
QCameraPostProcessor *pme = (QCameraPostProcessor *)user_data;
|
|
if (NULL != pme) {
|
|
pme->releaseJpegJobData((qcamera_jpeg_data_t *)data);
|
|
LOGH("Rleased job ID %u",
|
|
((qcamera_jpeg_data_t *)data)->jobId);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseOngoingPPData
|
|
*
|
|
* DESCRIPTION: callback function to release ongoing postprocess job node
|
|
*
|
|
* PARAMETERS :
|
|
* @data : ptr to onging postprocess job
|
|
* @user_data : user data ptr (QCameraReprocessor)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseOngoingPPData(void *data, void *user_data)
|
|
{
|
|
QCameraPostProcessor *pme = (QCameraPostProcessor *)user_data;
|
|
if (NULL != pme) {
|
|
qcamera_pp_data_t *pp_job = (qcamera_pp_data_t *)data;
|
|
if (NULL != pp_job->src_frame) {
|
|
if (!pp_job->reproc_frame_release) {
|
|
pme->releaseSuperBuf(pp_job->src_frame);
|
|
}
|
|
if (pp_job->src_frame == pp_job->src_reproc_frame)
|
|
pp_job->src_reproc_frame = NULL;
|
|
|
|
free(pp_job->src_frame);
|
|
pp_job->src_frame = NULL;
|
|
}
|
|
if (NULL != pp_job->src_reproc_frame) {
|
|
pme->releaseSuperBuf(pp_job->src_reproc_frame);
|
|
free(pp_job->src_reproc_frame);
|
|
pp_job->src_reproc_frame = NULL;
|
|
}
|
|
if ((pp_job->offline_reproc_buf != NULL)
|
|
&& (pp_job->offline_buffer)) {
|
|
free(pp_job->offline_reproc_buf);
|
|
pp_job->offline_buffer = false;
|
|
}
|
|
pp_job->reprocCount = 0;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseNotifyData
|
|
*
|
|
* DESCRIPTION: function to release internal resources in notify data struct
|
|
*
|
|
* PARAMETERS :
|
|
* @user_data : ptr user data
|
|
* @cookie : callback cookie
|
|
* @cb_status : callback status
|
|
*
|
|
* RETURN : None
|
|
*
|
|
* NOTE : deallocate jpeg heap memory if it's not NULL
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseNotifyData(void *user_data,
|
|
void *cookie,
|
|
int32_t cb_status)
|
|
{
|
|
LOGD("releaseNotifyData release_data %p", user_data);
|
|
|
|
qcamera_data_argm_t *app_cb = ( qcamera_data_argm_t * ) user_data;
|
|
QCameraPostProcessor *postProc = ( QCameraPostProcessor * ) cookie;
|
|
if ( ( NULL != app_cb ) && ( NULL != postProc ) ) {
|
|
|
|
if ( postProc->mUseSaveProc &&
|
|
app_cb->release_data.unlinkFile &&
|
|
( NO_ERROR != cb_status ) ) {
|
|
|
|
String8 unlinkPath((const char *) app_cb->release_data.data->data,
|
|
app_cb->release_data.data->size);
|
|
int rc = unlink(unlinkPath.string());
|
|
LOGH("Unlinking stored file rc = %d",
|
|
rc);
|
|
}
|
|
|
|
if (app_cb && NULL != app_cb->release_data.data) {
|
|
app_cb->release_data.data->release(app_cb->release_data.data);
|
|
app_cb->release_data.data = NULL;
|
|
}
|
|
if (app_cb && NULL != app_cb->release_data.frame) {
|
|
postProc->releaseSuperBuf(app_cb->release_data.frame);
|
|
free(app_cb->release_data.frame);
|
|
app_cb->release_data.frame = NULL;
|
|
}
|
|
if (app_cb && NULL != app_cb->release_data.streamBufs) {
|
|
app_cb->release_data.streamBufs->deallocate();
|
|
delete app_cb->release_data.streamBufs;
|
|
app_cb->release_data.streamBufs = NULL;
|
|
}
|
|
free(app_cb);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseSuperBuf
|
|
*
|
|
* DESCRIPTION: function to release a superbuf frame by returning back to kernel
|
|
*
|
|
* PARAMETERS :
|
|
* @super_buf : ptr to the superbuf frame
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseSuperBuf(mm_camera_super_buf_t *super_buf)
|
|
{
|
|
QCameraChannel *pChannel = NULL;
|
|
|
|
if (NULL != super_buf) {
|
|
pChannel = m_parent->getChannelByHandle(super_buf->ch_id);
|
|
|
|
if ( NULL == pChannel ) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if ((mPPChannels[i] != NULL) &&
|
|
(mPPChannels[i]->getMyHandle() == super_buf->ch_id)) {
|
|
pChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pChannel != NULL) {
|
|
pChannel->bufDone(super_buf);
|
|
} else {
|
|
LOGE("Channel id %d not found!!",
|
|
super_buf->ch_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseSuperBuf
|
|
*
|
|
* DESCRIPTION : function to release a superbuf frame by returning back to kernel
|
|
*
|
|
* PARAMETERS :
|
|
* @super_buf : ptr to the superbuf frame
|
|
* @stream_type: Type of stream to be released
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseSuperBuf(mm_camera_super_buf_t *super_buf,
|
|
cam_stream_type_t stream_type)
|
|
{
|
|
QCameraChannel *pChannel = NULL;
|
|
|
|
if (NULL != super_buf) {
|
|
pChannel = m_parent->getChannelByHandle(super_buf->ch_id);
|
|
if (pChannel == NULL) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if ((mPPChannels[i] != NULL) &&
|
|
(mPPChannels[i]->getMyHandle() == super_buf->ch_id)) {
|
|
pChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pChannel != NULL) {
|
|
for (uint32_t i = 0; i < super_buf->num_bufs; i++) {
|
|
if (super_buf->bufs[i] != NULL) {
|
|
QCameraStream *pStream =
|
|
pChannel->getStreamByHandle(super_buf->bufs[i]->stream_id);
|
|
if ((pStream != NULL) && ((pStream->getMyType() == stream_type)
|
|
|| (pStream->getMyOriginalType() == stream_type))) {
|
|
pChannel->bufDone(super_buf, super_buf->bufs[i]->stream_id);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
LOGE("Channel id %d not found!!",
|
|
super_buf->ch_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseJpegJobData
|
|
*
|
|
* DESCRIPTION: function to release internal resources in jpeg job struct
|
|
*
|
|
* PARAMETERS :
|
|
* @job : ptr to jpeg job struct
|
|
*
|
|
* RETURN : None
|
|
*
|
|
* NOTE : original source frame need to be queued back to kernel for
|
|
* future use. Output buf of jpeg job need to be released since
|
|
* it's allocated for each job. Exif object need to be deleted.
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseJpegJobData(qcamera_jpeg_data_t *job)
|
|
{
|
|
LOGD("E");
|
|
if (NULL != job) {
|
|
if (NULL != job->src_reproc_frame) {
|
|
if (!job->reproc_frame_release) {
|
|
releaseSuperBuf(job->src_reproc_frame);
|
|
}
|
|
free(job->src_reproc_frame);
|
|
job->src_reproc_frame = NULL;
|
|
}
|
|
|
|
if (NULL != job->src_frame) {
|
|
releaseSuperBuf(job->src_frame);
|
|
free(job->src_frame);
|
|
job->src_frame = NULL;
|
|
}
|
|
|
|
if (NULL != job->pJpegExifObj) {
|
|
delete job->pJpegExifObj;
|
|
job->pJpegExifObj = NULL;
|
|
}
|
|
|
|
if (NULL != job->src_reproc_bufs) {
|
|
delete [] job->src_reproc_bufs;
|
|
}
|
|
|
|
if ((job->offline_reproc_buf != NULL)
|
|
&& (job->offline_buffer)) {
|
|
free(job->offline_reproc_buf);
|
|
job->offline_buffer = false;
|
|
}
|
|
}
|
|
LOGD("X");
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseSaveJobData
|
|
*
|
|
* DESCRIPTION: function to release internal resources in store jobs
|
|
*
|
|
* PARAMETERS :
|
|
* @job : ptr to save job struct
|
|
*
|
|
* RETURN : None
|
|
*
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseSaveJobData(void *data, void *user_data)
|
|
{
|
|
LOGD("E");
|
|
|
|
QCameraPostProcessor *pme = (QCameraPostProcessor *) user_data;
|
|
if (NULL == pme) {
|
|
LOGE("Invalid postproc handle");
|
|
return;
|
|
}
|
|
|
|
qcamera_jpeg_evt_payload_t *job_data = (qcamera_jpeg_evt_payload_t *) data;
|
|
if (job_data == NULL) {
|
|
LOGE("Invalid jpeg event data");
|
|
return;
|
|
}
|
|
|
|
// find job by jobId
|
|
qcamera_jpeg_data_t *job = pme->findJpegJobByJobId(job_data->jobId);
|
|
|
|
if (NULL != job) {
|
|
pme->releaseJpegJobData(job);
|
|
free(job);
|
|
} else {
|
|
LOGE("Invalid jpeg job");
|
|
}
|
|
|
|
LOGD("X");
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseRawData
|
|
*
|
|
* DESCRIPTION: function to release internal resources in store jobs
|
|
*
|
|
* PARAMETERS :
|
|
* @job : ptr to save job struct
|
|
*
|
|
* RETURN : None
|
|
*
|
|
*==========================================================================*/
|
|
void QCameraPostProcessor::releaseRawData(void *data, void *user_data)
|
|
{
|
|
LOGD("E");
|
|
|
|
QCameraPostProcessor *pme = (QCameraPostProcessor *) user_data;
|
|
if (NULL == pme) {
|
|
LOGE("Invalid postproc handle");
|
|
return;
|
|
}
|
|
mm_camera_super_buf_t *super_buf = (mm_camera_super_buf_t *) data;
|
|
pme->releaseSuperBuf(super_buf);
|
|
|
|
LOGD("X");
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getColorfmtFromImgFmt
|
|
*
|
|
* DESCRIPTION: function to return jpeg color format based on its image format
|
|
*
|
|
* PARAMETERS :
|
|
* @img_fmt : image format
|
|
*
|
|
* RETURN : jpeg color format that can be understandable by omx lib
|
|
*==========================================================================*/
|
|
mm_jpeg_color_format QCameraPostProcessor::getColorfmtFromImgFmt(cam_format_t img_fmt)
|
|
{
|
|
switch (img_fmt) {
|
|
case CAM_FORMAT_YUV_420_NV21:
|
|
case CAM_FORMAT_YUV_420_NV21_VENUS:
|
|
return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
|
|
case CAM_FORMAT_YUV_420_NV21_ADRENO:
|
|
return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
|
|
case CAM_FORMAT_YUV_420_NV12:
|
|
case CAM_FORMAT_YUV_420_NV12_VENUS:
|
|
return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2;
|
|
case CAM_FORMAT_YUV_420_YV12:
|
|
return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2;
|
|
case CAM_FORMAT_YUV_422_NV61:
|
|
return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1;
|
|
case CAM_FORMAT_YUV_422_NV16:
|
|
return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1;
|
|
default:
|
|
return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getJpegImgTypeFromImgFmt
|
|
*
|
|
* DESCRIPTION: function to return jpeg encode image type based on its image format
|
|
*
|
|
* PARAMETERS :
|
|
* @img_fmt : image format
|
|
*
|
|
* RETURN : return jpeg source image format (YUV or Bitstream)
|
|
*==========================================================================*/
|
|
mm_jpeg_format_t QCameraPostProcessor::getJpegImgTypeFromImgFmt(cam_format_t img_fmt)
|
|
{
|
|
switch (img_fmt) {
|
|
case CAM_FORMAT_YUV_420_NV21:
|
|
case CAM_FORMAT_YUV_420_NV21_ADRENO:
|
|
case CAM_FORMAT_YUV_420_NV12:
|
|
case CAM_FORMAT_YUV_420_NV12_VENUS:
|
|
case CAM_FORMAT_YUV_420_NV21_VENUS:
|
|
case CAM_FORMAT_YUV_420_YV12:
|
|
case CAM_FORMAT_YUV_422_NV61:
|
|
case CAM_FORMAT_YUV_422_NV16:
|
|
return MM_JPEG_FMT_YUV;
|
|
default:
|
|
return MM_JPEG_FMT_YUV;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : queryStreams
|
|
*
|
|
* DESCRIPTION: utility method for retrieving main, thumbnail and reprocess
|
|
* streams and frame from bundled super buffer
|
|
*
|
|
* PARAMETERS :
|
|
* @main : ptr to main stream if present
|
|
* @thumb : ptr to thumbnail stream if present
|
|
* @reproc : ptr to reprocess stream if present
|
|
* @main_image : ptr to main image if present
|
|
* @thumb_image: ptr to thumbnail image if present
|
|
* @frame : bundled super buffer
|
|
* @reproc_frame : bundled source frame buffer
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::queryStreams(QCameraStream **main,
|
|
QCameraStream **thumb,
|
|
QCameraStream **reproc,
|
|
mm_camera_buf_def_t **main_image,
|
|
mm_camera_buf_def_t **thumb_image,
|
|
mm_camera_super_buf_t *frame,
|
|
mm_camera_super_buf_t *reproc_frame)
|
|
{
|
|
if (NULL == frame) {
|
|
return NO_INIT;
|
|
}
|
|
|
|
QCameraChannel *pChannel = m_parent->getChannelByHandle(frame->ch_id);
|
|
// check reprocess channel if not found
|
|
if (pChannel == NULL) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if ((mPPChannels[i] != NULL) &&
|
|
(mPPChannels[i]->getMyHandle() == frame->ch_id)) {
|
|
pChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (pChannel == NULL) {
|
|
LOGD("No corresponding channel (ch_id = %d) exist, return here",
|
|
frame->ch_id);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
// Use snapshot stream to create thumbnail if snapshot and preview
|
|
// flip settings doesn't match in ZSL mode.
|
|
bool thumb_stream_needed = ((!m_parent->isZSLMode() ||
|
|
(m_parent->mParameters.getFlipMode(CAM_STREAM_TYPE_SNAPSHOT) ==
|
|
m_parent->mParameters.getFlipMode(CAM_STREAM_TYPE_PREVIEW))) &&
|
|
!m_parent->mParameters.generateThumbFromMain());
|
|
|
|
*main = *thumb = *reproc = NULL;
|
|
*main_image = *thumb_image = NULL;
|
|
// find snapshot frame and thumnail frame
|
|
for (uint32_t i = 0; i < frame->num_bufs; i++) {
|
|
QCameraStream *pStream =
|
|
pChannel->getStreamByHandle(frame->bufs[i]->stream_id);
|
|
if (pStream != NULL) {
|
|
if (pStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
|
|
pStream->isTypeOf(CAM_STREAM_TYPE_VIDEO) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_VIDEO) ||
|
|
(m_parent->mParameters.getofflineRAW() &&
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW))) {
|
|
*main= pStream;
|
|
*main_image = frame->bufs[i];
|
|
} else if (thumb_stream_needed &&
|
|
(pStream->isTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
|
|
pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_POSTVIEW))) {
|
|
*thumb = pStream;
|
|
*thumb_image = frame->bufs[i];
|
|
}
|
|
if (pStream->isTypeOf(CAM_STREAM_TYPE_OFFLINE_PROC) ) {
|
|
*reproc = pStream;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (thumb_stream_needed && *thumb_image == NULL && reproc_frame != NULL) {
|
|
QCameraChannel *pSrcReprocChannel = NULL;
|
|
pSrcReprocChannel = m_parent->getChannelByHandle(reproc_frame->ch_id);
|
|
if (pSrcReprocChannel != NULL) {
|
|
// find thumbnail frame
|
|
for (uint32_t i = 0; i < reproc_frame->num_bufs; i++) {
|
|
QCameraStream *pStream =
|
|
pSrcReprocChannel->getStreamByHandle(
|
|
reproc_frame->bufs[i]->stream_id);
|
|
if (pStream != NULL) {
|
|
if (pStream->isTypeOf(CAM_STREAM_TYPE_PREVIEW) ||
|
|
pStream->isTypeOf(CAM_STREAM_TYPE_POSTVIEW)) {
|
|
*thumb = pStream;
|
|
*thumb_image = reproc_frame->bufs[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : syncStreamParams
|
|
*
|
|
* DESCRIPTION: Query the runtime parameters of all streams included
|
|
* in the main and reprocessed frames
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : Main image super buffer
|
|
* @reproc_frame : Image supper buffer that got processed
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::syncStreamParams(mm_camera_super_buf_t *frame,
|
|
mm_camera_super_buf_t *reproc_frame)
|
|
{
|
|
QCameraStream *reproc_stream = NULL;
|
|
QCameraStream *main_stream = NULL;
|
|
QCameraStream *thumb_stream = NULL;
|
|
mm_camera_buf_def_t *main_frame = NULL;
|
|
mm_camera_buf_def_t *thumb_frame = NULL;
|
|
int32_t ret = NO_ERROR;
|
|
|
|
ret = queryStreams(&main_stream,
|
|
&thumb_stream,
|
|
&reproc_stream,
|
|
&main_frame,
|
|
&thumb_frame,
|
|
frame,
|
|
reproc_frame);
|
|
if (NO_ERROR != ret) {
|
|
LOGE("Camera streams query from input frames failed %d",
|
|
ret);
|
|
return ret;
|
|
}
|
|
|
|
if (NULL != main_stream) {
|
|
ret = main_stream->syncRuntimeParams();
|
|
if (NO_ERROR != ret) {
|
|
LOGE("Syncing of main stream runtime parameters failed %d",
|
|
ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if (NULL != thumb_stream) {
|
|
ret = thumb_stream->syncRuntimeParams();
|
|
if (NO_ERROR != ret) {
|
|
LOGE("Syncing of thumb stream runtime parameters failed %d",
|
|
ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if ((NULL != reproc_stream) && (reproc_stream != main_stream)) {
|
|
ret = reproc_stream->syncRuntimeParams();
|
|
if (NO_ERROR != ret) {
|
|
LOGE("Syncing of reproc stream runtime parameters failed %d",
|
|
ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : encodeData
|
|
*
|
|
* DESCRIPTION: function to prepare encoding job information and send to
|
|
* mm-jpeg-interface to do the encoding job
|
|
*
|
|
* PARAMETERS :
|
|
* @jpeg_job_data : ptr to a struct saving job related information
|
|
* @needNewSess : flag to indicate if a new jpeg encoding session need
|
|
* to be created. After creation, this flag will be toggled
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::encodeData(qcamera_jpeg_data_t *jpeg_job_data,
|
|
uint8_t &needNewSess)
|
|
{
|
|
LOGD("E");
|
|
int32_t ret = NO_ERROR;
|
|
mm_jpeg_job_t jpg_job;
|
|
uint32_t jobId = 0;
|
|
QCameraStream *reproc_stream = NULL;
|
|
QCameraStream *main_stream = NULL;
|
|
mm_camera_buf_def_t *main_frame = NULL;
|
|
QCameraStream *thumb_stream = NULL;
|
|
mm_camera_buf_def_t *thumb_frame = NULL;
|
|
mm_camera_super_buf_t *recvd_frame = jpeg_job_data->src_frame;
|
|
cam_rect_t crop;
|
|
cam_stream_parm_buffer_t param;
|
|
cam_stream_img_prop_t imgProp;
|
|
|
|
// find channel
|
|
QCameraChannel *pChannel = m_parent->getChannelByHandle(recvd_frame->ch_id);
|
|
// check reprocess channel if not found
|
|
if (pChannel == NULL) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if ((mPPChannels[i] != NULL) &&
|
|
(mPPChannels[i]->getMyHandle() == recvd_frame->ch_id)) {
|
|
pChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pChannel == NULL) {
|
|
LOGE("No corresponding channel (ch_id = %d) exist, return here",
|
|
recvd_frame->ch_id);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
const uint32_t jpeg_rotation = m_parent->mParameters.getJpegRotation();
|
|
|
|
ret = queryStreams(&main_stream,
|
|
&thumb_stream,
|
|
&reproc_stream,
|
|
&main_frame,
|
|
&thumb_frame,
|
|
recvd_frame,
|
|
jpeg_job_data->src_reproc_frame);
|
|
if (NO_ERROR != ret) {
|
|
return ret;
|
|
}
|
|
|
|
if(NULL == main_frame){
|
|
LOGE("Main frame is NULL");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if(NULL == thumb_frame){
|
|
LOGD("Thumbnail frame does not exist");
|
|
}
|
|
|
|
QCameraMemory *memObj = (QCameraMemory *)main_frame->mem_info;
|
|
if (NULL == memObj) {
|
|
LOGE("Memeory Obj of main frame is NULL");
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
// dump snapshot frame if enabled
|
|
m_parent->dumpFrameToFile(main_stream, main_frame,
|
|
QCAMERA_DUMP_FRM_SNAPSHOT, (char *)"CPP");
|
|
|
|
// send upperlayer callback for raw image
|
|
camera_memory_t *mem = memObj->getMemory(main_frame->buf_idx, false);
|
|
if (NULL != m_parent->mDataCb &&
|
|
m_parent->msgTypeEnabledWithLock(CAMERA_MSG_RAW_IMAGE) > 0) {
|
|
qcamera_callback_argm_t cbArg;
|
|
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
|
|
cbArg.cb_type = QCAMERA_DATA_CALLBACK;
|
|
cbArg.msg_type = CAMERA_MSG_RAW_IMAGE;
|
|
cbArg.data = mem;
|
|
cbArg.index = 0;
|
|
m_parent->m_cbNotifier.notifyCallback(cbArg);
|
|
}
|
|
if (NULL != m_parent->mNotifyCb &&
|
|
m_parent->msgTypeEnabledWithLock(CAMERA_MSG_RAW_IMAGE_NOTIFY) > 0) {
|
|
qcamera_callback_argm_t cbArg;
|
|
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
|
|
cbArg.cb_type = QCAMERA_NOTIFY_CALLBACK;
|
|
cbArg.msg_type = CAMERA_MSG_RAW_IMAGE_NOTIFY;
|
|
cbArg.ext1 = 0;
|
|
cbArg.ext2 = 0;
|
|
m_parent->m_cbNotifier.notifyCallback(cbArg);
|
|
}
|
|
|
|
if (mJpegClientHandle <= 0) {
|
|
LOGE("Error: bug here, mJpegClientHandle is 0");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
if (needNewSess) {
|
|
// create jpeg encoding session
|
|
mm_jpeg_encode_params_t encodeParam;
|
|
memset(&encodeParam, 0, sizeof(mm_jpeg_encode_params_t));
|
|
ret = getJpegEncodingConfig(encodeParam, main_stream, thumb_stream);
|
|
if (ret != NO_ERROR) {
|
|
LOGE("error getting encoding config");
|
|
return ret;
|
|
}
|
|
LOGH("[KPI Perf] : call jpeg create_session");
|
|
ret = mJpegHandle.create_session(mJpegClientHandle, &encodeParam, &mJpegSessionId);
|
|
if (ret != NO_ERROR) {
|
|
LOGE("error creating a new jpeg encoding session");
|
|
return ret;
|
|
}
|
|
needNewSess = FALSE;
|
|
}
|
|
// Fill in new job
|
|
memset(&jpg_job, 0, sizeof(mm_jpeg_job_t));
|
|
jpg_job.job_type = JPEG_JOB_TYPE_ENCODE;
|
|
jpg_job.encode_job.session_id = mJpegSessionId;
|
|
jpg_job.encode_job.src_index = (int32_t)main_frame->buf_idx;
|
|
jpg_job.encode_job.dst_index = 0;
|
|
|
|
if (mJpegMemOpt) {
|
|
jpg_job.encode_job.dst_index = jpg_job.encode_job.src_index;
|
|
} else if (mUseJpegBurst) {
|
|
jpg_job.encode_job.dst_index = -1;
|
|
}
|
|
|
|
// use src to reproc frame as work buffer; if src buf is not available
|
|
// jpeg interface will allocate work buffer
|
|
if (jpeg_job_data->src_reproc_frame != NULL) {
|
|
int32_t ret = NO_ERROR;
|
|
QCameraStream *main_stream = NULL;
|
|
mm_camera_buf_def_t *main_frame = NULL;
|
|
QCameraStream *thumb_stream = NULL;
|
|
mm_camera_buf_def_t *thumb_frame = NULL;
|
|
QCameraStream *reproc_stream = NULL;
|
|
mm_camera_buf_def_t *workBuf = NULL;
|
|
// Call queryStreams to fetch source of reproc frame
|
|
ret = queryStreams(&main_stream,
|
|
&thumb_stream,
|
|
&reproc_stream,
|
|
&main_frame,
|
|
&thumb_frame,
|
|
jpeg_job_data->src_reproc_frame,
|
|
NULL);
|
|
|
|
if ((NO_ERROR == ret) && ((workBuf = main_frame) != NULL)
|
|
&& !m_parent->isLowPowerMode()) {
|
|
camera_memory_t *camWorkMem = NULL;
|
|
int workBufIndex = workBuf->buf_idx;
|
|
QCameraMemory *workMem = (QCameraMemory *)workBuf->mem_info;
|
|
if (workMem != NULL) {
|
|
camWorkMem = workMem->getMemory(workBufIndex, false);
|
|
}
|
|
if (camWorkMem != NULL && workMem != NULL) {
|
|
jpg_job.encode_job.work_buf.buf_size = camWorkMem->size;
|
|
jpg_job.encode_job.work_buf.buf_vaddr = (uint8_t *)camWorkMem->data;
|
|
jpg_job.encode_job.work_buf.fd = workMem->getFd(workBufIndex);
|
|
workMem->invalidateCache(workBufIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
cam_dimension_t src_dim;
|
|
memset(&src_dim, 0, sizeof(cam_dimension_t));
|
|
main_stream->getFrameDimension(src_dim);
|
|
|
|
bool hdr_output_crop = m_parent->mParameters.isHDROutputCropEnabled();
|
|
bool img_feature_enabled =
|
|
m_parent->mParameters.isUbiFocusEnabled() ||
|
|
m_parent->mParameters.isUbiRefocus() ||
|
|
m_parent->mParameters.isChromaFlashEnabled() ||
|
|
m_parent->mParameters.isOptiZoomEnabled() ||
|
|
m_parent->mParameters.isStillMoreEnabled();
|
|
|
|
LOGH("Crop needed %d", img_feature_enabled);
|
|
crop.left = 0;
|
|
crop.top = 0;
|
|
crop.height = src_dim.height;
|
|
crop.width = src_dim.width;
|
|
|
|
param = main_stream->getOutputCrop();
|
|
for (int i = 0; i < param.outputCrop.num_of_streams; i++) {
|
|
if (param.outputCrop.crop_info[i].stream_id
|
|
== main_stream->getMyServerID()) {
|
|
crop = param.outputCrop.crop_info[i].crop;
|
|
main_stream->setCropInfo(crop);
|
|
}
|
|
}
|
|
if (img_feature_enabled) {
|
|
memset(¶m, 0, sizeof(cam_stream_parm_buffer_t));
|
|
|
|
param = main_stream->getImgProp();
|
|
imgProp = param.imgProp;
|
|
main_stream->setCropInfo(imgProp.crop);
|
|
crop = imgProp.crop;
|
|
thumb_stream = NULL; /* use thumbnail from main image */
|
|
|
|
if ((reproc_stream != NULL) && (m_DataMem == NULL) &&
|
|
m_parent->mParameters.isUbiRefocus()) {
|
|
|
|
QCameraHeapMemory* miscBufHandler = reproc_stream->getMiscBuf();
|
|
cam_misc_buf_t* refocusResult =
|
|
reinterpret_cast<cam_misc_buf_t *>(miscBufHandler->getPtr(0));
|
|
uint32_t resultSize = refocusResult->header_size +
|
|
refocusResult->width * refocusResult->height;
|
|
camera_memory_t *dataMem = m_parent->mGetMemory(-1, resultSize,
|
|
1, m_parent->mCallbackCookie);
|
|
|
|
LOGH("Refocus result header %u dims %dx%d",
|
|
resultSize, refocusResult->width, refocusResult->height);
|
|
|
|
if (dataMem && dataMem->data) {
|
|
memcpy(dataMem->data, refocusResult->data, resultSize);
|
|
//save mem pointer for depth map
|
|
m_DataMem = dataMem;
|
|
}
|
|
}
|
|
} else if ((reproc_stream != NULL) && (m_parent->mParameters.isTruePortraitEnabled())) {
|
|
|
|
QCameraHeapMemory* miscBufHandler = reproc_stream->getMiscBuf();
|
|
cam_misc_buf_t* tpResult =
|
|
reinterpret_cast<cam_misc_buf_t *>(miscBufHandler->getPtr(0));
|
|
uint32_t tpMetaSize = tpResult->header_size + tpResult->width * tpResult->height;
|
|
|
|
LOGH("True portrait result header %d% dims dx%d",
|
|
tpMetaSize, tpResult->width, tpResult->height);
|
|
|
|
CAM_DUMP_TO_FILE(QCAMERA_DUMP_FRM_LOCATION"tp", "bm", -1, "y",
|
|
&tpResult->data, tpMetaSize);
|
|
}
|
|
|
|
cam_dimension_t dst_dim;
|
|
|
|
if (hdr_output_crop && crop.height) {
|
|
dst_dim.height = crop.height;
|
|
} else {
|
|
dst_dim.height = src_dim.height;
|
|
}
|
|
if (hdr_output_crop && crop.width) {
|
|
dst_dim.width = crop.width;
|
|
} else {
|
|
dst_dim.width = src_dim.width;
|
|
}
|
|
|
|
// main dim
|
|
jpg_job.encode_job.main_dim.src_dim = src_dim;
|
|
jpg_job.encode_job.main_dim.dst_dim = dst_dim;
|
|
jpg_job.encode_job.main_dim.crop = crop;
|
|
|
|
// get 3a sw version info
|
|
cam_q3a_version_t sw_version =
|
|
m_parent->getCamHalCapabilities()->q3a_version;
|
|
|
|
// get exif data
|
|
QCameraExif *pJpegExifObj = m_parent->getExifData();
|
|
jpeg_job_data->pJpegExifObj = pJpegExifObj;
|
|
if (pJpegExifObj != NULL) {
|
|
jpg_job.encode_job.exif_info.exif_data = pJpegExifObj->getEntries();
|
|
jpg_job.encode_job.exif_info.numOfEntries =
|
|
pJpegExifObj->getNumOfEntries();
|
|
jpg_job.encode_job.exif_info.debug_data.sw_3a_version[0] =
|
|
sw_version.major_version;
|
|
jpg_job.encode_job.exif_info.debug_data.sw_3a_version[1] =
|
|
sw_version.minor_version;
|
|
jpg_job.encode_job.exif_info.debug_data.sw_3a_version[2] =
|
|
sw_version.patch_version;
|
|
jpg_job.encode_job.exif_info.debug_data.sw_3a_version[3] =
|
|
sw_version.new_feature_des;
|
|
}
|
|
|
|
// set rotation only when no online rotation or offline pp rotation is done before
|
|
if (!m_parent->needRotationReprocess()) {
|
|
jpg_job.encode_job.rotation = jpeg_rotation;
|
|
}
|
|
LOGH("jpeg rotation is set to %d", jpg_job.encode_job.rotation);
|
|
|
|
// thumbnail dim
|
|
if (m_bThumbnailNeeded == TRUE) {
|
|
m_parent->getThumbnailSize(jpg_job.encode_job.thumb_dim.dst_dim);
|
|
|
|
if (thumb_stream == NULL) {
|
|
// need jpeg thumbnail, but no postview/preview stream exists
|
|
// we use the main stream/frame to encode thumbnail
|
|
thumb_stream = main_stream;
|
|
thumb_frame = main_frame;
|
|
}
|
|
if (m_parent->needRotationReprocess() &&
|
|
((90 == jpeg_rotation) || (270 == jpeg_rotation))) {
|
|
// swap thumbnail dimensions
|
|
cam_dimension_t tmp_dim = jpg_job.encode_job.thumb_dim.dst_dim;
|
|
jpg_job.encode_job.thumb_dim.dst_dim.width = tmp_dim.height;
|
|
jpg_job.encode_job.thumb_dim.dst_dim.height = tmp_dim.width;
|
|
}
|
|
|
|
memset(&src_dim, 0, sizeof(cam_dimension_t));
|
|
thumb_stream->getFrameDimension(src_dim);
|
|
jpg_job.encode_job.thumb_dim.src_dim = src_dim;
|
|
|
|
// crop is the same if frame is the same
|
|
if (thumb_frame != main_frame) {
|
|
crop.left = 0;
|
|
crop.top = 0;
|
|
crop.height = src_dim.height;
|
|
crop.width = src_dim.width;
|
|
|
|
param = thumb_stream->getOutputCrop();
|
|
for (int i = 0; i < param.outputCrop.num_of_streams; i++) {
|
|
if (param.outputCrop.crop_info[i].stream_id
|
|
== thumb_stream->getMyServerID()) {
|
|
crop = param.outputCrop.crop_info[i].crop;
|
|
thumb_stream->setCropInfo(crop);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
jpg_job.encode_job.thumb_dim.crop = crop;
|
|
if (thumb_frame != NULL) {
|
|
jpg_job.encode_job.thumb_index = thumb_frame->buf_idx;
|
|
}
|
|
LOGI("Thumbnail idx = %d src w/h (%dx%d), dst w/h (%dx%d)",
|
|
jpg_job.encode_job.thumb_index,
|
|
jpg_job.encode_job.thumb_dim.src_dim.width,
|
|
jpg_job.encode_job.thumb_dim.src_dim.height,
|
|
jpg_job.encode_job.thumb_dim.dst_dim.width,
|
|
jpg_job.encode_job.thumb_dim.dst_dim.height);
|
|
}
|
|
|
|
LOGI("Main image idx = %d src w/h (%dx%d), dst w/h (%dx%d)",
|
|
jpg_job.encode_job.src_index,
|
|
jpg_job.encode_job.main_dim.src_dim.width,
|
|
jpg_job.encode_job.main_dim.src_dim.height,
|
|
jpg_job.encode_job.main_dim.dst_dim.width,
|
|
jpg_job.encode_job.main_dim.dst_dim.height);
|
|
|
|
if (thumb_frame != NULL) {
|
|
// dump thumbnail frame if enabled
|
|
m_parent->dumpFrameToFile(thumb_stream, thumb_frame, QCAMERA_DUMP_FRM_THUMBNAIL);
|
|
}
|
|
|
|
if (jpeg_job_data->metadata != NULL) {
|
|
// fill in meta data frame ptr
|
|
jpg_job.encode_job.p_metadata = jpeg_job_data->metadata;
|
|
}
|
|
|
|
jpg_job.encode_job.hal_version = CAM_HAL_V1;
|
|
m_parent->mExifParams.sensor_params.sens_type = m_parent->getSensorType();
|
|
jpg_job.encode_job.cam_exif_params = m_parent->mExifParams;
|
|
jpg_job.encode_job.cam_exif_params.debug_params =
|
|
(mm_jpeg_debug_exif_params_t *) malloc (sizeof(mm_jpeg_debug_exif_params_t));
|
|
if (!jpg_job.encode_job.cam_exif_params.debug_params) {
|
|
LOGE("Out of Memory. Allocation failed for 3A debug exif params");
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
jpg_job.encode_job.mobicat_mask = m_parent->mParameters.getMobicatMask();
|
|
|
|
|
|
if (NULL != jpg_job.encode_job.p_metadata && (jpg_job.encode_job.mobicat_mask > 0)) {
|
|
|
|
if (m_parent->mExifParams.debug_params) {
|
|
memcpy(jpg_job.encode_job.cam_exif_params.debug_params,
|
|
m_parent->mExifParams.debug_params, (sizeof(mm_jpeg_debug_exif_params_t)));
|
|
|
|
/* Save a copy of mobicat params */
|
|
jpg_job.encode_job.p_metadata->is_mobicat_aec_params_valid =
|
|
jpg_job.encode_job.cam_exif_params.cam_3a_params_valid;
|
|
|
|
if (jpg_job.encode_job.cam_exif_params.cam_3a_params_valid) {
|
|
jpg_job.encode_job.p_metadata->mobicat_aec_params =
|
|
jpg_job.encode_job.cam_exif_params.cam_3a_params;
|
|
}
|
|
|
|
/* Save a copy of 3A debug params */
|
|
jpg_job.encode_job.p_metadata->is_statsdebug_ae_params_valid =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->ae_debug_params_valid;
|
|
jpg_job.encode_job.p_metadata->is_statsdebug_awb_params_valid =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->awb_debug_params_valid;
|
|
jpg_job.encode_job.p_metadata->is_statsdebug_af_params_valid =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->af_debug_params_valid;
|
|
jpg_job.encode_job.p_metadata->is_statsdebug_asd_params_valid =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->asd_debug_params_valid;
|
|
jpg_job.encode_job.p_metadata->is_statsdebug_stats_params_valid =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->stats_debug_params_valid;
|
|
|
|
if (jpg_job.encode_job.cam_exif_params.debug_params->ae_debug_params_valid) {
|
|
jpg_job.encode_job.p_metadata->statsdebug_ae_data =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->ae_debug_params;
|
|
}
|
|
if (jpg_job.encode_job.cam_exif_params.debug_params->awb_debug_params_valid) {
|
|
jpg_job.encode_job.p_metadata->statsdebug_awb_data =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->awb_debug_params;
|
|
}
|
|
if (jpg_job.encode_job.cam_exif_params.debug_params->af_debug_params_valid) {
|
|
jpg_job.encode_job.p_metadata->statsdebug_af_data =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->af_debug_params;
|
|
}
|
|
if (jpg_job.encode_job.cam_exif_params.debug_params->asd_debug_params_valid) {
|
|
jpg_job.encode_job.p_metadata->statsdebug_asd_data =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->asd_debug_params;
|
|
}
|
|
if (jpg_job.encode_job.cam_exif_params.debug_params->stats_debug_params_valid) {
|
|
jpg_job.encode_job.p_metadata->statsdebug_stats_buffer_data =
|
|
jpg_job.encode_job.cam_exif_params.debug_params->stats_debug_params;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* Init the QTable */
|
|
for (int i = 0; i < QTABLE_MAX; i++) {
|
|
jpg_job.encode_job.qtable_set[i] = 0;
|
|
}
|
|
|
|
const cam_sync_related_sensors_event_info_t* related_cam_info =
|
|
m_parent->getRelatedCamSyncInfo();
|
|
if (related_cam_info->sync_control == CAM_SYNC_RELATED_SENSORS_ON &&
|
|
m_parent->getMpoComposition()) {
|
|
jpg_job.encode_job.multi_image_info.type = MM_JPEG_TYPE_MPO;
|
|
if (related_cam_info->type == CAM_TYPE_MAIN ) {
|
|
jpg_job.encode_job.multi_image_info.is_primary = TRUE;
|
|
LOGD("Encoding MPO Primary JPEG");
|
|
} else {
|
|
jpg_job.encode_job.multi_image_info.is_primary = FALSE;
|
|
LOGD("Encoding MPO Aux JPEG");
|
|
}
|
|
jpg_job.encode_job.multi_image_info.num_of_images = 2;
|
|
} else {
|
|
LOGD("Encoding Single JPEG");
|
|
jpg_job.encode_job.multi_image_info.type = MM_JPEG_TYPE_JPEG;
|
|
jpg_job.encode_job.multi_image_info.is_primary = FALSE;
|
|
jpg_job.encode_job.multi_image_info.num_of_images = 1;
|
|
}
|
|
|
|
LOGI("[KPI Perf] : PROFILE_JPEG_JOB_START");
|
|
ret = mJpegHandle.start_job(&jpg_job, &jobId);
|
|
if (jpg_job.encode_job.cam_exif_params.debug_params) {
|
|
free(jpg_job.encode_job.cam_exif_params.debug_params);
|
|
}
|
|
if (ret == NO_ERROR) {
|
|
// remember job info
|
|
jpeg_job_data->jobId = jobId;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : processRawImageImpl
|
|
*
|
|
* DESCRIPTION: function to send raw image to upper layer
|
|
*
|
|
* PARAMETERS :
|
|
* @recvd_frame : frame to be encoded
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::processRawImageImpl(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
|
|
QCameraChannel *pChannel = m_parent->getChannelByHandle(recvd_frame->ch_id);
|
|
QCameraStream *pStream = NULL;
|
|
mm_camera_buf_def_t *frame = NULL;
|
|
// check reprocess channel if not found
|
|
if (pChannel == NULL) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if ((mPPChannels[i] != NULL) &&
|
|
(mPPChannels[i]->getMyHandle() == recvd_frame->ch_id)) {
|
|
pChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (pChannel == NULL) {
|
|
LOGE("No corresponding channel (ch_id = %d) exist, return here",
|
|
recvd_frame->ch_id);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
// find snapshot frame
|
|
for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
|
|
QCameraStream *pCurStream =
|
|
pChannel->getStreamByHandle(recvd_frame->bufs[i]->stream_id);
|
|
if (pCurStream != NULL) {
|
|
if (pCurStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
|
|
pCurStream->isTypeOf(CAM_STREAM_TYPE_RAW) ||
|
|
pCurStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
|
|
pCurStream->isOrignalTypeOf(CAM_STREAM_TYPE_RAW)) {
|
|
pStream = pCurStream;
|
|
frame = recvd_frame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( NULL == frame ) {
|
|
LOGE("No valid raw buffer");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
QCameraMemory *rawMemObj = (QCameraMemory *)frame->mem_info;
|
|
bool zslChannelUsed = m_parent->isZSLMode() &&
|
|
( pChannel != mPPChannels[0] );
|
|
camera_memory_t *raw_mem = NULL;
|
|
|
|
if (rawMemObj != NULL) {
|
|
if (zslChannelUsed) {
|
|
raw_mem = rawMemObj->getMemory(frame->buf_idx, false);
|
|
} else {
|
|
raw_mem = m_parent->mGetMemory(-1,
|
|
frame->frame_len,
|
|
1,
|
|
m_parent->mCallbackCookie);
|
|
if (NULL == raw_mem) {
|
|
LOGE("Not enough memory for RAW cb ");
|
|
return NO_MEMORY;
|
|
}
|
|
memcpy(raw_mem->data, frame->buffer, frame->frame_len);
|
|
}
|
|
}
|
|
|
|
if (NULL != rawMemObj && NULL != raw_mem) {
|
|
// dump frame into file
|
|
if (frame->stream_type == CAM_STREAM_TYPE_SNAPSHOT ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
|
|
// for YUV422 NV16 case
|
|
m_parent->dumpFrameToFile(pStream, frame, QCAMERA_DUMP_FRM_SNAPSHOT);
|
|
} else {
|
|
//Received RAW snapshot taken notification
|
|
m_parent->dumpFrameToFile(pStream, frame, QCAMERA_DUMP_FRM_RAW);
|
|
|
|
if(true == m_parent->m_bIntRawEvtPending) {
|
|
//Sending RAW snapshot taken notification to HAL
|
|
memset(&m_dst_dim, 0, sizeof(m_dst_dim));
|
|
pStream->getFrameDimension(m_dst_dim);
|
|
pthread_mutex_lock(&m_parent->m_int_lock);
|
|
pthread_cond_signal(&m_parent->m_int_cond);
|
|
pthread_mutex_unlock(&m_parent->m_int_lock);
|
|
raw_mem->release(raw_mem);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
// send data callback / notify for RAW_IMAGE
|
|
if (NULL != m_parent->mDataCb &&
|
|
m_parent->msgTypeEnabledWithLock(CAMERA_MSG_RAW_IMAGE) > 0) {
|
|
qcamera_callback_argm_t cbArg;
|
|
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
|
|
cbArg.cb_type = QCAMERA_DATA_CALLBACK;
|
|
cbArg.msg_type = CAMERA_MSG_RAW_IMAGE;
|
|
cbArg.data = raw_mem;
|
|
cbArg.index = 0;
|
|
m_parent->m_cbNotifier.notifyCallback(cbArg);
|
|
}
|
|
if (NULL != m_parent->mNotifyCb &&
|
|
m_parent->msgTypeEnabledWithLock(CAMERA_MSG_RAW_IMAGE_NOTIFY) > 0) {
|
|
qcamera_callback_argm_t cbArg;
|
|
memset(&cbArg, 0, sizeof(qcamera_callback_argm_t));
|
|
cbArg.cb_type = QCAMERA_NOTIFY_CALLBACK;
|
|
cbArg.msg_type = CAMERA_MSG_RAW_IMAGE_NOTIFY;
|
|
cbArg.ext1 = 0;
|
|
cbArg.ext2 = 0;
|
|
m_parent->m_cbNotifier.notifyCallback(cbArg);
|
|
}
|
|
|
|
if ((m_parent->mDataCb != NULL) &&
|
|
m_parent->msgTypeEnabledWithLock(CAMERA_MSG_COMPRESSED_IMAGE) > 0) {
|
|
qcamera_release_data_t release_data;
|
|
memset(&release_data, 0, sizeof(qcamera_release_data_t));
|
|
if ( zslChannelUsed ) {
|
|
release_data.frame = recvd_frame;
|
|
} else {
|
|
release_data.data = raw_mem;
|
|
}
|
|
rc = sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
|
|
raw_mem,
|
|
0,
|
|
NULL,
|
|
&release_data);
|
|
} else {
|
|
raw_mem->release(raw_mem);
|
|
}
|
|
} else {
|
|
LOGE("Cannot get raw mem");
|
|
rc = UNKNOWN_ERROR;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : dataSaveRoutine
|
|
*
|
|
* DESCRIPTION: data saving routine
|
|
*
|
|
* PARAMETERS :
|
|
* @data : user data ptr (QCameraPostProcessor)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void *QCameraPostProcessor::dataSaveRoutine(void *data)
|
|
{
|
|
int running = 1;
|
|
int ret;
|
|
uint8_t is_active = FALSE;
|
|
QCameraPostProcessor *pme = (QCameraPostProcessor *)data;
|
|
QCameraCmdThread *cmdThread = &pme->m_saveProcTh;
|
|
cmdThread->setName("CAM_JpegSave");
|
|
char saveName[PROPERTY_VALUE_MAX];
|
|
|
|
LOGH("E");
|
|
do {
|
|
do {
|
|
ret = cam_sem_wait(&cmdThread->cmd_sem);
|
|
if (ret != 0 && errno != EINVAL) {
|
|
LOGE("cam_sem_wait error (%s)",
|
|
strerror(errno));
|
|
return NULL;
|
|
}
|
|
} while (ret != 0);
|
|
|
|
// we got notified about new cmd avail in cmd queue
|
|
camera_cmd_type_t cmd = cmdThread->getCmd();
|
|
switch (cmd) {
|
|
case CAMERA_CMD_TYPE_START_DATA_PROC:
|
|
LOGH("start data proc");
|
|
is_active = TRUE;
|
|
pme->m_inputSaveQ.init();
|
|
break;
|
|
case CAMERA_CMD_TYPE_STOP_DATA_PROC:
|
|
{
|
|
LOGH("stop data proc");
|
|
is_active = FALSE;
|
|
|
|
// flush input save Queue
|
|
pme->m_inputSaveQ.flush();
|
|
|
|
// signal cmd is completed
|
|
cam_sem_post(&cmdThread->sync_sem);
|
|
}
|
|
break;
|
|
case CAMERA_CMD_TYPE_DO_NEXT_JOB:
|
|
{
|
|
LOGH("Do next job, active is %d", is_active);
|
|
|
|
qcamera_jpeg_evt_payload_t *job_data = (qcamera_jpeg_evt_payload_t *) pme->m_inputSaveQ.dequeue();
|
|
if (job_data == NULL) {
|
|
LOGE("Invalid jpeg event data");
|
|
continue;
|
|
}
|
|
//qcamera_jpeg_data_t *jpeg_job =
|
|
// (qcamera_jpeg_data_t *)pme->m_ongoingJpegQ.dequeue(false);
|
|
//uint32_t frame_idx = jpeg_job->src_frame->bufs[0]->frame_idx;
|
|
uint32_t frame_idx = 75;
|
|
|
|
pme->m_ongoingJpegQ.flushNodes(matchJobId, (void*)&job_data->jobId);
|
|
|
|
LOGH("[KPI Perf] : jpeg job %d", job_data->jobId);
|
|
|
|
if (is_active == TRUE) {
|
|
memset(saveName, '\0', sizeof(saveName));
|
|
snprintf(saveName,
|
|
sizeof(saveName),
|
|
QCameraPostProcessor::STORE_LOCATION,
|
|
pme->mSaveFrmCnt);
|
|
|
|
int file_fd = open(saveName, O_RDWR | O_CREAT, 0655);
|
|
if (file_fd >= 0) {
|
|
ssize_t written_len = write(file_fd, job_data->out_data.buf_vaddr,
|
|
job_data->out_data.buf_filled_len);
|
|
if ((ssize_t)job_data->out_data.buf_filled_len != written_len) {
|
|
LOGE("Failed save complete data %d bytes "
|
|
"written instead of %d bytes!",
|
|
written_len,
|
|
job_data->out_data.buf_filled_len);
|
|
} else {
|
|
LOGH("written number of bytes %d\n",
|
|
written_len);
|
|
}
|
|
|
|
close(file_fd);
|
|
} else {
|
|
LOGE("fail t open file for saving");
|
|
}
|
|
pme->mSaveFrmCnt++;
|
|
|
|
camera_memory_t* jpeg_mem = pme->m_parent->mGetMemory(-1,
|
|
strlen(saveName),
|
|
1,
|
|
pme->m_parent->mCallbackCookie);
|
|
if (NULL == jpeg_mem) {
|
|
ret = NO_MEMORY;
|
|
LOGE("getMemory for jpeg, ret = NO_MEMORY");
|
|
goto end;
|
|
}
|
|
memcpy(jpeg_mem->data, saveName, strlen(saveName));
|
|
|
|
LOGH("Calling upperlayer callback to store JPEG image");
|
|
qcamera_release_data_t release_data;
|
|
memset(&release_data, 0, sizeof(qcamera_release_data_t));
|
|
release_data.data = jpeg_mem;
|
|
release_data.unlinkFile = true;
|
|
LOGI("[KPI Perf]: PROFILE_JPEG_CB ");
|
|
ret = pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
|
|
jpeg_mem,
|
|
0,
|
|
NULL,
|
|
&release_data,
|
|
frame_idx);
|
|
}
|
|
|
|
end:
|
|
free(job_data);
|
|
}
|
|
break;
|
|
case CAMERA_CMD_TYPE_EXIT:
|
|
LOGH("save thread exit");
|
|
running = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} while (running);
|
|
LOGH("X");
|
|
return NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : dataProcessRoutine
|
|
*
|
|
* DESCRIPTION: data process routine that handles input data either from input
|
|
* Jpeg Queue to do jpeg encoding, or from input PP Queue to do
|
|
* reprocess.
|
|
*
|
|
* PARAMETERS :
|
|
* @data : user data ptr (QCameraPostProcessor)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void *QCameraPostProcessor::dataProcessRoutine(void *data)
|
|
{
|
|
int running = 1;
|
|
int ret;
|
|
uint8_t is_active = FALSE;
|
|
QCameraPostProcessor *pme = (QCameraPostProcessor *)data;
|
|
QCameraCmdThread *cmdThread = &pme->m_dataProcTh;
|
|
cmdThread->setName("CAM_DataProc");
|
|
|
|
LOGH("E");
|
|
do {
|
|
do {
|
|
ret = cam_sem_wait(&cmdThread->cmd_sem);
|
|
if (ret != 0 && errno != EINVAL) {
|
|
LOGE("cam_sem_wait error (%s)",
|
|
strerror(errno));
|
|
return NULL;
|
|
}
|
|
} while (ret != 0);
|
|
|
|
// we got notified about new cmd avail in cmd queue
|
|
camera_cmd_type_t cmd = cmdThread->getCmd();
|
|
switch (cmd) {
|
|
case CAMERA_CMD_TYPE_START_DATA_PROC:
|
|
LOGH("start data proc");
|
|
is_active = TRUE;
|
|
|
|
pme->m_ongoingPPQ.init();
|
|
pme->m_inputJpegQ.init();
|
|
pme->m_inputPPQ.init();
|
|
pme->m_inputRawQ.init();
|
|
|
|
pme->m_saveProcTh.sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC,
|
|
FALSE,
|
|
FALSE);
|
|
|
|
// signal cmd is completed
|
|
cam_sem_post(&cmdThread->sync_sem);
|
|
|
|
break;
|
|
case CAMERA_CMD_TYPE_STOP_DATA_PROC:
|
|
{
|
|
LOGH("stop data proc");
|
|
is_active = FALSE;
|
|
|
|
pme->m_saveProcTh.sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC,
|
|
TRUE,
|
|
TRUE);
|
|
// cancel all ongoing jpeg jobs
|
|
qcamera_jpeg_data_t *jpeg_job =
|
|
(qcamera_jpeg_data_t *)pme->m_ongoingJpegQ.dequeue();
|
|
while (jpeg_job != NULL) {
|
|
pme->mJpegHandle.abort_job(jpeg_job->jobId);
|
|
|
|
pme->releaseJpegJobData(jpeg_job);
|
|
free(jpeg_job);
|
|
|
|
jpeg_job = (qcamera_jpeg_data_t *)pme->m_ongoingJpegQ.dequeue();
|
|
}
|
|
|
|
// destroy jpeg encoding session
|
|
if ( 0 < pme->mJpegSessionId ) {
|
|
pme->mJpegHandle.destroy_session(pme->mJpegSessionId);
|
|
pme->mJpegSessionId = 0;
|
|
}
|
|
|
|
// free jpeg out buf and exif obj
|
|
FREE_JPEG_OUTPUT_BUFFER(pme->m_pJpegOutputMem,
|
|
pme->m_JpegOutputMemCount);
|
|
|
|
if (pme->m_pJpegExifObj != NULL) {
|
|
delete pme->m_pJpegExifObj;
|
|
pme->m_pJpegExifObj = NULL;
|
|
}
|
|
|
|
// flush ongoing postproc Queue
|
|
pme->m_ongoingPPQ.flush();
|
|
|
|
// flush input jpeg Queue
|
|
pme->m_inputJpegQ.flush();
|
|
|
|
// flush input Postproc Queue
|
|
pme->m_inputPPQ.flush();
|
|
|
|
// flush input raw Queue
|
|
pme->m_inputRawQ.flush();
|
|
|
|
// signal cmd is completed
|
|
cam_sem_post(&cmdThread->sync_sem);
|
|
|
|
pme->mNewJpegSessionNeeded = true;
|
|
}
|
|
break;
|
|
case CAMERA_CMD_TYPE_DO_NEXT_JOB:
|
|
{
|
|
LOGH("Do next job, active is %d", is_active);
|
|
if (is_active == TRUE) {
|
|
qcamera_jpeg_data_t *jpeg_job =
|
|
(qcamera_jpeg_data_t *)pme->m_inputJpegQ.dequeue();
|
|
|
|
if (NULL != jpeg_job) {
|
|
// To avoid any race conditions,
|
|
// sync any stream specific parameters here.
|
|
if (pme->m_parent->mParameters.isAdvCamFeaturesEnabled()) {
|
|
// Sync stream params, only if advanced features configured
|
|
// Reduces the latency for normal snapshot.
|
|
pme->syncStreamParams(jpeg_job->src_frame, NULL);
|
|
}
|
|
|
|
// add into ongoing jpeg job Q
|
|
if (pme->m_ongoingJpegQ.enqueue((void *)jpeg_job)) {
|
|
ret = pme->encodeData(jpeg_job,
|
|
pme->mNewJpegSessionNeeded);
|
|
if (NO_ERROR != ret) {
|
|
// dequeue the last one
|
|
pme->m_ongoingJpegQ.dequeue(false);
|
|
pme->releaseJpegJobData(jpeg_job);
|
|
free(jpeg_job);
|
|
jpeg_job = NULL;
|
|
pme->sendEvtNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
|
|
}
|
|
} else {
|
|
LOGW("m_ongoingJpegQ is not active!!!");
|
|
pme->releaseJpegJobData(jpeg_job);
|
|
free(jpeg_job);
|
|
jpeg_job = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
// process raw data if any
|
|
mm_camera_super_buf_t *super_buf =
|
|
(mm_camera_super_buf_t *)pme->m_inputRawQ.dequeue();
|
|
|
|
if (NULL != super_buf) {
|
|
//play shutter sound
|
|
pme->m_parent->playShutter();
|
|
ret = pme->processRawImageImpl(super_buf);
|
|
if (NO_ERROR != ret) {
|
|
pme->releaseSuperBuf(super_buf);
|
|
free(super_buf);
|
|
pme->sendEvtNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
|
|
}
|
|
}
|
|
|
|
ret = pme->doReprocess();
|
|
if (NO_ERROR != ret) {
|
|
pme->sendEvtNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
|
|
} else {
|
|
ret = pme->stopCapture();
|
|
}
|
|
|
|
} else {
|
|
// not active, simply return buf and do no op
|
|
qcamera_jpeg_data_t *jpeg_data =
|
|
(qcamera_jpeg_data_t *)pme->m_inputJpegQ.dequeue();
|
|
if (NULL != jpeg_data) {
|
|
pme->releaseJpegJobData(jpeg_data);
|
|
free(jpeg_data);
|
|
}
|
|
mm_camera_super_buf_t *super_buf =
|
|
(mm_camera_super_buf_t *)pme->m_inputRawQ.dequeue();
|
|
if (NULL != super_buf) {
|
|
pme->releaseSuperBuf(super_buf);
|
|
free(super_buf);
|
|
}
|
|
|
|
// flush input Postproc Queue
|
|
pme->m_inputPPQ.flush();
|
|
}
|
|
}
|
|
break;
|
|
case CAMERA_CMD_TYPE_EXIT:
|
|
running = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} while (running);
|
|
LOGH("X");
|
|
return NULL;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : doReprocess
|
|
*
|
|
* DESCRIPTION: Trigger channel reprocessing
|
|
*
|
|
* PARAMETERS :None
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::doReprocess()
|
|
{
|
|
int32_t ret = NO_ERROR;
|
|
QCameraChannel *m_pSrcChannel = NULL;
|
|
QCameraStream *pMetaStream = NULL;
|
|
uint8_t meta_buf_index = 0;
|
|
mm_camera_buf_def_t *meta_buf = NULL;
|
|
bool found_meta = FALSE;
|
|
mm_camera_super_buf_t *ppInputFrame = NULL;
|
|
|
|
qcamera_pp_data_t *ppreq_job = (qcamera_pp_data_t *)m_inputPPQ.peek();
|
|
if ((ppreq_job == NULL) || (ppreq_job->src_frame == NULL)) {
|
|
return ret;
|
|
}
|
|
|
|
if (!validatePostProcess(ppreq_job->src_frame)) {
|
|
return ret;
|
|
}
|
|
|
|
ppreq_job = (qcamera_pp_data_t *)m_inputPPQ.dequeue();
|
|
if (ppreq_job == NULL || ppreq_job->src_frame == NULL ||
|
|
ppreq_job->src_reproc_frame == NULL) {
|
|
return ret;
|
|
}
|
|
|
|
mm_camera_super_buf_t *src_frame = ppreq_job->src_frame;
|
|
mm_camera_super_buf_t *src_reproc_frame = ppreq_job->src_reproc_frame;
|
|
int8_t mCurReprocCount = ppreq_job->reprocCount;
|
|
int8_t mCurChannelIdx = ppreq_job->ppChannelIndex;
|
|
|
|
LOGD("frame = %p src_frame = %p mCurReprocCount = %d mCurChannelIdx = %d",
|
|
src_frame,src_reproc_frame,mCurReprocCount, mCurChannelIdx);
|
|
|
|
if ((m_parent->mParameters.getManualCaptureMode() >=
|
|
CAM_MANUAL_CAPTURE_TYPE_3) && (mCurChannelIdx == 0)) {
|
|
ppInputFrame = src_reproc_frame;
|
|
} else {
|
|
ppInputFrame = src_frame;
|
|
}
|
|
|
|
// find meta data stream and index of meta data frame in the superbuf
|
|
for (int8_t j = 0; j < mPPChannelCount; j++) {
|
|
uint32_t i;
|
|
|
|
/*First search in src buffer for any offline metadata */
|
|
for (i = 0; i < src_frame->num_bufs; i++) {
|
|
QCameraStream *pStream = mPPChannels[j]->getStreamByHandle(
|
|
src_frame->bufs[i]->stream_id);
|
|
if (pStream != NULL && pStream->isOrignalTypeOf(CAM_STREAM_TYPE_METADATA)) {
|
|
meta_buf_index = (uint8_t) src_frame->bufs[i]->buf_idx;
|
|
pMetaStream = pStream;
|
|
meta_buf = src_frame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((pMetaStream != NULL) && (meta_buf != NULL)) {
|
|
LOGD("Found Offline stream metadata = %d",
|
|
(int)meta_buf_index);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((pMetaStream == NULL) && (meta_buf == NULL)) {
|
|
for (int8_t j = 0; j < mPPChannelCount; j++) {
|
|
uint32_t i;
|
|
m_pSrcChannel = mPPChannels[j]->getSrcChannel();
|
|
if (m_pSrcChannel == NULL)
|
|
continue;
|
|
for (i = 0; i < src_reproc_frame->num_bufs; i++) {
|
|
QCameraStream *pStream =
|
|
m_pSrcChannel->getStreamByHandle(
|
|
src_reproc_frame->bufs[i]->stream_id);
|
|
if (pStream != NULL && pStream->isTypeOf(CAM_STREAM_TYPE_METADATA)) {
|
|
meta_buf_index = (uint8_t) src_reproc_frame->bufs[i]->buf_idx;
|
|
pMetaStream = pStream;
|
|
meta_buf = src_reproc_frame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
if ((pMetaStream != NULL) && (meta_buf != NULL)) {
|
|
LOGD("Found Meta data info for reprocessing index = %d",
|
|
(int)meta_buf_index);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_parent->mParameters.isAdvCamFeaturesEnabled()) {
|
|
// No need to sync stream params, if none of the advanced features configured
|
|
// Reduces the latency for normal snapshot.
|
|
syncStreamParams(src_frame, src_reproc_frame);
|
|
}
|
|
if (mPPChannels[mCurChannelIdx] != NULL) {
|
|
// add into ongoing PP job Q
|
|
ppreq_job->reprocCount = (int8_t) (mCurReprocCount + 1);
|
|
|
|
if ((m_parent->isRegularCapture()) || (ppreq_job->offline_buffer)) {
|
|
m_bufCountPPQ++;
|
|
if (m_ongoingPPQ.enqueue((void *)ppreq_job)) {
|
|
ret = mPPChannels[mCurChannelIdx]->doReprocessOffline(ppInputFrame,
|
|
meta_buf, m_parent->mParameters);
|
|
if (ret != NO_ERROR) {
|
|
goto end;
|
|
}
|
|
|
|
if ((ppreq_job->offline_buffer) &&
|
|
(ppreq_job->offline_reproc_buf)) {
|
|
mPPChannels[mCurChannelIdx]->doReprocessOffline(
|
|
ppreq_job->offline_reproc_buf, meta_buf);
|
|
}
|
|
} else {
|
|
LOGW("m_ongoingPPQ is not active!!!");
|
|
ret = UNKNOWN_ERROR;
|
|
goto end;
|
|
}
|
|
} else {
|
|
m_bufCountPPQ++;
|
|
if (!m_ongoingPPQ.enqueue((void *)ppreq_job)) {
|
|
LOGW("m_ongoingJpegQ is not active!!!");
|
|
ret = UNKNOWN_ERROR;
|
|
goto end;
|
|
}
|
|
|
|
int32_t numRequiredPPQBufsForSingleOutput = (int32_t)
|
|
m_parent->mParameters.getNumberInBufsForSingleShot();
|
|
|
|
if (m_bufCountPPQ % numRequiredPPQBufsForSingleOutput == 0) {
|
|
int32_t extra_pp_job_count =
|
|
m_parent->mParameters.getNumberOutBufsForSingleShot() -
|
|
m_parent->mParameters.getNumberInBufsForSingleShot();
|
|
|
|
for (int32_t i = 0; i < extra_pp_job_count; i++) {
|
|
qcamera_pp_data_t *extra_pp_job =
|
|
(qcamera_pp_data_t *)calloc(1, sizeof(qcamera_pp_data_t));
|
|
if (!extra_pp_job) {
|
|
LOGE("no mem for qcamera_pp_data_t");
|
|
ret = NO_MEMORY;
|
|
break;
|
|
}
|
|
extra_pp_job->reprocCount = ppreq_job->reprocCount;
|
|
if (!m_ongoingPPQ.enqueue((void *)extra_pp_job)) {
|
|
LOGW("m_ongoingJpegQ is not active!!!");
|
|
releaseOngoingPPData(extra_pp_job, this);
|
|
free(extra_pp_job);
|
|
extra_pp_job = NULL;
|
|
goto end;
|
|
}
|
|
}
|
|
}
|
|
|
|
ret = mPPChannels[mCurChannelIdx]->doReprocess(ppInputFrame,
|
|
m_parent->mParameters, pMetaStream, meta_buf_index);
|
|
}
|
|
} else {
|
|
LOGE("Reprocess channel is NULL");
|
|
ret = UNKNOWN_ERROR;
|
|
}
|
|
|
|
end:
|
|
if (ret != NO_ERROR) {
|
|
releaseOngoingPPData(ppreq_job, this);
|
|
if (ppreq_job != NULL) {
|
|
free(ppreq_job);
|
|
ppreq_job = NULL;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getReprocChannel
|
|
*
|
|
* DESCRIPTION: Returns reprocessing channel handle
|
|
*
|
|
* PARAMETERS : index for reprocessing array
|
|
*
|
|
* RETURN : QCameraReprocessChannel * type of pointer
|
|
NULL if no reprocessing channel
|
|
*==========================================================================*/
|
|
QCameraReprocessChannel * QCameraPostProcessor::getReprocChannel(uint8_t index)
|
|
{
|
|
if (index >= mPPChannelCount) {
|
|
LOGE("Invalid index value");
|
|
return NULL;
|
|
}
|
|
return mPPChannels[index];
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : stopCapture
|
|
*
|
|
* DESCRIPTION: Trigger image capture stop
|
|
*
|
|
* PARAMETERS :
|
|
* None
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::stopCapture()
|
|
{
|
|
int rc = NO_ERROR;
|
|
|
|
if (m_parent->isRegularCapture()) {
|
|
rc = m_parent->processAPI(
|
|
QCAMERA_SM_EVT_STOP_CAPTURE_CHANNEL,
|
|
NULL);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getJpegPaddingReq
|
|
*
|
|
* DESCRIPTION: function to add an entry to exif data
|
|
*
|
|
* PARAMETERS :
|
|
* @padding_info : jpeg specific padding requirement
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::getJpegPaddingReq(cam_padding_info_t &padding_info)
|
|
{
|
|
// TODO: hardcode for now, needs to query from mm-jpeg-interface
|
|
padding_info.width_padding = CAM_PAD_NONE;
|
|
padding_info.height_padding = CAM_PAD_TO_16;
|
|
padding_info.plane_padding = CAM_PAD_TO_WORD;
|
|
padding_info.offset_info.offset_x = 0;
|
|
padding_info.offset_info.offset_y = 0;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setYUVFrameInfo
|
|
*
|
|
* DESCRIPTION: set Raw YUV frame data info for up-layer
|
|
*
|
|
* PARAMETERS :
|
|
* @frame : process frame received from mm-camera-interface
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : currently we return frame len, y offset, cbcr offset and frame format
|
|
*==========================================================================*/
|
|
int32_t QCameraPostProcessor::setYUVFrameInfo(mm_camera_super_buf_t *recvd_frame)
|
|
{
|
|
QCameraChannel *pChannel = m_parent->getChannelByHandle(recvd_frame->ch_id);
|
|
// check reprocess channel if not found
|
|
if (pChannel == NULL) {
|
|
for (int8_t i = 0; i < mPPChannelCount; i++) {
|
|
if ((mPPChannels[i] != NULL) &&
|
|
(mPPChannels[i]->getMyHandle() == recvd_frame->ch_id)) {
|
|
pChannel = mPPChannels[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pChannel == NULL) {
|
|
LOGE("No corresponding channel (ch_id = %d) exist, return here",
|
|
recvd_frame->ch_id);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
// find snapshot frame
|
|
for (uint32_t i = 0; i < recvd_frame->num_bufs; i++) {
|
|
QCameraStream *pStream =
|
|
pChannel->getStreamByHandle(recvd_frame->bufs[i]->stream_id);
|
|
if (pStream != NULL) {
|
|
if (pStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
|
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
|
|
//get the main frame, use stream info
|
|
cam_frame_len_offset_t frame_offset;
|
|
cam_dimension_t frame_dim;
|
|
cam_format_t frame_fmt;
|
|
const char *fmt_string;
|
|
pStream->getFrameDimension(frame_dim);
|
|
pStream->getFrameOffset(frame_offset);
|
|
pStream->getFormat(frame_fmt);
|
|
fmt_string = m_parent->mParameters.getFrameFmtString(frame_fmt);
|
|
|
|
int cbcr_offset = (int32_t)frame_offset.mp[0].len -
|
|
frame_dim.width * frame_dim.height;
|
|
|
|
LOGH("frame width=%d, height=%d, yoff=%d, cbcroff=%d, fmt_string=%s",
|
|
frame_dim.width, frame_dim.height, frame_offset.mp[0].offset, cbcr_offset, fmt_string);
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
bool QCameraPostProcessor::matchJobId(void *data, void *, void *match_data)
|
|
{
|
|
qcamera_jpeg_data_t * job = (qcamera_jpeg_data_t *) data;
|
|
uint32_t job_id = *((uint32_t *) match_data);
|
|
return job->jobId == job_id;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getJpegMemory
|
|
*
|
|
* DESCRIPTION: buffer allocation function
|
|
* to pass to jpeg interface
|
|
*
|
|
* PARAMETERS :
|
|
* @out_buf : buffer descriptor struct
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int QCameraPostProcessor::getJpegMemory(omx_jpeg_ouput_buf_t *out_buf)
|
|
{
|
|
LOGH("Allocating jpeg out buffer of size: %d", out_buf->size);
|
|
QCameraPostProcessor *procInst = (QCameraPostProcessor *) out_buf->handle;
|
|
camera_memory_t *cam_mem = procInst->m_parent->mGetMemory(out_buf->fd, out_buf->size, 1U,
|
|
procInst->m_parent->mCallbackCookie);
|
|
out_buf->mem_hdl = cam_mem;
|
|
out_buf->vaddr = cam_mem->data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseJpegMemory
|
|
*
|
|
* DESCRIPTION: release jpeg memory function
|
|
* to pass to jpeg interface, in case of abort
|
|
*
|
|
* PARAMETERS :
|
|
* @out_buf : buffer descriptor struct
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int QCameraPostProcessor::releaseJpegMemory(omx_jpeg_ouput_buf_t *out_buf)
|
|
{
|
|
if (out_buf && out_buf->mem_hdl) {
|
|
LOGD("releasing jpeg out buffer of size: %d", out_buf->size);
|
|
camera_memory_t *cam_mem = (camera_memory_t*)out_buf->mem_hdl;
|
|
cam_mem->release(cam_mem);
|
|
out_buf->mem_hdl = NULL;
|
|
out_buf->vaddr = NULL;
|
|
return NO_ERROR;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCameraExif
|
|
*
|
|
* DESCRIPTION: constructor of QCameraExif
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraExif::QCameraExif()
|
|
: m_nNumEntries(0)
|
|
{
|
|
memset(m_Entries, 0, sizeof(m_Entries));
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCameraExif
|
|
*
|
|
* DESCRIPTION: deconstructor of QCameraExif. Will release internal memory ptr.
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraExif::~QCameraExif()
|
|
{
|
|
for (uint32_t i = 0; i < m_nNumEntries; i++) {
|
|
switch (m_Entries[i].tag_entry.type) {
|
|
case EXIF_BYTE:
|
|
{
|
|
if (m_Entries[i].tag_entry.count > 1 &&
|
|
m_Entries[i].tag_entry.data._bytes != NULL) {
|
|
free(m_Entries[i].tag_entry.data._bytes);
|
|
m_Entries[i].tag_entry.data._bytes = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_ASCII:
|
|
{
|
|
if (m_Entries[i].tag_entry.data._ascii != NULL) {
|
|
free(m_Entries[i].tag_entry.data._ascii);
|
|
m_Entries[i].tag_entry.data._ascii = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_SHORT:
|
|
{
|
|
if (m_Entries[i].tag_entry.count > 1 &&
|
|
m_Entries[i].tag_entry.data._shorts != NULL) {
|
|
free(m_Entries[i].tag_entry.data._shorts);
|
|
m_Entries[i].tag_entry.data._shorts = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_LONG:
|
|
{
|
|
if (m_Entries[i].tag_entry.count > 1 &&
|
|
m_Entries[i].tag_entry.data._longs != NULL) {
|
|
free(m_Entries[i].tag_entry.data._longs);
|
|
m_Entries[i].tag_entry.data._longs = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_RATIONAL:
|
|
{
|
|
if (m_Entries[i].tag_entry.count > 1 &&
|
|
m_Entries[i].tag_entry.data._rats != NULL) {
|
|
free(m_Entries[i].tag_entry.data._rats);
|
|
m_Entries[i].tag_entry.data._rats = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_UNDEFINED:
|
|
{
|
|
if (m_Entries[i].tag_entry.data._undefined != NULL) {
|
|
free(m_Entries[i].tag_entry.data._undefined);
|
|
m_Entries[i].tag_entry.data._undefined = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_SLONG:
|
|
{
|
|
if (m_Entries[i].tag_entry.count > 1 &&
|
|
m_Entries[i].tag_entry.data._slongs != NULL) {
|
|
free(m_Entries[i].tag_entry.data._slongs);
|
|
m_Entries[i].tag_entry.data._slongs = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_SRATIONAL:
|
|
{
|
|
if (m_Entries[i].tag_entry.count > 1 &&
|
|
m_Entries[i].tag_entry.data._srats != NULL) {
|
|
free(m_Entries[i].tag_entry.data._srats);
|
|
m_Entries[i].tag_entry.data._srats = NULL;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : addEntry
|
|
*
|
|
* DESCRIPTION: function to add an entry to exif data
|
|
*
|
|
* PARAMETERS :
|
|
* @tagid : exif tag ID
|
|
* @type : data type
|
|
* @count : number of data in uint of its type
|
|
* @data : input data ptr
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraExif::addEntry(exif_tag_id_t tagid,
|
|
exif_tag_type_t type,
|
|
uint32_t count,
|
|
void *data)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
if(m_nNumEntries >= MAX_EXIF_TABLE_ENTRIES) {
|
|
LOGE("Number of entries exceeded limit");
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
m_Entries[m_nNumEntries].tag_id = tagid;
|
|
m_Entries[m_nNumEntries].tag_entry.type = type;
|
|
m_Entries[m_nNumEntries].tag_entry.count = count;
|
|
m_Entries[m_nNumEntries].tag_entry.copy = 1;
|
|
switch (type) {
|
|
case EXIF_BYTE:
|
|
{
|
|
if (count > 1) {
|
|
uint8_t *values = (uint8_t *)malloc(count);
|
|
if (values == NULL) {
|
|
LOGE("No memory for byte array");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memcpy(values, data, count);
|
|
m_Entries[m_nNumEntries].tag_entry.data._bytes = values;
|
|
}
|
|
} else {
|
|
m_Entries[m_nNumEntries].tag_entry.data._byte = *(uint8_t *)data;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_ASCII:
|
|
{
|
|
char *str = NULL;
|
|
str = (char *)malloc(count + 1);
|
|
if (str == NULL) {
|
|
LOGE("No memory for ascii string");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memset(str, 0, count + 1);
|
|
memcpy(str, data, count);
|
|
m_Entries[m_nNumEntries].tag_entry.data._ascii = str;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_SHORT:
|
|
{
|
|
if (count > 1) {
|
|
uint16_t *values = (uint16_t *)malloc(count * sizeof(uint16_t));
|
|
if (values == NULL) {
|
|
LOGE("No memory for short array");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memcpy(values, data, count * sizeof(uint16_t));
|
|
m_Entries[m_nNumEntries].tag_entry.data._shorts = values;
|
|
}
|
|
} else {
|
|
m_Entries[m_nNumEntries].tag_entry.data._short = *(uint16_t *)data;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_LONG:
|
|
{
|
|
if (count > 1) {
|
|
uint32_t *values = (uint32_t *)malloc(count * sizeof(uint32_t));
|
|
if (values == NULL) {
|
|
LOGE("No memory for long array");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memcpy(values, data, count * sizeof(uint32_t));
|
|
m_Entries[m_nNumEntries].tag_entry.data._longs = values;
|
|
}
|
|
} else {
|
|
m_Entries[m_nNumEntries].tag_entry.data._long = *(uint32_t *)data;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_RATIONAL:
|
|
{
|
|
if (count > 1) {
|
|
rat_t *values = (rat_t *)malloc(count * sizeof(rat_t));
|
|
if (values == NULL) {
|
|
LOGE("No memory for rational array");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memcpy(values, data, count * sizeof(rat_t));
|
|
m_Entries[m_nNumEntries].tag_entry.data._rats = values;
|
|
}
|
|
} else {
|
|
m_Entries[m_nNumEntries].tag_entry.data._rat = *(rat_t *)data;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_UNDEFINED:
|
|
{
|
|
uint8_t *values = (uint8_t *)malloc(count);
|
|
if (values == NULL) {
|
|
LOGE("No memory for undefined array");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memcpy(values, data, count);
|
|
m_Entries[m_nNumEntries].tag_entry.data._undefined = values;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_SLONG:
|
|
{
|
|
if (count > 1) {
|
|
int32_t *values = (int32_t *)malloc(count * sizeof(int32_t));
|
|
if (values == NULL) {
|
|
LOGE("No memory for signed long array");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memcpy(values, data, count * sizeof(int32_t));
|
|
m_Entries[m_nNumEntries].tag_entry.data._slongs = values;
|
|
}
|
|
} else {
|
|
m_Entries[m_nNumEntries].tag_entry.data._slong = *(int32_t *)data;
|
|
}
|
|
}
|
|
break;
|
|
case EXIF_SRATIONAL:
|
|
{
|
|
if (count > 1) {
|
|
srat_t *values = (srat_t *)malloc(count * sizeof(srat_t));
|
|
if (values == NULL) {
|
|
LOGE("No memory for signed rational array");
|
|
rc = NO_MEMORY;
|
|
} else {
|
|
memcpy(values, data, count * sizeof(srat_t));
|
|
m_Entries[m_nNumEntries].tag_entry.data._srats = values;
|
|
}
|
|
} else {
|
|
m_Entries[m_nNumEntries].tag_entry.data._srat = *(srat_t *)data;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Increase number of entries
|
|
m_nNumEntries++;
|
|
return rc;
|
|
}
|
|
|
|
}; // namespace qcamera
|