[GitHub/LineageOS/android_hardware_samsung_slsi_exynos5.git] / libcamera2 / ExynosCameraHWInterface2.h

/*
**
** Copyright 2008, The Android Open Source Project
** Copyright 2012, Samsung Electronics Co. LTD
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

/*!
 * \file      ExynosCameraHWInterface2.h
 * \brief     header file for Android Camera API 2.0 HAL
 * \author    Sungjoong Kang(sj3.kang@samsung.com)
 * \date      2012/07/10
 *
 * <b>Revision History: </b>
 * - 2012/05/31 : Sungjoong Kang(sj3.kang@samsung.com) \n
 *   Initial Release
  *
 * - 2012/07/10 : Sungjoong Kang(sj3.kang@samsung.com) \n
 *   2nd Release
 *
 */

#ifndef EXYNOS_CAMERA_HW_INTERFACE_2_H
#define EXYNOS_CAMERA_HW_INTERFACE_2_H

#include <hardware/camera2.h>
#include <camera/Camera.h>
#include <camera/CameraParameters.h>
#include "SignalDrivenThread.h"
#include "MetadataConverter.h"
#include "exynos_v4l2.h"
#include "ExynosRect.h"
#include "ExynosBuffer.h"
#include "videodev2_exynos_camera.h"
#include "gralloc_priv.h"
#include "ExynosJpegEncoderForCamera.h"
#include <fcntl.h>
#include "fimc-is-metadata.h"
#include "ion.h"
#include "ExynosExif.h"
#include "csc.h"
#include "ExynosCamera2.h"
#include "cutils/properties.h"

namespace android {


#define NODE_PREFIX     "/dev/video"

#define NUM_MAX_STREAM_THREAD       (5)
#define NUM_MAX_REQUEST_MGR_ENTRY   (10)
#define NUM_MAX_DEQUEUED_REQUEST NUM_MAX_REQUEST_MGR_ENTRY
#define MAX_CAMERA_MEMORY_PLANE_NUM	(4)
#define NUM_MAX_CAMERA_BUFFERS      (16)
#define NUM_BAYER_BUFFERS           (8)
#define NUM_SENSOR_QBUF             (3)

#define PICTURE_GSC_NODE_NUM (2)
#define VIDEO_GSC_NODE_NUM (1)

#define STREAM_TYPE_DIRECT   (0)
#define STREAM_TYPE_INDIRECT (1)

#define SIGNAL_MAIN_REQ_Q_NOT_EMPTY             (SIGNAL_THREAD_COMMON_LAST<<1)
#define SIGNAL_MAIN_REPROCESS_Q_NOT_EMPTY       (SIGNAL_THREAD_COMMON_LAST<<2)
#define SIGNAL_MAIN_STREAM_OUTPUT_DONE          (SIGNAL_THREAD_COMMON_LAST<<3)
#define SIGNAL_SENSOR_START_REQ_PROCESSING      (SIGNAL_THREAD_COMMON_LAST<<4)
#define SIGNAL_STREAM_GET_BUFFER                (SIGNAL_THREAD_COMMON_LAST<<5)
#define SIGNAL_STREAM_PUT_BUFFER                (SIGNAL_THREAD_COMMON_LAST<<6)
#define SIGNAL_STREAM_CHANGE_PARAMETER          (SIGNAL_THREAD_COMMON_LAST<<7)
#define SIGNAL_THREAD_RELEASE                   (SIGNAL_THREAD_COMMON_LAST<<8)
#define SIGNAL_ISP_START_BAYER_INPUT            (SIGNAL_THREAD_COMMON_LAST<<9)
#define SIGNAL_ISP_START_BAYER_DEQUEUE          (SIGNAL_THREAD_COMMON_LAST<<10)

#define SIGNAL_STREAM_DATA_COMING               (SIGNAL_THREAD_COMMON_LAST<<15)

#define NO_TRANSITION                   (0)
#define HAL_AFSTATE_INACTIVE            (1)
#define HAL_AFSTATE_NEEDS_COMMAND       (2)
#define HAL_AFSTATE_STARTED             (3)
#define HAL_AFSTATE_SCANNING            (4)
#define HAL_AFSTATE_LOCKED              (5)
#define HAL_AFSTATE_FAILED              (6)
#define HAL_AFSTATE_NEEDS_DETERMINATION (7)
#define HAL_AFSTATE_PASSIVE_FOCUSED     (8)

enum sensor_name {
    SENSOR_NAME_S5K3H2  = 1,
    SENSOR_NAME_S5K6A3  = 2,
    SENSOR_NAME_S5K4E5  = 3,
    SENSOR_NAME_S5K3H7  = 4,
    SENSOR_NAME_CUSTOM  = 5,
    SENSOR_NAME_END
};

enum is_subscenario_id {
	ISS_SUB_SCENARIO_STILL,
	ISS_SUB_SCENARIO_VIDEO,
	ISS_SUB_SCENARIO_SCENE1,
	ISS_SUB_SCENARIO_SCENE2,
	ISS_SUB_SCENARIO_SCENE3,
	ISS_SUB_END
};

typedef struct node_info {
    int fd;
    int width;
    int height;
    int format;
    int planes;
    int buffers;
    enum v4l2_memory memory;
    enum v4l2_buf_type type;
    ion_client ionClient;
    ExynosBuffer buffer[NUM_MAX_CAMERA_BUFFERS];
    int status;
} node_info_t;


typedef struct camera_hw_info {
    int sensor_id;

    node_info_t sensor;
    node_info_t isp;
    node_info_t capture;

    /*shot*/  // temp
    struct camera2_shot_ext dummy_shot;

} camera_hw_info_t;

typedef enum request_entry_status {
    EMPTY,
    REGISTERED,
    REQUESTED,
    CAPTURED
} request_entry_status_t;

typedef struct request_manager_entry {
    request_entry_status_t      status;
    camera_metadata_t           *original_request;
    struct camera2_shot_ext     internal_shot;
    int                         output_stream_count;
    bool                         dynamic_meta_vaild;
} request_manager_entry_t;

class RequestManager {
public:
    RequestManager(SignalDrivenThread* main_thread);
    ~RequestManager();
    int     GetNumEntries();
    bool    IsRequestQueueFull();

