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.
335 lines
10 KiB
335 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
|