1/* Copyright (c) 2012-2015, The Linux Foundataion. 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#include <hardware/camera3.h>
34#include "QCamera3Stream.h"
35#include "QCamera3Mem.h"
36#include "QCamera3StreamMem.h"
37#include "QCamera3PostProc.h"
38#include "QCamera3HALHeader.h"
39#include "utils/Vector.h"
40#include <utils/List.h>
41
42extern "C" {
43#include <mm_camera_interface.h>
44}
45
46using namespace android;
47
48#define MIN_STREAMING_BUFFER_NUM 7+11
49
50namespace qcamera {
51
52typedef void (*channel_cb_routine)(mm_camera_super_buf_t *metadata,
53                                camera3_stream_buffer_t *buffer,
54                                uint32_t frame_number, bool isInputBuffer,
55                                void *userdata);
56class QCamera3Channel
57{
58public:
59    QCamera3Channel(uint32_t cam_handle,
60                   uint32_t channel_handle,
61                   mm_camera_ops_t *cam_ops,
62                   channel_cb_routine cb_routine,
63                   cam_padding_info_t *paddingInfo,
64                   uint32_t postprocess_mask,
65                   void *userData, uint32_t numBuffers);
66    virtual ~QCamera3Channel();
67
68    virtual int32_t start();
69    virtual int32_t stop();
70    virtual int32_t setBatchSize(uint32_t);
71    virtual int32_t queueBatchBuf();
72    virtual int32_t setPerFrameMapUnmap(bool enable);
73    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
74    int32_t setBundleInfo(const cam_bundle_config_t &bundleInfo);
75
76    virtual uint32_t getStreamTypeMask();
77    uint32_t getStreamID(uint32_t streamMask);
78    virtual int32_t initialize(cam_is_type_t isType) = 0;
79    virtual int32_t request(buffer_handle_t * /*buffer*/,
80                uint32_t /*frameNumber*/){ return 0;};
81    virtual int32_t request(buffer_handle_t * /*buffer*/,
82                uint32_t /*frameNumber*/,
83                camera3_stream_buffer_t* /*pInputBuffer*/,
84                metadata_buffer_t* /*metadata*/){ return 0;};
85    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
86                            QCamera3Stream *stream) = 0;
87
88    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType) = 0;
89    virtual QCamera3StreamMem *getStreamBufs(uint32_t len) = 0;
90    virtual void putStreamBufs() = 0;
91
92    QCamera3Stream *getStreamByHandle(uint32_t streamHandle);
93    uint32_t getMyHandle() const {return m_handle;};
94    uint32_t getNumOfStreams() const {return m_numStreams;};
95    uint32_t getNumBuffers() const {return mNumBuffers;};
96    QCamera3Stream *getStreamByIndex(uint32_t index);
97
98    static void streamCbRoutine(mm_camera_super_buf_t *super_frame,
99                QCamera3Stream *stream, void *userdata);
100    void dumpYUV(mm_camera_buf_def_t *frame, cam_dimension_t dim,
101            cam_frame_len_offset_t offset, uint8_t name);
102
103    void *mUserData;
104    cam_padding_info_t *mPaddingInfo;
105    QCamera3Stream *mStreams[MAX_STREAM_NUM_IN_BUNDLE];
106    uint32_t m_numStreams;
107protected:
108
109    int32_t addStream(cam_stream_type_t streamType,
110                      cam_format_t streamFormat,
111                      cam_dimension_t streamDim,
112                      cam_rotation_t streamRotation,
113                      uint8_t minStreamBufnum,
114                      uint32_t postprocessMask,
115                      cam_is_type_t isType,
116                      uint32_t batchSize = 0);
117    int32_t allocateStreamInfoBuf(camera3_stream_t *stream);
118
119    uint32_t m_camHandle;
120    mm_camera_ops_t *m_camOps;
121    bool m_bIsActive;
122
123    uint32_t m_handle;
124
125
126    mm_camera_buf_notify_t mDataCB;
127
128
129    QCamera3HeapMemory *mStreamInfoBuf;
130    channel_cb_routine mChannelCB;
131    //cam_padding_info_t *mPaddingInfo;
132    uint32_t mPostProcMask;
133    uint8_t mYUVDump;
134    cam_is_type_t mIsType;
135    uint32_t mNumBuffers;
136    /* Enable unmapping of buffer before issuing buffer callback. Default value
137     * for this flag is true and is selectively set to false for the usecases
138     * such as HFR to avoid any performance hit due to mapping/unmapping */
139    bool    mPerFrameMapUnmapEnable;
140};
141
142/* QCamera3ProcessingChannel is used to handle all streams that are directly
143 * generated by hardware and given to frameworks without any postprocessing at HAL.
144 * It also handles input streams that require reprocessing by hardware and then
145 * returned to frameworks. */
146class QCamera3ProcessingChannel : public QCamera3Channel
147{
148public:
149   QCamera3ProcessingChannel(uint32_t cam_handle,
150           uint32_t channel_handle,
151           mm_camera_ops_t *cam_ops,
152           channel_cb_routine cb_routine,
153           cam_padding_info_t *paddingInfo,
154           void *userData,
155           camera3_stream_t *stream,
156           cam_stream_type_t stream_type,
157           uint32_t postprocess_mask,
158           QCamera3Channel *metadataChannel,
159           uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
160
161    ~QCamera3ProcessingChannel();
162
163    virtual int32_t initialize(cam_is_type_t isType);
164    virtual int32_t request(buffer_handle_t *buffer,
165            uint32_t frameNumber,
166            camera3_stream_buffer_t* pInputBuffer,
167            metadata_buffer_t* metadata);
168    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
169            QCamera3Stream *stream);
170    virtual QCamera3StreamMem *getStreamBufs(uint32_t len);
171    virtual void putStreamBufs();
172    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType);
173
174    virtual int32_t stop();
175
176    virtual reprocess_type_t getReprocessType() = 0;
177
178    virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer,
179            uint32_t resultFrameNumber);
180
181    int32_t queueReprocMetadata(mm_camera_super_buf_t *metadata);
182    int32_t metadataBufDone(mm_camera_super_buf_t *recvd_frame);
183    int32_t translateStreamTypeAndFormat(camera3_stream_t *stream,
184            cam_stream_type_t &streamType,
185            cam_format_t &streamFormat);
186    int32_t setReprocConfig(reprocess_config_t &reproc_cfg,
187            camera3_stream_buffer_t *pInputBuffer,
188            metadata_buffer_t *metadata,
189            cam_format_t streamFormat, cam_dimension_t dim);
190    int32_t setFwkInputPPData(qcamera_fwk_input_pp_data_t *src_frame,
191            camera3_stream_buffer_t *pInputBuffer,
192            reprocess_config_t *reproc_cfg,
193            metadata_buffer_t *metadata,
194            buffer_handle_t *output_buffer,
195            uint32_t frameNumber);
196    int32_t checkStreamCbErrors(mm_camera_super_buf_t *super_frame,
197            QCamera3Stream *stream);
198    int32_t getStreamSize(cam_dimension_t &dim);
199
200    QCamera3PostProcessor m_postprocessor; // post processor
201    int32_t releaseOfflineMemory(uint32_t resultFrameNumber);
202
203protected:
204    bool isWNREnabled() {return m_bWNROn;};
205    void startPostProc(const reprocess_config_t &reproc_cfg);
206    void issueChannelCb(buffer_handle_t *resultBuffer,
207            uint32_t resultFrameNumber);
208
209    QCamera3StreamMem mMemory; //output buffer allocated by fwk
210    camera3_stream_t *mCamera3Stream;
211    uint32_t mNumBufs;
212    cam_stream_type_t mStreamType;
213    cam_format_t mStreamFormat;
214    uint8_t mIntent;
215
216    bool mPostProcStarted;
217    bool mInputBufferConfig;   // Set when the processing channel is configured
218                               // for processing input(framework) buffers
219
220    QCamera3Channel *m_pMetaChannel;
221    mm_camera_super_buf_t *mMetaFrame;
222    QCamera3StreamMem mOfflineMemory;      //reprocessing input buffer
223    QCamera3StreamMem mOfflineMetaMemory; //reprocessing metadata buffer
224    List<uint32_t> mFreeOfflineMetaBuffersList;
225    Mutex mFreeOfflineMetaBuffersLock;
226
227private:
228
229    bool m_bWNROn;
230};
231
232/* QCamera3RegularChannel is used to handle all streams that are directly
233 * generated by hardware and given to frameworks without any postprocessing at HAL.
234 * Examples are: all IMPLEMENTATION_DEFINED streams, CPU_READ streams. */
235class QCamera3RegularChannel : public QCamera3ProcessingChannel
236{
237public:
238    QCamera3RegularChannel(uint32_t cam_handle,
239                    uint32_t channel_handle,
240                    mm_camera_ops_t *cam_ops,
241                    channel_cb_routine cb_routine,
242                    cam_padding_info_t *paddingInfo,
243                    void *userData,
244                    camera3_stream_t *stream,
245                    cam_stream_type_t stream_type,
246                    uint32_t postprocess_mask,
247                    QCamera3Channel *metadataChannel,
248                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
249
250    virtual ~QCamera3RegularChannel();
251
252    virtual int32_t setBatchSize(uint32_t batchSize);
253    virtual uint32_t getStreamTypeMask();
254    virtual int32_t queueBatchBuf();
255    virtual int32_t initialize(cam_is_type_t isType);
256    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
257    virtual reprocess_type_t getReprocessType();
258
259private:
260    int32_t initialize(struct private_handle_t *priv_handle);
261
262    cam_rotation_t mRotation;
263    uint32_t mBatchSize;
264
265};
266
267/* QCamera3MetadataChannel is for metadata stream generated by camera daemon. */
268class QCamera3MetadataChannel : public QCamera3Channel
269{
270public:
271    QCamera3MetadataChannel(uint32_t cam_handle,
272                    uint32_t channel_handle,
273                    mm_camera_ops_t *cam_ops,
274                    channel_cb_routine cb_routine,
275                    cam_padding_info_t *paddingInfo,
276                    uint32_t postprocess_mask,
277                    void *userData,
278                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM);
279    virtual ~QCamera3MetadataChannel();
280
281    virtual int32_t initialize(cam_is_type_t isType);
282
283    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
284    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
285                            QCamera3Stream *stream);
286
287    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
288    virtual void putStreamBufs();
289    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
290            { return NO_ERROR; };
291
292private:
293    QCamera3StreamMem *mMemory;
294};
295
296/* QCamera3RawChannel is for opaqueu/cross-platform raw stream containing
297 * vendor specific bayer data or 16-bit unpacked bayer data */
298class QCamera3RawChannel : public QCamera3RegularChannel
299{
300public:
301    QCamera3RawChannel(uint32_t cam_handle,
302                    uint32_t channel_handle,
303                    mm_camera_ops_t *cam_ops,
304                    channel_cb_routine cb_routine,
305                    cam_padding_info_t *paddingInfo,
306                    void *userData,
307                    camera3_stream_t *stream,
308                    uint32_t postprocess_mask,
309                    QCamera3Channel *metadataChannel,
310                    bool raw_16 = false,
311                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
312
313    virtual ~QCamera3RawChannel();
314
315    virtual int32_t initialize(cam_is_type_t isType);
316
317    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
318                            QCamera3Stream *stream);
319
320    virtual reprocess_type_t getReprocessType();
321
322private:
323    bool mRawDump;
324    bool mIsRaw16;
325
326    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
327    void convertLegacyToRaw16(mm_camera_buf_def_t *frame);
328    void convertMipiToRaw16(mm_camera_buf_def_t *frame);
329};
330
331/*
332 * QCamera3RawDumpChannel is for internal use only for Raw dump
333 */
334
335class QCamera3RawDumpChannel : public QCamera3Channel
336{
337public:
338    QCamera3RawDumpChannel(uint32_t cam_handle,
339                    uint32_t channel_handle,
340                    mm_camera_ops_t *cam_ops,
341                    cam_dimension_t rawDumpSize,
342                    cam_padding_info_t *paddingInfo,
343                    void *userData,
344                    uint32_t postprocess_mask, uint32_t numBuffers = 3U);
345    virtual ~QCamera3RawDumpChannel();
346    virtual int32_t initialize(cam_is_type_t isType);
347    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
348                            QCamera3Stream *stream);
349    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
350    virtual void putStreamBufs();
351    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
352            { return NO_ERROR; };
353    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
354    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
355
356public:
357    cam_dimension_t mDim;
358
359private:
360    bool mRawDump;
361    QCamera3StreamMem *mMemory;
362};
363
364/* QCamera3YUVChannel is used to handle flexible YUV streams that are directly
365 * generated by hardware and given to frameworks without any postprocessing at HAL.
366 * It is also used to handle input buffers that generate YUV outputs */
367class QCamera3YUVChannel : public QCamera3ProcessingChannel
368{
369public:
370    QCamera3YUVChannel(uint32_t cam_handle,
371            uint32_t channel_handle,
372            mm_camera_ops_t *cam_ops,
373            channel_cb_routine cb_routine,
374            cam_padding_info_t *paddingInfo,
375            void *userData,
376            camera3_stream_t *stream,
377            cam_stream_type_t stream_type,
378            uint32_t postprocess_mask,
379            QCamera3Channel *metadataChannel);
380    ~QCamera3YUVChannel();
381    virtual int32_t initialize(cam_is_type_t isType);
382    virtual int32_t request(buffer_handle_t *buffer,
383            uint32_t frameNumber,
384            camera3_stream_buffer_t* pInputBuffer,
385            metadata_buffer_t* metadata, bool &needMetadata);
386    virtual reprocess_type_t getReprocessType();
387    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
388            QCamera3Stream *stream);
389    virtual void putStreamBufs();
390    virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer,
391        uint32_t resultFrameNumber);
392
393private:
394    typedef struct {
395        uint32_t frameNumber;
396        bool offlinePpFlag;
397        buffer_handle_t *output;
398        mm_camera_super_buf_t *callback_buffer;
399    } PpInfo;
400
401    // Whether offline postprocessing is required for this channel
402    bool mBypass;
403    uint32_t mFrameLen;
404
405    // Current edge, noise, and crop region setting
406    cam_edge_application_t mEdgeMode;
407    uint32_t mNoiseRedMode;
408    cam_crop_region_t mCropRegion;
409
410    // Mutex to protect mOfflinePpFlagMap and mFreeHeapBufferList
411    Mutex mOfflinePpLock;
412    // Map between free number and whether the request needs to be
413    // postprocessed.
414    List<PpInfo> mOfflinePpInfoList;
415    // Heap buffer index list
416    List<uint32_t> mFreeHeapBufferList;
417
418private:
419    bool needsFramePostprocessing(metadata_buffer_t* meta);
420    int32_t handleOfflinePpCallback(uint32_t resultFrameNumber,
421            Vector<mm_camera_super_buf_t *>& pendingCbs);
422};
423
424/* QCamera3PicChannel is for JPEG stream, which contains a YUV stream generated
425 * by the hardware, and encoded to a JPEG stream */
426class QCamera3PicChannel : public QCamera3ProcessingChannel
427{
428public:
429    QCamera3PicChannel(uint32_t cam_handle,
430            uint32_t channel_handle,
431            mm_camera_ops_t *cam_ops,
432            channel_cb_routine cb_routine,
433            cam_padding_info_t *paddingInfo,
434            void *userData,
435            camera3_stream_t *stream,
436            uint32_t postprocess_mask,
437            bool is4KVideo,
438            bool isInputStreamConfigured,
439            QCamera3Channel *metadataChannel,
440            uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
441    ~QCamera3PicChannel();
442
443    virtual int32_t initialize(cam_is_type_t isType);
444    virtual int32_t request(buffer_handle_t *buffer,
445            uint32_t frameNumber,
446            camera3_stream_buffer_t* pInputBuffer,
447            metadata_buffer_t* metadata);
448    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
449            QCamera3Stream *stream);
450
451    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
452    virtual void putStreamBufs();
453    virtual reprocess_type_t getReprocessType();
454
455    QCamera3Exif *getExifData(metadata_buffer_t *metadata,
456            jpeg_settings_t *jpeg_settings);
457    void overrideYuvSize(uint32_t width, uint32_t height);
458    static void jpegEvtHandle(jpeg_job_status_t status,
459            uint32_t /*client_hdl*/,
460            uint32_t jobId,
461            mm_jpeg_output_t *p_output,
462            void *userdata);
463    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
464            void *userdata);
465
466private:
467    int32_t queueJpegSetting(uint32_t out_buf_index, metadata_buffer_t *metadata);
468
469public:
470    cam_dimension_t m_max_pic_dim;
471
472private:
473    uint32_t mNumSnapshotBufs;
474    uint32_t mYuvWidth, mYuvHeight;
475    int32_t mCurrentBufIndex;
476    bool mInputBufferHint;
477    QCamera3StreamMem *mYuvMemory;
478    // Keep a list of free buffers
479    Mutex mFreeBuffersLock;
480    List<uint32_t> mFreeBufferList;
481    uint32_t mFrameLen;
482};
483
484// reprocess channel class
485class QCamera3ReprocessChannel : public QCamera3Channel
486{
487public:
488    QCamera3ReprocessChannel(uint32_t cam_handle,
489                            uint32_t channel_handle,
490                            mm_camera_ops_t *cam_ops,
491                            channel_cb_routine cb_routine,
492                            cam_padding_info_t *paddingInfo,
493                            uint32_t postprocess_mask,
494                            void *userData, void *ch_hdl);
495    QCamera3ReprocessChannel();
496    virtual ~QCamera3ReprocessChannel();
497    // offline reprocess
498    virtual int32_t start();
499    virtual int32_t stop();
500    int32_t doReprocessOffline(qcamera_fwk_input_pp_data_t *frame);
501    int32_t doReprocess(int buf_fd, size_t buf_length, int32_t &ret_val,
502                        mm_camera_super_buf_t *meta_buf);
503    int32_t overrideMetadata(qcamera_hal3_pp_buffer_t *pp_buffer,
504            mm_camera_buf_def_t *meta_buffer,
505            jpeg_settings_t *jpeg_settings,
506            qcamera_fwk_input_pp_data_t &fwk_frame);
507    int32_t overrideFwkMetadata(qcamera_fwk_input_pp_data_t *frame);
508    virtual QCamera3StreamMem *getStreamBufs(uint32_t len);
509    virtual void putStreamBufs();
510    virtual int32_t initialize(cam_is_type_t isType);
511    int32_t unmapOfflineBuffers(bool all);
512    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
513    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
514                            QCamera3Stream *stream);
515    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
516                                       void* userdata);
517    int32_t addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config,
518           const reprocess_config_t &src_config,
519           cam_is_type_t is_type,
520           QCamera3Channel *pMetaChannel);
521    QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle);
522    QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle);
523    virtual int32_t registerBuffer(buffer_handle_t * buffer, cam_is_type_t isType);
524
525public:
526    void *inputChHandle;
527
528private:
529    typedef struct {
530        QCamera3Stream *stream;
531        cam_mapping_buf_type type;
532        uint32_t index;
533    } OfflineBuffer;
534
535    android::List<OfflineBuffer> mOfflineBuffers;
536    android::List<OfflineBuffer> mOfflineMetaBuffers;
537    int32_t mOfflineBuffersIndex;
538    int32_t mOfflineMetaIndex;
539    uint32_t mFrameLen;
540    Mutex mFreeBuffersLock; // Lock for free heap buffers
541    List<int32_t> mFreeBufferList; // Free heap buffers list
542    reprocess_type_t mReprocessType;
543    uint32_t mSrcStreamHandles[MAX_STREAM_NUM_IN_BUNDLE];
544    QCamera3ProcessingChannel *m_pSrcChannel; // ptr to source channel for reprocess
545    QCamera3Channel *m_pMetaChannel;
546    QCamera3StreamMem *mMemory;
547    QCamera3StreamMem mGrallocMemory;
548};
549
550
551/* QCamera3SupportChannel is for HAL internal consumption only */
552class QCamera3SupportChannel : public QCamera3Channel
553{
554public:
555    QCamera3SupportChannel(uint32_t cam_handle,
556                    uint32_t channel_handle,
557                    mm_camera_ops_t *cam_ops,
558                    cam_padding_info_t *paddingInfo,
559                    uint32_t postprocess_mask,
560                    cam_stream_type_t streamType,
561                    cam_dimension_t *dim,
562                    cam_format_t streamFormat,
563                    void *userData,
564                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM
565                    );
566    virtual ~QCamera3SupportChannel();
567
568    virtual int32_t initialize(cam_is_type_t isType);
569
570    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
571    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
572                            QCamera3Stream *stream);
573
574    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
575    virtual void putStreamBufs();
576    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
577            { return NO_ERROR; };
578
579    static cam_dimension_t kDim;
580private:
581    QCamera3StreamMem *mMemory;
582    cam_dimension_t mDim;
583    cam_stream_type_t mStreamType;
584    cam_format_t mStreamFormat;
585};
586
587}; // namespace qcamera
588
589#endif /* __QCAMERA_CHANNEL_H__ */
590