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