    void    RegisterRequest(camera_metadata_t *new_request);
    void    DeregisterRequest(camera_metadata_t **deregistered_request);
    bool    PrepareFrame(size_t *num_entries, size_t *frame_size,
                camera_metadata_t **prepared_frame, int afState);
    int     MarkProcessingRequest(ExynosBuffer * buf, int *afMode);
    void      NotifyStreamOutput(int frameCnt, int stream_id);
    void    DumpInfoWithIndex(int index);
    void    ApplyDynamicMetadata(struct camera2_shot_ext *shot_ext);
    void    CheckCompleted(int index);
    void    UpdateIspParameters(struct camera2_shot_ext *shot_ext, int frameCnt, bool afTrigger);
    void    RegisterTimestamp(int frameCnt, nsecs_t *frameTime);
    uint64_t  GetTimestamp(int frameCnt);
    int     FindFrameCnt(struct camera2_shot_ext * shot_ext);
    int     FindEntryIndexByFrameCnt(int frameCnt);
    void    Dump(void);
    int     GetNextIndex(int index);
    void    SetDefaultParameters(int cropX);
    void    SetInitialSkip(int count);
    int     GetSkipCnt();
    void    SetFrameIndex(int index);
    int    GetFrameIndex();
private:

    MetadataConverter               *m_metadataConverter;
    SignalDrivenThread              *m_mainThread;
    int                             m_numOfEntries;
    int                             m_entryInsertionIndex;
    int                             m_entryProcessingIndex;
    int                             m_entryFrameOutputIndex;
    request_manager_entry_t         entries[NUM_MAX_REQUEST_MGR_ENTRY];
    int                             m_completedIndex;

    Mutex                           m_requestMutex;

    //TODO : alloc dynamically
    char                            m_tempFrameMetadataBuf[2000];
    camera_metadata_t               *m_tempFrameMetadata;

    int                             m_sensorPipelineSkipCnt;
    int                             m_cropX;
    int		         m_frameIndex;
    int                             m_lastAeMode;
    int                             m_lastAaMode;
    int                             m_lastAwbMode;
    int                             m_lastAeComp;
};


typedef struct bayer_buf_entry {
    int     status;
    int     reqFrameCnt;
    nsecs_t timeStamp;
} bayer_buf_entry_t;


class BayerBufManager {
public:
    BayerBufManager();
    ~BayerBufManager();
    int                 GetIndexForSensorEnqueue();
    int                 MarkSensorEnqueue(int index);
    int                 MarkSensorDequeue(int index, int reqFrameCnt, nsecs_t *timeStamp);
    int                 GetIndexForIspEnqueue(int *reqFrameCnt);
    int                 GetIndexForIspDequeue(int *reqFrameCnt);
    int                 MarkIspEnqueue(int index);
    int                 MarkIspDequeue(int index);
    int                 GetNumOnSensor();
    int                 GetNumOnHalFilled();
    int                 GetNumOnIsp();

private:
    int                 GetNextIndex(int index);

    int                 sensorEnqueueHead;
    int                 sensorDequeueHead;
    int                 ispEnqueueHead;
    int                 ispDequeueHead;
    int                 numOnSensor;
    int                 numOnIsp;
    int                 numOnHalFilled;
    int                 numOnHalEmpty;

    bayer_buf_entry_t   entries[NUM_BAYER_BUFFERS];
};


#define NOT_AVAILABLE           (0)
#define REQUIRES_DQ_FROM_SVC    (1)
#define ON_DRIVER               (2)
#define ON_HAL                  (3)
#define ON_SERVICE              (4)

#define BAYER_NOT_AVAILABLE     (0)
#define BAYER_ON_SENSOR         (1)
#define BAYER_ON_HAL_FILLED     (2)
#define BAYER_ON_ISP            (3)
#define BAYER_ON_SERVICE        (4)
#define BAYER_ON_HAL_EMPTY      (5)

typedef struct stream_parameters {
            int                     streamType;
            uint32_t                outputWidth;
            uint32_t                outputHeight;
            uint32_t                nodeWidth;
            uint32_t                nodeHeight;
            int                     outputFormat;
            int                     nodeFormat;
    const   camera2_stream_ops_t*   streamOps;
            uint32_t                usage;
            int                     numHwBuffers;
            int                     numSvcBuffers;
            int                     numOwnSvcBuffers;
            int                     fd;
            int                     svcPlanes;
            int                     nodePlanes;
    enum v4l2_memory                memory;
    enum v4l2_buf_type              halBuftype;
            int                     numSvcBufsInHal;
            buffer_handle_t         svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
            ExynosBuffer            svcBuffers[NUM_MAX_CAMERA_BUFFERS];
            int                     svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
            int                     svcBufIndex;
            ion_client              ionClient;
            node_info_t             node;
} stream_parameters_t;

typedef struct record_parameters {
            uint32_t                outputWidth;
            uint32_t                outputHeight;
            int                     outputFormat;
    const   camera2_stream_ops_t*   streamOps;
            uint32_t                usage;
            int                     numSvcBuffers;
            int                     numOwnSvcBuffers;
            int                     svcPlanes;
            buffer_handle_t         svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
            ExynosBuffer            svcBuffers[NUM_MAX_CAMERA_BUFFERS];
            int                     svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
            int                     svcBufIndex;
            int                     numSvcBufsInHal;
} record_parameters_t;

class ExynosCameraHWInterface2 : public virtual RefBase {
public:
    ExynosCameraHWInterface2(int cameraId, camera2_device_t *dev, ExynosCamera2 * camera);
    virtual             ~ExynosCameraHWInterface2();

    virtual void        release();

    inline  int         getCameraId() const;

