QCamera3Channel.h revision 4d017a7ea03989adb115cef482889a8172f30634 
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 "QCamera3PostProc.h"
37#include "QCamera3HALHeader.h"
38#include "utils/Vector.h"
39#include <utils/List.h>
40
41extern "C" {
42#include <mm_camera_interface.h>
43}
44
45using namespace android;
46
47#define MIN_STREAMING_BUFFER_NUM 7+11
48
49namespace qcamera {
50
51typedef void (*channel_cb_routine)(mm_camera_super_buf_t *metadata,
52                                camera3_stream_buffer_t *buffer,
53                                uint32_t frame_number, void *userdata);
54class QCamera3Channel
55{
56public:
57    QCamera3Channel(uint32_t cam_handle,
58                   mm_camera_ops_t *cam_ops,
59                   channel_cb_routine cb_routine,
60                   cam_padding_info_t *paddingInfo,
61                   uint32_t postprocess_mask,
62                   void *userData, uint32_t numBuffers);
63    QCamera3Channel();
64    virtual ~QCamera3Channel();
65
66    int32_t addStream(cam_stream_type_t streamType,
67                      cam_format_t streamFormat,
68                      cam_dimension_t streamDim,
69                      cam_rotation_t streamRotation,
70                      uint8_t minStreamBufnum,
71                      uint32_t postprocessMask,
72                      cam_is_type_t isType);
73    virtual int32_t start();
74    virtual int32_t stop();
75    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
76
77    uint32_t getStreamTypeMask();
78    uint32_t getStreamID(uint32_t streamMask);
79    virtual int32_t initialize(cam_is_type_t isType) = 0;
80    virtual int32_t request(buffer_handle_t * /*buffer*/,
81                uint32_t /*frameNumber*/){ return 0;};
82    virtual int32_t request(buffer_handle_t * /*buffer*/,
83                uint32_t /*frameNumber*/,
84                camera3_stream_buffer_t* /*pInputBuffer*/,
85                metadata_buffer_t* /*metadata*/){ return 0;};
86    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
87                            QCamera3Stream *stream) = 0;
88
89    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType) = 0;
90    virtual QCamera3Memory *getStreamBufs(uint32_t len) = 0;
91    virtual void putStreamBufs() = 0;
92
93    QCamera3Stream *getStreamByHandle(uint32_t streamHandle);
94    uint32_t getMyHandle() const {return m_handle;};
95    uint32_t getNumOfStreams() const {return m_numStreams;};
96    uint32_t getNumBuffers() const {return mNumBuffers;};
97    QCamera3Stream *getStreamByIndex(uint32_t index);
98
99    static void streamCbRoutine(mm_camera_super_buf_t *super_frame,
100                QCamera3Stream *stream, void *userdata);
101    void dumpYUV(mm_camera_buf_def_t *frame, cam_dimension_t dim,
102            cam_frame_len_offset_t offset, uint8_t name);
103
104    void *mUserData;
105    cam_padding_info_t *mPaddingInfo;
106    QCamera3Stream *mStreams[MAX_STREAM_NUM_IN_BUNDLE];
107    uint32_t m_numStreams;
108protected:
109
110   virtual int32_t init(mm_camera_channel_attr_t *attr,
111                         mm_camera_buf_notify_t dataCB);
112    int32_t allocateStreamInfoBuf(camera3_stream_t *stream);
113
114    uint32_t m_camHandle;
115    mm_camera_ops_t *m_camOps;
116    bool m_bIsActive;
117
118    uint32_t m_handle;
119
120
121    mm_camera_buf_notify_t mDataCB;
122
123
124    QCamera3HeapMemory *mStreamInfoBuf;
125    channel_cb_routine mChannelCB;
126    //cam_padding_info_t *mPaddingInfo;
127    uint32_t mPostProcMask;
128    uint8_t mYUVDump;
129    cam_is_type_t mIsType;
130    uint32_t mNumBuffers;
131};
132
133/* QCamera3RegularChannel is used to handle all streams that are directly
134 * generated by hardware and given to frameworks without any postprocessing at HAL.
135 * Examples are: all IMPLEMENTATION_DEFINED streams, CPU_READ streams. */
136class QCamera3RegularChannel : public QCamera3Channel
137{
138public:
139    QCamera3RegularChannel(uint32_t cam_handle,
140                    mm_camera_ops_t *cam_ops,
141                    channel_cb_routine cb_routine,
142                    cam_padding_info_t *paddingInfo,
143                    void *userData,
144                    camera3_stream_t *stream,
145                    cam_stream_type_t stream_type,
146                    uint32_t postprocess_mask,
147                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
148
149    QCamera3RegularChannel(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                    uint32_t width, uint32_t height,
158                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
159
160    virtual ~QCamera3RegularChannel();
161
162    virtual int32_t start();
163    virtual int32_t initialize(cam_is_type_t isType);
164    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
165    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
166                                            QCamera3Stream *stream);
167
168    virtual QCamera3Memory *getStreamBufs(uint32_t le);
169    virtual void putStreamBufs();
170    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType);
171
172protected:
173    QCamera3GrallocMemory mMemory;
174private:
175    int32_t initialize(struct private_handle_t *priv_handle);
176
177    camera3_stream_t *mCamera3Stream;
178    uint8_t mNumBufs;
179    cam_stream_type_t mStreamType; // Stream type
180    uint32_t mWidth, mHeight;
181    cam_rotation_t mRotation;
182
183};
184
185/* QCamera3MetadataChannel is for metadata stream generated by camera daemon. */
186class QCamera3MetadataChannel : public QCamera3Channel
187{
188public:
189    QCamera3MetadataChannel(uint32_t cam_handle,
190                    mm_camera_ops_t *cam_ops,
191                    channel_cb_routine cb_routine,
192                    cam_padding_info_t *paddingInfo,
193                    uint32_t postprocess_mask,
194                    void *userData,
195                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM);
196    virtual ~QCamera3MetadataChannel();
197
198    virtual int32_t initialize(cam_is_type_t isType);
199
200    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
201    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
202                            QCamera3Stream *stream);
203
204    virtual QCamera3Memory *getStreamBufs(uint32_t le);
205    virtual void putStreamBufs();
206    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
207            { return NO_ERROR; };
208
209private:
210    QCamera3HeapMemory *mMemory;
211};
212
213/* QCamera3RawChannel is for opaqueu/cross-platform raw stream containing
214 * vendor specific bayer data or 16-bit unpacked bayer data */
215class QCamera3RawChannel : public QCamera3RegularChannel
216{
217public:
218    QCamera3RawChannel(uint32_t cam_handle,
219                    mm_camera_ops_t *cam_ops,
220                    channel_cb_routine cb_routine,
221                    cam_padding_info_t *paddingInfo,
222                    void *userData,
223                    camera3_stream_t *stream,
224                    uint32_t postprocess_mask,
225                    bool raw_16 = false,
226                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
227    virtual ~QCamera3RawChannel();
228
229    virtual int32_t initialize(cam_is_type_t isType);
230
231    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
232                            QCamera3Stream *stream);
233
234private:
235    bool mRawDump;
236    bool mIsRaw16;
237
238    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
239    void convertLegacyToRaw16(mm_camera_buf_def_t *frame);
240    void convertMipiToRaw16(mm_camera_buf_def_t *frame);
241};
242
243/*
244 * QCamera3RawDumpChannel is for internal use only for Raw dump
245 */
246
247class QCamera3RawDumpChannel : public QCamera3Channel
248{
249public:
250    QCamera3RawDumpChannel(uint32_t cam_handle,
251                    mm_camera_ops_t *cam_ops,
252                    cam_dimension_t rawDumpSize,
253                    cam_padding_info_t *paddingInfo,
254                    void *userData,
255                    uint32_t postprocess_mask, uint32_t numBuffers = 3U);
256    virtual ~QCamera3RawDumpChannel();
257    virtual int32_t initialize(cam_is_type_t isType);
258    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
259                            QCamera3Stream *stream);
260    virtual QCamera3Memory *getStreamBufs(uint32_t le);
261    virtual void putStreamBufs();
262    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
263            { return NO_ERROR; };
264    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
265    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
266
267public:
268    cam_dimension_t mDim;
269
270private:
271    bool mRawDump;
272    QCamera3HeapMemory *mMemory;
273};
274
275/* QCamera3PicChannel is for JPEG stream, which contains a YUV stream generated
276 * by the hardware, and encoded to a JPEG stream */
277class QCamera3PicChannel : public QCamera3Channel
278{
279public:
280    QCamera3PicChannel(uint32_t cam_handle,
281            mm_camera_ops_t *cam_ops,
282            channel_cb_routine cb_routine,
283            cam_padding_info_t *paddingInfo,
284            void *userData,
285            camera3_stream_t *stream,
286            uint32_t postprocess_mask,
287            bool is4KVideo,
288            QCamera3Channel *metadataChannel,
289            uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
290    ~QCamera3PicChannel();
291
292    virtual int32_t initialize(cam_is_type_t isType);
293    virtual int32_t stop();
294    virtual int32_t request(buffer_handle_t *buffer,
295            uint32_t frameNumber,
296            camera3_stream_buffer_t* pInputBuffer,
297            metadata_buffer_t* metadata);
298    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
299            QCamera3Stream *stream);
300
301    virtual QCamera3Memory *getStreamBufs(uint32_t le);
302    virtual void putStreamBufs();
303
304    bool isWNREnabled() {return m_bWNROn;};
305    bool needOnlineRotation();
306    int32_t metadataBufDone(mm_camera_super_buf_t *recvd_frame);
307    QCamera3Exif *getExifData(metadata_buffer_t *metadata,
308            jpeg_settings_t *jpeg_settings);
309    void overrideYuvSize(uint32_t width, uint32_t height);
310    static void jpegEvtHandle(jpeg_job_status_t status,
311            uint32_t /*client_hdl*/,
312            uint32_t jobId,
313            mm_jpeg_output_t *p_output,
314            void *userdata);
315    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
316            void *userdata);
317    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType);
318    int32_t queueReprocMetadata(mm_camera_super_buf_t *metadata);
319
320private:
321    int32_t queueJpegSetting(uint32_t out_buf_index, metadata_buffer_t *metadata);
322
323public:
324    QCamera3PostProcessor m_postprocessor; // post processor
325    cam_dimension_t m_max_pic_dim;
326
327private:
328    camera3_stream_t *mCamera3Stream;
329    uint32_t mNumBufsRegistered;
330    uint32_t mNumSnapshotBufs;
331    uint32_t mYuvWidth, mYuvHeight;
332    uint32_t mCurrentBufIndex;
333    cam_stream_type_t mStreamType;
334    cam_format_t mStreamFormat;
335    bool m_bWNROn;
336    bool mPostProcStarted;
337    bool mInputBufferConfig;   // Set when the picture channel is configured
338                               // for processing input(framework) buffers
339
340    QCamera3GrallocMemory mMemory;
341    QCamera3HeapMemory *mYuvMemory;
342    QCamera3Channel *m_pMetaChannel;
343    mm_camera_super_buf_t *mMetaFrame;
344    QCamera3GrallocMemory mOfflineMemory;
345    QCamera3HeapMemory mOfflineMetaMemory;
346
347    // Keep a list of free buffers
348    Mutex mFreeBuffersLock;
349    List<uint32_t> mFreeBufferList;
350};
351
352// reprocess channel class
353class QCamera3ReprocessChannel : public QCamera3Channel
354{
355public:
356    QCamera3ReprocessChannel(uint32_t cam_handle,
357                            mm_camera_ops_t *cam_ops,
358                            channel_cb_routine cb_routine,
359                            cam_padding_info_t *paddingInfo,
360                            uint32_t postprocess_mask,
361                            void *userData, void *ch_hdl);
362    QCamera3ReprocessChannel();
363    virtual ~QCamera3ReprocessChannel();
364    // offline reprocess
365    int32_t doReprocessOffline(qcamera_fwk_input_pp_data_t *frame);
366    int32_t doReprocess(int buf_fd, size_t buf_length, int32_t &ret_val,
367                        mm_camera_super_buf_t *meta_buf);
368    int32_t extractFrameCropAndRotation(mm_camera_super_buf_t *frame,
369            mm_camera_buf_def_t *meta_buffer,
370            jpeg_settings_t *jpeg_settings,
371            qcamera_fwk_input_pp_data_t &fwk_frame);
372    int32_t extractCrop(qcamera_fwk_input_pp_data_t *frame);
373    virtual QCamera3Memory *getStreamBufs(uint32_t len);
374    virtual void putStreamBufs();
375    virtual int32_t initialize(cam_is_type_t isType);
376    int32_t unmapOfflineBuffers(bool all);
377    virtual int32_t stop();
378    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
379                            QCamera3Stream *stream);
380    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
381                                       void* userdata);
382    int32_t addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config,
383           const reprocess_config_t &src_config,
384           cam_is_type_t is_type,
385           QCamera3Channel *pMetaChannel);
386    QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle);
387    QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle);
388    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
389            { return NO_ERROR; };
390
391public:
392    void *picChHandle;
393private:
394    typedef struct {
395        QCamera3Stream *stream;
396        cam_mapping_buf_type type;
397        uint32_t index;
398    } OfflineBuffer;
399
400    android::List<OfflineBuffer> mOfflineBuffers;
401    android::List<OfflineBuffer> mOfflineMetaBuffers;
402    int32_t mOfflineBuffersIndex;
403    int32_t mOfflineMetaIndex;
404    uint32_t mSrcStreamHandles[MAX_STREAM_NUM_IN_BUNDLE];
405    QCamera3Channel *m_pSrcChannel; // ptr to source channel for reprocess
406    QCamera3Channel *m_pMetaChannel;
407    QCamera3HeapMemory *mMemory;
408};
409
410
411/* QCamera3SupportChannel is for HAL internal consumption only */
412class QCamera3SupportChannel : public QCamera3Channel
413{
414public:
415    QCamera3SupportChannel(uint32_t cam_handle,
416                    mm_camera_ops_t *cam_ops,
417                    cam_padding_info_t *paddingInfo,
418                    uint32_t postprocess_mask,
419                    cam_stream_type_t streamType,
420                    cam_dimension_t *dim,
421                    void *userData,
422                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM);
423    virtual ~QCamera3SupportChannel();
424
425    virtual int32_t initialize(cam_is_type_t isType);
426
427    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
428    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
429                            QCamera3Stream *stream);
430
431    virtual QCamera3Memory *getStreamBufs(uint32_t le);
432    virtual void putStreamBufs();
433    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
434            { return NO_ERROR; };
435
436    static cam_dimension_t kDim;
437private:
438    QCamera3HeapMemory *mMemory;
439    cam_dimension_t mDim;
440    cam_stream_type_t mStreamType;
441};
442
443}; // namespace qcamera
444
445#endif /* __QCAMERA_CHANNEL_H__ */
446