563 lines
22 KiB
C++
563 lines
22 KiB
C++
|
|
/*
|
|
* Copyright (C) 2017 Intel Corporation.
|
|
* Copyright (c) 2017, Fuzhou Rockchip Electronics Co., Ltd
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef HAL_ROCKCHIP_PSL_RKISP2_WORKERS_RKISP2PostProcessPipeline_H_
|
|
#define HAL_ROCKCHIP_PSL_RKISP2_WORKERS_RKISP2PostProcessPipeline_H_
|
|
|
|
#include <memory>
|
|
#include <Utils.h>
|
|
#include <vector>
|
|
#include <mutex>
|
|
#include <array>
|
|
#include <dlfcn.h>
|
|
#include <condition_variable>
|
|
#include "common/MessageThread.h"
|
|
#include "common/SharedItemPool.h"
|
|
#include "CameraBuffer.h"
|
|
#include "RKISP2ProcUnitSettings.h"
|
|
#include "tasks/RKISP2JpegEncodeTask.h"
|
|
#include "LogHelper.h"
|
|
#include "uvc_hal_types.h"
|
|
#include "RKISP2CameraHw.h"
|
|
#ifdef RK_EPTZ
|
|
#include "RKISP2DevImpl.h"
|
|
#endif
|
|
#include "RKISP2FecUnit.h"
|
|
|
|
namespace android {
|
|
namespace camera2 {
|
|
namespace rkisp2 {
|
|
|
|
class RKISP2PostProcessPipeline;
|
|
/* priority form high to low, and from common process to
|
|
* stream only
|
|
*/
|
|
#define MAX_COMMON_PROC_UNIT_SHIFT 16
|
|
#define MAX_STREAM_PROC_UNIT_SHIFT 32
|
|
enum PostProcessType {
|
|
/* common */
|
|
kPostProcessTypeComposingFileds = 1 << 0,
|
|
kPostProcessTypeFaceDetection = 1 << 1,
|
|
kPostProcessTypeSwLsc = 1 << 2,
|
|
kPostProcessTypeCropRotationScale = 1 << 3,
|
|
kPostprocessTypeUvnr = 1 << 4,
|
|
kPostProcessTypeDigitalZoom = 1 << 5,
|
|
kPostProcessTypeFec = 1 << 6,
|
|
kPostProcessTypeCommonMax = 1 << MAX_COMMON_PROC_UNIT_SHIFT,
|
|
/* stream only */
|
|
kPostProcessTypeScaleAndRotation = 1 << 17,
|
|
kPostProcessTypeJpegEncoder = 1 << 18,
|
|
kPostProcessTypeCopy = 1 << 19,
|
|
kPostProcessTypeUVC = 1 << 20,
|
|
kPostProcessTypeRaw = 1 << 21,
|
|
kPostProcessTypeDummy = 1 << 22,
|
|
kPostProcessTypeStreamMax = 1 << MAX_STREAM_PROC_UNIT_SHIFT,
|
|
};
|
|
|
|
#define NO_NEED_INTERNAL_BUFFER_PROCESS_TYPES \
|
|
(kPostProcessTypeFaceDetection | kPostProcessTypeCopy)
|
|
/*
|
|
* encapsulate the CameraBuffer so we can use SharedItemPool
|
|
* to manage the CameraBuffer
|
|
*/
|
|
struct PostProcBuffer {
|
|
public:
|
|
PostProcBuffer() : index(-1), cambuf(nullptr) {}
|
|
~PostProcBuffer() {}
|
|
static void reset(PostProcBuffer *me) {
|
|
me->cambuf = nullptr;
|
|
me->request = nullptr;
|
|
}
|
|
int index;
|
|
FrameInfo fmt;
|
|
std::shared_ptr<CameraBuffer> cambuf;
|
|
Camera3Request* request;
|
|
};
|
|
|
|
class PostProcBufferPools {
|
|
public:
|
|
PostProcBufferPools() : mPostProcItemsPool("PostProcBufPool"),
|
|
mBufferPoolSize(0) {}
|
|
virtual ~PostProcBufferPools() {}
|
|
status_t createBufferPools(RKISP2PostProcessPipeline* pl, const FrameInfo& outfmt, int numBufs);
|
|
status_t acquireItem(std::shared_ptr<PostProcBuffer> &procbuf);
|
|
std::shared_ptr<PostProcBuffer> acquireItem();
|
|
private:
|
|
RKISP2PostProcessPipeline* mPipeline;
|
|
SharedItemPool<PostProcBuffer> mPostProcItemsPool;
|
|
unsigned int mBufferPoolSize;
|
|
};
|
|
|
|
/*
|
|
* notify next post procss unit that the new filled
|
|
* buffer is ready. This acts as a buffer consumer.
|
|
*/
|
|
class RKISP2IPostProcessListener {
|
|
public:
|
|
RKISP2IPostProcessListener() {}
|
|
virtual ~RKISP2IPostProcessListener() {}
|
|
virtual status_t notifyNewFrame(const std::shared_ptr<PostProcBuffer>& buf,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings,
|
|
int err) = 0;
|
|
};
|
|
|
|
/*
|
|
* This is frame provider, and it will notify all listeners
|
|
* that new frame is ready.
|
|
*/
|
|
class IPostProcessSource {
|
|
public:
|
|
IPostProcessSource() {}
|
|
virtual ~IPostProcessSource() {}
|
|
virtual status_t attachListener(RKISP2IPostProcessListener* listener);
|
|
virtual status_t notifyListeners(const std::shared_ptr<PostProcBuffer>& buf,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings, int err);
|
|
protected:
|
|
std::mutex mListenersLock;
|
|
std::vector<RKISP2IPostProcessListener*> mListeners;
|
|
};
|
|
|
|
class IBufferDone {
|
|
public:
|
|
IBufferDone() {}
|
|
virtual ~IBufferDone() {}
|
|
virtual status_t bufferDone(const int64_t reqId);
|
|
};
|
|
|
|
/*
|
|
* some process units such as field composing need one
|
|
* more than input frames.
|
|
*/
|
|
#define STATUS_NEED_NEXT_INPUT_FRAME (-EAGAIN)
|
|
#define STATUS_FORWRAD_TO_NEXT_UNIT (1)
|
|
#define kDefaultAllocBufferNums (4)
|
|
/*
|
|
* Post process unit is a base class that is used to extend the
|
|
* frame propcess pipeline. A single process unit would do tasks
|
|
* such as digital zoom, jpeg encorder, GPU uvnr, GPU face detection,
|
|
* etc.
|
|
*/
|
|
class RKISP2PostProcessUnit : public RKISP2IPostProcessListener,
|
|
public IPostProcessSource,
|
|
public IMessageHandler {
|
|
public:
|
|
friend class RKISP2PostProcessPipeline;
|
|
/* describe where the processed frame data will be stored */
|
|
enum PostProcBufType {
|
|
kPostProcBufTypeInt, // stored to unit internal allocated buffer
|
|
kPostProcBufTypePre, // stored to previous unit provided buffer
|
|
kPostProcBufTypeExt // stored to external set buffer
|
|
};
|
|
|
|
explicit RKISP2PostProcessUnit(const char* name, int type, uint32_t buftype = kPostProcBufTypeInt,
|
|
RKISP2PostProcessPipeline* pl = nullptr);
|
|
virtual ~RKISP2PostProcessUnit();
|
|
virtual status_t prepare(const FrameInfo& outfmt, int bufNum = kDefaultAllocBufferNums);
|
|
virtual status_t start();
|
|
virtual status_t stop();
|
|
virtual status_t flush();
|
|
virtual status_t drain();
|
|
/*
|
|
* The processed frame result should be filled in output buffer
|
|
* instead of the internal allocated buffer in this process unit.
|
|
*/
|
|
status_t addOutputBuffer(std::shared_ptr<PostProcBuffer> buf);
|
|
/* bypass this process unit if disabled */
|
|
status_t setEnable(bool enable);
|
|
/* process frame in |notifyListener| instead of threadloop if sync is true */
|
|
status_t setProcessSync(bool sync);
|
|
protected:
|
|
/* overload IMessageHandler */
|
|
void messageThreadLoop(void);
|
|
/* overload RKISP2IPostProcessListener */
|
|
virtual status_t notifyNewFrame(const std::shared_ptr<PostProcBuffer>& buf,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings, int err);
|
|
|
|
/*
|
|
* If the process need more than one input frame, the overload
|
|
* should cache the PostProcBuffer shared_ptr, and release
|
|
* after use.
|
|
*/
|
|
virtual status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::shared_ptr<PostProcBuffer>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
|
|
virtual bool checkFmt(CameraBuffer* in, CameraBuffer* out);
|
|
typedef std::pair<std::shared_ptr<PostProcBuffer>, \
|
|
std::shared_ptr<RKISP2ProcUnitSettings>> ProcInfo;
|
|
|
|
std::vector<ProcInfo> mInBufferPool;
|
|
std::vector<std::shared_ptr<PostProcBuffer>> mOutBufferPool;
|
|
/*
|
|
* buffer pool owened by this process unit, and the buffers
|
|
* in this pool can be sent to next process unit to do the
|
|
* further process, and could be recycled automatically.
|
|
*/
|
|
std::unique_ptr<PostProcBufferPools> mInternalBufPool;
|
|
status_t allocCameraBuffer(const FrameInfo& outfmt, int bufNum);
|
|
void prepareProcess();
|
|
virtual status_t doProcess();
|
|
status_t relayToNextProcUnit(int err);
|
|
const char* mName;
|
|
uint32_t mBufType;
|
|
bool mEnable;
|
|
bool mSyncProcess;
|
|
bool mThreadRunning;
|
|
std::unique_ptr<MessageThread> mProcThread;
|
|
/* synchronize between api caller and work thread */
|
|
std::mutex mApiLock;
|
|
std::condition_variable mCondition;
|
|
/* enum PostProcessType */
|
|
int mProcessUnitType;
|
|
RKISP2PostProcessPipeline* mPipeline;
|
|
/*
|
|
* below members are only used in threadloop context when
|
|
* mSyncProcess is fales, and contrarily only in caller thread.
|
|
*/
|
|
std::shared_ptr<PostProcBuffer> mCurPostProcBufIn;
|
|
std::shared_ptr<RKISP2ProcUnitSettings> mCurProcSettings;
|
|
std::shared_ptr<PostProcBuffer> mCurPostProcBufOut;
|
|
#ifdef RK_EPTZ
|
|
sp<EptzThread> mEptzThread;
|
|
virtual status_t processEptzFrame(const std::shared_ptr<PostProcBuffer>& buf);
|
|
#endif
|
|
std::shared_ptr<RKISP2FecUnit> mFecUnit;
|
|
IBufferDone *mBufferDone;
|
|
|
|
private:
|
|
/*disable copy constructor and assignment*/
|
|
RKISP2PostProcessUnit(const RKISP2PostProcessUnit&);
|
|
RKISP2PostProcessUnit& operator=(const RKISP2PostProcessUnit&);
|
|
};
|
|
|
|
class RKISP2PostProcessUnitUVC : public RKISP2PostProcessUnit
|
|
{
|
|
public:
|
|
explicit RKISP2PostProcessUnitUVC(const char* name, int type, uint32_t buftype = kPostProcBufTypeExt, RKISP2PostProcessPipeline* pl = nullptr);
|
|
virtual ~RKISP2PostProcessUnitUVC();
|
|
virtual status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::shared_ptr<PostProcBuffer>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
virtual status_t prepare(const FrameInfo& outfmt, int bufNum = kDefaultAllocBufferNums);
|
|
private:
|
|
/*disable copy constructor and assignment*/
|
|
RKISP2PostProcessUnitUVC(const RKISP2PostProcessUnitUVC&);
|
|
RKISP2PostProcessUnitUVC& operator=(const RKISP2PostProcessUnitUVC&);
|
|
int uvcFrameW;
|
|
int uvcFrameH;
|
|
FrameInfo mOutFmtInfo;
|
|
int mBufNum;
|
|
uvc_vpu_ops_t *pUvc_vpu_ops;
|
|
uvc_proc_ops_t *pUvc_proc_ops;
|
|
};
|
|
|
|
class RKISP2PostProcessUnitJpegEnc : public RKISP2PostProcessUnit
|
|
{
|
|
public:
|
|
explicit RKISP2PostProcessUnitJpegEnc(const char* name, int type, uint32_t buftype = kPostProcBufTypeExt,
|
|
RKISP2PostProcessPipeline* pl = nullptr);
|
|
virtual ~RKISP2PostProcessUnitJpegEnc();
|
|
status_t notifyNewFrame(const std::shared_ptr<PostProcBuffer>& buf,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings,
|
|
int err);
|
|
virtual status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::shared_ptr<PostProcBuffer>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
virtual status_t prepare(const FrameInfo& outfmt, int bufNum = kDefaultAllocBufferNums);
|
|
private:
|
|
status_t convertJpeg(std::shared_ptr<CameraBuffer> buffer,
|
|
std::shared_ptr<CameraBuffer> jpegBuffer,
|
|
Camera3Request *request);
|
|
private:
|
|
std::unique_ptr<RKISP2JpegEncodeTask> mJpegTask;
|
|
/*disable copy constructor and assignment*/
|
|
RKISP2PostProcessUnitJpegEnc(const RKISP2PostProcessUnitJpegEnc&);
|
|
RKISP2PostProcessUnitJpegEnc& operator=(const RKISP2PostProcessUnitJpegEnc&);
|
|
};
|
|
|
|
class RKISP2PostProcessUnitRaw : public RKISP2PostProcessUnit
|
|
{
|
|
public:
|
|
explicit RKISP2PostProcessUnitRaw(const char* name, int type, uint32_t buftype = kPostProcBufTypeExt);
|
|
virtual ~RKISP2PostProcessUnitRaw();
|
|
virtual status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::shared_ptr<PostProcBuffer>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
private:
|
|
/*disable copy constructor and assignment*/
|
|
RKISP2PostProcessUnitRaw(const RKISP2PostProcessUnitRaw&);
|
|
RKISP2PostProcessUnitRaw& operator=(const RKISP2PostProcessUnitRaw&);
|
|
};
|
|
|
|
class RKISP2PostProcessUnitSwLsc : public RKISP2PostProcessUnit
|
|
{
|
|
public:
|
|
explicit RKISP2PostProcessUnitSwLsc(const char* name, int type, uint32_t buftype = kPostProcBufTypeExt,
|
|
RKISP2PostProcessPipeline* pl = nullptr);
|
|
virtual ~RKISP2PostProcessUnitSwLsc();
|
|
virtual status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::shared_ptr<PostProcBuffer>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
virtual status_t prepare(const FrameInfo& outfmt, int bufNum = kDefaultAllocBufferNums);
|
|
private:
|
|
typedef struct lsc_para
|
|
{
|
|
uint16_t sizex[8]; //width of 8 blocks
|
|
uint16_t sizey[8]; //heigth of 8 blocks
|
|
uint16_t gradx[8]; //pre-calculated factors of 8 blocks in horizontal direction
|
|
uint16_t grady[8]; ////pre-calculated factors of 8 blocks in vertical direction
|
|
uint16_t u16_coef_r[2][17][18]; // 2 table for r channel lens shade correction
|
|
uint16_t u16_coef_gr[2][17][18];// 2 table for gr channel lens shade correction
|
|
uint16_t u16_coef_gb[2][17][18];// 2 table for gb channel lens shade correction
|
|
uint16_t u16_coef_b[2][17][18];// 2 table for b channel lens shade correction
|
|
uint8_t lsc_en;
|
|
uint8_t table_sel; // lesns shade correction coef table set selection
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t *u32_coef_pic_gr;
|
|
} lsc_para_t;
|
|
|
|
static void calcu_coef(lsc_para_t const * plsc_a,
|
|
uint16_t u16_coef_blk[2][17][18],
|
|
uint32_t * pu32_coef_pic,
|
|
uint32_t u32_z_max,
|
|
uint32_t u32_y_max,
|
|
uint32_t u32_x_max);
|
|
static int lsc_config(void *para_v);
|
|
static int lsc(uint8_t *indata, uint16_t input_h_size,
|
|
uint16_t input_v_size,
|
|
uint8_t bayer_pat, lsc_para_t *lsc_para,
|
|
uint8_t *outdata, uint8_t c_dw_si);
|
|
private:
|
|
lsc_para_t mLscPara;
|
|
/*disable copy constructor and assignment*/
|
|
RKISP2PostProcessUnitSwLsc(const RKISP2PostProcessUnitSwLsc&);
|
|
RKISP2PostProcessUnitSwLsc& operator=(const RKISP2PostProcessUnitSwLsc&);
|
|
};
|
|
|
|
class RKISP2PostProcessUnitDigitalZoom : public RKISP2PostProcessUnit
|
|
{
|
|
public:
|
|
RKISP2PostProcessUnitDigitalZoom(const char* name, int type, int camid, uint32_t buftype = kPostProcBufTypeInt,
|
|
RKISP2PostProcessPipeline* pl = nullptr);
|
|
virtual ~RKISP2PostProcessUnitDigitalZoom();
|
|
virtual status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::shared_ptr<PostProcBuffer>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
private:
|
|
virtual bool checkFmt(CameraBuffer* in, CameraBuffer* out);
|
|
// cache active pixel array
|
|
CameraWindow mApa;
|
|
/*disable copy constructor and assignment*/
|
|
RKISP2PostProcessUnitDigitalZoom(const RKISP2PostProcessUnitDigitalZoom&);
|
|
RKISP2PostProcessUnitDigitalZoom& operator=(const RKISP2PostProcessUnitDigitalZoom&);
|
|
};
|
|
|
|
class RKISP2PostProcessUnitFec : public RKISP2PostProcessUnit
|
|
{
|
|
public:
|
|
RKISP2PostProcessUnitFec(const char* name, int type, int camid, uint32_t buftype = kPostProcBufTypeInt,
|
|
RKISP2PostProcessPipeline* pl = nullptr);
|
|
virtual ~RKISP2PostProcessUnitFec();
|
|
virtual status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::shared_ptr<PostProcBuffer>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
private:
|
|
virtual bool checkFmt(CameraBuffer* in, CameraBuffer* out);
|
|
// cache active pixel array
|
|
CameraWindow mApa;
|
|
/*disable copy constructor and assignment*/
|
|
RKISP2PostProcessUnitFec(const RKISP2PostProcessUnitFec&);
|
|
RKISP2PostProcessUnitFec& operator=(const RKISP2PostProcessUnitFec&);
|
|
};
|
|
|
|
/*
|
|
* used to do post processes for camera3 stream.
|
|
*
|
|
*/
|
|
class RKISP2PostProcessPipeline: public IMessageHandler {
|
|
public:
|
|
// thread message id's
|
|
enum MessageId {
|
|
MESSAGE_ID_EXIT = 0,
|
|
MESSAGE_ID_START,
|
|
MESSAGE_ID_STOP,
|
|
MESSAGE_ID_PREPARE,
|
|
MESSAGE_ID_PROCESSFRAME,
|
|
MESSAGE_ID_FLUSH,
|
|
MESSAGE_ID_MAX
|
|
};
|
|
|
|
struct MessagePrepare {
|
|
FrameInfo in;
|
|
std::vector<camera3_stream_t*> streams;
|
|
bool needpostprocess;
|
|
int pipelineDepth;
|
|
};
|
|
|
|
struct MessageProcess {
|
|
std::shared_ptr<PostProcBuffer> in;
|
|
std::vector<std::shared_ptr<PostProcBuffer>> out;
|
|
std::shared_ptr<RKISP2ProcUnitSettings> settings;
|
|
};
|
|
|
|
// union of all message data
|
|
union MessageData {
|
|
MessagePrepare msgPrepare;
|
|
MessageProcess msgProcess;
|
|
};
|
|
|
|
struct Message {
|
|
MessageId id;
|
|
MessagePrepare prepareMsg;
|
|
MessageProcess processMsg;
|
|
Message(): id(MESSAGE_ID_EXIT) {
|
|
CLEAR(prepareMsg);
|
|
CLEAR(processMsg);
|
|
}
|
|
};
|
|
|
|
/* Describle the unit position in pipeline */
|
|
enum ProcessUnitLevel {
|
|
kFirstLevel,
|
|
kMiddleLevel,
|
|
kLastLevel,
|
|
kMaxLevel
|
|
};
|
|
|
|
/*
|
|
* |worker| defines which ISP phisical path to be extended.
|
|
* |listener| specifies where the processed buffer will be output.
|
|
*/
|
|
RKISP2PostProcessPipeline(RKISP2IPostProcessListener* listener, int camid);
|
|
RKISP2PostProcessPipeline(RKISP2IPostProcessListener* listener,IBufferDone *bufferListener, int camid);
|
|
~RKISP2PostProcessPipeline();
|
|
/* construt the pipeline*/
|
|
status_t prepare(const FrameInfo& in,
|
|
const std::vector<camera3_stream_t*>& streams,
|
|
bool& needpostprocess,
|
|
int pipelineDepth = kDefaultAllocBufferNums);
|
|
status_t prepare_internal(const FrameInfo& in,
|
|
const std::vector<camera3_stream_t*>& streams,
|
|
bool& needpostprocess,
|
|
int pipelineDepth = kDefaultAllocBufferNums);
|
|
status_t start();
|
|
status_t stop();
|
|
status_t clear();
|
|
void flush();
|
|
/*
|
|
* |in| buffer usually comes from driver,
|
|
* |out| buffers usually comes from camera3 streams, can be empty
|
|
*/
|
|
status_t processFrame(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::vector<std::shared_ptr<PostProcBuffer>>& out,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings);
|
|
|
|
int getCameraId() { return mCameraId; };
|
|
camera3_stream_t* getStreamByType(int stream_type);
|
|
bool mIsNeedcached;
|
|
IBufferDone *mBufferListener;
|
|
|
|
private:
|
|
virtual void messageThreadLoop(void);
|
|
status_t requestExitAndWait();
|
|
status_t handleMessageExit();
|
|
status_t handleStart(Message &msg);
|
|
status_t handleStop(Message &msg);
|
|
status_t handlePrepare(Message &msg);
|
|
status_t handleProcessFrame(Message &msg);
|
|
status_t handleFlush(Message &msg);
|
|
|
|
int getRotationDegrees(camera3_stream_t* stream) const;
|
|
/*
|
|
* Links the unit together.
|
|
* |from| is the unit that would be added as a consumer to |to|.
|
|
* If |to| is null, then |from| represents the first level unit
|
|
* in pipeline.
|
|
*/
|
|
status_t linkPostProcUnit(const std::shared_ptr<RKISP2PostProcessUnit>& from,
|
|
const std::shared_ptr<RKISP2PostProcessUnit>& to,
|
|
enum ProcessUnitLevel level);
|
|
status_t enablePostProcUnit(RKISP2PostProcessUnit* procunit, bool enable);
|
|
status_t setPostProcUnitAsync(RKISP2PostProcessUnit* procunit, bool async);
|
|
status_t addOutputBuffer(const std::vector<std::shared_ptr<PostProcBuffer>>& out);
|
|
|
|
bool IsRawStream(camera3_stream_t* stream);
|
|
|
|
std::vector<std::map<camera3_stream_t*, int>> mStreamToTypeMap;
|
|
std::vector<std::shared_ptr<RKISP2PostProcessUnit>> mPostProcUnits;
|
|
std::map<camera3_stream_t*, RKISP2PostProcessUnit*> mStreamToProcUnitMap;
|
|
typedef std::vector<RKISP2PostProcessUnit*> ProcUnitList;
|
|
std::array<ProcUnitList, kMaxLevel> mPostProcUnitArray;
|
|
RKISP2IPostProcessListener* mPostProcFrameListener;
|
|
int mCameraId;
|
|
bool mThreadRunning;
|
|
MessageQueue<Message, MessageId> mMessageQueue;
|
|
std::unique_ptr<MessageThread> mMessageThread;
|
|
|
|
std::condition_variable mCondition;
|
|
/*
|
|
* when more than one camera3_stream is linked to one pipeline, the
|
|
* OutputBuffer of same request from different stream may need to be
|
|
* returned concurrently. The size of |streams| of prepare call determins
|
|
* this variable's value, and whether the sync is needed actually is
|
|
* decided by |processFrame| call. If |out| size bigger than 1, and out
|
|
* buffers come from different stream, and |in| is the same as one of |out|,
|
|
* then the sync is really needed
|
|
*/
|
|
bool mMayNeedSyncStreamsOutput;
|
|
friend class OutputBuffersHandler;
|
|
class OutputBuffersHandler : public RKISP2IPostProcessListener {
|
|
public:
|
|
explicit OutputBuffersHandler(RKISP2PostProcessPipeline* pipeline);
|
|
virtual ~OutputBuffersHandler() {}
|
|
status_t notifyNewFrame(const std::shared_ptr<PostProcBuffer>& buf,
|
|
const std::shared_ptr<RKISP2ProcUnitSettings>& settings,
|
|
int err);
|
|
void addSyncBuffersIfNeed(const std::shared_ptr<PostProcBuffer>& in,
|
|
const std::vector<std::shared_ptr<PostProcBuffer>>& out);
|
|
private:
|
|
RKISP2PostProcessPipeline* mPipeline;
|
|
struct syncItem {
|
|
std::vector<std::shared_ptr<PostProcBuffer>> sync_buffers;
|
|
int sync_nums;
|
|
};
|
|
std::map<CameraBuffer*, std::shared_ptr<syncItem>> mCamBufToSyncItemMap;
|
|
std::mutex mLock;
|
|
};
|
|
explicit RKISP2PostProcessPipeline(const RKISP2PostProcessPipeline&);
|
|
RKISP2PostProcessPipeline& operator=(const RKISP2PostProcessPipeline&);
|
|
std::unique_ptr<OutputBuffersHandler> mOutputBuffersHandler;
|
|
camera3_stream_t mUvc;
|
|
};
|
|
const element_value_t PPMsg_stringEnum[] = {
|
|
{"MESSAGE_ID_EXIT", RKISP2PostProcessPipeline::MESSAGE_ID_EXIT },
|
|
{"MESSAGE_ID_START", RKISP2PostProcessPipeline::MESSAGE_ID_START },
|
|
{"MESSAGE_ID_STOP", RKISP2PostProcessPipeline::MESSAGE_ID_STOP },
|
|
{"MESSAGE_ID_PREPARE", RKISP2PostProcessPipeline::MESSAGE_ID_PREPARE },
|
|
{"MESSAGE_ID_PROCESSFRAME", RKISP2PostProcessPipeline::MESSAGE_ID_PROCESSFRAME },
|
|
{"MESSAGE_ID_FLUSH", RKISP2PostProcessPipeline::MESSAGE_ID_FLUSH },
|
|
{"MESSAGE_ID_MAX", RKISP2PostProcessPipeline::MESSAGE_ID_MAX },
|
|
};
|
|
|
|
} /* namespace rkisp2 */
|
|
} /* namespace camera2 */
|
|
} /* namespace android */
|
|
|
|
#endif // HAL_ROCKCHIP_PSL_RKISP1_WORKERS_RKISP2PostProcessPipeline_H_
|