641 lines
21 KiB
C++
641 lines
21 KiB
C++
/* Copyright (c) 2017, 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 "QCameraHALPPManager"
|
|
|
|
#include "QCameraPprocManager.h"
|
|
#include "QCameraHALPP.h"
|
|
#include "QCameraDualFOVPP.h"
|
|
#include "QCameraBokeh.h"
|
|
#include "QCameraClearSight.h"
|
|
|
|
using namespace android;
|
|
|
|
namespace qcamera {
|
|
|
|
QCameraHALPPManager* QCameraHALPPManager::s_pInstance = NULL;
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCameraHALPPManager
|
|
*
|
|
* DESCRIPTION: constructor of QCameraHALPPManager.
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraHALPPManager::QCameraHALPPManager()
|
|
: m_inputQ(releaseDataCb, this),
|
|
//m_outgoingQ(releaseDataCb, this),
|
|
m_pPprocModule(NULL),
|
|
m_pprocType(CAM_HAL_PP_TYPE_NONE),
|
|
m_bInited(FALSE),
|
|
m_bStarted(FALSE),
|
|
m_halPPBufNotifyCB(NULL),
|
|
m_halPPReleaseBufCB(NULL)
|
|
{
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCameraHALPPManager
|
|
*
|
|
* DESCRIPTION: destructor of QCameraHALPPManager.
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraHALPPManager::~QCameraHALPPManager()
|
|
{
|
|
if (m_pPprocModule) {
|
|
delete m_pPprocModule;
|
|
m_pPprocModule = NULL;
|
|
}
|
|
}
|
|
|
|
void QCameraHALPPManager::release() {
|
|
Mutex::Autolock lock(mLock);
|
|
if (s_pInstance) {
|
|
delete s_pInstance;
|
|
s_pInstance = NULL;
|
|
}
|
|
}
|
|
|
|
QCameraHALPPManager* QCameraHALPPManager::getInstance() {
|
|
if (!s_pInstance) {
|
|
s_pInstance = new QCameraHALPPManager();
|
|
}
|
|
return s_pInstance;
|
|
}
|
|
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : init
|
|
*
|
|
* DESCRIPTION: initialization of HAL PProc manager
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraHALPPManager::init(
|
|
cam_hal_pp_type_t type,
|
|
halPPBufNotify bufNotifyCb,
|
|
halPPReleaseSuperbuf releaseBufCb,
|
|
void *pStaticParam) {
|
|
int32_t rc = NO_ERROR;
|
|
|
|
if (m_bInited == TRUE) {
|
|
return NO_ERROR;
|
|
}
|
|
LOGH("E halppType: %d", type);
|
|
m_pprocType = type;
|
|
m_halPPBufNotifyCB = bufNotifyCb;
|
|
m_halPPReleaseBufCB = releaseBufCb;
|
|
// Init the HAL Pproc module
|
|
switch (m_pprocType) {
|
|
case CAM_HAL_PP_TYPE_DUAL_FOV:
|
|
m_pPprocModule = new QCameraDualFOVPP();
|
|
break;
|
|
case CAM_HAL_PP_TYPE_BOKEH:
|
|
m_pPprocModule = new QCameraBokeh();
|
|
break;
|
|
case CAM_HAL_PP_TYPE_CLEARSIGHT:
|
|
m_pPprocModule = new QCameraClearSight();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (m_pPprocModule != NULL) {
|
|
rc = m_pPprocModule->init(
|
|
QCameraHALPPManager::processHalPPDataCB,
|
|
QCameraHALPPManager::getHalPPOutputBufferCB,
|
|
this,
|
|
pStaticParam);
|
|
if (rc != NO_ERROR) {
|
|
LOGE("HAL PP type %d init failed, rc = %d", m_pprocType, rc);
|
|
delete m_pPprocModule;
|
|
m_pPprocModule = NULL;
|
|
return rc;
|
|
}
|
|
// Launch the Pproc thread
|
|
m_pprocTh.launch(dataProcessRoutine, this);
|
|
m_bInited = TRUE;
|
|
LOGH("X");
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : deinit
|
|
*
|
|
* DESCRIPTION: deinitialization of HAL PProc manager
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraHALPPManager::deinit() {
|
|
int32_t rc = NO_ERROR;
|
|
Mutex::Autolock lock(mLock);
|
|
LOGH("E");
|
|
if (m_bInited == TRUE) {
|
|
if (m_pPprocModule) {
|
|
m_pPprocModule->deinit();
|
|
delete m_pPprocModule;
|
|
m_pPprocModule = NULL;
|
|
}
|
|
m_pprocType = CAM_HAL_PP_TYPE_NONE;
|
|
m_halPPBufNotifyCB = NULL;
|
|
m_pprocTh.exit();
|
|
}
|
|
m_bInited = FALSE;
|
|
LOGH("X");
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : start
|
|
*
|
|
* DESCRIPTION: start HAL PProc Manager. Data process thread will start.
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : HAL PP module will start
|
|
*==========================================================================*/
|
|
int32_t QCameraHALPPManager::start()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
Mutex::Autolock lock(mLock);
|
|
if (m_bStarted) return NO_ERROR;
|
|
LOGH("E");
|
|
if (m_bInited) {
|
|
m_pprocTh.sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, TRUE, FALSE);
|
|
m_bStarted = true;
|
|
} else {
|
|
m_bStarted = false;
|
|
return -EACCES;
|
|
}
|
|
LOGH("X");
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : stop
|
|
*
|
|
* DESCRIPTION: stop HAL PProc Manager. Data process thread will stop.
|
|
*
|
|
* PARAMETERS :
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*
|
|
* NOTE : HAL PP module will stop
|
|
*==========================================================================*/
|
|
int32_t QCameraHALPPManager::stop()
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
Mutex::Autolock lock(mLock);
|
|
if (!m_bStarted) return NO_ERROR;
|
|
LOGH("E");
|
|
if (m_bStarted) {
|
|
m_pprocTh.sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, TRUE, TRUE);
|
|
m_bStarted = false;
|
|
}
|
|
LOGH("X");
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : feedInput
|
|
*
|
|
* DESCRIPTION: function to feed input data.
|
|
*
|
|
* PARAMETERS :
|
|
* @pInput : ptr to input data
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraHALPPManager::feedInput(qcamera_hal_pp_data_t *pInput)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
Mutex::Autolock lock(mLock);
|
|
LOGD("E");
|
|
if (!m_bStarted) {
|
|
LOGE("X NOT SUPPORTED");
|
|
return -EACCES;
|
|
}
|
|
// enqueue HAL PProc frame to input queue
|
|
if (false == m_inputQ.enqueue((void *)pInput)) {
|
|
LOGW("Input Q is not active!!!");
|
|
releaseData(pInput);
|
|
free(pInput);
|
|
}
|
|
// wake up data proc thread
|
|
m_pprocTh.sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
|
|
LOGD("X");
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : feedOutput
|
|
*
|
|
* DESCRIPTION: function to feed output buffer.
|
|
*
|
|
* PARAMETERS :
|
|
* @pOutputData : ptr to output data buffer
|
|
*
|
|
* RETURN : int32_t type of status
|
|
* NO_ERROR -- success
|
|
* none-zero failure code
|
|
*==========================================================================*/
|
|
int32_t QCameraHALPPManager::feedOutput(qcamera_hal_pp_data_t *pOutputData)
|
|
{
|
|
int32_t rc = NO_ERROR;
|
|
LOGD("E");
|
|
if (!m_bStarted) {
|
|
LOGE("X NOT SUPPORTED");
|
|
return -EACCES;
|
|
}
|
|
m_pPprocModule->feedOutput(pOutputData);
|
|
LOGD("X");
|
|
return rc;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseDataCb
|
|
*
|
|
* DESCRIPTION: callback function to release data
|
|
*
|
|
* PARAMETERS :
|
|
* @pData : ptr to ongoing job data
|
|
* @pUserData : user data ptr (QCameraHALPPManager)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraHALPPManager::releaseDataCb(void *pData, void *pUserData)
|
|
{
|
|
LOGH("E");
|
|
if (pUserData != NULL && pData != NULL) {
|
|
QCameraHALPPManager *pme = (QCameraHALPPManager *)pUserData;
|
|
pme->releaseData((qcamera_hal_pp_data_t*)pData);
|
|
}
|
|
LOGH("X");
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseData
|
|
*
|
|
* DESCRIPTION: release buffer in qcamera_hal_pp_data_t
|
|
*
|
|
* PARAMETERS :
|
|
* @pData : hal pp data
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraHALPPManager::releaseData(qcamera_hal_pp_data_t *pData)
|
|
{
|
|
if (pData) {
|
|
if (pData->src_reproc_frame) {
|
|
if (!pData->reproc_frame_release) {
|
|
m_halPPReleaseBufCB(pData->src_reproc_frame, pData->pUserData);
|
|
}
|
|
free(pData->src_reproc_frame);
|
|
pData->src_reproc_frame = NULL;
|
|
}
|
|
mm_camera_super_buf_t *frame = pData->frame;
|
|
if (frame) {
|
|
if (pData->halPPAllocatedBuf && pData->bufs) {
|
|
free(pData->bufs);
|
|
} else {
|
|
m_halPPReleaseBufCB(frame, pData->pUserData);
|
|
}
|
|
free(frame);
|
|
frame = NULL;
|
|
}
|
|
if (pData->snapshot_heap) {
|
|
pData->snapshot_heap->deallocate();
|
|
delete pData->snapshot_heap;
|
|
pData->snapshot_heap = NULL;
|
|
}
|
|
if (pData->metadata_heap) {
|
|
pData->metadata_heap->deallocate();
|
|
delete pData->metadata_heap;
|
|
pData->metadata_heap = NULL;
|
|
}
|
|
if (NULL != pData->src_reproc_bufs) {
|
|
delete [] pData->src_reproc_bufs;
|
|
}
|
|
if ((pData->offline_reproc_buf != NULL)
|
|
&& (pData->offline_buffer)) {
|
|
free(pData->offline_reproc_buf);
|
|
pData->offline_reproc_buf = NULL;
|
|
pData->offline_buffer = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getSnapshotBuf
|
|
*
|
|
* DESCRIPTION: function to get snapshot buf def and the stream from frame
|
|
* PARAMETERS :
|
|
* @pData : input frame super buffer
|
|
* @pSnapshotStream : stream of snapshot that found
|
|
* RETURN : snapshot buf def
|
|
*==========================================================================*/
|
|
mm_camera_buf_def_t* QCameraHALPPManager::getSnapshotBuf(qcamera_hal_pp_data_t* pData)
|
|
{
|
|
LOGH("E");
|
|
mm_camera_buf_def_t *pBufDef = NULL;
|
|
if (pData == NULL) {
|
|
LOGE("Cannot find input frame super buffer");
|
|
return pBufDef;
|
|
}
|
|
mm_camera_super_buf_t *pFrame = pData->frame;
|
|
// Search for input snapshot frame buf
|
|
for (uint32_t i = 0; i < pFrame->num_bufs; i++) {
|
|
if (pFrame->bufs[i]->stream_type == CAM_STREAM_TYPE_SNAPSHOT ||
|
|
pFrame->bufs[i]->stream_type == CAM_STREAM_TYPE_OFFLINE_PROC) {
|
|
pBufDef = pFrame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
LOGH("X");
|
|
return pBufDef;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getMetadataBuf
|
|
*
|
|
* DESCRIPTION: function to get metadata buf def and the stream from frame
|
|
* PARAMETERS :
|
|
* @pData : input frame super buffer
|
|
* @pMetadataStream : stream of metadata that found
|
|
* RETURN : metadata buf def
|
|
*==========================================================================*/
|
|
mm_camera_buf_def_t* QCameraHALPPManager::getMetadataBuf(qcamera_hal_pp_data_t *pData)
|
|
{
|
|
LOGH("E");
|
|
mm_camera_buf_def_t *pBufDef = NULL;
|
|
if ((pData == NULL) ||(pData->src_reproc_frame == NULL)) {
|
|
LOGE("Cannot find input frame super buffer");
|
|
return pBufDef;
|
|
}
|
|
|
|
if (pData->src_metadata != NULL) {
|
|
pBufDef = pData->src_metadata->bufs[0];
|
|
return pBufDef;
|
|
}
|
|
|
|
mm_camera_super_buf_t* pFrame = pData->frame;
|
|
LOGD("src_reproc_frame num_bufs = %d", pFrame->num_bufs);
|
|
|
|
for (uint32_t i = 0; i < pData->src_reproc_frame->num_bufs; i++) {
|
|
if (pData->src_reproc_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
pBufDef = pData->src_reproc_frame->bufs[i];
|
|
LOGD("find metadata stream and buf from src_reproc_frame");
|
|
break;
|
|
}
|
|
}
|
|
if (pBufDef == NULL) {
|
|
LOGD("frame num_bufs = %d", pFrame->num_bufs);
|
|
for (uint32_t i = 0; i < pFrame->num_bufs; i++) {
|
|
LOGD("bufs[%d] stream_type = %d", i, pFrame->bufs[i]->stream_type);
|
|
if (pFrame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
|
|
pBufDef = pFrame->bufs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGH("X");
|
|
return pBufDef;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : processHalPPDataCB
|
|
*
|
|
* DESCRIPTION: callback function to process frame after HAL PP block
|
|
*
|
|
* PARAMETERS :
|
|
* @pOutput : output after HAL PP processed
|
|
* @pUserData : user data ptr (QCameraHALPPManager)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraHALPPManager::processHalPPDataCB(qcamera_hal_pp_data_t *pOutput, void* pUserData)
|
|
{
|
|
LOGH("E");
|
|
QCameraHALPPManager *pme = (QCameraHALPPManager *)pUserData;
|
|
pme->m_halPPBufNotifyCB(pOutput, pOutput->pUserData);
|
|
LOGH("X");
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getHalPPOutputBufferCB
|
|
*
|
|
* DESCRIPTION: callback function to request output buffer
|
|
*
|
|
* PARAMETERS :
|
|
* @frameIndex : frameIndex needs to be appended in the output data
|
|
* @pUserData : user data ptr (QCameraHALPPManager)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraHALPPManager::getHalPPOutputBufferCB(uint32_t frameIndex, void* pUserData)
|
|
{
|
|
LOGH("E");
|
|
QCameraHALPPManager *pme = (QCameraHALPPManager *)pUserData;
|
|
pme->getHalPPOutputBuffer(frameIndex);
|
|
LOGH("X");
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getHalPPOutputBuffer
|
|
*
|
|
* DESCRIPTION: function to send HAL PP output buffer
|
|
* PARAMETERS :
|
|
* @frameIndex : frameIndex needs to be appended in the output data
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void QCameraHALPPManager::getHalPPOutputBuffer(uint32_t frameIndex)
|
|
{
|
|
LOGD("E. Allocate HAL PP Output buffer");
|
|
qcamera_hal_pp_data_t *output_data =
|
|
(qcamera_hal_pp_data_t*) malloc(sizeof(qcamera_hal_pp_data_t));
|
|
if (output_data == NULL) {
|
|
LOGE("No memory for qcamera_hal_pp_data_t output data");
|
|
return;
|
|
}
|
|
memset(output_data, 0, sizeof(qcamera_hal_pp_data_t));
|
|
mm_camera_super_buf_t* output_frame =
|
|
(mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
|
|
if (output_frame == NULL) {
|
|
LOGE("No memory for mm_camera_super_buf_t frame");
|
|
free(output_data);
|
|
return;
|
|
}
|
|
memset(output_frame, 0, sizeof(mm_camera_super_buf_t));
|
|
output_data->frame = output_frame;
|
|
output_data->bufs =
|
|
(mm_camera_buf_def_t *)malloc(HAL_PP_NUM_BUFS * sizeof(mm_camera_buf_def_t));
|
|
if (output_data->bufs == NULL) {
|
|
LOGE("No memory for output_data->bufs");
|
|
free(output_frame);
|
|
free(output_data);
|
|
return;
|
|
}
|
|
memset(output_data->bufs, 0, HAL_PP_NUM_BUFS * sizeof(mm_camera_buf_def_t));
|
|
output_data->halPPAllocatedBuf = true;
|
|
output_data->snapshot_heap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
|
|
if (output_data->snapshot_heap == NULL) {
|
|
LOGE("Unable to new heap memory obj for image buf");
|
|
free(output_frame);
|
|
free(output_data->bufs);
|
|
free(output_data);
|
|
return;
|
|
}
|
|
output_data->metadata_heap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
|
|
if (output_data->metadata_heap == NULL) {
|
|
LOGE("Unable to new heap memory obj for metadata buf");
|
|
delete output_data->snapshot_heap;
|
|
free(output_frame);
|
|
free(output_data->bufs);
|
|
free(output_data);
|
|
return;
|
|
}
|
|
|
|
output_data->frameIndex = frameIndex;
|
|
feedOutput(output_data);
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : dataProcessRoutine
|
|
*
|
|
* DESCRIPTION: data process routine that handles input data either from input
|
|
* PP Queue to do HAL post processing, or from outgoing PP Queue to
|
|
* send the final output frame back.
|
|
*
|
|
* PARAMETERS :
|
|
* @data : user data ptr (QCameraHALPPManager)
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
void *QCameraHALPPManager::dataProcessRoutine(void *pData)
|
|
{
|
|
int running = 1;
|
|
int ret;
|
|
uint8_t is_active = FALSE;
|
|
QCameraHALPPManager *pme = (QCameraHALPPManager *)pData;
|
|
QCameraCmdThread *cmdThread = &(pme->m_pprocTh);
|
|
cmdThread->setName("CAM_HALPProc");
|
|
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_inputQ.init();
|
|
//m_outgoingQ->init();
|
|
if (pme->m_pPprocModule != NULL) {
|
|
pme->m_pPprocModule->initQ();
|
|
}
|
|
// 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_inputQ.flush();
|
|
//m_outgoingQ->flush();
|
|
// flush m_halPP
|
|
if (pme->m_pPprocModule != NULL) {
|
|
pme->m_pPprocModule->stop();
|
|
pme->m_pPprocModule->flushQ();
|
|
}
|
|
// 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);
|
|
if (is_active == TRUE) {
|
|
// Feed Input buffer to PP module
|
|
qcamera_hal_pp_data_t* inputJob =
|
|
(qcamera_hal_pp_data_t*)pme->m_inputQ.dequeue();
|
|
// Process HAL PP data if ready
|
|
if (pme->m_pPprocModule != NULL) {
|
|
if(inputJob != NULL) {
|
|
ret = pme->m_pPprocModule->feedInput(inputJob);
|
|
if (ret != NO_ERROR) {
|
|
LOGE("Error feeding input to HAL PP!!");
|
|
}
|
|
}
|
|
pme->m_pPprocModule->process();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case CAMERA_CMD_TYPE_EXIT:
|
|
running = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} while (running);
|
|
LOGH("X");
|
|
return NULL;
|
|
}
|
|
|
|
}; // namespace qcamera
|
|
|
|
|