QCamera3Channel.h revision 994b23c3be9b00a77b60b8d07ff8aeea1de4d47b 
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
40extern "C" {
41#include <mm_camera_interface.h>
42}
43
44using namespace android;
45
46namespace qcamera {
47
48typedef void (*channel_cb_routine)(mm_camera_super_buf_t *metadata,
49                                camera3_stream_buffer_t *buffer,
50                                uint32_t frame_number, void *userdata);
51
52class QCamera3Channel
53{
54public:
55    QCamera3Channel(uint32_t cam_handle,
56                   mm_camera_ops_t *cam_ops,
57                   channel_cb_routine cb_routine,
58                   cam_padding_info_t *paddingInfo,
59                   void *userData);
60    QCamera3Channel();
61    virtual ~QCamera3Channel();
62
63    int32_t addStream(cam_stream_type_t streamType,
64                              cam_format_t streamFormat,
65                              cam_dimension_t streamDim,
66                              uint8_t minStreamBufnum);
67    virtual int32_t start();
68    int32_t stop();
69    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
70
71    uint32_t getStreamTypeMask();
72    uint32_t getStreamID(uint32_t streamMask);
73    virtual int32_t initialize() = 0;
74    virtual int32_t request(buffer_handle_t * /*buffer*/,
75                uint32_t /*frameNumber*/){ return 0;};
76    virtual int32_t request(buffer_handle_t * /*buffer*/,
77                uint32_t /*frameNumber*/,
78                mm_camera_buf_def_t* /*pInputBuffer*/,
79                metadata_buffer_t* /*metadata*/){ return 0;};
80    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
81                            QCamera3Stream *stream) = 0;
82
83    virtual int32_t registerBuffer(buffer_handle_t *buffer) = 0;
84    virtual QCamera3Memory *getStreamBufs(uint32_t len) = 0;
85    virtual void putStreamBufs() = 0;
86
87    QCamera3Stream *getStreamByHandle(uint32_t streamHandle);
88    uint32_t getMyHandle() const {return m_handle;};
89    uint8_t getNumOfStreams() const {return m_numStreams;};
90    QCamera3Stream *getStreamByIndex(uint8_t index);
91
92    static void streamCbRoutine(mm_camera_super_buf_t *super_frame,
93                QCamera3Stream *stream, void *userdata);
94    void *mUserData;
95    cam_padding_info_t *mPaddingInfo;
96    QCamera3Stream *mStreams[MAX_STREAM_NUM_IN_BUNDLE];
97    uint8_t m_numStreams;
98protected:
99
100   virtual int32_t init(mm_camera_channel_attr_t *attr,
101                         mm_camera_buf_notify_t dataCB);
102    int32_t allocateStreamInfoBuf(camera3_stream_t *stream);
103
104    uint32_t m_camHandle;
105    mm_camera_ops_t *m_camOps;
106    bool m_bIsActive;
107
108    uint32_t m_handle;
109
110
111    mm_camera_buf_notify_t mDataCB;
112
113
114    QCamera3HeapMemory *mStreamInfoBuf;
115    channel_cb_routine mChannelCB;
116    //cam_padding_info_t *mPaddingInfo;
117};
118
119/* QCamera3RegularChannel is used to handle all streams that are directly
120 * generated by hardware and given to frameworks without any postprocessing at HAL.
121 * Examples are: all IMPLEMENTATION_DEFINED streams, CPU_READ streams. */
122class QCamera3RegularChannel : public QCamera3Channel
123{
124public:
125    QCamera3RegularChannel(uint32_t cam_handle,
126                    mm_camera_ops_t *cam_ops,
127                    channel_cb_routine cb_routine,
128                    cam_padding_info_t *paddingInfo,
129                    void *userData,
130                    camera3_stream_t *stream,
131                    cam_stream_type_t stream_type);
132    QCamera3RegularChannel(uint32_t cam_handle,
133                    mm_camera_ops_t *cam_ops,
134                    channel_cb_routine cb_routine,
135                    cam_padding_info_t *paddingInfo,
136                    void *userData,
137                    camera3_stream_t *stream,
138                    uint32_t width, uint32_t height,
139                    cam_stream_type_t stream_type);
140
141    virtual ~QCamera3RegularChannel();
142
143    virtual int32_t start();
144    virtual int32_t initialize();
145    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
146    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
147                                            QCamera3Stream *stream);
148
149    virtual QCamera3Memory *getStreamBufs(uint32_t le);
150    virtual void putStreamBufs();
151    mm_camera_buf_def_t* getInternalFormatBuffer(buffer_handle_t* buffer);
152    virtual int32_t registerBuffer(buffer_handle_t *buffer);
153
154public:
155    static int kMaxBuffers;
156private:
157    int32_t initialize(struct private_handle_t *priv_handle);
158
159    camera3_stream_t *mCamera3Stream;
160    uint32_t mNumBufs;
161
162    QCamera3GrallocMemory mMemory;
163    // width and height of internal stream may be different than what's
164    // specified in camera3_stream_t. For example: ZSL stream size is
165    // always the active region size, but internally we use the JPEG
166    // size.
167    uint32_t mWidth, mHeight;
168    cam_stream_type_t mStreamType; // Stream type
169};
170
171/* QCamera3MetadataChannel is for metadata stream generated by camera daemon. */
172class QCamera3MetadataChannel : public QCamera3Channel
173{
174public:
175    QCamera3MetadataChannel(uint32_t cam_handle,
176                    mm_camera_ops_t *cam_ops,
177                    channel_cb_routine cb_routine,
178                    cam_padding_info_t *paddingInfo,
179                    void *userData);
180    virtual ~QCamera3MetadataChannel();
181
182    virtual int32_t initialize();
183
184    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
185    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
186                            QCamera3Stream *stream);
187
188    virtual QCamera3Memory *getStreamBufs(uint32_t le);
189    virtual void putStreamBufs();
190    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
191            { return NO_ERROR; };
192
193private:
194    QCamera3HeapMemory *mMemory;
195};
196
197/* QCameraRawChannel is for Dumping raw stream generated by camera daemon. */
198class QCameraRawChannel : public QCamera3Channel
199{
200public:
201    QCameraRawChannel(uint32_t cam_handle,
202                    mm_camera_ops_t *cam_ops,
203                    channel_cb_routine cb_routine,
204                    cam_padding_info_t *paddingInfo,
205                    void *userData,
206                    cam_dimension_t *raw_dim);
207    virtual ~QCameraRawChannel();
208
209    virtual int32_t initialize();
210
211    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber);
212    virtual int32_t registerBuffers(uint32_t num_buffers,
213                buffer_handle_t **buffers);
214    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
215                            QCamera3Stream *stream);
216
217    virtual QCamera3Memory *getStreamBufs(uint32_t le);
218    virtual void putStreamBufs();
219    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
220    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
221            { return NO_ERROR; };
222
223private:
224    QCamera3HeapMemory *mMemory;
225    uint32_t mWidth, mHeight;
226    uint32_t mMaxBuffers;
227};
228
229
230/* QCamera3PicChannel is for JPEG stream, which contains a YUV stream generated
231 * by the hardware, and encoded to a JPEG stream */
232class QCamera3PicChannel : public QCamera3Channel
233{
234public:
235    QCamera3PicChannel(uint32_t cam_handle,
236            mm_camera_ops_t *cam_ops,
237            channel_cb_routine cb_routine,
238            cam_padding_info_t *paddingInfo,
239            void *userData,
240            camera3_stream_t *stream);
241    ~QCamera3PicChannel();
242
243    virtual int32_t initialize();
244
245    virtual int32_t request(buffer_handle_t *buffer,
246            uint32_t frameNumber,
247            mm_camera_buf_def_t* pInputBuffer,
248            metadata_buffer_t* metadata);
249    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
250            QCamera3Stream *stream);
251
252    virtual QCamera3Memory *getStreamBufs(uint32_t le);
253    virtual void putStreamBufs();
254
255    bool isWNREnabled() {return m_bWNROn;};
256    bool needOnlineRotation();
257    QCamera3Exif *getExifData(metadata_buffer_t *metadata,
258            jpeg_settings_t *jpeg_settings);
259    void overrideYuvSize(uint32_t width, uint32_t height);
260    static void jpegEvtHandle(jpeg_job_status_t status,
261            uint32_t /*client_hdl*/,
262            uint32_t jobId,
263            mm_jpeg_output_t *p_output,
264            void *userdata);
265    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
266            void *userdata);
267    virtual int32_t registerBuffer(buffer_handle_t *buffer);
268    int32_t queueReprocMetadata(metadata_buffer_t *metadata);
269
270private:
271    int32_t queueJpegSetting(int32_t out_buf_index, metadata_buffer_t *metadata);
272
273public:
274    static int kMaxBuffers;
275    QCamera3PostProcessor m_postprocessor; // post processor
276    cam_dimension_t m_max_pic_dim;
277
278private:
279    camera3_stream_t *mCamera3Stream;
280    uint32_t mNumBufs;
281    uint32_t mYuvWidth, mYuvHeight;
282    int32_t mCurrentBufIndex;
283    bool m_bWNROn;
284
285    QCamera3GrallocMemory mMemory;
286    QCamera3HeapMemory *mYuvMemory;
287    QCamera3Channel *m_pMetaChannel;
288    mm_camera_super_buf_t *mMetaFrame;
289
290};
291
292// reprocess channel class
293class QCamera3ReprocessChannel : public QCamera3Channel
294{
295public:
296    QCamera3ReprocessChannel(uint32_t cam_handle,
297                            mm_camera_ops_t *cam_ops,
298                            channel_cb_routine cb_routine,
299                            cam_padding_info_t *paddingInfo,
300                            void *userData, void *ch_hdl);
301    QCamera3ReprocessChannel();
302    virtual ~QCamera3ReprocessChannel();
303    // online reprocess
304    int32_t doReprocess(mm_camera_super_buf_t *frame,
305                        mm_camera_super_buf_t *meta_frame);
306    int32_t doReprocessOffline(mm_camera_super_buf_t *frame,
307                        metadata_buffer_t *metadata);
308    // offline reprocess
309    int32_t doReprocess(int buf_fd, uint32_t buf_length, int32_t &ret_val,
310                        mm_camera_super_buf_t *meta_buf);
311    virtual QCamera3Memory *getStreamBufs(uint32_t len);
312    virtual void putStreamBufs();
313    virtual int32_t initialize();
314    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
315                            QCamera3Stream *stream);
316    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
317                                       void* userdata);
318    int32_t addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config,
319                                       QCamera3Channel *pSrcChannel,
320                                       QCamera3Channel *pMetaChannel);
321    QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle);
322    QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle);
323    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/)
324            { return NO_ERROR; };
325
326public:
327    void *picChHandle;
328private:
329    uint32_t mSrcStreamHandles[MAX_STREAM_NUM_IN_BUNDLE];
330    QCamera3Channel *m_pSrcChannel; // ptr to source channel for reprocess
331    QCamera3Channel *m_pMetaChannel;
332    QCamera3HeapMemory *mMemory;
333};
334
335}; // namespace qcamera
336
337#endif /* __QCAMERA_CHANNEL_H__ */
338