1/* Copyright (c) 2012-2016, The Linux Foundation. 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// System dependencies
34#include <utils/List.h>
35#include <utils/Mutex.h>
36#include <utils/Vector.h>
37#include "gralloc_priv.h"
38#include <sys/stat.h>
39// Camera dependencies
40#include "cam_intf.h"
41#include "cam_types.h"
42#include "hardware/camera3.h"
43#include "QCamera3HALHeader.h"
44#include "QCamera3Mem.h"
45#include "QCamera3PostProc.h"
46#include "QCamera3Stream.h"
47#include "QCamera3StreamMem.h"
48
49#include "HdrPlusClient.h"
50
51extern "C" {
52#include "mm_camera_interface.h"
53#include "mm_jpeg_interface.h"
54}
55
56using namespace android;
57
58#define MIN_STREAMING_BUFFER_NUM 7+11
59
60#define QCAMERA_DUMP_FRM_PREVIEW          1
61#define QCAMERA_DUMP_FRM_VIDEO            (1<<1)
62#define QCAMERA_DUMP_FRM_INPUT_JPEG       (1<<2)
63#define QCAMERA_DUMP_FRM_CALLBACK         (1<<3)
64#define QCAMERA_DUMP_FRM_OUTPUT_JPEG      (1<<5)
65#define QCAMERA_DUMP_FRM_INPUT_REPROCESS  (1<<6)
66
67typedef int64_t nsecs_t;
68
69namespace qcamera {
70
71typedef void (*channel_cb_routine)(mm_camera_super_buf_t *metadata,
72                                camera3_stream_buffer_t *buffer,
73                                uint32_t frame_number, bool isInputBuffer,
74                                void *userdata);
75
76typedef void (*channel_cb_buffer_err)(QCamera3Channel* ch, uint32_t frameNumber,
77                                camera3_buffer_status_t err,
78                                void *userdata);
79
80class QCamera3Channel
81{
82public:
83    QCamera3Channel(uint32_t cam_handle,
84                   uint32_t channel_handle,
85                   mm_camera_ops_t *cam_ops,
86                   channel_cb_routine cb_routine,
87                   channel_cb_buffer_err cb_buf_err,
88                   cam_padding_info_t *paddingInfo,
89                   cam_feature_mask_t postprocess_mask,
90                   void *userData, uint32_t numBuffers);
91    virtual ~QCamera3Channel();
92
93    virtual int32_t start();
94    virtual int32_t stop();
95    virtual int32_t setBatchSize(uint32_t);
96    virtual int32_t queueBatchBuf();
97    virtual int32_t setPerFrameMapUnmap(bool enable);
98    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
99    virtual int32_t setBundleInfo(const cam_bundle_config_t &bundleInfo);
100
101    virtual uint32_t getStreamTypeMask();
102    uint32_t getStreamID(uint32_t streamMask);
103    void destroy();
104    virtual int32_t initialize(cam_is_type_t isType) = 0;
105    virtual int32_t request(buffer_handle_t * /*buffer*/,
106                uint32_t /*frameNumber*/,
107                int &/*indexUsed*/){ return 0;};
108    virtual int32_t request(buffer_handle_t * /*buffer*/,
109                uint32_t /*frameNumber*/,
110                camera3_stream_buffer_t* /*pInputBuffer*/,
111                metadata_buffer_t* /*metadata*/,
112                int & /*indexUsed*/,
113                __unused bool internalRequest = false,
114                __unused bool meteringOnly = false){ return 0;};
115    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
116                            QCamera3Stream *stream) = 0;
117
118    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType) = 0;
119    virtual QCamera3StreamMem *getStreamBufs(uint32_t len) = 0;
120    virtual void putStreamBufs() = 0;
121    virtual int32_t flush();
122
123    QCamera3Stream *getStreamByHandle(uint32_t streamHandle);
124    uint32_t getMyHandle() const {return m_handle;};
125    uint32_t getNumOfStreams() const {return m_numStreams;};
126    uint32_t getNumBuffers() const {return mNumBuffers;};
127    QCamera3Stream *getStreamByIndex(uint32_t index);
128
129    static void streamCbRoutine(mm_camera_super_buf_t *super_frame,
130                QCamera3Stream *stream, void *userdata);
131    void dumpYUV(mm_camera_buf_def_t *frame, cam_dimension_t dim,
132            cam_frame_len_offset_t offset, uint8_t name);
133    static bool isUBWCEnabled();
134    void setUBWCEnabled(bool val);
135    static cam_format_t getStreamDefaultFormat(cam_stream_type_t type,
136            uint32_t width, uint32_t height, bool forcePreviewUBWC, cam_is_type_t isType);
137    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) = 0;
138
139    void setNRMode(uint8_t nrMode) { mNRMode = nrMode; }
140    uint8_t getNRMode() { return mNRMode; }
141
142    void *mUserData;
143    cam_padding_info_t mPaddingInfo;
144    QCamera3Stream *mStreams[MAX_STREAM_NUM_IN_BUNDLE];
145    uint32_t m_numStreams;
146protected:
147
148    int32_t addStream(cam_stream_type_t streamType,
149                      cam_format_t streamFormat,
150                      cam_dimension_t streamDim,
151                      cam_rotation_t streamRotation,
152                      uint8_t minStreamBufnum,
153                      cam_feature_mask_t postprocessMask,
154                      cam_is_type_t isType,
155                      uint32_t batchSize = 0);
156
157    int32_t allocateStreamInfoBuf(camera3_stream_t *stream);
158
159    uint32_t m_camHandle;
160    mm_camera_ops_t *m_camOps;
161    bool m_bIsActive;
162    bool m_bUBWCenable;
163
164    uint32_t m_handle;
165
166
167    mm_camera_buf_notify_t mDataCB;
168
169
170    QCamera3HeapMemory *mStreamInfoBuf;
171    channel_cb_routine mChannelCB;
172    channel_cb_buffer_err mChannelCbBufErr;
173    //cam_padding_info_t *mPaddingInfo;
174    cam_feature_mask_t mPostProcMask;
175    uint32_t mYUVDump;
176    cam_is_type_t mIsType;
177    uint32_t mNumBuffers;
178    /* Enable unmapping of buffer before issuing buffer callback. Default value
179     * for this flag is true and is selectively set to false for the usecases
180     * such as HFR to avoid any performance hit due to mapping/unmapping */
181    bool    mPerFrameMapUnmapEnable;
182    uint32_t mFrmNum;
183    uint32_t mDumpFrmCnt;
184    uint32_t mSkipMode;
185    uint32_t mDumpSkipCnt;
186    uint8_t mNRMode;
187    bool    mMapStreamBuffers; // Whether to mmap all stream buffers
188};
189
190/* QCamera3ProcessingChannel is used to handle all streams that are directly
191 * generated by hardware and given to frameworks without any postprocessing at HAL.
192 * It also handles input streams that require reprocessing by hardware and then
193 * returned to frameworks. */
194class QCamera3ProcessingChannel : public QCamera3Channel
195{
196public:
197   QCamera3ProcessingChannel(uint32_t cam_handle,
198           uint32_t channel_handle,
199           mm_camera_ops_t *cam_ops,
200           channel_cb_routine cb_routine,
201           channel_cb_buffer_err cb_buffer_err,
202           cam_padding_info_t *paddingInfo,
203           void *userData,
204           camera3_stream_t *stream,
205           cam_stream_type_t stream_type,
206           cam_feature_mask_t postprocess_mask,
207           QCamera3Channel *metadataChannel,
208           uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
209
210    ~QCamera3ProcessingChannel();
211
212    virtual int32_t initialize(cam_is_type_t isType);
213    virtual int32_t request(buffer_handle_t *buffer,
214            uint32_t frameNumber,
215            camera3_stream_buffer_t* pInputBuffer,
216            metadata_buffer_t* metadata, int &indexUsed,
217            __unused bool internalRequest, __unused bool meteringOnly);
218    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
219            QCamera3Stream *stream);
220    virtual QCamera3StreamMem *getStreamBufs(uint32_t len);
221    virtual void putStreamBufs();
222    virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType);
223    // Register a buffer and get the buffer def for the registered buffer.
224    virtual int32_t registerBufferAndGetBufDef(buffer_handle_t *buffer, mm_camera_buf_def_t *frame);
225    // Unregister a buffer.
226    virtual void unregisterBuffer(mm_camera_buf_def_t *frame);
227    virtual int32_t stop();
228
229    virtual reprocess_type_t getReprocessType() = 0;
230
231    virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer,
232            uint32_t resultFrameNumber);
233
234    int32_t queueReprocMetadata(mm_camera_super_buf_t *metadata);
235    virtual int32_t metadataBufDone(mm_camera_super_buf_t *recvd_frame);
236    int32_t translateStreamTypeAndFormat(camera3_stream_t *stream,
237            cam_stream_type_t &streamType,
238            cam_format_t &streamFormat);
239    int32_t setReprocConfig(reprocess_config_t &reproc_cfg,
240            camera3_stream_buffer_t *pInputBuffer,
241            metadata_buffer_t *metadata,
242            cam_format_t streamFormat, cam_dimension_t dim);
243    int32_t setFwkInputPPData(qcamera_fwk_input_pp_data_t *src_frame,
244            camera3_stream_buffer_t *pInputBuffer,
245            reprocess_config_t *reproc_cfg,
246            metadata_buffer_t *metadata,
247            buffer_handle_t *output_buffer,
248            uint32_t frameNumber);
249    int32_t checkStreamCbErrors(mm_camera_super_buf_t *super_frame,
250            QCamera3Stream *stream);
251    int32_t getStreamSize(cam_dimension_t &dim);
252    virtual int32_t timeoutFrame(uint32_t frameNumber);
253
254    QCamera3PostProcessor m_postprocessor; // post processor
255    void showDebugFPS(int32_t streamType);
256
257    int32_t releaseOfflineMemory(uint32_t resultFrameNumber);
258protected:
259    uint8_t mDebugFPS;
260    int mFrameCount;
261    int mLastFrameCount;
262    nsecs_t mLastFpsTime;
263    bool isWNREnabled() {return m_bWNROn;};
264    void startPostProc(const reprocess_config_t &reproc_cfg);
265    void issueChannelCb(buffer_handle_t *resultBuffer,
266            uint32_t resultFrameNumber);
267
268    QCamera3StreamMem mMemory; //output buffer allocated by fwk
269    camera3_stream_t *mCamera3Stream;
270    uint32_t mNumBufs;
271    cam_stream_type_t mStreamType;
272    cam_format_t mStreamFormat;
273    uint8_t mIntent;
274
275    bool mPostProcStarted;
276    reprocess_type_t mReprocessType; // Only valid when mPostProcStarted is true.
277    bool mInputBufferConfig;   // Set when the processing channel is configured
278                               // for processing input(framework) buffers
279
280    QCamera3Channel *m_pMetaChannel;
281    mm_camera_super_buf_t *mMetaFrame;
282    QCamera3StreamMem mOfflineMemory;      //reprocessing input buffer
283    QCamera3StreamMem mOfflineMetaMemory; //reprocessing metadata buffer
284    List<uint32_t> mFreeOfflineMetaBuffersList;
285    Mutex mFreeOfflineMetaBuffersLock;
286    android::List<mm_camera_super_buf_t *> mOutOfSequenceBuffers;
287
288private:
289
290    bool m_bWNROn;
291};
292
293/* QCamera3RegularChannel is used to handle all streams that are directly
294 * generated by hardware and given to frameworks without any postprocessing at HAL.
295 * Examples are: all IMPLEMENTATION_DEFINED streams, CPU_READ streams. */
296class QCamera3RegularChannel : public QCamera3ProcessingChannel
297{
298public:
299    QCamera3RegularChannel(uint32_t cam_handle,
300                    uint32_t channel_handle,
301                    mm_camera_ops_t *cam_ops,
302                    channel_cb_routine cb_routine,
303                    channel_cb_buffer_err cb_buffer_err,
304                    cam_padding_info_t *paddingInfo,
305                    void *userData,
306                    camera3_stream_t *stream,
307                    cam_stream_type_t stream_type,
308                    cam_feature_mask_t postprocess_mask,
309                    QCamera3Channel *metadataChannel,
310                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
311
312    virtual ~QCamera3RegularChannel();
313
314    virtual int32_t setBatchSize(uint32_t batchSize);
315    virtual uint32_t getStreamTypeMask();
316    virtual int32_t queueBatchBuf();
317    virtual int32_t initialize(cam_is_type_t isType);
318    using QCamera3ProcessingChannel::request;
319    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
320                    int &indexUsed);
321    virtual reprocess_type_t getReprocessType();
322
323private:
324    int32_t initialize(struct private_handle_t *priv_handle);
325
326    uint32_t mBatchSize;
327    cam_rotation_t mRotation;
328};
329
330/* QCamera3MetadataChannel is for metadata stream generated by camera daemon. */
331class QCamera3MetadataChannel : public QCamera3Channel
332{
333public:
334    QCamera3MetadataChannel(uint32_t cam_handle,
335                    uint32_t channel_handle,
336                    mm_camera_ops_t *cam_ops,
337                    channel_cb_routine cb_routine,
338                    channel_cb_buffer_err cb_buffer_err,
339                    cam_padding_info_t *paddingInfo,
340                    cam_feature_mask_t postprocess_mask,
341                    void *userData,
342                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM);
343    virtual ~QCamera3MetadataChannel();
344
345    virtual int32_t initialize(cam_is_type_t isType);
346
347    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
348                    int &indexUsed);
349    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
350                            QCamera3Stream *stream);
351
352    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
353    virtual void putStreamBufs();
354    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
355            { return NO_ERROR; };
356    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR; };
357
358    void enableDepthData(bool enable) { mDepthDataPresent = enable; }
359
360private:
361    QCamera3StreamMem *mMemory;
362    bool mDepthDataPresent;
363};
364
365/* QCamera3RawChannel is for opaqueu/cross-platform raw stream containing
366 * vendor specific bayer data or 16-bit unpacked bayer data */
367class QCamera3RawChannel : public QCamera3RegularChannel
368{
369public:
370    QCamera3RawChannel(uint32_t cam_handle,
371                    uint32_t channel_handle,
372                    mm_camera_ops_t *cam_ops,
373                    channel_cb_routine cb_routine,
374                    channel_cb_buffer_err cb_buffer_err,
375                    cam_padding_info_t *paddingInfo,
376                    void *userData,
377                    camera3_stream_t *stream,
378                    cam_feature_mask_t postprocess_mask,
379                    QCamera3Channel *metadataChannel,
380                    bool raw_16 = false,
381                    uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
382
383    virtual ~QCamera3RawChannel();
384
385    virtual int32_t initialize(cam_is_type_t isType);
386
387    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
388                            QCamera3Stream *stream);
389
390    virtual reprocess_type_t getReprocessType();
391
392private:
393    bool mRawDump;
394    bool mIsRaw16;
395
396    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
397    void convertLegacyToRaw16(mm_camera_buf_def_t *frame);
398    void convertMipiToRaw16(mm_camera_buf_def_t *frame);
399};
400
401/*
402 * QCamera3RawDumpChannel is for internal use only for Raw dump
403 */
404
405class QCamera3RawDumpChannel : public QCamera3Channel
406{
407public:
408    QCamera3RawDumpChannel(uint32_t cam_handle,
409                    uint32_t channel_handle,
410                    mm_camera_ops_t *cam_ops,
411                    cam_dimension_t rawDumpSize,
412                    cam_padding_info_t *paddingInfo,
413                    void *userData,
414                    cam_feature_mask_t postprocess_mask, uint32_t numBuffers = 3U);
415    virtual ~QCamera3RawDumpChannel();
416    virtual int32_t initialize(cam_is_type_t isType);
417    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
418                            QCamera3Stream *stream);
419    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
420    virtual void putStreamBufs();
421    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
422            { return NO_ERROR; };
423    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;};
424    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
425            int &indexUsed);
426    void dumpRawSnapshot(mm_camera_buf_def_t *frame);
427
428public:
429    cam_dimension_t mDim;
430
431private:
432    bool mRawDump;
433    QCamera3StreamMem *mMemory;
434};
435
436/*
437 * QCamera3HdrPlusRawSrcChannel is for internal use only for providing RAW input buffers to HDR+
438 * client for prototyping Paintbox HDR+.
439 */
440
441class QCamera3HdrPlusRawSrcChannel : public QCamera3RawDumpChannel
442{
443public:
444    QCamera3HdrPlusRawSrcChannel(
445                    uint32_t cam_handle,
446                    uint32_t channel_handle,
447                    mm_camera_ops_t *cam_ops,
448                    cam_dimension_t rawDumpSize,
449                    cam_padding_info_t *paddingInfo,
450                    void *userData,
451                    cam_feature_mask_t postprocess_mask,
452                    std::shared_ptr<HdrPlusClient> hdrPlusClient,
453                    uint32_t hdrPlusStreamId,   // HDR+ stream ID for RAW input
454                    uint32_t numBuffers = 3U);
455    virtual ~QCamera3HdrPlusRawSrcChannel();
456
457    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
458                            QCamera3Stream *stream) override;
459
460private:
461    // Send a RAW frame to HDR+ service as HDR+ input buffers.
462    void sendRawToHdrPlusService(mm_camera_buf_def_t *frame);
463    std::shared_ptr<HdrPlusClient> mHdrPlusClient;
464    // HDR+ stream ID.
465    uint32_t mHdrPlusStreamId;
466
467};
468
469/* QCamera3YUVChannel is used to handle flexible YUV streams that are directly
470 * generated by hardware and given to frameworks without any postprocessing at HAL.
471 * It is also used to handle input buffers that generate YUV outputs */
472class QCamera3YUVChannel : public QCamera3ProcessingChannel
473{
474public:
475    QCamera3YUVChannel(uint32_t cam_handle,
476            uint32_t channel_handle,
477            mm_camera_ops_t *cam_ops,
478            channel_cb_routine cb_routine,
479            channel_cb_buffer_err cb_buffer_err,
480            cam_padding_info_t *paddingInfo,
481            void *userData,
482            camera3_stream_t *stream,
483            cam_stream_type_t stream_type,
484            cam_feature_mask_t postprocess_mask,
485            QCamera3Channel *metadataChannel);
486    ~QCamera3YUVChannel();
487    virtual int32_t initialize(cam_is_type_t isType);
488    using QCamera3ProcessingChannel::request;
489    virtual int32_t request(buffer_handle_t *buffer,
490            uint32_t frameNumber,
491            camera3_stream_buffer_t* pInputBuffer,
492            metadata_buffer_t* metadata, bool &needMetadata,
493            int &indexUsed, bool internalRequest, bool meteringOnly);
494    virtual reprocess_type_t getReprocessType();
495    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
496            QCamera3Stream *stream);
497    virtual void putStreamBufs();
498    virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer,
499        uint32_t resultFrameNumber);
500
501private:
502    typedef struct {
503        uint32_t frameNumber;
504        bool offlinePpFlag;
505        buffer_handle_t *output;
506        mm_camera_super_buf_t *callback_buffer;
507    } PpInfo;
508
509    // Whether offline postprocessing is required for this channel
510    bool mBypass;
511    uint32_t mFrameLen;
512
513    // Current edge, noise, and crop region setting
514    cam_edge_application_t mEdgeMode;
515    uint32_t mNoiseRedMode;
516    cam_crop_region_t mCropRegion;
517
518    // Mutex to protect mOfflinePpFlagMap and mFreeHeapBufferList
519    Mutex mOfflinePpLock;
520    // Map between free number and whether the request needs to be
521    // postprocessed.
522    List<PpInfo> mOfflinePpInfoList;
523    // Heap buffer index list
524    List<uint32_t> mFreeHeapBufferList;
525
526private:
527    bool needsFramePostprocessing(metadata_buffer_t* meta);
528    int32_t handleOfflinePpCallback(uint32_t resultFrameNumber,
529            Vector<mm_camera_super_buf_t *>& pendingCbs);
530    mm_camera_super_buf_t* getNextPendingCbBuffer();
531};
532
533/* QCamera3PicChannel is for JPEG stream, which contains a YUV stream generated
534 * by the hardware, and encoded to a JPEG stream */
535class QCamera3PicChannel : public QCamera3ProcessingChannel
536{
537public:
538    QCamera3PicChannel(uint32_t cam_handle,
539            uint32_t channel_handle,
540            mm_camera_ops_t *cam_ops,
541            channel_cb_routine cb_routine,
542            channel_cb_buffer_err cb_buffer_err,
543            cam_padding_info_t *paddingInfo,
544            void *userData,
545            camera3_stream_t *stream,
546            cam_feature_mask_t postprocess_mask,
547            bool is4KVideo,
548            bool isInputStreamConfigured,
549            QCamera3Channel *metadataChannel,
550            uint32_t numBuffers = MAX_INFLIGHT_REQUESTS);
551    ~QCamera3PicChannel();
552
553    virtual int32_t initialize(cam_is_type_t isType);
554    virtual int32_t flush();
555    virtual int32_t request(buffer_handle_t *buffer,
556            uint32_t frameNumber,
557            camera3_stream_buffer_t* pInputBuffer,
558            metadata_buffer_t* metadata,
559            int &indexUsed, bool internalRequest, bool meteringOnly);
560    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
561            QCamera3Stream *stream);
562
563    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
564    virtual void putStreamBufs();
565    virtual reprocess_type_t getReprocessType();
566    virtual int32_t timeoutFrame(uint32_t frameNumber);
567
568    QCamera3Exif *getExifData(metadata_buffer_t *metadata,
569            jpeg_settings_t *jpeg_settings);
570    void overrideYuvSize(uint32_t width, uint32_t height);
571    static void jpegEvtHandle(jpeg_job_status_t status,
572            uint32_t /*client_hdl*/,
573            uint32_t jobId,
574            mm_jpeg_output_t *p_output,
575            void *userdata);
576    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
577            void *userdata);
578
579    // Reprocessing is done with the metadata. This function frees the metadata or returns the
580    // metadata to the metadata channel.
581    int32_t metadataBufDone(mm_camera_super_buf_t *recvd_frame) override;
582
583    // Get a YUV buffer for a request from camera service.
584    int32_t getYuvBufferForRequest(mm_camera_buf_def_t *frame, uint32_t frameNumber);
585
586    // Return a YUV buffer (from getYuvBufferForRequest) and request jpeg encoding.
587    int32_t returnYuvBufferAndEncode(mm_camera_buf_def_t *frame,
588            buffer_handle_t *outBuffer, uint32_t frameNumber,
589            std::shared_ptr<metadata_buffer_t> metadata);
590
591    // Return a YUV buffer (from getYuvBufferForRequest) without requesting jpeg encoding.
592    int32_t returnYuvBuffer(mm_camera_buf_def_t *frame);
593
594private:
595    int32_t queueJpegSetting(uint32_t out_buf_index, metadata_buffer_t *metadata);
596
597public:
598    cam_dimension_t m_max_pic_dim;
599
600private:
601    uint32_t mNumSnapshotBufs;
602    uint32_t mYuvWidth, mYuvHeight;
603    int32_t mCurrentBufIndex;
604    bool mInputBufferHint;
605    QCamera3StreamMem *mYuvMemory;
606    // Keep a list of free buffers
607    Mutex mFreeBuffersLock;
608    List<uint32_t> mFreeBufferList;
609    uint32_t mFrameLen;
610
611    // The metadata passed in via returnYuvBufferAndEncode and is allocated externally.
612    // These should not be returned to metadata channel.
613    Mutex mPendingExternalMetadataLock;
614    std::vector<std::shared_ptr<metadata_buffer_t>> mPendingExternalMetadata;
615};
616
617// reprocess channel class
618class QCamera3ReprocessChannel : public QCamera3Channel
619{
620public:
621    QCamera3ReprocessChannel(uint32_t cam_handle,
622                            uint32_t channel_handle,
623                            mm_camera_ops_t *cam_ops,
624                            channel_cb_routine cb_routine,
625                            channel_cb_buffer_err cb_buffer_err,
626                            cam_padding_info_t *paddingInfo,
627                            cam_feature_mask_t postprocess_mask,
628                            void *userData, void *ch_hdl);
629    QCamera3ReprocessChannel();
630    virtual ~QCamera3ReprocessChannel();
631    // offline reprocess
632    virtual int32_t start();
633    virtual int32_t stop();
634    int32_t doReprocessOffline(qcamera_fwk_input_pp_data_t *frame,
635            bool isPriorityFrame = false);
636    int32_t doReprocess(int buf_fd,void *buffer, size_t buf_length, int32_t &ret_val,
637                        mm_camera_super_buf_t *meta_buf);
638    int32_t overrideMetadata(qcamera_hal3_pp_buffer_t *pp_buffer,
639            mm_camera_buf_def_t *meta_buffer,
640            jpeg_settings_t *jpeg_settings,
641            qcamera_fwk_input_pp_data_t &fwk_frame);
642    int32_t overrideFwkMetadata(qcamera_fwk_input_pp_data_t *frame);
643    virtual QCamera3StreamMem *getStreamBufs(uint32_t len);
644    virtual void putStreamBufs();
645    virtual int32_t initialize(cam_is_type_t isType);
646    int32_t unmapOfflineBuffers(bool all);
647    int32_t bufDone(mm_camera_super_buf_t *recvd_frame);
648    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
649                            QCamera3Stream *stream);
650    static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame,
651                                       void* userdata);
652    int32_t addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config,
653           const reprocess_config_t &src_config,
654           cam_is_type_t is_type,
655           QCamera3Channel *pMetaChannel);
656    QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle);
657    QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle);
658    virtual int32_t registerBuffer(buffer_handle_t * buffer, cam_is_type_t isType);
659    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;};
660
661public:
662    void *inputChHandle;
663
664private:
665    typedef struct {
666        QCamera3Stream *stream;
667        cam_mapping_buf_type type;
668        uint32_t index;
669    } OfflineBuffer;
670
671    int32_t resetToCamPerfNormal(uint32_t frameNumber);
672    Mutex mOfflineBuffersLock; // Lock for offline buffers
673    android::List<OfflineBuffer> mOfflineBuffers;
674    android::List<OfflineBuffer> mOfflineMetaBuffers;
675    int32_t mOfflineBuffersIndex;
676    int32_t mOfflineMetaIndex;
677    uint32_t mFrameLen;
678    Mutex mFreeBuffersLock; // Lock for free heap buffers
679    List<int32_t> mFreeBufferList; // Free heap buffers list
680    reprocess_type_t mReprocessType;
681    uint32_t mSrcStreamHandles[MAX_STREAM_NUM_IN_BUNDLE];
682    QCamera3ProcessingChannel *m_pSrcChannel; // ptr to source channel for reprocess
683    QCamera3Channel *m_pMetaChannel;
684    QCamera3StreamMem *mMemory;
685    QCamera3StreamMem mGrallocMemory;
686    Vector<uint32_t> mPriorityFrames;
687    Mutex            mPriorityFramesLock;
688    bool             mReprocessPerfMode;
689};
690
691
692/* QCamera3SupportChannel is for HAL internal consumption only */
693class QCamera3SupportChannel : public QCamera3Channel
694{
695public:
696    QCamera3SupportChannel(uint32_t cam_handle,
697                    uint32_t channel_handle,
698                    mm_camera_ops_t *cam_ops,
699                    cam_padding_info_t *paddingInfo,
700                    cam_feature_mask_t postprocess_mask,
701                    cam_stream_type_t streamType,
702                    cam_dimension_t *dim,
703                    cam_format_t streamFormat,
704                    uint8_t hw_analysis_supported,
705                    cam_color_filter_arrangement_t color_arrangement,
706                    void *userData,
707                    uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM
708                    );
709    virtual ~QCamera3SupportChannel();
710
711    virtual int32_t initialize(cam_is_type_t isType);
712
713    virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber,
714                    int &indexUsed);
715    virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame,
716                            QCamera3Stream *stream);
717
718    virtual QCamera3StreamMem *getStreamBufs(uint32_t le);
719    virtual void putStreamBufs();
720    virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/)
721            { return NO_ERROR; };
722    virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;};
723
724    static cam_dimension_t kDim;
725private:
726    QCamera3StreamMem *mMemory;
727    cam_dimension_t mDim;
728    cam_stream_type_t mStreamType;
729    cam_format_t mStreamFormat;
730    uint8_t mHwAnalysisSupported;
731    cam_color_filter_arrangement_t mColorArrangement;
732};
733
734class QCamera3DepthChannel : public QCamera3ProcessingChannel {
735public:
736
737    QCamera3DepthChannel(QCamera3DepthChannel const&) = delete;
738    QCamera3DepthChannel& operator=(QCamera3DepthChannel const&) = delete;
739
740    QCamera3DepthChannel(uint32_t cam_handle,
741            uint32_t channel_handle,
742            mm_camera_ops_t *cam_ops,
743            channel_cb_routine cb_routine,
744            channel_cb_buffer_err cb_buf_err,
745            cam_padding_info_t *paddingInfo,
746            cam_feature_mask_t postprocess_mask,
747            void *userData, uint32_t numBuffers,
748            camera3_stream_t *stream,
749            QCamera3Channel *metadataChannel) :
750                QCamera3ProcessingChannel(cam_handle, channel_handle, cam_ops,
751                        cb_routine, cb_buf_err, paddingInfo, userData, stream,
752                        CAM_STREAM_TYPE_DEFAULT, postprocess_mask,
753                        metadataChannel, numBuffers),
754                        mStream(stream), mGrallocMem(0) {}
755    ~QCamera3DepthChannel();
756
757    int32_t mapBuffer(buffer_handle_t *buffer, uint32_t frameNumber);
758    int32_t populateDepthData(const cam_depth_data_t &data,
759            uint32_t frameNumber);
760    buffer_handle_t *getOldestFrame(uint32_t &frameNumber);
761    int32_t unmapBuffer(uint32_t frameNumber);
762    int32_t unmapAllBuffers();
763    camera3_stream_t *getStream() { return mStream; }
764
765    int32_t start() override { return NO_ERROR; };
766    int32_t stop() override { return NO_ERROR; };
767    int32_t setBatchSize(uint32_t) override { return NO_ERROR; }
768    int32_t queueBatchBuf() override { return NO_ERROR; }
769    int32_t setPerFrameMapUnmap(bool) override { return NO_ERROR; }
770    uint32_t getStreamTypeMask() override { return 0; };
771    int32_t initialize(cam_is_type_t) { return NO_ERROR; }
772    void streamCbRoutine(mm_camera_super_buf_t *, QCamera3Stream *) override {}
773    int32_t registerBuffer(buffer_handle_t *, cam_is_type_t) override
774            { return NO_ERROR; }
775    QCamera3StreamMem *getStreamBufs(uint32_t) override { return NULL; }
776    void putStreamBufs() override {}
777    int32_t timeoutFrame(uint32_t) override { return NO_ERROR; }
778    int32_t flush() override { return NO_ERROR; }
779    reprocess_type_t getReprocessType() override { return REPROCESS_TYPE_NONE; }
780    int32_t setBundleInfo(const cam_bundle_config_t &) override
781            { return NO_ERROR; }
782
783private:
784    camera3_stream_t *mStream;
785    QCamera3GrallocMemory mGrallocMem;
786};
787
788}; // namespace qcamera
789
790#endif /* __QCAMERA_CHANNEL_H__ */
791