    virtual int         setRequestQueueSrcOps(const camera2_request_queue_src_ops_t *request_src_ops);
    virtual int         notifyRequestQueueNotEmpty();
    virtual int         setFrameQueueDstOps(const camera2_frame_queue_dst_ops_t *frame_dst_ops);
    virtual int         getInProgressCount();
    virtual int         flushCapturesInProgress();
    virtual int         constructDefaultRequest(int request_template, camera_metadata_t **request);
    virtual int         allocateStream(uint32_t width, uint32_t height,
                                    int format, const camera2_stream_ops_t *stream_ops,
                                    uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers);
    virtual int         registerStreamBuffers(uint32_t stream_id, int num_buffers, buffer_handle_t *buffers);
    virtual int         releaseStream(uint32_t stream_id);
    virtual int         allocateReprocessStream(uint32_t width, uint32_t height,
                                    uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops,
                                    uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers);
    virtual int         releaseReprocessStream(uint32_t stream_id);
    virtual int         triggerAction(uint32_t trigger_id, int ext1, int ext2);
    virtual int         setNotifyCallback(camera2_notify_callback notify_cb, void *user);
    virtual int         getMetadataVendorTagOps(vendor_tag_query_ops_t **ops);
    virtual int         dump(int fd);
private:
class MainThread : public SignalDrivenThread {
        ExynosCameraHWInterface2 *mHardware;
    public:
        MainThread(ExynosCameraHWInterface2 *hw):
            SignalDrivenThread(),
            mHardware(hw) {
//            Start("MainThread", PRIORITY_DEFAULT, 0);
        }
        ~MainThread();
        status_t readyToRunInternal()
	{
            return NO_ERROR;
        }
        void threadFunctionInternal()
	{
            mHardware->m_mainThreadFunc(this);
            return;
        }
        void        release(void);
        bool        m_releasing;
    };

    class SensorThread : public SignalDrivenThread {
        ExynosCameraHWInterface2 *mHardware;
    public:
        SensorThread(ExynosCameraHWInterface2 *hw):
            SignalDrivenThread("SensorThread", PRIORITY_DEFAULT, 0),
            mHardware(hw),
            m_isBayerOutputEnabled(false) { }
        ~SensorThread();
        status_t readyToRunInternal() {
            mHardware->m_sensorThreadInitialize(this);
            return NO_ERROR;
        }
        void threadFunctionInternal() {
            mHardware->m_sensorThreadFunc(this);
            return;
        }
        void            release(void);
    //private:
        bool            m_isBayerOutputEnabled;
        int             m_sensorFd;
        bool            m_releasing;
    };

    class IspThread : public SignalDrivenThread {
        ExynosCameraHWInterface2 *mHardware;
    public:
        IspThread(ExynosCameraHWInterface2 *hw):
            SignalDrivenThread("IspThread", PRIORITY_DEFAULT, 0),
            mHardware(hw) { }
        ~IspThread();
        status_t readyToRunInternal() {
            mHardware->m_ispThreadInitialize(this);
            return NO_ERROR;
        }
        void threadFunctionInternal() {
            mHardware->m_ispThreadFunc(this);
            return;
        }
        void            release(void);
    //private:
        int             m_ispFd;
        bool            m_releasing;
    };

    class StreamThread : public SignalDrivenThread {
        ExynosCameraHWInterface2 *mHardware;
    public:
        StreamThread(ExynosCameraHWInterface2 *hw, uint8_t new_index):
            SignalDrivenThread("StreamThread", PRIORITY_DEFAULT, 0),
            mHardware(hw),
            m_index(new_index) { }
        ~StreamThread();
        status_t readyToRunInternal() {
            mHardware->m_streamThreadInitialize(this);
            return NO_ERROR;
        }
        void threadFunctionInternal() {
            mHardware->m_streamThreadFunc(this);
            return;
        }
        void        setRecordingParameter(record_parameters_t * recordParm);
        void        setParameter(stream_parameters_t * new_parameters);
        void        applyChange(void);
        void        release(void);
        int         findBufferIndex(void * bufAddr);


        uint8_t                         m_index;
        bool                            m_activated;
    //private:
        stream_parameters_t             m_parameters;
        stream_parameters_t             *m_tempParameters;
        record_parameters_t             m_recordParameters;
        bool                            m_isBufferInit;
        bool                            m_releasing;
     };

    sp<MainThread>      m_mainThread;
    sp<SensorThread>    m_sensorThread;
    sp<IspThread>       m_ispThread;
    sp<StreamThread>    m_streamThreads[NUM_MAX_STREAM_THREAD];


    RequestManager      *m_requestManager;
    BayerBufManager     *m_BayerManager;
    ExynosCamera2       *m_camera2;

    void                m_mainThreadFunc(SignalDrivenThread * self);
    void                m_sensorThreadFunc(SignalDrivenThread * self);
    void                m_sensorThreadInitialize(SignalDrivenThread * self);
    void                m_ispThreadFunc(SignalDrivenThread * self);
    void                m_ispThreadInitialize(SignalDrivenThread * self);
    void                m_streamThreadFunc(SignalDrivenThread * self);
    void                m_streamThreadInitialize(SignalDrivenThread * self);

    void                m_getAlignedYUVSize(int colorFormat, int w, int h,
                                                ExynosBuffer *buf);
    bool                m_getRatioSize(int  src_w,  int   src_h,
                                             int  dst_w,  int   dst_h,
                                             int *crop_x, int *crop_y,
                                             int *crop_w, int *crop_h,
                                             int zoom);
	int				createIonClient(ion_client ionClient);
	int					deleteIonClient(ion_client ionClient);

    int				allocCameraMemory(ion_client ionClient, ExynosBuffer *buf, int iMemoryNum);
	void				freeCameraMemory(ExynosBuffer *buf, int iMemoryNum);
	void				initCameraMemory(ExynosBuffer *buf, int iMemoryNum);

