You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
334 lines
10 KiB
334 lines
10 KiB
/* Copyright (c) 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 "QCameraHALPP" |
|
|
|
// Camera dependencies |
|
#include <sys/stat.h> |
|
#include "QCameraTrace.h" |
|
#include "QCameraHALPP.h" |
|
#include "QCameraQueue.h" |
|
extern "C" { |
|
#include "mm_camera_dbg.h" |
|
} |
|
|
|
namespace qcamera { |
|
|
|
/*=========================================================================== |
|
* FUNCTION : QCameraHALPP |
|
* |
|
* DESCRIPTION: constructor of QCameraHALPP. |
|
* |
|
* PARAMETERS : None |
|
* |
|
* RETURN : None |
|
*==========================================================================*/ |
|
QCameraHALPP::QCameraHALPP() |
|
: m_iuputQ(releaseInputDataCb, this), |
|
m_outgoingQ(releaseOngoingDataCb, this), |
|
m_halPPBufNotifyCB(NULL), |
|
m_halPPGetOutputCB(NULL), |
|
m_pQCameraPostProc(NULL) |
|
{ |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : ~QCameraHALPP |
|
* |
|
* DESCRIPTION: destructor of QCameraHALPP. |
|
* |
|
* PARAMETERS : None |
|
* |
|
* RETURN : None |
|
*==========================================================================*/ |
|
QCameraHALPP::~QCameraHALPP() |
|
{ |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : init |
|
* |
|
* DESCRIPTION: initialization of QCameraHALPP |
|
* |
|
* PARAMETERS : |
|
* @bufNotifyCb : call back function after HALPP process done and return frame |
|
* @getOutputCb : call back function to request output buffer |
|
* @pUserData : Parent of HALPP, i.e. QCameraPostProc |
|
* |
|
* RETURN : int32_t type of status |
|
* NO_ERROR -- success |
|
* none-zero failure code |
|
*==========================================================================*/ |
|
int32_t QCameraHALPP::init(halPPBufNotify bufNotifyCb, halPPGetOutput getOutputCb, void *pUserData) |
|
{ |
|
int32_t rc = NO_ERROR; |
|
// connect HALPP call back function |
|
m_halPPBufNotifyCB = bufNotifyCb; |
|
m_halPPGetOutputCB = getOutputCb; |
|
m_pQCameraPostProc = (QCameraPostProcessor*)pUserData; |
|
return rc; |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : deinit |
|
* |
|
* DESCRIPTION: de-initialization of QCameraHALPP |
|
* |
|
* PARAMETERS : |
|
* |
|
* RETURN : int32_t type of status |
|
* NO_ERROR -- success |
|
* none-zero failure code |
|
*==========================================================================*/ |
|
int32_t QCameraHALPP::deinit() |
|
{ |
|
int32_t rc = NO_ERROR; |
|
m_halPPBufNotifyCB = NULL; |
|
m_halPPGetOutputCB = NULL; |
|
m_pQCameraPostProc = NULL; |
|
return rc; |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : start |
|
* |
|
* DESCRIPTION: starting QCameraHALPP |
|
* |
|
* PARAMETERS : |
|
* |
|
* RETURN : int32_t type of status |
|
* NO_ERROR -- success |
|
* none-zero failure code |
|
*==========================================================================*/ |
|
int32_t QCameraHALPP::start() |
|
{ |
|
int32_t rc = NO_ERROR; |
|
LOGD("E"); |
|
|
|
LOGD("X"); |
|
return rc; |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : stop |
|
* |
|
* DESCRIPTION: stop QCameraHALPP |
|
* |
|
* PARAMETERS : |
|
* |
|
* RETURN : int32_t type of status |
|
* NO_ERROR -- success |
|
* none-zero failure code |
|
*==========================================================================*/ |
|
int32_t QCameraHALPP::stop() |
|
{ |
|
int32_t rc = NO_ERROR; |
|
LOGD("E"); |
|
|
|
LOGD("X"); |
|
return rc; |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : flushQ |
|
* |
|
* DESCRIPTION: flush m_iuputQ and m_outgoingQ. |
|
* |
|
* PARAMETERS : None |
|
* |
|
* RETURN : None |
|
*==========================================================================*/ |
|
int32_t QCameraHALPP::flushQ() |
|
{ |
|
int32_t rc = NO_ERROR; |
|
m_iuputQ.flush(); |
|
m_outgoingQ.flush(); |
|
return rc; |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : initQ |
|
* |
|
* DESCRIPTION: init m_iuputQ and m_outgoingQ. |
|
* |
|
* PARAMETERS : None |
|
* |
|
* RETURN : None |
|
*==========================================================================*/ |
|
int32_t QCameraHALPP::initQ() |
|
{ |
|
int32_t rc = NO_ERROR; |
|
m_iuputQ.init(); |
|
m_outgoingQ.init(); |
|
return rc; |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : getFrameVector |
|
* |
|
* DESCRIPTION: get vector of input frames from map |
|
* |
|
* PARAMETERS : |
|
* @frameIndex : frame index (key of the map) |
|
* |
|
* RETURN : vector pointer |
|
*==========================================================================*/ |
|
std::vector<qcamera_hal_pp_data_t*>* |
|
QCameraHALPP::getFrameVector(uint32_t frameIndex) |
|
{ |
|
std::vector<qcamera_hal_pp_data_t*> *pVector = NULL; |
|
// Search vector of input frames in frame map |
|
if (m_frameMap.find(frameIndex) != m_frameMap.end()) { |
|
pVector = m_frameMap[frameIndex]; |
|
} |
|
return pVector; |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : releaseData |
|
* |
|
* DESCRIPTION: release buffer in qcamera_hal_pp_data_t |
|
* |
|
* PARAMETERS : |
|
* @pData : hal pp data |
|
* |
|
* RETURN : None |
|
*==========================================================================*/ |
|
void QCameraHALPP::releaseData(qcamera_hal_pp_data_t *pData) |
|
{ |
|
if (pData) { |
|
if (pData->src_reproc_frame) { |
|
if (!pData->reproc_frame_release) { |
|
m_pQCameraPostProc->releaseSuperBuf(pData->src_reproc_frame); |
|
} |
|
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_pQCameraPostProc->releaseSuperBuf(frame); |
|
} |
|
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 : releaseOngoingDataCb |
|
* |
|
* DESCRIPTION: callback function to release ongoing data node |
|
* |
|
* PARAMETERS : |
|
* @pData : ptr to ongoing job data |
|
* @pUserData : user data ptr (QCameraHALPP) |
|
* |
|
* RETURN : None |
|
*==========================================================================*/ |
|
void QCameraHALPP::releaseOngoingDataCb(void *pData, void *pUserData) |
|
{ |
|
if (pUserData != NULL && pData != NULL) { |
|
QCameraHALPP *pme = (QCameraHALPP *)pUserData; |
|
pme->releaseData((qcamera_hal_pp_data_t*)pData); |
|
} |
|
} |
|
|
|
/*=========================================================================== |
|
* FUNCTION : releaseInputDataCb |
|
* |
|
* DESCRIPTION: callback function to release input data node |
|
* |
|
* PARAMETERS : |
|
* @pData : ptr to input job data |
|
* @pUserData : user data ptr (QCameraHALPP) |
|
* |
|
* RETURN : None |
|
*==========================================================================*/ |
|
void QCameraHALPP::releaseInputDataCb(void *pData, void *pUserData) |
|
{ |
|
if (pUserData != NULL && pData != NULL) { |
|
QCameraHALPP *pme = (QCameraHALPP *)pUserData; |
|
// what enqueued to the input queue is just the frame index |
|
// we need to use hash map to find the vector of frames and release the buffers |
|
uint32_t *pFrameIndex = (uint32_t *)pData; |
|
uint32_t frameIndex = *pFrameIndex; |
|
std::vector<qcamera_hal_pp_data_t*> *pVector = pme->getFrameVector(frameIndex); |
|
if (pVector != NULL) { |
|
for (size_t i = 0; i < pVector->size(); i++) { |
|
if (pVector->at(i) != NULL) { |
|
pme->releaseData(pVector->at(i)); |
|
} |
|
} |
|
delete pVector; |
|
pVector = NULL; |
|
} |
|
delete pFrameIndex; |
|
pFrameIndex = NULL; |
|
} |
|
} |
|
|
|
void QCameraHALPP::dumpYUVtoFile(const uint8_t* pBuf, const char *name, ssize_t buf_len) |
|
{ |
|
LOGD("E."); |
|
|
|
int file_fd = open(name, O_RDWR | O_CREAT, 0777); |
|
if (file_fd > 0) { |
|
fchmod(file_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); |
|
ssize_t writen_bytes = 0; |
|
writen_bytes = write(file_fd, pBuf, buf_len); |
|
close(file_fd); |
|
LOGD("dump output frame to file: %s, size:%d", name, buf_len); |
|
} |
|
|
|
LOGD("X."); |
|
} |
|
|
|
} // namespace qcamera
|
|
|