mirror of
https://github.com/S3NEO/android_device_samsung_msm8226-common.git
synced 2024-11-06 21:55:45 +00:00
1701 lines
60 KiB
C++
1701 lines
60 KiB
C++
|
/* Copyright (c) 2012-2013, The Linux Foundataion. 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"
|
||
|
|
||
|
#include <stdlib.h>
|
||
|
#include <utils/Errors.h>
|
||
|
|
||
|
#include "QCamera2HWI.h"
|
||
|
#include "QCameraPostProc.h"
|
||
|
|
||
|
namespace qcamera {
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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_pJpegOutputMem(NULL),
|
||
|
m_pJpegExifObj(NULL),
|
||
|
m_bThumbnailNeeded(TRUE),
|
||
|
m_pReprocChannel(NULL),
|
||
|
m_inputPPQ(releasePPInputData, this),
|
||
|
m_ongoingPPQ(releaseOngoingPPData, this),
|
||
|
m_inputJpegQ(releaseJpegData, this),
|
||
|
m_ongoingJpegQ(releaseJpegData, this),
|
||
|
m_inputRawQ(releasePPInputData, this)
|
||
|
{
|
||
|
memset(&mJpegHandle, 0, sizeof(mJpegHandle));
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* FUNCTION : ~QCameraPostProcessor
|
||
|
*
|
||
|
* DESCRIPTION: deconstructor of QCameraPostProcessor.
|
||
|
*
|
||
|
* PARAMETERS : None
|
||
|
*
|
||
|
* RETURN : None
|
||
|
*==========================================================================*/
|
||
|
QCameraPostProcessor::~QCameraPostProcessor()
|
||
|
{
|
||
|
if (m_pJpegOutputMem != NULL) {
|
||
|
m_pJpegOutputMem->deallocate();
|
||
|
delete m_pJpegOutputMem;
|
||
|
m_pJpegOutputMem = NULL;
|
||
|
}
|
||
|
if (m_pJpegExifObj != NULL) {
|
||
|
delete m_pJpegExifObj;
|
||
|
m_pJpegExifObj = NULL;
|
||
|
}
|
||
|
if (m_pReprocChannel != NULL) {
|
||
|
m_pReprocChannel->stop();
|
||
|
delete m_pReprocChannel;
|
||
|
m_pReprocChannel = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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;
|
||
|
|
||
|
mJpegClientHandle = jpeg_open(&mJpegHandle);
|
||
|
if(!mJpegClientHandle) {
|
||
|
ALOGE("%s : jpeg_open did not work", __func__);
|
||
|
return UNKNOWN_ERROR;
|
||
|
}
|
||
|
|
||
|
m_dataProcTh.launch(dataProcessRoutine, this);
|
||
|
|
||
|
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()
|
||
|
{
|
||
|
m_dataProcTh.exit();
|
||
|
|
||
|
if(mJpegClientHandle > 0) {
|
||
|
int rc = mJpegHandle.close(mJpegClientHandle);
|
||
|
ALOGE("%s: Jpeg closed, rc = %d, mJpegClientHandle = %x",
|
||
|
__func__, rc, mJpegClientHandle);
|
||
|
mJpegClientHandle = 0;
|
||
|
memset(&mJpegHandle, 0, sizeof(mJpegHandle));
|
||
|
}
|
||
|
|
||
|
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)
|
||
|
{
|
||
|
int32_t rc = NO_ERROR;
|
||
|
if (m_parent->needReprocess()) {
|
||
|
if (m_pReprocChannel != NULL) {
|
||
|
delete m_pReprocChannel;
|
||
|
m_pReprocChannel = NULL;
|
||
|
}
|
||
|
// if reprocess is needed, start reprocess channel
|
||
|
m_pReprocChannel = m_parent->addOnlineReprocChannel(pSrcChannel);
|
||
|
if (m_pReprocChannel == NULL) {
|
||
|
ALOGE("%s: cannot add reprocess channel", __func__);
|
||
|
return UNKNOWN_ERROR;
|
||
|
}
|
||
|
|
||
|
rc = m_pReprocChannel->start();
|
||
|
if (rc != 0) {
|
||
|
ALOGE("%s: cannot start reprocess channel", __func__);
|
||
|
delete m_pReprocChannel;
|
||
|
m_pReprocChannel = NULL;
|
||
|
return rc;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, FALSE, FALSE);
|
||
|
m_parent->m_cbNotifier.startSnapshots();
|
||
|
|
||
|
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()
|
||
|
{
|
||
|
m_parent->m_cbNotifier.stopSnapshots();
|
||
|
// 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);
|
||
|
|
||
|
return NO_ERROR;
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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)
|
||
|
{
|
||
|
ALOGV("%s : E", __func__);
|
||
|
int32_t ret = NO_ERROR;
|
||
|
camera_memory_t *jpeg_mem = NULL;
|
||
|
|
||
|
encode_parm.jpeg_cb = mJpegCB;
|
||
|
encode_parm.userdata = mJpegUserData;
|
||
|
|
||
|
m_bThumbnailNeeded = TRUE; // need encode thumbnail by default
|
||
|
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
|
||
|
encode_parm.quality = m_parent->getJpegQuality();
|
||
|
if (encode_parm.quality <= 0) {
|
||
|
encode_parm.quality = 85;
|
||
|
}
|
||
|
|
||
|
// get exif data
|
||
|
if (m_pJpegExifObj != NULL) {
|
||
|
delete m_pJpegExifObj;
|
||
|
m_pJpegExifObj = NULL;
|
||
|
}
|
||
|
m_pJpegExifObj = m_parent->getExifData();
|
||
|
if (m_pJpegExifObj != NULL) {
|
||
|
encode_parm.exif_info.exif_data = m_pJpegExifObj->getEntries();
|
||
|
encode_parm.exif_info.numOfEntries = m_pJpegExifObj->getNumOfEntries();
|
||
|
}
|
||
|
|
||
|
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) {
|
||
|
ALOGE("%s: cannot get stream bufs from main stream", __func__);
|
||
|
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;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (m_bThumbnailNeeded == TRUE) {
|
||
|
if (thumb_stream == NULL) {
|
||
|
thumb_stream = main_stream;
|
||
|
}
|
||
|
pStreamMem = thumb_stream->getStreamBufs();
|
||
|
if (pStreamMem == NULL) {
|
||
|
ALOGE("%s: cannot get stream bufs from thumb stream", __func__);
|
||
|
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 (int 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;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// allocate output buf for jpeg encoding
|
||
|
if (m_pJpegOutputMem != NULL) {
|
||
|
m_pJpegOutputMem->deallocate();
|
||
|
delete m_pJpegOutputMem;
|
||
|
m_pJpegOutputMem = NULL;
|
||
|
}
|
||
|
m_pJpegOutputMem = new QCameraStreamMemory(m_parent->mGetMemory,
|
||
|
QCAMERA_ION_USE_CACHE);
|
||
|
if (NULL == m_pJpegOutputMem) {
|
||
|
ret = NO_MEMORY;
|
||
|
ALOGE("%s : No memory for m_pJpegOutputMem", __func__);
|
||
|
goto on_error;
|
||
|
}
|
||
|
ret = m_pJpegOutputMem->allocate(1, main_offset.frame_len);
|
||
|
if(ret != OK) {
|
||
|
ret = NO_MEMORY;
|
||
|
ALOGE("%s : No memory for m_pJpegOutputMem", __func__);
|
||
|
goto on_error;
|
||
|
}
|
||
|
jpeg_mem = m_pJpegOutputMem->getMemory(0, false);
|
||
|
if (NULL == jpeg_mem) {
|
||
|
ret = NO_MEMORY;
|
||
|
ALOGE("%s : initHeapMem for jpeg, ret = NO_MEMORY", __func__);
|
||
|
goto on_error;
|
||
|
}
|
||
|
encode_parm.num_dst_bufs = 1;
|
||
|
encode_parm.dest_buf[0].index = 0;
|
||
|
encode_parm.dest_buf[0].buf_size = jpeg_mem->size;
|
||
|
encode_parm.dest_buf[0].buf_vaddr = (uint8_t *)jpeg_mem->data;
|
||
|
encode_parm.dest_buf[0].fd = m_pJpegOutputMem->getFd(0);
|
||
|
encode_parm.dest_buf[0].format = MM_JPEG_FMT_YUV;
|
||
|
encode_parm.dest_buf[0].offset = main_offset;
|
||
|
|
||
|
ALOGV("%s : X", __func__);
|
||
|
return NO_ERROR;
|
||
|
|
||
|
on_error:
|
||
|
if (m_pJpegOutputMem != NULL) {
|
||
|
m_pJpegOutputMem->deallocate();
|
||
|
delete m_pJpegOutputMem;
|
||
|
m_pJpegOutputMem = NULL;
|
||
|
}
|
||
|
if (m_pJpegExifObj != NULL) {
|
||
|
delete m_pJpegExifObj;
|
||
|
m_pJpegExifObj = NULL;
|
||
|
}
|
||
|
ALOGV("%s : X with error %d", __func__, 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
|
||
|
*
|
||
|
* 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)
|
||
|
{
|
||
|
qcamera_data_argm_t *data_cb = (qcamera_data_argm_t *)malloc(sizeof(qcamera_data_argm_t));
|
||
|
if (NULL == data_cb) {
|
||
|
ALOGE("%s: no mem for acamera_data_argm_t", __func__);
|
||
|
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;
|
||
|
int rc = m_parent->m_cbNotifier.notifyCallback(cbArg);
|
||
|
if ( NO_ERROR != rc ) {
|
||
|
ALOGE("%s: Error enqueuing jpeg data into notify queue", __func__);
|
||
|
free(data_cb);
|
||
|
return UNKNOWN_ERROR;
|
||
|
}
|
||
|
|
||
|
return rc;
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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)
|
||
|
{
|
||
|
if (m_parent->needReprocess()) {
|
||
|
ALOGD("%s: need reprocess", __func__);
|
||
|
// enqueu to post proc input queue
|
||
|
m_inputPPQ.enqueue((void *)frame);
|
||
|
} else if (m_parent->mParameters.isNV16PictureFormat()) {
|
||
|
processRawData(frame);
|
||
|
} else {
|
||
|
ALOGD("%s: no need offline reprocess, sending to jpeg encoding", __func__);
|
||
|
qcamera_jpeg_data_t *jpeg_job =
|
||
|
(qcamera_jpeg_data_t *)malloc(sizeof(qcamera_jpeg_data_t));
|
||
|
if (jpeg_job == NULL) {
|
||
|
ALOGE("%s: No memory for jpeg job", __func__);
|
||
|
return NO_MEMORY;
|
||
|
}
|
||
|
|
||
|
memset(jpeg_job, 0, sizeof(qcamera_jpeg_data_t));
|
||
|
jpeg_job->src_frame = frame;
|
||
|
|
||
|
// enqueu to jpeg input queue
|
||
|
m_inputJpegQ.enqueue((void *)jpeg_job);
|
||
|
}
|
||
|
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)
|
||
|
{
|
||
|
// enqueu to raw input queue
|
||
|
m_inputRawQ.enqueue((void *)frame);
|
||
|
m_dataProcTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
||
|
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)
|
||
|
{
|
||
|
int32_t rc = NO_ERROR;
|
||
|
camera_memory_t *jpeg_mem = NULL;
|
||
|
|
||
|
// find job by jobId
|
||
|
qcamera_jpeg_data_t *job = findJpegJobByJobId(evt->jobId);
|
||
|
|
||
|
if (job == NULL) {
|
||
|
ALOGE("%s: Cannot find jpeg job by jobId(%d)", __func__, evt->jobId);
|
||
|
rc = BAD_VALUE;
|
||
|
goto end;
|
||
|
}
|
||
|
|
||
|
ALOGD("[KPI Perf] %s : jpeg job %d", __func__, evt->jobId);
|
||
|
|
||
|
if (m_parent->mDataCb == NULL ||
|
||
|
m_parent->msgTypeEnabledWithLock(CAMERA_MSG_COMPRESSED_IMAGE) == 0 ) {
|
||
|
ALOGD("%s: No dataCB or CAMERA_MSG_COMPRESSED_IMAGE not enabled",
|
||
|
__func__);
|
||
|
rc = NO_ERROR;
|
||
|
goto end;
|
||
|
}
|
||
|
|
||
|
if(evt->status == JPEG_JOB_STATUS_ERROR) {
|
||
|
ALOGE("%s: Error event handled from jpeg, status = %d",
|
||
|
__func__, evt->status);
|
||
|
rc = FAILED_TRANSACTION;
|
||
|
goto end;
|
||
|
}
|
||
|
|
||
|
m_parent->dumpFrameToFile(evt->out_data.buf_vaddr,
|
||
|
evt->out_data.buf_filled_len,
|
||
|
evt->jobId,
|
||
|
QCAMERA_DUMP_FRM_JPEG);
|
||
|
ALOGD("%s: Dump jpeg_size=%d", __func__, evt->out_data.buf_filled_len);
|
||
|
|
||
|
// 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;
|
||
|
ALOGE("%s : getMemory for jpeg, ret = NO_MEMORY", __func__);
|
||
|
goto end;
|
||
|
}
|
||
|
memcpy(jpeg_mem->data, evt->out_data.buf_vaddr, evt->out_data.buf_filled_len);
|
||
|
|
||
|
ALOGE("%s : Calling upperlayer callback to store JPEG image", __func__);
|
||
|
qcamera_release_data_t release_data;
|
||
|
memset(&release_data, 0, sizeof(qcamera_release_data_t));
|
||
|
release_data.data = jpeg_mem;
|
||
|
rc = sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
|
||
|
jpeg_mem,
|
||
|
0,
|
||
|
NULL,
|
||
|
&release_data);
|
||
|
|
||
|
end:
|
||
|
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;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// release internal data for jpeg job
|
||
|
if (job != NULL) {
|
||
|
releaseJpegJobData(job);
|
||
|
free(job);
|
||
|
}
|
||
|
|
||
|
// 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)
|
||
|
{
|
||
|
qcamera_pp_data_t *job = (qcamera_pp_data_t *)m_ongoingPPQ.dequeue();
|
||
|
|
||
|
if (job == NULL || job->src_frame == NULL) {
|
||
|
ALOGE("%s: Cannot find reprocess job", __func__);
|
||
|
return BAD_VALUE;
|
||
|
}
|
||
|
|
||
|
if (m_parent->mParameters.isNV16PictureFormat()) {
|
||
|
releaseSuperBuf(job->src_frame);
|
||
|
free(job->src_frame);
|
||
|
free(job);
|
||
|
return processRawData(frame);
|
||
|
}
|
||
|
|
||
|
qcamera_jpeg_data_t *jpeg_job =
|
||
|
(qcamera_jpeg_data_t *)malloc(sizeof(qcamera_jpeg_data_t));
|
||
|
if (jpeg_job == NULL) {
|
||
|
ALOGE("%s: No memory for jpeg job", __func__);
|
||
|
return NO_MEMORY;
|
||
|
}
|
||
|
|
||
|
memset(jpeg_job, 0, sizeof(qcamera_jpeg_data_t));
|
||
|
jpeg_job->src_frame = frame;
|
||
|
jpeg_job->src_reproc_frame = job->src_frame;
|
||
|
|
||
|
// free pp job buf
|
||
|
free(job);
|
||
|
|
||
|
// enqueu reprocessed frame to jpeg input queue
|
||
|
m_inputJpegQ.enqueue((void *)jpeg_job);
|
||
|
|
||
|
// wait up data proc thread
|
||
|
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) {
|
||
|
ALOGE("%s: not a valid jpeg jobId", __func__);
|
||
|
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) {
|
||
|
pme->releaseSuperBuf((mm_camera_super_buf_t *)data);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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) {
|
||
|
pme->releaseSuperBuf(pp_job->src_frame);
|
||
|
free(pp_job->src_frame);
|
||
|
pp_job->src_frame = NULL;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* FUNCTION : releaseNotifyData
|
||
|
*
|
||
|
* DESCRIPTION: function to release internal resources in notify data struct
|
||
|
*
|
||
|
* PARAMETERS :
|
||
|
* @user_data : ptr user data
|
||
|
* @cookie : callback cookie
|
||
|
*
|
||
|
* RETURN : None
|
||
|
*
|
||
|
* NOTE : deallocate jpeg heap memory if it's not NULL
|
||
|
*==========================================================================*/
|
||
|
void QCameraPostProcessor::releaseNotifyData(void *user_data, void *cookie)
|
||
|
{
|
||
|
qcamera_data_argm_t *app_cb = ( qcamera_data_argm_t * ) user_data;
|
||
|
QCameraPostProcessor *postProc = ( QCameraPostProcessor * ) cookie;
|
||
|
if ( ( NULL != app_cb ) && ( NULL != postProc ) ) {
|
||
|
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;
|
||
|
}
|
||
|
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 ) {
|
||
|
if (m_pReprocChannel != NULL &&
|
||
|
m_pReprocChannel->getMyHandle() == super_buf->ch_id) {
|
||
|
pChannel = m_pReprocChannel;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (pChannel != NULL) {
|
||
|
pChannel->bufDone(super_buf);
|
||
|
} else {
|
||
|
ALOGE(" %s : Channel id %d not found!!",
|
||
|
__func__,
|
||
|
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)
|
||
|
{
|
||
|
ALOGV("%s: E", __func__);
|
||
|
if (NULL != job) {
|
||
|
if (NULL != job->src_reproc_frame) {
|
||
|
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;
|
||
|
}
|
||
|
}
|
||
|
ALOGV("%s: X", __func__);
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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:
|
||
|
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:
|
||
|
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_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 : 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)
|
||
|
{
|
||
|
ALOGV("%s : E", __func__);
|
||
|
int32_t ret = NO_ERROR;
|
||
|
mm_jpeg_job_t jpg_job;
|
||
|
uint32_t jobId = 0;
|
||
|
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;
|
||
|
|
||
|
// find channel
|
||
|
QCameraChannel *pChannel = m_parent->getChannelByHandle(recvd_frame->ch_id);
|
||
|
// check reprocess channel if not found
|
||
|
if (pChannel == NULL) {
|
||
|
if (m_pReprocChannel != NULL &&
|
||
|
m_pReprocChannel->getMyHandle() == recvd_frame->ch_id) {
|
||
|
pChannel = m_pReprocChannel;
|
||
|
}
|
||
|
}
|
||
|
if (pChannel == NULL) {
|
||
|
ALOGE("%s: No corresponding channel (ch_id = %d) exist, return here",
|
||
|
__func__, recvd_frame->ch_id);
|
||
|
return BAD_VALUE;
|
||
|
}
|
||
|
|
||
|
// find snapshot frame and thumnail frame
|
||
|
for (int 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->isTypeOf(CAM_STREAM_TYPE_NON_ZSL_SNAPSHOT) ||
|
||
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
|
||
|
pStream->isOrignalTypeOf(CAM_STREAM_TYPE_NON_ZSL_SNAPSHOT)) {
|
||
|
main_stream = pStream;
|
||
|
main_frame = recvd_frame->bufs[i];
|
||
|
} else if (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_stream = pStream;
|
||
|
thumb_frame = recvd_frame->bufs[i];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if(NULL == main_frame){
|
||
|
ALOGE("%s : Main frame is NULL", __func__);
|
||
|
return BAD_VALUE;
|
||
|
}
|
||
|
|
||
|
QCameraMemory *memObj = (QCameraMemory *)main_frame->mem_info;
|
||
|
if (NULL == memObj) {
|
||
|
ALOGE("%s : Memeory Obj of main frame is NULL", __func__);
|
||
|
return NO_MEMORY;
|
||
|
}
|
||
|
|
||
|
// dump snapshot frame if enabled
|
||
|
m_parent->dumpFrameToFile(main_frame->buffer, main_frame->frame_len,
|
||
|
main_frame->frame_idx, QCAMERA_DUMP_FRM_SNAPSHOT);
|
||
|
|
||
|
// 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 = 1;
|
||
|
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 (thumb_frame != NULL) {
|
||
|
// dump thumbnail frame if enabled
|
||
|
m_parent->dumpFrameToFile(thumb_frame->buffer, thumb_frame->frame_len,
|
||
|
thumb_frame->frame_idx, QCAMERA_DUMP_FRM_THUMBNAIL);
|
||
|
}
|
||
|
|
||
|
if (mJpegClientHandle <= 0) {
|
||
|
ALOGE("%s: Error: bug here, mJpegClientHandle is 0", __func__);
|
||
|
return UNKNOWN_ERROR;
|
||
|
}
|
||
|
|
||
|
if (needNewSess) {
|
||
|
// create jpeg encoding session
|
||
|
mm_jpeg_encode_params_t encodeParam;
|
||
|
memset(&encodeParam, 0, sizeof(mm_jpeg_encode_params_t));
|
||
|
getJpegEncodingConfig(encodeParam, main_stream, thumb_stream);
|
||
|
ALOGD("[KPI Perf] %s : call jpeg create_session", __func__);
|
||
|
ret = mJpegHandle.create_session(mJpegClientHandle, &encodeParam, &mJpegSessionId);
|
||
|
if (ret != NO_ERROR) {
|
||
|
ALOGE("%s: error creating a new jpeg encoding session", __func__);
|
||
|
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 = main_frame->buf_idx;
|
||
|
jpg_job.encode_job.dst_index = 0;
|
||
|
|
||
|
cam_rect_t crop;
|
||
|
memset(&crop, 0, sizeof(cam_rect_t));
|
||
|
main_stream->getCropInfo(crop);
|
||
|
|
||
|
cam_dimension_t src_dim;
|
||
|
memset(&src_dim, 0, sizeof(cam_dimension_t));
|
||
|
main_stream->getFrameDimension(src_dim);
|
||
|
|
||
|
// main dim
|
||
|
jpg_job.encode_job.main_dim.src_dim = src_dim;
|
||
|
jpg_job.encode_job.main_dim.dst_dim = src_dim;
|
||
|
jpg_job.encode_job.main_dim.crop = crop;
|
||
|
|
||
|
// thumbnail dim
|
||
|
if (m_bThumbnailNeeded == TRUE) {
|
||
|
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;
|
||
|
}
|
||
|
memset(&crop, 0, sizeof(cam_rect_t));
|
||
|
thumb_stream->getCropInfo(crop);
|
||
|
memset(&src_dim, 0, sizeof(cam_dimension_t));
|
||
|
thumb_stream->getFrameDimension(src_dim);
|
||
|
jpg_job.encode_job.thumb_dim.src_dim = src_dim;
|
||
|
m_parent->getThumbnailSize(jpg_job.encode_job.thumb_dim.dst_dim);
|
||
|
int rotation = m_parent->getJpegRotation();
|
||
|
if (rotation == 90 || rotation ==270) {
|
||
|
// swap dimension if rotation is 90 or 270
|
||
|
int32_t temp = jpg_job.encode_job.thumb_dim.dst_dim.height;
|
||
|
jpg_job.encode_job.thumb_dim.dst_dim.height =
|
||
|
jpg_job.encode_job.thumb_dim.dst_dim.width;
|
||
|
jpg_job.encode_job.thumb_dim.dst_dim.width = temp;
|
||
|
}
|
||
|
jpg_job.encode_job.thumb_dim.crop = crop;
|
||
|
jpg_job.encode_job.thumb_index = thumb_frame->buf_idx;
|
||
|
}
|
||
|
|
||
|
// set rotation only when no online rotation or offline pp rotation is done before
|
||
|
if (!m_parent->needRotationReprocess()) {
|
||
|
jpg_job.encode_job.rotation = m_parent->getJpegRotation();
|
||
|
}
|
||
|
ALOGV("%s: jpeg rotation is set to %d", __func__, jpg_job.encode_job.rotation);
|
||
|
|
||
|
// find meta data frame
|
||
|
mm_camera_buf_def_t *meta_frame = NULL;
|
||
|
for (int i = 0; i < jpeg_job_data->src_frame->num_bufs; i++) {
|
||
|
// look through input superbuf
|
||
|
if (jpeg_job_data->src_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
||
|
meta_frame = jpeg_job_data->src_frame->bufs[i];
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if (meta_frame == NULL && jpeg_job_data->src_reproc_frame != NULL) {
|
||
|
// look through reprocess source superbuf
|
||
|
for (int i = 0; i < jpeg_job_data->src_reproc_frame->num_bufs; i++) {
|
||
|
if (jpeg_job_data->src_reproc_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
||
|
meta_frame = jpeg_job_data->src_reproc_frame->bufs[i];
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (meta_frame != NULL) {
|
||
|
// fill in meta data frame ptr
|
||
|
jpg_job.encode_job.p_metadata_v1 = (cam_metadata_info_t *)meta_frame->buffer;
|
||
|
}
|
||
|
|
||
|
ALOGD("[KPI Perf] %s : call jpeg start_job", __func__);
|
||
|
ret = mJpegHandle.start_job(&jpg_job, &jobId);
|
||
|
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;
|
||
|
|
||
|
mm_camera_buf_def_t *frame = NULL;
|
||
|
for ( int i= 0 ; i < recvd_frame->num_bufs ; i++ ) {
|
||
|
if ( recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_SNAPSHOT ||
|
||
|
recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_NON_ZSL_SNAPSHOT ||
|
||
|
recvd_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_RAW ) {
|
||
|
frame = recvd_frame->bufs[i];
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if ( NULL == frame ) {
|
||
|
ALOGE("%s: No valid raw buffer", __func__);
|
||
|
return BAD_VALUE;
|
||
|
}
|
||
|
|
||
|
QCameraMemory *rawMemObj = (QCameraMemory *)frame->mem_info;
|
||
|
camera_memory_t *raw_mem = NULL;
|
||
|
|
||
|
if (rawMemObj != NULL) {
|
||
|
raw_mem = rawMemObj->getMemory(frame->buf_idx, false);
|
||
|
}
|
||
|
|
||
|
if (NULL != rawMemObj && NULL != raw_mem) {
|
||
|
// dump frame into file
|
||
|
m_parent->dumpFrameToFile(frame->buffer, frame->frame_len,
|
||
|
frame->frame_idx, QCAMERA_DUMP_FRM_RAW);
|
||
|
|
||
|
// 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));
|
||
|
release_data.frame = recvd_frame;
|
||
|
sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
|
||
|
raw_mem,
|
||
|
0,
|
||
|
NULL,
|
||
|
&release_data);
|
||
|
}
|
||
|
} else {
|
||
|
ALOGE("%s: Cannot get raw mem", __func__);
|
||
|
rc = UNKNOWN_ERROR;
|
||
|
}
|
||
|
|
||
|
return rc;
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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;
|
||
|
uint8_t needNewSess = TRUE;
|
||
|
QCameraPostProcessor *pme = (QCameraPostProcessor *)data;
|
||
|
QCameraCmdThread *cmdThread = &pme->m_dataProcTh;
|
||
|
|
||
|
ALOGD("%s: E", __func__);
|
||
|
do {
|
||
|
do {
|
||
|
ret = cam_sem_wait(&cmdThread->cmd_sem);
|
||
|
if (ret != 0 && errno != EINVAL) {
|
||
|
ALOGE("%s: cam_sem_wait error (%s)",
|
||
|
__func__, 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:
|
||
|
ALOGD("%s: start data proc", __func__);
|
||
|
is_active = TRUE;
|
||
|
needNewSess = TRUE;
|
||
|
break;
|
||
|
case CAMERA_CMD_TYPE_STOP_DATA_PROC:
|
||
|
{
|
||
|
ALOGD("%s: stop data proc", __func__);
|
||
|
is_active = FALSE;
|
||
|
|
||
|
// 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
|
||
|
if (pme->m_pJpegOutputMem != NULL) {
|
||
|
pme->m_pJpegOutputMem->deallocate();
|
||
|
delete pme->m_pJpegOutputMem;
|
||
|
pme->m_pJpegOutputMem = NULL;
|
||
|
}
|
||
|
if (pme->m_pJpegExifObj != NULL) {
|
||
|
delete pme->m_pJpegExifObj;
|
||
|
pme->m_pJpegExifObj = NULL;
|
||
|
}
|
||
|
needNewSess = TRUE;
|
||
|
|
||
|
// stop reproc channel if exists
|
||
|
if (pme->m_pReprocChannel != NULL) {
|
||
|
pme->m_pReprocChannel->stop();
|
||
|
delete pme->m_pReprocChannel;
|
||
|
pme->m_pReprocChannel = 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);
|
||
|
}
|
||
|
break;
|
||
|
case CAMERA_CMD_TYPE_DO_NEXT_JOB:
|
||
|
{
|
||
|
ALOGD("%s: Do next job, active is %d", __func__, is_active);
|
||
|
if (is_active == TRUE) {
|
||
|
// check if there is any ongoing jpeg jobs
|
||
|
if (pme->m_ongoingJpegQ.isEmpty()) {
|
||
|
// no ongoing jpeg job, we are fine to send jpeg encoding job
|
||
|
qcamera_jpeg_data_t *jpeg_job =
|
||
|
(qcamera_jpeg_data_t *)pme->m_inputJpegQ.dequeue();
|
||
|
|
||
|
if (NULL != jpeg_job) {
|
||
|
//play shutter sound
|
||
|
pme->m_parent->playShutter();
|
||
|
|
||
|
// add into ongoing jpeg job Q
|
||
|
pme->m_ongoingJpegQ.enqueue((void *)jpeg_job);
|
||
|
ret = pme->encodeData(jpeg_job, needNewSess);
|
||
|
if (NO_ERROR != ret) {
|
||
|
// dequeue the last one
|
||
|
pme->m_ongoingJpegQ.dequeue(false);
|
||
|
|
||
|
pme->releaseJpegJobData(jpeg_job);
|
||
|
free(jpeg_job);
|
||
|
pme->sendEvtNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// 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);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
mm_camera_super_buf_t *pp_frame =
|
||
|
(mm_camera_super_buf_t *)pme->m_inputPPQ.dequeue();
|
||
|
if (NULL != pp_frame) {
|
||
|
qcamera_pp_data_t *pp_job =
|
||
|
(qcamera_pp_data_t *)malloc(sizeof(qcamera_pp_data_t));
|
||
|
if (pp_job != NULL) {
|
||
|
memset(pp_job, 0, sizeof(qcamera_pp_data_t));
|
||
|
if (pme->m_pReprocChannel != NULL) {
|
||
|
// add into ongoing PP job Q
|
||
|
pp_job->src_frame = pp_frame;
|
||
|
pme->m_ongoingPPQ.enqueue((void *)pp_job);
|
||
|
ret = pme->m_pReprocChannel->doReprocess(pp_frame);
|
||
|
if (NO_ERROR != ret) {
|
||
|
// remove from ongoing PP job Q
|
||
|
pme->m_ongoingPPQ.dequeue(false);
|
||
|
}
|
||
|
} else {
|
||
|
ALOGE("%s: Reprocess channel is NULL", __func__);
|
||
|
ret = -1;
|
||
|
}
|
||
|
} else {
|
||
|
ALOGE("%s: no mem for qcamera_pp_data_t", __func__);
|
||
|
ret = -1;
|
||
|
}
|
||
|
|
||
|
if (0 != ret) {
|
||
|
// free pp_job
|
||
|
if (pp_job != NULL) {
|
||
|
free(pp_job);
|
||
|
}
|
||
|
// free frame
|
||
|
if (pp_frame != NULL) {
|
||
|
pme->releaseSuperBuf(pp_frame);
|
||
|
free(pp_frame);
|
||
|
}
|
||
|
// send error notify
|
||
|
pme->sendEvtNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
|
||
|
}
|
||
|
}
|
||
|
} 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);
|
||
|
}
|
||
|
super_buf = (mm_camera_super_buf_t *)pme->m_inputPPQ.dequeue();
|
||
|
if (NULL != super_buf) {
|
||
|
pme->releaseSuperBuf(super_buf);
|
||
|
free(super_buf);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
case CAMERA_CMD_TYPE_EXIT:
|
||
|
running = 0;
|
||
|
break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
} while (running);
|
||
|
ALOGD("%s: X", __func__);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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;
|
||
|
return NO_ERROR;
|
||
|
}
|
||
|
|
||
|
/*===========================================================================
|
||
|
* 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) {
|
||
|
ALOGE("%s: Number of entries exceeded limit", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for byte array", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for ascii string", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for short array", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for long array", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for rational array", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for undefined array", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for signed long array", __func__);
|
||
|
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) {
|
||
|
ALOGE("%s: No memory for signed rational array", __func__);
|
||
|
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
|