    void            DumpInfoWithShot(struct camera2_shot_ext * shot_ext);
    bool            yuv2Jpeg(ExynosBuffer *yuvBuf,
                            ExynosBuffer *jpegBuf,
                            ExynosRect *rect);
    void            InitializeISPChain();
    void            StartISP();
    int             GetAfState();
    void            SetAfMode(enum aa_afmode afMode);
    void            OnAfTrigger(int id);
    void            OnAfTriggerAutoMacro(int id);
    void            OnAfTriggerCAFPicture(int id);
    void            OnAfTriggerCAFVideo(int id);
    void            OnAfCancel(int id);
    void            OnAfCancelAutoMacro(int id);
    void            OnAfCancelCAFPicture(int id);
    void            OnAfCancelCAFVideo(int id);
    void            OnAfNotification(enum aa_afstate noti);
    void            OnAfNotificationAutoMacro(enum aa_afstate noti);
    void            OnAfNotificationCAFPicture(enum aa_afstate noti);
    void            OnAfNotificationCAFVideo(enum aa_afstate noti);
    void            SetAfStateForService(int newState);
    int             GetAfStateForService();
    exif_attribute_t    mExifInfo;
    void            m_setExifFixedAttribute(void);
    void            m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosRect *rect,
                         camera2_shot *currentEntry);
    void               *m_exynosPictureCSC;
    void               *m_exynosVideoCSC;

    int                 m_jpegEncodingFrameCnt;

    camera2_request_queue_src_ops_t     *m_requestQueueOps;
    camera2_frame_queue_dst_ops_t       *m_frameQueueOps;
    camera2_notify_callback             m_notifyCb;
    void                                *m_callbackCookie;

    int                                 m_numOfRemainingReqInSvc;
    bool                                m_isRequestQueuePending;
    bool                                m_isRequestQueueNull;
    camera2_device_t                    *m_halDevice;
    static gralloc_module_t const*      m_grallocHal;


    camera_hw_info_t                     m_camera_info;

	ion_client m_ionCameraClient;

    bool                                m_isSensorThreadOn;
    bool                                m_isSensorStarted;
    bool                                m_isIspStarted;

    int                                 m_need_streamoff;

    bool                                m_initFlag1;
    bool                                m_initFlag2;

    int                                 indexToQueue[3+1];
    int                                 m_fd_scp;

    bool                                m_scp_flushing;
    bool                                m_closing;
    ExynosBuffer                        m_resizeBuf;
    bool                                m_recordingEnabled;
    int                                 m_previewOutput;
    int                                 m_recordOutput;
    bool                                m_needsRecordBufferInit;
    int                                 lastFrameCnt;
    int             				    m_cameraId;
    bool                                m_scp_closing;
    bool                                m_scp_closed;
    bool                                m_wideAspect;

    mutable Mutex    m_qbufLock;

    int                                 m_afState;
    int                                 m_afTriggerId;
    enum aa_afmode                      m_afMode;
    enum aa_afmode                      m_afMode2;
    bool                                m_IsAfModeUpdateRequired;
    bool                                m_IsAfTriggerRequired;
    bool                                m_IsAfLockRequired;
    int                                 m_serviceAfState;
    struct camera2_shot                 m_jpegMetadata;
};

}; // namespace android

#endif
Commit	Line	Data
c15a6b00 JS	1	/*
	2	**
	3	** Copyright 2008, The Android Open Source Project
	4	** Copyright 2012, Samsung Electronics Co. LTD
	5	**
	6	** Licensed under the Apache License, Version 2.0 (the "License");
	7	** you may not use this file except in compliance with the License.
	8	** You may obtain a copy of the License at
	9	**
	10	** http://www.apache.org/licenses/LICENSE-2.0
	11	**
	12	** Unless required by applicable law or agreed to in writing, software
	13	** distributed under the License is distributed on an "AS IS" BASIS,
	14	** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	15	** See the License for the specific language governing permissions and
	16	** limitations under the License.
	17	*/
	18
	19	/*!
	20	* \file ExynosCameraHWInterface2.h
	21	* \brief header file for Android Camera API 2.0 HAL
	22	* \author Sungjoong Kang(sj3.kang@samsung.com)
13d8c7b4	23	* \date 2012/07/10
c15a6b00 JS	24	*
	25	* <b>Revision History: </b>
	26	* - 2012/05/31 : Sungjoong Kang(sj3.kang@samsung.com) \n
	27	* Initial Release
13d8c7b4 SK	28	*
	29	* - 2012/07/10 : Sungjoong Kang(sj3.kang@samsung.com) \n
	30	* 2nd Release
	31	*
c15a6b00	32	*/
13d8c7b4	33
c15a6b00 JS	34	#ifndef EXYNOS_CAMERA_HW_INTERFACE_2_H
	35	#define EXYNOS_CAMERA_HW_INTERFACE_2_H
	36
	37	#include <hardware/camera2.h>
	38	#include <camera/Camera.h>
	39	#include <camera/CameraParameters.h>
	40	#include "SignalDrivenThread.h"
	41	#include "MetadataConverter.h"
	42	#include "exynos_v4l2.h"
13d8c7b4 SK	43	#include "ExynosRect.h"
13d8c7b4 SK	44	#include "ExynosBuffer.h"
c15a6b00 JS	45	#include "videodev2_exynos_camera.h"
c15a6b00 JS	46	#include "gralloc_priv.h"
13d8c7b4	47	#include "ExynosJpegEncoderForCamera.h"
c15a6b00 JS	48	#include <fcntl.h>
	49	#include "fimc-is-metadata.h"
	50	#include "ion.h"
