QCamera3Channel.h revision e363fcca375a7083001c406c0aad97382bfbba9f 
1/* Copyright (c) 2012-2013, 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
47namespace qcamera {
48
49typedef void (*channel_cb_routine)(mm_camera_super_buf_t *metadata,
50                                camera3_stream_buffer_t *buffer,
51                                uint32_t frame_number, void *userdata);
52
53class QCamera3Channel
54{
55public:
56    QCamera3Channel(uint32_t cam_handle,
57                   mm_camera_ops_t *cam_ops,
58                   channel_cb_routine cb_routine,
59                   cam_padding_info_t *paddingInfo,
60                   uint32_t postprocess_mask,
61                   void *userData);
62    QCamera3Channel();
63    virtual ~QCamera3Channel();
64
65    int32_t addStream(cam_stream_type_t streamType,
66                      cam_format_t streamFormat,
67                      cam_dimension_t streamDim,
68                      uint8_t minStreamBufnum,
69                      uint32_t postproc_mask);
70    virtual int32_t start();
71    int32_t stop();
72    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
73
74    uint32_t getStreamTypeMask();
75    uint32_t getStreamID(uint32_t streamMask);
76    virtual int32_t initialize() = 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) = 0;
87    virtual QCamera3Memory *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    uint8_t getNumOfStreams() const {return m_numStreams;};
93    QCamera3Stream *getStreamByIndex(uint8_t index);
94
95    static void streamCbRoutine(mm_camera_super_buf_t *super_frame,
96                QCamera3Stream *stream, void *userdata);
97    void *mUserData;
98    cam_padding_info_t *mPaddingInfo;
99    QCamera3Stream *mStreams[MAX_STREAM_NUM_IN_BUNDLE];
100    uint8_t m_numStreams;
101protected:
102
103   virtual int32_t init(mm_camera_channel_attr_t *attr,
104                         mm_camera_buf_notify_t dataCB);
105    int32_t allocateStreamInfoBuf(camera3_stream_t *stream);
106
107    uint32_t m_camHandle;
108    mm_camera_ops_t *m_camOps;
109    bool m_bIsActive;
110
111    uint32_t m_handle;
112
113
114    mm_camera_buf_notify_t mDataCB;
115
116
117    QCamera3HeapMemory *mStreamInfoBuf;
118    channel_cb_routine mChannelCB;
119    //cam_padding_info_t *mPaddingInfo;
120    uint32_t mPostProcMask;
121};
122
123/* QCamera3RegularChannel is used to handle all streams that are directly
124 * generated by hardware and given to frameworks without any postprocessing at HAL.
125 * Examples are: all IMPLEMENTATION_DEFINED streams, CPU_READ streams. */
126class QCamera3RegularChannel : public QCamera3Channel
127{
128public:
129    QCamera3RegularChannel(uint32_t cam_handle,
130                    mm_camera_ops_t *cam_ops,
131                    channel_cb_routine cb_routine,
132                    cam_padding_info_t *paddingInfo,
133                    void *userData,
134                    camera3_stream_t *stream,
135                    cam_stream_type_t stream_type,
136                    uint32_t postprocess_mask);
137
138    virtual ~QCamera3RegularChannel();
139
140    virtual int32_t start();
141    virtual int32_t initialize();
142    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
143    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
144                                            QCamera3Stream *stream);
145
146    virtual QCamera3Memory *getStreamBufs(uint32_t le);
147    virtual void putStreamBufs();
148    virtual int32_t registerBuffer(buffer_handle_t *buffer);
149
150public:
151    static int kMaxBuffers;
152protected:
153    QCamera3GrallocMemory mMemory;
154private:
155    int32_t initialize(struct private_handle_t *priv_handle);
156
157    camera3_stream_t *mCamera3Stream;
158    uint32_t mNumBufs;
159    cam_stream_type_t mStreamType; // Stream type
160};
161
162/* QCamera3MetadataChannel is for metadata stream generated by camera daemon. */
163class QCamera3MetadataChannel : public QCamera3Channel
164{
165public:
166    QCamera3MetadataChannel(uint32_t cam_handle,
167                    mm_camera_ops_t *cam_ops,
168                    channel_cb_routine cb_routine,
169                    cam_padding_info_t *paddingInfo,
170                    uint32_t postprocess_mask,
171                    void *userData);
172    virtual ~QCamera3MetadataChannel();
173
174    virtual int32_t initialize();
175
176    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
177    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
178                            QCamera3Stream *stream);
179
180    virtual QCamera3Memory *getStreamBufs(uint32_t le);
181    virtual void putStreamBufs();
182    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
183            { return NO_ERROR; };
184
185private:
186    QCamera3HeapMemory *mMemory;
187};
188
189/* QCamera3RawChannel is for opaqueu/cross-platform raw stream containing
190 * vendor specific bayer data or 16-bit unpacked bayer data */
191class QCamera3RawChannel : public QCamera3RegularChannel
192{
193public:
194    QCamera3RawChannel(uint32_t cam_handle,
195                    mm_camera_ops_t *cam_ops,
196                    channel_cb_routine cb_routine,
197                    cam_padding_info_t *paddingInfo,
198                    void *userData,
199                    camera3_stream_t *stream,
200                    uint32_t postprocess_mask,
201                    bool raw_16 = false);
202    virtual ~QCamera3RawChannel();
203
204    virtual int32_t initialize();
205
206    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
207                            QCamera3Stream *stream);
208
209public:
210    static int kMaxBuffers;
211
212private:
213    bool mRawDump;
214    bool mIsRaw16;
215
216    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
217    void convertToRaw16(mm_camera_buf_def_t *frame);
218};
219
220/* QCamera3PicChannel is for JPEG stream, which contains a YUV stream generated
221 * by the hardware, and encoded to a JPEG stream */
222class QCamera3PicChannel : public QCamera3Channel
223{
224public:
225    QCamera3PicChannel(uint32_t cam_handle,
226            mm_camera_ops_t *cam_ops,
227            channel_cb_routine cb_routine,
228            cam_padding_info_t *paddingInfo,
229            void *userData,
230            camera3_stream_t *stream,
231            uint32_t postprocess_mask);
232    ~QCamera3PicChannel();
233
234    virtual int32_t initialize();
235
236    virtual int32_t request(buffer_handle_t *buffer,
237            uint32_t frameNumber,
238            camera3_stream_buffer_t* pInputBuffer,
239            metadata_buffer_t* metadata);
240    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
241            QCamera3Stream *stream);
242
243    virtual QCamera3Memory *getStreamBufs(uint32_t le);
244    virtual void putStreamBufs();
245
246    bool isWNREnabled() {return m_bWNROn;};
247    bool needOnlineRotation();
248    QCamera3Exif *getExifData(metadata_buffer_t *metadata,
249            jpeg_settings_t *jpeg_settings);
250    void overrideYuvSize(uint32_t width, uint32_t height);
251    static void jpegEvtHandle(jpeg_job_status_t status,
252            uint32_t /*client_hdl*/,
253            uint32_t jobId,
254            mm_jpeg_output_t *p_output,
255            void *userdata);
256    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
257            void *userdata);
258    virtual int32_t registerBuffer(buffer_handle_t *buffer);
259    int32_t queueReprocMetadata(metadata_buffer_t *metadata);
260
261private:
262    int32_t queueJpegSetting(int32_t out_buf_index, metadata_buffer_t *metadata);
263
264public:
265    static int kMaxBuffers;
266    QCamera3PostProcessor m_postprocessor; // post processor
267    cam_dimension_t m_max_pic_dim;
268
269private:
270    camera3_stream_t *mCamera3Stream;
271    uint32_t mNumBufs;
272    uint32_t mYuvWidth, mYuvHeight;
273    int32_t mCurrentBufIndex;
274    cam_stream_type_t mStreamType;
275    cam_format_t mStreamFormat;
276    bool m_bWNROn;
277
278    QCamera3GrallocMemory mMemory;
279    QCamera3HeapMemory *mYuvMemory;
280    QCamera3Channel *m_pMetaChannel;
281    mm_camera_super_buf_t *mMetaFrame;
282    QCamera3GrallocMemory mOfflineMemory;
283    QCamera3HeapMemory mOfflineMetaMemory;
284};
285
286// reprocess channel class
287class QCamera3ReprocessChannel : public QCamera3Channel
288{
289public:
290    QCamera3ReprocessChannel(uint32_t cam_handle,
291                            mm_camera_ops_t *cam_ops,
292                            channel_cb_routine cb_routine,
293                            cam_padding_info_t *paddingInfo,
294                            uint32_t postprocess_mask,
295                            void *userData, void *ch_hdl);
296    QCamera3ReprocessChannel();
297    virtual ~QCamera3ReprocessChannel();
298    // offline reprocess
299    int32_t doReprocessOffline(mm_camera_super_buf_t *frame,
300                        metadata_buffer_t *metadata);
301    int32_t doReprocessOffline(qcamera_fwk_input_pp_data_t *frame);
302    int32_t doReprocess(int buf_fd, uint32_t buf_length, int32_t &ret_val,
303                        mm_camera_super_buf_t *meta_buf);
304    virtual QCamera3Memory *getStreamBufs(uint32_t len);
305    virtual void putStreamBufs();
306    virtual int32_t initialize();
307    int32_t unmapOfflineBuffers();
308    virtual int32_t stop();
309    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
310                            QCamera3Stream *stream);
311    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
312                                       void* userdata);
313    int32_t addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config,
314           const reprocess_config_t &src_config,
315           QCamera3Channel *pMetaChannel);
316    QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle);
317    QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle);
318    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
319            { return NO_ERROR; };
320
321public:
322    void *picChHandle;
323private:
324    typedef struct {
325        QCamera3Stream *stream;
326        cam_mapping_buf_type type;
327        int index;
328    } OfflineBuffer;
329
330    android::List<OfflineBuffer> mOfflineBuffers;
331    uint32_t mSrcStreamHandles[MAX_STREAM_NUM_IN_BUNDLE];
332    QCamera3Channel *m_pSrcChannel; // ptr to source channel for reprocess
333    QCamera3Channel *m_pMetaChannel;
334    QCamera3HeapMemory *mMemory;
335};
336
337/* QCamera3SupportChannel is for HAL internal consumption only */
338class QCamera3SupportChannel : public QCamera3Channel
339{
340public:
341    QCamera3SupportChannel(uint32_t cam_handle,
342                    mm_camera_ops_t *cam_ops,
343                    cam_padding_info_t *paddingInfo,
344                    uint32_t postprocess_mask,
345                    void *userData);
346    virtual ~QCamera3SupportChannel();
347
348    virtual int32_t initialize();
349
350    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
351    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
352                            QCamera3Stream *stream);
353
354    virtual QCamera3Memory *getStreamBufs(uint32_t le);
355    virtual void putStreamBufs();
356    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
357            { return NO_ERROR; };
358
359    static cam_dimension_t kDim;
360private:
361    QCamera3HeapMemory *mMemory;
362};
363
364}; // namespace qcamera
365
366#endif /* __QCAMERA_CHANNEL_H__ */
367