1/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 *     * Redistributions of source code must retain the above copyright
7 *       notice, this list of conditions and the following disclaimer.
8 *     * Redistributions in binary form must reproduce the above
9 *       copyright notice, this list of conditions and the following
10 *       disclaimer in the documentation and/or other materials provided
11 *       with the distribution.
12 *     * Neither the name of The Linux Foundation nor the names of its
13 *       contributors may be used to endorse or promote products derived
14 *       from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#ifndef __QCAMERA3_CHANNEL_H__
31#define __QCAMERA3_CHANNEL_H__
32
33// System dependencies
34#include <utils/List.h>
35#include <utils/Mutex.h>
36#include <utils/Vector.h>
37#include "gralloc_priv.h"
38
39// Camera dependencies
40#include "cam_intf.h"
41#include "cam_types.h"
42#include "camera3.h"
43#include "QCamera3HALHeader.h"
44#include "QCamera3Mem.h"
45#include "QCamera3PostProc.h"
46#include "QCamera3Stream.h"
47#include "QCamera3StreamMem.h"
48
49extern "C" {
50#include "mm_camera_interface.h"
51#include "mm_jpeg_interface.h"
52}
53
54using namespace android;
55
56#define MIN_STREAMING_BUFFER_NUM 7+11
57
58#define QCAMERA_DUMP_FRM_PREVIEW          1
59#define QCAMERA_DUMP_FRM_VIDEO            (1<<1)
60#define QCAMERA_DUMP_FRM_SNAPSHOT         (1<<2)
61#define QCAMERA_DUMP_FRM_CALLBACK         (1<<3)
62#define QCAMERA_DUMP_FRM_INPUT_REPROCESS  (1<<6)
63
64typedef int64_t nsecs_t;
65
66namespace qcamera {
67
68typedef void (*channel_cb_routine)(mm_camera_super_buf_t *metadata,
69                                camera3_stream_buffer_t *buffer,
70                                uint32_t frame_number, bool isInputBuffer,
71                                void *userdata);
72
73typedef void (*channel_cb_buffer_err)(QCamera3Channel* ch, uint32_t frameNumber,
74                                camera3_buffer_status_t err,
75                                void *userdata);
76
77class QCamera3Channel
78{
79public:
80    QCamera3Channel(uint32_t cam_handle,
81                   uint32_t channel_handle,
82                   mm_camera_ops_t *cam_ops,
83                   channel_cb_routine cb_routine,
84                   channel_cb_buffer_err cb_buf_err,
85                   cam_padding_info_t *paddingInfo,
86                   cam_feature_mask_t postprocess_mask,
87                   void *userData, uint32_t numBuffers);
88    virtual ~QCamera3Channel();
89
90    virtual int32_t start();
91    virtual int32_t stop();
92    virtual int32_t setBatchSize(uint32_t);
93    virtual int32_t queueBatchBuf();
94    virtual int32_t setPerFrameMapUnmap(bool enable);
95    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
96    int32_t setBundleInfo(const cam_bundle_config_t &bundleInfo);
97
98    virtual uint32_t getStreamTypeMask();
99    uint32_t getStreamID(uint32_t streamMask);
100    void destroy();
101    virtual int32_t initialize(cam_is_type_t isType) = 0;
102    virtual int32_t request(buffer_handle_t * /*buffer*/,
103                uint32_t /*frameNumber*/,
104                int &/*indexUsed*/){ return 0;};
105    virtual int32_t request(buffer_handle_t * /*buffer*/,
106                uint32_t /*frameNumber*/,
107                camera3_stream_buffer_t* /*pInputBuffer*/,
108                metadata_buffer_t* /*metadata*/,
109                int & /*indexUsed*/){ return 0;};
110    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
111                            QCamera3Stream *stream) = 0;
112
113    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType) = 0;
114    virtual QCamera3StreamMem *getStreamBufs(uint32_t len) = 0;
115    virtual void putStreamBufs() = 0;
116    virtual int32_t flush();
117
118    QCamera3Stream *getStreamByHandle(uint32_t streamHandle);
119    uint32_t getMyHandle() const {return m_handle;};
120    uint32_t getNumOfStreams() const {return m_numStreams;};
121    uint32_t getNumBuffers() const {return mNumBuffers;};
122    QCamera3Stream *getStreamByIndex(uint32_t index);
123
124    static void streamCbRoutine(mm_camera_super_buf_t *super_frame,
125                QCamera3Stream *stream, void *userdata);
126    void dumpYUV(mm_camera_buf_def_t *frame, cam_dimension_t dim,
127            cam_frame_len_offset_t offset, uint8_t name);
128    bool isUBWCEnabled();
129    cam_format_t getStreamDefaultFormat(cam_stream_type_t type,
130            uint32_t width, uint32_t height);
131    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) = 0;
132
133    void *mUserData;
134    cam_padding_info_t mPaddingInfo;
135    QCamera3Stream *mStreams[MAX_STREAM_NUM_IN_BUNDLE];
136    uint32_t m_numStreams;
137protected:
138
139    int32_t addStream(cam_stream_type_t streamType,
140                      cam_format_t streamFormat,
141                      cam_dimension_t streamDim,
142                      cam_rotation_t streamRotation,
143                      uint8_t minStreamBufnum,
144                      cam_feature_mask_t postprocessMask,
145                      cam_is_type_t isType,
146                      uint32_t batchSize = 0);
147
148    int32_t allocateStreamInfoBuf(camera3_stream_t *stream);
149
150    uint32_t m_camHandle;
151    mm_camera_ops_t *m_camOps;
152    bool m_bIsActive;
153
154    uint32_t m_handle;
155
156
157    mm_camera_buf_notify_t mDataCB;
158
159
160    QCamera3HeapMemory *mStreamInfoBuf;
161    channel_cb_routine mChannelCB;
162    channel_cb_buffer_err mChannelCbBufErr;
163    //cam_padding_info_t *mPaddingInfo;
164    cam_feature_mask_t mPostProcMask;
165    uint32_t mYUVDump;
166    cam_is_type_t mIsType;
167    uint32_t mNumBuffers;
168    /* Enable unmapping of buffer before issuing buffer callback. Default value
169     * for this flag is true and is selectively set to false for the usecases
170     * such as HFR to avoid any performance hit due to mapping/unmapping */
171    bool    mPerFrameMapUnmapEnable;
172    uint32_t mFrmNum;
173    uint32_t mDumpFrmCnt;
174    uint32_t mSkipMode;
175    uint32_t mDumpSkipCnt;
176};
177
178/* QCamera3ProcessingChannel is used to handle all streams that are directly
179 * generated by hardware and given to frameworks without any postprocessing at HAL.
180 * It also handles input streams that require reprocessing by hardware and then
181 * returned to frameworks. */
182class QCamera3ProcessingChannel : public QCamera3Channel
183{
184public:
185   QCamera3ProcessingChannel(uint32_t cam_handle,
186           uint32_t channel_handle,
187           mm_camera_ops_t *cam_ops,
188           channel_cb_routine cb_routine,
189           channel_cb_buffer_err cb_buffer_err,
190           cam_padding_info_t *paddingInfo,
191           void *userData,
192           camera3_stream_t *stream,
193           cam_stream_type_t stream_type,
194           cam_feature_mask_t postprocess_mask,
195           QCamera3Channel *metadataChannel,
196           uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
197
198    ~QCamera3ProcessingChannel();
199
200    virtual int32_t initialize(cam_is_type_t isType);
201    virtual int32_t request(buffer_handle_t *buffer,
202            uint32_t frameNumber,
203            camera3_stream_buffer_t* pInputBuffer,
204            metadata_buffer_t* metadata, int &indexUsed);
205    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
206            QCamera3Stream *stream);
207    virtual QCamera3StreamMem *getStreamBufs(uint32_t len);
208    virtual void putStreamBufs();
209    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType);
210
211    virtual int32_t stop();
212
213    virtual reprocess_type_t getReprocessType() = 0;
214
215    virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer,
216            uint32_t resultFrameNumber);
217
218    int32_t queueReprocMetadata(mm_camera_super_buf_t *metadata);
219    int32_t metadataBufDone(mm_camera_super_buf_t *recvd_frame);
220    int32_t translateStreamTypeAndFormat(camera3_stream_t *stream,
221            cam_stream_type_t &streamType,
222            cam_format_t &streamFormat);
223    int32_t setReprocConfig(reprocess_config_t &reproc_cfg,
224            camera3_stream_buffer_t *pInputBuffer,
225            metadata_buffer_t *metadata,
226            cam_format_t streamFormat, cam_dimension_t dim);
227    int32_t setFwkInputPPData(qcamera_fwk_input_pp_data_t *src_frame,
228            camera3_stream_buffer_t *pInputBuffer,
229            reprocess_config_t *reproc_cfg,
230            metadata_buffer_t *metadata,
231            buffer_handle_t *output_buffer,
232            uint32_t frameNumber);
233    int32_t checkStreamCbErrors(mm_camera_super_buf_t *super_frame,
234            QCamera3Stream *stream);
235    int32_t getStreamSize(cam_dimension_t &dim);
236    virtual int32_t timeoutFrame(uint32_t frameNumber);
237
238    QCamera3PostProcessor m_postprocessor; // post processor
239    void showDebugFPS(int32_t streamType);
240
241protected:
242    uint8_t mDebugFPS;
243    int mFrameCount;
244    int mLastFrameCount;
245    nsecs_t mLastFpsTime;
246    bool isWNREnabled() {return m_bWNROn;};
247    void startPostProc(const reprocess_config_t &reproc_cfg);
248    void issueChannelCb(buffer_handle_t *resultBuffer,
249            uint32_t resultFrameNumber);
250    int32_t releaseOfflineMemory(uint32_t resultFrameNumber);
251
252    QCamera3StreamMem mMemory; //output buffer allocated by fwk
253    camera3_stream_t *mCamera3Stream;
254    uint32_t mNumBufs;
255    cam_stream_type_t mStreamType;
256    cam_format_t mStreamFormat;
257    uint8_t mIntent;
258
259    bool mPostProcStarted;
260    bool mInputBufferConfig;   // Set when the processing channel is configured
261                               // for processing input(framework) buffers
262
263    QCamera3Channel *m_pMetaChannel;
264    mm_camera_super_buf_t *mMetaFrame;
265    QCamera3StreamMem mOfflineMemory;      //reprocessing input buffer
266    QCamera3StreamMem mOfflineMetaMemory; //reprocessing metadata buffer
267    List<uint32_t> mFreeOfflineMetaBuffersList;
268    Mutex mFreeOfflineMetaBuffersLock;
269    android::List<mm_camera_super_buf_t *> mOutOfSequenceBuffers;
270
271private:
272
273    bool m_bWNROn;
274};
275
276/* QCamera3RegularChannel is used to handle all streams that are directly
277 * generated by hardware and given to frameworks without any postprocessing at HAL.
278 * Examples are: all IMPLEMENTATION_DEFINED streams, CPU_READ streams. */
279class QCamera3RegularChannel : public QCamera3ProcessingChannel
280{
281public:
282    QCamera3RegularChannel(uint32_t cam_handle,
283                    uint32_t channel_handle,
284                    mm_camera_ops_t *cam_ops,
285                    channel_cb_routine cb_routine,
286                    channel_cb_buffer_err cb_buffer_err,
287                    cam_padding_info_t *paddingInfo,
288                    void *userData,
289                    camera3_stream_t *stream,
290                    cam_stream_type_t stream_type,
291                    cam_feature_mask_t postprocess_mask,
292                    QCamera3Channel *metadataChannel,
293                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
294
295    virtual ~QCamera3RegularChannel();
296
297    virtual int32_t setBatchSize(uint32_t batchSize);
298    virtual uint32_t getStreamTypeMask();
299    virtual int32_t queueBatchBuf();
300    virtual int32_t initialize(cam_is_type_t isType);
301    using QCamera3ProcessingChannel::request;
302    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
303                    int &indexUsed);
304    virtual reprocess_type_t getReprocessType();
305
306private:
307    int32_t initialize(struct private_handle_t *priv_handle);
308
309    uint32_t mBatchSize;
310    cam_rotation_t mRotation;
311};
312
313/* QCamera3MetadataChannel is for metadata stream generated by camera daemon. */
314class QCamera3MetadataChannel : public QCamera3Channel
315{
316public:
317    QCamera3MetadataChannel(uint32_t cam_handle,
318                    uint32_t channel_handle,
319                    mm_camera_ops_t *cam_ops,
320                    channel_cb_routine cb_routine,
321                    channel_cb_buffer_err cb_buffer_err,
322                    cam_padding_info_t *paddingInfo,
323                    cam_feature_mask_t postprocess_mask,
324                    void *userData,
325                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM);
326    virtual ~QCamera3MetadataChannel();
327
328    virtual int32_t initialize(cam_is_type_t isType);
329
330    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
331                    int &indexUsed);
332    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
333                            QCamera3Stream *stream);
334
335    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
336    virtual void putStreamBufs();
337    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
338            { return NO_ERROR; };
339    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR; };
340
341private:
342    QCamera3StreamMem *mMemory;
343};
344
345/* QCamera3RawChannel is for opaqueu/cross-platform raw stream containing
346 * vendor specific bayer data or 16-bit unpacked bayer data */
347class QCamera3RawChannel : public QCamera3RegularChannel
348{
349public:
350    QCamera3RawChannel(uint32_t cam_handle,
351                    uint32_t channel_handle,
352                    mm_camera_ops_t *cam_ops,
353                    channel_cb_routine cb_routine,
354                    channel_cb_buffer_err cb_buffer_err,
355                    cam_padding_info_t *paddingInfo,
356                    void *userData,
357                    camera3_stream_t *stream,
358                    cam_feature_mask_t postprocess_mask,
359                    QCamera3Channel *metadataChannel,
360                    bool raw_16 = false,
361                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
362
363    virtual ~QCamera3RawChannel();
364
365    virtual int32_t initialize(cam_is_type_t isType);
366
367    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
368                            QCamera3Stream *stream);
369
370    virtual reprocess_type_t getReprocessType();
371
372private:
373    bool mRawDump;
374    bool mIsRaw16;
375
376    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
377    void convertLegacyToRaw16(mm_camera_buf_def_t *frame);
378    void convertMipiToRaw16(mm_camera_buf_def_t *frame);
379};
380
381/*
382 * QCamera3RawDumpChannel is for internal use only for Raw dump
383 */
384
385class QCamera3RawDumpChannel : public QCamera3Channel
386{
387public:
388    QCamera3RawDumpChannel(uint32_t cam_handle,
389                    uint32_t channel_handle,
390                    mm_camera_ops_t *cam_ops,
391                    cam_dimension_t rawDumpSize,
392                    cam_padding_info_t *paddingInfo,
393                    void *userData,
394                    cam_feature_mask_t postprocess_mask, uint32_t numBuffers = 3U);
395    virtual ~QCamera3RawDumpChannel();
396    virtual int32_t initialize(cam_is_type_t isType);
397    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
398                            QCamera3Stream *stream);
399    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
400    virtual void putStreamBufs();
401    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
402            { return NO_ERROR; };
403    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;};
404    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
405            int &indexUsed);
406    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
407
408public:
409    cam_dimension_t mDim;
410
411private:
412    bool mRawDump;
413    QCamera3StreamMem *mMemory;
414};
415
416/* QCamera3YUVChannel is used to handle flexible YUV streams that are directly
417 * generated by hardware and given to frameworks without any postprocessing at HAL.
418 * It is also used to handle input buffers that generate YUV outputs */
419class QCamera3YUVChannel : public QCamera3ProcessingChannel
420{
421public:
422    QCamera3YUVChannel(uint32_t cam_handle,
423            uint32_t channel_handle,
424            mm_camera_ops_t *cam_ops,
425            channel_cb_routine cb_routine,
426            channel_cb_buffer_err cb_buffer_err,
427            cam_padding_info_t *paddingInfo,
428            void *userData,
429            camera3_stream_t *stream,
430            cam_stream_type_t stream_type,
431            cam_feature_mask_t postprocess_mask,
432            QCamera3Channel *metadataChannel);
433    ~QCamera3YUVChannel();
434    virtual int32_t initialize(cam_is_type_t isType);
435    using QCamera3ProcessingChannel::request;
436    virtual int32_t request(buffer_handle_t *buffer,
437            uint32_t frameNumber,
438            camera3_stream_buffer_t* pInputBuffer,
439            metadata_buffer_t* metadata, bool &needMetadata,
440            int &indexUsed);
441    virtual reprocess_type_t getReprocessType();
442    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
443            QCamera3Stream *stream);
444    virtual void putStreamBufs();
445    virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer,
446        uint32_t resultFrameNumber);
447
448private:
449    typedef struct {
450        uint32_t frameNumber;
451        bool offlinePpFlag;
452        buffer_handle_t *output;
453        mm_camera_super_buf_t *callback_buffer;
454    } PpInfo;
455
456    // Whether offline postprocessing is required for this channel
457    bool mBypass;
458    uint32_t mFrameLen;
459
460    // Current edge, noise, and crop region setting
461    cam_edge_application_t mEdgeMode;
462    uint32_t mNoiseRedMode;
463    cam_crop_region_t mCropRegion;
464
465    // Mutex to protect mOfflinePpFlagMap and mFreeHeapBufferList
466    Mutex mOfflinePpLock;
467    // Map between free number and whether the request needs to be
468    // postprocessed.
469    List<PpInfo> mOfflinePpInfoList;
470    // Heap buffer index list
471    List<uint32_t> mFreeHeapBufferList;
472
473private:
474    bool needsFramePostprocessing(metadata_buffer_t* meta);
475    int32_t handleOfflinePpCallback(uint32_t resultFrameNumber,
476            Vector<mm_camera_super_buf_t *>& pendingCbs);
477    mm_camera_super_buf_t* getNextPendingCbBuffer();
478};
479
480/* QCamera3PicChannel is for JPEG stream, which contains a YUV stream generated
481 * by the hardware, and encoded to a JPEG stream */
482class QCamera3PicChannel : public QCamera3ProcessingChannel
483{
484public:
485    QCamera3PicChannel(uint32_t cam_handle,
486            uint32_t channel_handle,
487            mm_camera_ops_t *cam_ops,
488            channel_cb_routine cb_routine,
489            channel_cb_buffer_err cb_buffer_err,
490            cam_padding_info_t *paddingInfo,
491            void *userData,
492            camera3_stream_t *stream,
493            cam_feature_mask_t postprocess_mask,
494            bool is4KVideo,
495            bool isInputStreamConfigured,
496            QCamera3Channel *metadataChannel,
497            uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
498    ~QCamera3PicChannel();
499
500    virtual int32_t initialize(cam_is_type_t isType);
501    virtual int32_t flush();
502    virtual int32_t request(buffer_handle_t *buffer,
503            uint32_t frameNumber,
504            camera3_stream_buffer_t* pInputBuffer,
505            metadata_buffer_t* metadata,
506            int &indexUsed);
507    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
508            QCamera3Stream *stream);
509
510    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
511    virtual void putStreamBufs();
512    virtual reprocess_type_t getReprocessType();
513    virtual int32_t timeoutFrame(uint32_t frameNumber);
514
515    QCamera3Exif *getExifData(metadata_buffer_t *metadata,
516            jpeg_settings_t *jpeg_settings);
517    void overrideYuvSize(uint32_t width, uint32_t height);
518    static void jpegEvtHandle(jpeg_job_status_t status,
519            uint32_t /*client_hdl*/,
520            uint32_t jobId,
521            mm_jpeg_output_t *p_output,
522            void *userdata);
523    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
524            void *userdata);
525    void setCppPerfParam();
526    void resetCppPerfParam();
527
528private:
529    int32_t queueJpegSetting(uint32_t out_buf_index, metadata_buffer_t *metadata);
530
531public:
532    cam_dimension_t m_max_pic_dim;
533
534private:
535    uint32_t mNumSnapshotBufs;
536    uint32_t mYuvWidth, mYuvHeight;
537    int32_t mCurrentBufIndex;
538    bool mInputBufferHint;
539    QCamera3StreamMem *mYuvMemory;
540    // Keep a list of free buffers
541    Mutex mFreeBuffersLock;
542    List<uint32_t> mFreeBufferList;
543    uint32_t mFrameLen;
544    uint32_t mPendingLiveSnapshotFrames;
545};
546
547// reprocess channel class
548class QCamera3ReprocessChannel : public QCamera3Channel
549{
550public:
551    QCamera3ReprocessChannel(uint32_t cam_handle,
552                            uint32_t channel_handle,
553                            mm_camera_ops_t *cam_ops,
554                            channel_cb_routine cb_routine,
555                            channel_cb_buffer_err cb_buffer_err,
556                            cam_padding_info_t *paddingInfo,
557                            cam_feature_mask_t postprocess_mask,
558                            void *userData, void *ch_hdl);
559    QCamera3ReprocessChannel();
560    virtual ~QCamera3ReprocessChannel();
561    // offline reprocess
562    virtual int32_t start();
563    virtual int32_t stop();
564    int32_t doReprocessOffline(qcamera_fwk_input_pp_data_t *frame,
565            bool isPriorityFrame = false);
566    int32_t doReprocess(int buf_fd,void *buffer, size_t buf_length, int32_t &ret_val,
567                        mm_camera_super_buf_t *meta_buf);
568    int32_t overrideMetadata(qcamera_hal3_pp_buffer_t *pp_buffer,
569            mm_camera_buf_def_t *meta_buffer,
570            jpeg_settings_t *jpeg_settings,
571            qcamera_fwk_input_pp_data_t &fwk_frame);
572    int32_t overrideFwkMetadata(qcamera_fwk_input_pp_data_t *frame);
573    virtual QCamera3StreamMem *getStreamBufs(uint32_t len);
574    virtual void putStreamBufs();
575    virtual int32_t initialize(cam_is_type_t isType);
576    int32_t unmapOfflineBuffers(bool all);
577    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
578    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
579                            QCamera3Stream *stream);
580    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
581                                       void* userdata);
582    int32_t addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config,
583           const reprocess_config_t &src_config,
584           cam_is_type_t is_type,
585           QCamera3Channel *pMetaChannel);
586    QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle);
587    QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle);
588    virtual int32_t registerBuffer(buffer_handle_t * buffer, cam_is_type_t isType);
589    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;};
590
591public:
592    void *inputChHandle;
593
594private:
595    typedef struct {
596        QCamera3Stream *stream;
597        cam_mapping_buf_type type;
598        uint32_t index;
599    } OfflineBuffer;
600
601    int32_t resetToCamPerfNormal(uint32_t frameNumber);
602    android::List<OfflineBuffer> mOfflineBuffers;
603    android::List<OfflineBuffer> mOfflineMetaBuffers;
604    int32_t mOfflineBuffersIndex;
605    int32_t mOfflineMetaIndex;
606    uint32_t mFrameLen;
607    Mutex mFreeBuffersLock; // Lock for free heap buffers
608    List<int32_t> mFreeBufferList; // Free heap buffers list
609    reprocess_type_t mReprocessType;
610    uint32_t mSrcStreamHandles[MAX_STREAM_NUM_IN_BUNDLE];
611    QCamera3ProcessingChannel *m_pSrcChannel; // ptr to source channel for reprocess
612    QCamera3Channel *m_pMetaChannel;
613    QCamera3StreamMem *mMemory;
614    QCamera3StreamMem mGrallocMemory;
615    Vector<uint32_t> mPriorityFrames;
616    Mutex            mPriorityFramesLock;
617    bool             mReprocessPerfMode;
618};
619
620
621/* QCamera3SupportChannel is for HAL internal consumption only */
622class QCamera3SupportChannel : public QCamera3Channel
623{
624public:
625    QCamera3SupportChannel(uint32_t cam_handle,
626                    uint32_t channel_handle,
627                    mm_camera_ops_t *cam_ops,
628                    cam_padding_info_t *paddingInfo,
629                    cam_feature_mask_t postprocess_mask,
630                    cam_stream_type_t streamType,
631                    cam_dimension_t *dim,
632                    cam_format_t streamFormat,
633                    uint8_t hw_analysis_supported,
634                    void *userData,
635                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM
636                    );
637    virtual ~QCamera3SupportChannel();
638
639    virtual int32_t initialize(cam_is_type_t isType);
640
641    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
642                    int &indexUsed);
643    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
644                            QCamera3Stream *stream);
645
646    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
647    virtual void putStreamBufs();
648    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
649            { return NO_ERROR; };
650    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;};
651
652    static cam_dimension_t kDim;
653private:
654    QCamera3StreamMem *mMemory;
655    cam_dimension_t mDim;
656    cam_stream_type_t mStreamType;
657    cam_format_t mStreamFormat;
658};
659
660}; // namespace qcamera
661
662#endif /* __QCAMERA_CHANNEL_H__ */
663