13d8c7b4 SK	51	#include "ExynosExif.h"
13d8c7b4 SK	52	#include "csc.h"
daa1fcd6	53	#include "ExynosCamera2.h"
eed7ed1b	54	#include "cutils/properties.h"
c15a6b00 JS	55
	56	namespace android {
	57
	58
	59	#define NODE_PREFIX "/dev/video"
	60
	61	#define NUM_MAX_STREAM_THREAD (5)
13d8c7b4	62	#define NUM_MAX_REQUEST_MGR_ENTRY (10)
ad37861e	63	#define NUM_MAX_DEQUEUED_REQUEST NUM_MAX_REQUEST_MGR_ENTRY
c15a6b00	64	#define MAX_CAMERA_MEMORY_PLANE_NUM (4)
13d8c7b4 SK	65	#define NUM_MAX_CAMERA_BUFFERS (16)
13d8c7b4 SK	66	#define NUM_BAYER_BUFFERS (8)
b56dcc00	67	#define NUM_SENSOR_QBUF (3)
13d8c7b4 SK	68
13d8c7b4 SK	69	#define PICTURE_GSC_NODE_NUM (2)
15fd8231	70	#define VIDEO_GSC_NODE_NUM (1)
c15a6b00	71
37e122d5 SK	72	#define STREAM_TYPE_DIRECT (0)
	73	#define STREAM_TYPE_INDIRECT (1)
	74
13d8c7b4 SK	75	#define SIGNAL_MAIN_REQ_Q_NOT_EMPTY (SIGNAL_THREAD_COMMON_LAST<<1)
	76	#define SIGNAL_MAIN_REPROCESS_Q_NOT_EMPTY (SIGNAL_THREAD_COMMON_LAST<<2)
	77	#define SIGNAL_MAIN_STREAM_OUTPUT_DONE (SIGNAL_THREAD_COMMON_LAST<<3)
	78	#define SIGNAL_SENSOR_START_REQ_PROCESSING (SIGNAL_THREAD_COMMON_LAST<<4)
c15a6b00 JS	79	#define SIGNAL_STREAM_GET_BUFFER (SIGNAL_THREAD_COMMON_LAST<<5)
	80	#define SIGNAL_STREAM_PUT_BUFFER (SIGNAL_THREAD_COMMON_LAST<<6)
	81	#define SIGNAL_STREAM_CHANGE_PARAMETER (SIGNAL_THREAD_COMMON_LAST<<7)
13d8c7b4 SK	82	#define SIGNAL_THREAD_RELEASE (SIGNAL_THREAD_COMMON_LAST<<8)
13d8c7b4 SK	83	#define SIGNAL_ISP_START_BAYER_INPUT (SIGNAL_THREAD_COMMON_LAST<<9)
9dd63e1f	84	#define SIGNAL_ISP_START_BAYER_DEQUEUE (SIGNAL_THREAD_COMMON_LAST<<10)
c15a6b00 JS	85
	86	#define SIGNAL_STREAM_DATA_COMING (SIGNAL_THREAD_COMMON_LAST<<15)
	87
0f26b20f SK	88	#define NO_TRANSITION (0)
	89	#define HAL_AFSTATE_INACTIVE (1)
	90	#define HAL_AFSTATE_NEEDS_COMMAND (2)
	91	#define HAL_AFSTATE_STARTED (3)
	92	#define HAL_AFSTATE_SCANNING (4)
	93	#define HAL_AFSTATE_LOCKED (5)
	94	#define HAL_AFSTATE_FAILED (6)
	95	#define HAL_AFSTATE_NEEDS_DETERMINATION (7)
	96	#define HAL_AFSTATE_PASSIVE_FOCUSED (8)
13d8c7b4	97
c15a6b00 JS	98	enum sensor_name {
	99	SENSOR_NAME_S5K3H2 = 1,
	100	SENSOR_NAME_S5K6A3 = 2,
	101	SENSOR_NAME_S5K4E5 = 3,
	102	SENSOR_NAME_S5K3H7 = 4,
	103	SENSOR_NAME_CUSTOM = 5,
	104	SENSOR_NAME_END
	105	};
	106
15fd8231 SK	107	enum is_subscenario_id {
	108	ISS_SUB_SCENARIO_STILL,
	109	ISS_SUB_SCENARIO_VIDEO,
	110	ISS_SUB_SCENARIO_SCENE1,
	111	ISS_SUB_SCENARIO_SCENE2,
	112	ISS_SUB_SCENARIO_SCENE3,
	113	ISS_SUB_END
	114	};
c15a6b00 JS	115
	116	typedef struct node_info {
	117	int fd;
	118	int width;
	119	int height;
	120	int format;
	121	int planes;
	122	int buffers;
c15a6b00 JS	123	enum v4l2_memory memory;
c15a6b00 JS	124	enum v4l2_buf_type type;
be494d19 SK	125	ion_client ionClient;
be494d19 SK	126	ExynosBuffer buffer[NUM_MAX_CAMERA_BUFFERS];
15fd8231	127	int status;
c15a6b00 JS	128	} node_info_t;
	129
	130
	131	typedef struct camera_hw_info {
	132	int sensor_id;
	133
	134	node_info_t sensor;
13d8c7b4 SK	135	node_info_t isp;
	136	node_info_t capture;
	137
	138	/shot/ // temp
	139	struct camera2_shot_ext dummy_shot;
c15a6b00	140
c15a6b00 JS	141	} camera_hw_info_t;
c15a6b00 JS	142
13d8c7b4	143	typedef enum request_entry_status {
c15a6b00 JS	144	EMPTY,
c15a6b00 JS	145	REGISTERED,
be494d19 SK	146	REQUESTED,
be494d19 SK	147	CAPTURED
c15a6b00 JS	148	} request_entry_status_t;
	149
	150	typedef struct request_manager_entry {
13d8c7b4	151	request_entry_status_t status;
13d8c7b4	152	camera_metadata_t *original_request;
be494d19	153	struct camera2_shot_ext internal_shot;
13d8c7b4 SK	154	int output_stream_count;
13d8c7b4 SK	155	bool dynamic_meta_vaild;
c15a6b00 JS	156	} request_manager_entry_t;
	157
	158	class RequestManager {
	159	public:
	160	RequestManager(SignalDrivenThread* main_thread);
	161	~RequestManager();
	162	int GetNumEntries();
	163	bool IsRequestQueueFull();
13d8c7b4 SK	164
	165	void RegisterRequest(camera_metadata_t *new_request);
	166	void DeregisterRequest(camera_metadata_t **deregistered_request);
	167	bool PrepareFrame(size_t num_entries, size_t frame_size,
0f26b20f SK	168	camera_metadata_t **prepared_frame, int afState);
0f26b20f SK	169	int MarkProcessingRequest(ExynosBuffer * buf, int *afMode);
9dd63e1f	170	void NotifyStreamOutput(int frameCnt, int stream_id);
13d8c7b4	171	void DumpInfoWithIndex(int index);
ad37861e	172	void ApplyDynamicMetadata(struct camera2_shot_ext *shot_ext);
13d8c7b4	173	void CheckCompleted(int index);
0f26b20f	174	void UpdateIspParameters(struct camera2_shot_ext *shot_ext, int frameCnt, bool afTrigger);
9dd63e1f SK	175	void RegisterTimestamp(int frameCnt, nsecs_t *frameTime);
	176	uint64_t GetTimestamp(int frameCnt);
	177	int FindFrameCnt(struct camera2_shot_ext * shot_ext);
	178	int FindEntryIndexByFrameCnt(int frameCnt);
b5237e6b SK	179	void Dump(void);
	180	int GetNextIndex(int index);
	181	void SetDefaultParameters(int cropX);
	182	void SetInitialSkip(int count);
ad37861e SK	183	int GetSkipCnt();
	184	void SetFrameIndex(int index);
	185	int GetFrameIndex();
c15a6b00 JS	186	private:
	187
	188	MetadataConverter *m_metadataConverter;
	189	SignalDrivenThread *m_mainThread;
	190	int m_numOfEntries;
	191	int m_entryInsertionIndex;
	192	int m_entryProcessingIndex;
	193	int m_entryFrameOutputIndex;
	194	request_manager_entry_t entries[NUM_MAX_REQUEST_MGR_ENTRY];
13d8c7b4	195	int m_completedIndex;
c15a6b00 JS	196
	197	Mutex m_requestMutex;
	198
	199	//TODO : alloc dynamically
	200	char m_tempFrameMetadataBuf[2000];
	201	camera_metadata_t *m_tempFrameMetadata;
9dd63e1f	202
b5237e6b	203	int m_sensorPipelineSkipCnt;
9dd63e1f	204	int m_cropX;
ad37861e	205	int m_frameIndex;
2bdec060 SK	206	int m_lastAeMode;
	207	int m_lastAaMode;
	208	int m_lastAwbMode;
	209	int m_lastAeComp;
c15a6b00 JS	210	};
c15a6b00 JS	211
9dd63e1f SK	212
	213	typedef struct bayer_buf_entry {
	214	int status;
	215	int reqFrameCnt;
	216	nsecs_t timeStamp;
	217	} bayer_buf_entry_t;
	218
	219
	220	class BayerBufManager {
	221	public:
	222	BayerBufManager();
	223	~BayerBufManager();
	224	int GetIndexForSensorEnqueue();
	225	int MarkSensorEnqueue(int index);
	226	int MarkSensorDequeue(int index, int reqFrameCnt, nsecs_t *timeStamp);
	227	int GetIndexForIspEnqueue(int *reqFrameCnt);
	228	int GetIndexForIspDequeue(int *reqFrameCnt);
	229	int MarkIspEnqueue(int index);
	230	int MarkIspDequeue(int index);
	231	int GetNumOnSensor();
	232	int GetNumOnHalFilled();
	233	int GetNumOnIsp();
	234
	235	private:
	236	int GetNextIndex(int index);
	237
	238	int sensorEnqueueHead;
	239	int sensorDequeueHead;
	240	int ispEnqueueHead;
	241	int ispDequeueHead;
	242	int numOnSensor;
	243	int numOnIsp;
	244	int numOnHalFilled;
	245	int numOnHalEmpty;
	246
	247	bayer_buf_entry_t entries[NUM_BAYER_BUFFERS];
	248	};
	249
	250
13d8c7b4 SK	251	#define NOT_AVAILABLE (0)
	252	#define REQUIRES_DQ_FROM_SVC (1)
	253	#define ON_DRIVER (2)
	254	#define ON_HAL (3)
	255	#define ON_SERVICE (4)
	256
	257	#define BAYER_NOT_AVAILABLE (0)
	258	#define BAYER_ON_SENSOR (1)
	259	#define BAYER_ON_HAL_FILLED (2)
	260	#define BAYER_ON_ISP (3)
	261	#define BAYER_ON_SERVICE (4)
	262	#define BAYER_ON_HAL_EMPTY (5)
	263
	264	typedef struct stream_parameters {
	265	int streamType;
	266	uint32_t outputWidth;
	267	uint32_t outputHeight;
	268	uint32_t nodeWidth;
	269	uint32_t nodeHeight;
	270	int outputFormat;
	271	int nodeFormat;
c15a6b00 JS	272	const camera2_stream_ops_t* streamOps;
c15a6b00 JS	273	uint32_t usage;
13d8c7b4 SK	274	int numHwBuffers;
13d8c7b4 SK	275	int numSvcBuffers;
be494d19	276	int numOwnSvcBuffers;
c15a6b00	277	int fd;
13d8c7b4 SK	278	int svcPlanes;
	279	int nodePlanes;
	280	enum v4l2_memory memory;
	281	enum v4l2_buf_type halBuftype;
be494d19	282	int numSvcBufsInHal;
13d8c7b4 SK	283	buffer_handle_t svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
	284	ExynosBuffer svcBuffers[NUM_MAX_CAMERA_BUFFERS];
	285	int svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
be494d19 SK	286	int svcBufIndex;
be494d19 SK	287	ion_client ionClient;
13d8c7b4	288	node_info_t node;
c15a6b00 JS	289	} stream_parameters_t;
c15a6b00 JS	290
9dd63e1f SK	291	typedef struct record_parameters {
	292	uint32_t outputWidth;
	293	uint32_t outputHeight;
	294	int outputFormat;
	295	const camera2_stream_ops_t* streamOps;
	296	uint32_t usage;
	297	int numSvcBuffers;
be494d19	298	int numOwnSvcBuffers;
9dd63e1f SK	299	int svcPlanes;
	300	buffer_handle_t svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
	301	ExynosBuffer svcBuffers[NUM_MAX_CAMERA_BUFFERS];
	302	int svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
be494d19 SK	303	int svcBufIndex;
be494d19 SK	304	int numSvcBufsInHal;
9dd63e1f	305	} record_parameters_t;
13d8c7b4	306
c15a6b00 JS	307	class ExynosCameraHWInterface2 : public virtual RefBase {
c15a6b00 JS	308	public:
daa1fcd6	309	ExynosCameraHWInterface2(int cameraId, camera2_device_t dev, ExynosCamera2 camera);
c15a6b00 JS	310	virtual ~ExynosCameraHWInterface2();
	311
	312	virtual void release();
13d8c7b4	313
c15a6b00 JS	314	inline int getCameraId() const;
	315
	316	virtual int setRequestQueueSrcOps(const camera2_request_queue_src_ops_t *request_src_ops);
	317	virtual int notifyRequestQueueNotEmpty();
	318	virtual int setFrameQueueDstOps(const camera2_frame_queue_dst_ops_t *frame_dst_ops);
	319	virtual int getInProgressCount();
	320	virtual int flushCapturesInProgress();
	321	virtual int constructDefaultRequest(int request_template, camera_metadata_t **request);
13d8c7b4	322	virtual int allocateStream(uint32_t width, uint32_t height,
c15a6b00 JS	323	int format, const camera2_stream_ops_t *stream_ops,
	324	uint32_t stream_id, uint32_t format_actual, uint32_t usage, uint32_t max_buffers);
	325	virtual int registerStreamBuffers(uint32_t stream_id, int num_buffers, buffer_handle_t *buffers);
	326	virtual int releaseStream(uint32_t stream_id);
	327	virtual int allocateReprocessStream(uint32_t width, uint32_t height,
	328	uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops,
	329	uint32_t stream_id, uint32_t consumer_usage, uint32_t *max_buffers);
	330	virtual int releaseReprocessStream(uint32_t stream_id);
	331	virtual int triggerAction(uint32_t trigger_id, int ext1, int ext2);
	332	virtual int setNotifyCallback(camera2_notify_callback notify_cb, void *user);
	333	virtual int getMetadataVendorTagOps(vendor_tag_query_ops_t **ops);
	334	virtual int dump(int fd);
	335	private:
13d8c7b4 SK	336	class MainThread : public SignalDrivenThread {
	337	ExynosCameraHWInterface2 *mHardware;
	338	public:
	339	MainThread(ExynosCameraHWInterface2 *hw):
	340	SignalDrivenThread(),
	341	mHardware(hw) {
	342	// Start("MainThread", PRIORITY_DEFAULT, 0);
	343	}
	344	~MainThread();
	345	status_t readyToRunInternal()
	346	{
	347	return NO_ERROR;
	348	}
	349	void threadFunctionInternal()
	350	{
	351	mHardware->m_mainThreadFunc(this);
	352	return;
	353	}
	354	void release(void);
15fd8231	355	bool m_releasing;
13d8c7b4	356	};
9dd63e1f	357
c15a6b00 JS	358	class SensorThread : public SignalDrivenThread {
	359	ExynosCameraHWInterface2 *mHardware;
	360	public:
	361	SensorThread(ExynosCameraHWInterface2 *hw):
	362	SignalDrivenThread("SensorThread", PRIORITY_DEFAULT, 0),
	363	mHardware(hw),
	364	m_isBayerOutputEnabled(false) { }
13d8c7b4	365	~SensorThread();
c15a6b00	366	status_t readyToRunInternal() {
13d8c7b4	367	mHardware->m_sensorThreadInitialize(this);
c15a6b00 JS	368	return NO_ERROR;
c15a6b00 JS	369	}
13d8c7b4	370	void threadFunctionInternal() {
c15a6b00 JS	371	mHardware->m_sensorThreadFunc(this);
	372	return;
	373	}
9dd63e1f	374	void release(void);
c15a6b00 JS	375	//private:
	376	bool m_isBayerOutputEnabled;
	377	int m_sensorFd;
15fd8231	378	bool m_releasing;
13d8c7b4 SK	379	};
	380
	381	class IspThread : public SignalDrivenThread {
	382	ExynosCameraHWInterface2 *mHardware;
	383	public:
	384	IspThread(ExynosCameraHWInterface2 *hw):
	385	SignalDrivenThread("IspThread", PRIORITY_DEFAULT, 0),
	386	mHardware(hw) { }
	387	~IspThread();
	388	status_t readyToRunInternal() {
	389	mHardware->m_ispThreadInitialize(this);
	390	return NO_ERROR;
	391	}
	392	void threadFunctionInternal() {
	393	mHardware->m_ispThreadFunc(this);
	394	return;
	395	}
	396	void release(void);
	397	//private:
c15a6b00	398	int m_ispFd;
15fd8231	399	bool m_releasing;
c15a6b00 JS	400	};
	401
	402	class StreamThread : public SignalDrivenThread {
	403	ExynosCameraHWInterface2 *mHardware;
	404	public:
	405	StreamThread(ExynosCameraHWInterface2 *hw, uint8_t new_index):
	406	SignalDrivenThread("StreamThread", PRIORITY_DEFAULT, 0),
	407	mHardware(hw),
	408	m_index(new_index) { }
13d8c7b4	409	~StreamThread();
c15a6b00	410	status_t readyToRunInternal() {
13d8c7b4	411	mHardware->m_streamThreadInitialize(this);
c15a6b00 JS	412	return NO_ERROR;
c15a6b00 JS	413	}
13d8c7b4	414	void threadFunctionInternal() {
c15a6b00 JS	415	mHardware->m_streamThreadFunc(this);
	416	return;
	417	}
9dd63e1f	418	void setRecordingParameter(record_parameters_t * recordParm);
13d8c7b4 SK	419	void setParameter(stream_parameters_t * new_parameters);
	420	void applyChange(void);
	421	void release(void);
	422	int findBufferIndex(void * bufAddr);
c15a6b00	423
c15a6b00	424
13d8c7b4	425	uint8_t m_index;
9dd63e1f	426	bool m_activated;
13d8c7b4 SK	427	//private:
13d8c7b4 SK	428	stream_parameters_t m_parameters;
9dd63e1f SK	429	stream_parameters_t *m_tempParameters;
9dd63e1f SK	430	record_parameters_t m_recordParameters;
13d8c7b4	431	bool m_isBufferInit;
b5237e6b	432	bool m_releasing;
13d8c7b4	433	};
c15a6b00 JS	434
	435	sp<MainThread> m_mainThread;
	436	sp<SensorThread> m_sensorThread;
13d8c7b4 SK	437	sp<IspThread> m_ispThread;
	438	sp<StreamThread> m_streamThreads[NUM_MAX_STREAM_THREAD];
	439
	440
9dd63e1f	441
c15a6b00	442	RequestManager *m_requestManager;
9dd63e1f	443	BayerBufManager *m_BayerManager;
daa1fcd6	444	ExynosCamera2 *m_camera2;
c15a6b00 JS	445
	446	void m_mainThreadFunc(SignalDrivenThread * self);
	447	void m_sensorThreadFunc(SignalDrivenThread * self);
13d8c7b4 SK	448	void m_sensorThreadInitialize(SignalDrivenThread * self);
	449	void m_ispThreadFunc(SignalDrivenThread * self);
	450	void m_ispThreadInitialize(SignalDrivenThread * self);
c15a6b00	451	void m_streamThreadFunc(SignalDrivenThread * self);
13d8c7b4 SK	452	void m_streamThreadInitialize(SignalDrivenThread * self);
	453
	454	void m_getAlignedYUVSize(int colorFormat, int w, int h,
	455	ExynosBuffer *buf);
	456	bool m_getRatioSize(int src_w, int src_h,
	457	int dst_w, int dst_h,
	458	int crop_x, int crop_y,
	459	int crop_w, int crop_h,
	460	int zoom);
	461	int createIonClient(ion_client ionClient);
	462	int deleteIonClient(ion_client ionClient);
13d8c7b4 SK	463
	464	int allocCameraMemory(ion_client ionClient, ExynosBuffer *buf, int iMemoryNum);
	465	void freeCameraMemory(ExynosBuffer *buf, int iMemoryNum);
	466	void initCameraMemory(ExynosBuffer *buf, int iMemoryNum);
	467
	468	void DumpInfoWithShot(struct camera2_shot_ext * shot_ext);
	469	bool yuv2Jpeg(ExynosBuffer *yuvBuf,
	470	ExynosBuffer *jpegBuf,
	471	ExynosRect *rect);
ad37861e SK	472	void InitializeISPChain();
ad37861e SK	473	void StartISP();
0f26b20f SK	474	int GetAfState();
	475	void SetAfMode(enum aa_afmode afMode);
	476	void OnAfTrigger(int id);
	477	void OnAfTriggerAutoMacro(int id);
	478	void OnAfTriggerCAFPicture(int id);
	479	void OnAfTriggerCAFVideo(int id);
	480	void OnAfCancel(int id);
	481	void OnAfCancelAutoMacro(int id);
	482	void OnAfCancelCAFPicture(int id);
	483	void OnAfCancelCAFVideo(int id);
	484	void OnAfNotification(enum aa_afstate noti);
	485	void OnAfNotificationAutoMacro(enum aa_afstate noti);
	486	void OnAfNotificationCAFPicture(enum aa_afstate noti);
	487	void OnAfNotificationCAFVideo(enum aa_afstate noti);
	488	void SetAfStateForService(int newState);
	489	int GetAfStateForService();
13d8c7b4	490	exif_attribute_t mExifInfo;
eed7ed1b SK	491	void m_setExifFixedAttribute(void);
	492	void m_setExifChangedAttribute(exif_attribute_t exifInfo, ExynosRect rect,
	493	camera2_shot *currentEntry);
13d8c7b4	494	void *m_exynosPictureCSC;
9dd63e1f	495	void *m_exynosVideoCSC;
13d8c7b4	496
9dd63e1f	497	int m_jpegEncodingFrameCnt;
c15a6b00 JS	498
	499	camera2_request_queue_src_ops_t *m_requestQueueOps;
	500	camera2_frame_queue_dst_ops_t *m_frameQueueOps;
	501	camera2_notify_callback m_notifyCb;
	502	void *m_callbackCookie;
	503
	504	int m_numOfRemainingReqInSvc;
	505	bool m_isRequestQueuePending;
13d8c7b4 SK	506	bool m_isRequestQueueNull;
	507	camera2_device_t *m_halDevice;
	508	static gralloc_module_t const* m_grallocHal;
c15a6b00	509
c15a6b00	510
13d8c7b4	511	camera_hw_info_t m_camera_info;
c15a6b00 JS	512
	513	ion_client m_ionCameraClient;
	514
13d8c7b4 SK	515	bool m_isSensorThreadOn;
13d8c7b4 SK	516	bool m_isSensorStarted;
ad37861e	517	bool m_isIspStarted;
13d8c7b4	518
ad37861e	519	int m_need_streamoff;
13d8c7b4 SK	520
	521	bool m_initFlag1;
	522	bool m_initFlag2;
13d8c7b4 SK	523
	524	int indexToQueue[3+1];
	525	int m_fd_scp;
	526
	527	bool m_scp_flushing;
	528	bool m_closing;
	529	ExynosBuffer m_resizeBuf;
9dd63e1f SK	530	bool m_recordingEnabled;
	531	int m_previewOutput;
	532	int m_recordOutput;
	533	bool m_needsRecordBufferInit;
	534	int lastFrameCnt;
9dd63e1f SK	535	int m_cameraId;
	536	bool m_scp_closing;
	537	bool m_scp_closed;
15fd8231	538	bool m_wideAspect;
ad37861e SK	539
	540	mutable Mutex m_qbufLock;
	541
0f26b20f SK	542	int m_afState;
	543	int m_afTriggerId;
	544	enum aa_afmode m_afMode;
	545	enum aa_afmode m_afMode2;
	546	bool m_IsAfModeUpdateRequired;
	547	bool m_IsAfTriggerRequired;
	548	bool m_IsAfLockRequired;
	549	int m_serviceAfState;
eed7ed1b	550	struct camera2_shot m_jpegMetadata;
c15a6b00 JS	551	};
	552
	553	}; // namespace android
	554
	555	#endif