camera/hal/intel/ipu6/src/core/CameraDevice.h - mirrors/cros/chromiumos/platform2 - Git at Google

 /*
  * Copyright (C) 2016-2020 Intel Corporation.
  *
  * 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.
  */

 #pragma once

 #include "CameraStream.h"
 #include "RequestThread.h"
 #include "StreamSource.h"
 #include "AiqUnit.h"
 #include "Parameters.h"
 #include "ParameterGenerator.h"
 #include "SensorHwCtrl.h"
 #include "SofSource.h"
 #include "LensHw.h"

 #include "ProcessorManager.h"

 #include "gc/IGraphConfigManager.h"

 namespace icamera {

 class RequestThread;

 /**
   * CameraDevice : Create elements to construct the streaming pipeline
   * Each element must be a producer or a consumer or Both.
   *
   * These are the typical pipelines:
   *
   * For a single SOC YUV capture in by pass mode
   * StreamSource -> CameraStream
   *
   * For a single NV12 capture of TPG/Sensor using SwImageProcess
   * StreamSource -> SwImageProcessor -> CameraStream
   *
   * For a single NV12 capture of TPG/Sensor using PSYS processor
   * StreamSource -> PsysProcessor -> CameraStream
   *
   * For a dual streams NV12 video capture of TPG/Sensor using PSYS processor
   * StreamSource -> PsysProcessor | -> CameraStream (For video recording)
   *                              | -> CameraStream (for Preview)
   *
   * For a SDV(Snapshot during video) capture of TPG/Sensor uinsg PSYS processor
   * StreamSource | -> PsysProcessor | -> CameraStream (For video recording)
   *             |                  | -> CameraStream (for Preview)
   *             | -> PsysProcessor | -> CameraStream (For still YUV)
   *
   * The buffer notification between the Class is based on Interface defined
   * in BufferQueue. The upstream element use "onFrameAvailable" message to notfiy
   * downstream elements that the buffers are ready for further processing
   *
   * Following singleton instances are created and maintained by CameraDevice
   * 1. IGraphConfigManager
   * 2. AiqResultStorage
   */
 class CameraDevice : public EventListener {

 public:
     CameraDevice(int cameraId);
     ~CameraDevice();

     /**
      * \brief Camera device class init
      *
      * 1.Related classes init: StreamSource, SofSource, 3AControl, lensCtrl
      * 2.Register listener if enable AIQ
      * 3.Set the defualt parameters
      *
      * \return OK if succeed, other value indicates failed
      */
     int init();

     /**
      * \brief Camera device class deinit
      *
      * 1.Change the state
      * 2.Destory the listeners
      * 3.Delete the streams
      * 4.Deinit the Related classes.
      */
     void deinit();

     /**
      * \brief Camera device start
      *
      * 1. Start all streams
      * 2. Related classes start
      *
      * \return OK if succeed, other value indicates failed
      */
     int start();

     /**
      * \brief Camera device stop
      *
      * 1. Stop all related class module.
      * 2. Change the state
      */
     int stop();

     /**
      * \brief Allocate momery according to user buffer
      *
      * 1. Convert user buffer to CameraBuffer and push it into UserBufferQueue
      * 2. Calling CameraStream class to allocateMemory.
      *
      * \return OK if succeed, other value indicates failed
      */
     int allocateMemory(camera_buffer_t *ubuffer);

     /**
      * \brief dequeue buffer from cameraStream.
      *
      * 1. Dequeue one CameraBuffer from CameraStream
      * 2. Fill the user buffer base on CameraBuffer
      * 3. Fill the settings was used for this buffer if settings is not nullptr
      *
      * \return 0 if succeed, other value indicates failed
      */
     int dqbuf(int streamId, camera_buffer_t **ubuffer, Parameters* settings = nullptr);

     /**
      * \brief Queue one buffer to CameraStream
      *
      * 1. Get the CameraBuffer base on the ubuffer
      * 2. Calling CameraStream to queue one CameraBuffer
      *
      * \return OK if succeed and BAD_VALUE if failed
      */
     int qbuf(camera_buffer_t **ubuffer, int bufferNum = 1, const Parameters* settings = nullptr);

     /**
      * \brief Configure the device sensor input
      *
      *
      * \param inputConfig: the Output format/resolution of the isys
      *
      * \return OK if succeed and BAD_VALUE if failed
      */
     int configureInput(const stream_t *inputConfig);

     /**
      * \brief Configure the streams, devices and post processor.
      *
      * Configure the streams according to the streamList info
      * Extra processor is needed if the format isn't supported in Psys output
      *
      * \param streamList: all the streams info
      *
      * \return OK if succeed and BAD_VALUE if failed
      */
     int configure(stream_config_t *streamList);

     /**
      * \brief Set the parameters
      *
      * Merge the param to internal parameters and set them to 3A
      * and processor.
      *
      * \param param: the parameters need to set
      *
      * \return OK if succeed, other value indicates failed
      */
     int setParameters(const Parameters& param);

     /**
      * \brief Get the parameters
      *
      * Get the internal parameters list
      *
      * \return OK if succeed, other value indicates failed
      */
     int getParameters(Parameters& param, long sequence);

     void handleEvent(EventData eventData);

     void callbackRegister(const camera_callback_ops_t* callback);
 private:
     DISALLOW_COPY_AND_ASSIGN(CameraDevice);

     /**
      * \brief Reconfigure the streams, devices and post processor.
      *
      * \param streamList: all the streams info
      *
      * \return OK if succeed and BAD_VALUE if failed
      */
     int reconfigure(stream_config_t *streamList);

     int startLocked();
     int stopLocked();
     int initDefaultParameters();
     std::shared_ptr<CameraBuffer> userBufferToCameraBuffer(Port port,
                                                                 camera_buffer_t *ubuffer);

     StreamSource* createBufferProducer();
     std::map<Port, stream_t> selectProducerConfig(const stream_config_t *streamList, int mcId);
     bool isProcessorNeeded(const stream_config_t *streamList, const stream_t &producerConfig);
     bool isStillDuringVideo(const stream_config_t *streamList);
     int analyzeStream(stream_config_t *streamList);
     int createStreams(stream_config_t *streamList);
     int bindStreams(stream_config_t *streamList);
     void deleteStreams();

     /**
      * Bind all event listeners with their source.
      */
     void bindListeners();

     /**
      * Unbind all event listeners from their source.
      */
     void unbindListeners();

     long fetchCaptureSettings(const Parameters * params);

     // The second phase of qbuf(), done in RequestThread
     int handleQueueBuffer(int bufferNum, camera_buffer_t **ubuffer, long sequence);

     // No lock protect for internal usage, should be protected by mDeviceLock from outside
     int configureL(stream_config_t *streamList, bool clean = true);
     int setParametersL(const Parameters& param);

     int registerBuffer(camera_buffer_t **ubuffer, int bufferNum);

 private:
     enum {
         DEVICE_UNINIT = 0,
         DEVICE_INIT,
         DEVICE_CONFIGURE, //means stream configured
         DEVICE_START,
         DEVICE_STOP,
         DEVICE_BUFFER_READY, //At least one buffer is queued to ISP
     } mState;

     // Guard for CameraDevice public API
     Mutex mDeviceLock;

     static const nsecs_t kWaitDuration = 5000000000; //5000ms

     // Pipeline elements
     CameraStream* mStreams[MAX_STREAM_NUMBER];
     std::map<int, Port> mStreamIdToPortMap;
     std::vector<int> mSortedStreamIds; // Used to save sorted stream ids with descending order.
     StreamSource *mProducer;

     ProcessorManager* mProcessorManager;
     std::vector<BufferQueue*> mProcessors;

     ParameterGenerator *mParamGenerator;

     LensHw *mLensCtrl;
     SensorHwCtrl *mSensorCtrl;
     SofSource* mSofSource;
     AiqUnitBase *m3AControl;

     //Internal used variable
     int     mCameraId;
     int     mStreamNum;
     Parameters mParameter;
     //The latest result parameters
     Parameters mResultParameter;
     bool mPerframeControlSupport;

     RequestThread* mRequestThread;
     IGraphConfigManager *mGCM;
     stream_t mInputConfig;
     camera_callback_ops_t *mCallback;
 };

 } //namespace icamera
	/*
	* Copyright (C) 2016-2020 Intel Corporation.
	*
	* 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.
	*/

	#pragma once

	#include "CameraStream.h"
	#include "RequestThread.h"
	#include "StreamSource.h"
	#include "AiqUnit.h"
	#include "Parameters.h"
	#include "ParameterGenerator.h"
	#include "SensorHwCtrl.h"
	#include "SofSource.h"
	#include "LensHw.h"

	#include "ProcessorManager.h"

	#include "gc/IGraphConfigManager.h"

	namespace icamera {

	class RequestThread;

	/**
	* CameraDevice : Create elements to construct the streaming pipeline
	* Each element must be a producer or a consumer or Both.
	*
	* These are the typical pipelines:
	*
	* For a single SOC YUV capture in by pass mode
	* StreamSource -> CameraStream
	*
	* For a single NV12 capture of TPG/Sensor using SwImageProcess
	* StreamSource -> SwImageProcessor -> CameraStream
	*
	* For a single NV12 capture of TPG/Sensor using PSYS processor
	* StreamSource -> PsysProcessor -> CameraStream
	*
	* For a dual streams NV12 video capture of TPG/Sensor using PSYS processor
	* StreamSource -> PsysProcessor \| -> CameraStream (For video recording)
	* \| -> CameraStream (for Preview)
	*
	* For a SDV(Snapshot during video) capture of TPG/Sensor uinsg PSYS processor
	* StreamSource \| -> PsysProcessor \| -> CameraStream (For video recording)
	* \| \| -> CameraStream (for Preview)
	* \| -> PsysProcessor \| -> CameraStream (For still YUV)
	*
	* The buffer notification between the Class is based on Interface defined
	* in BufferQueue. The upstream element use "onFrameAvailable" message to notfiy
	* downstream elements that the buffers are ready for further processing
	*
	* Following singleton instances are created and maintained by CameraDevice
	* 1. IGraphConfigManager
	* 2. AiqResultStorage
	*/
	class CameraDevice : public EventListener {

	public:
	CameraDevice(int cameraId);
	~CameraDevice();

	/**
	* \brief Camera device class init
	*
	* 1.Related classes init: StreamSource, SofSource, 3AControl, lensCtrl
	* 2.Register listener if enable AIQ
	* 3.Set the defualt parameters
	*
	* \return OK if succeed, other value indicates failed
	*/
	int init();

	/**
	* \brief Camera device class deinit
	*
	* 1.Change the state
	* 2.Destory the listeners
	* 3.Delete the streams
	* 4.Deinit the Related classes.
	*/
	void deinit();

	/**
	* \brief Camera device start
	*
	* 1. Start all streams
	* 2. Related classes start
	*
	* \return OK if succeed, other value indicates failed
	*/
	int start();

	/**
	* \brief Camera device stop
	*
	* 1. Stop all related class module.
	* 2. Change the state
	*/
	int stop();

	/**
	* \brief Allocate momery according to user buffer
	*
	* 1. Convert user buffer to CameraBuffer and push it into UserBufferQueue
	* 2. Calling CameraStream class to allocateMemory.
	*
	* \return OK if succeed, other value indicates failed
	*/
	int allocateMemory(camera_buffer_t *ubuffer);

	/**
	* \brief dequeue buffer from cameraStream.
	*
	* 1. Dequeue one CameraBuffer from CameraStream
	* 2. Fill the user buffer base on CameraBuffer
	* 3. Fill the settings was used for this buffer if settings is not nullptr
	*
	* \return 0 if succeed, other value indicates failed
	*/
	int dqbuf(int streamId, camera_buffer_t *ubuffer, Parameters settings = nullptr);

	/**
	* \brief Queue one buffer to CameraStream
	*
	* 1. Get the CameraBuffer base on the ubuffer
	* 2. Calling CameraStream to queue one CameraBuffer
	*
	* \return OK if succeed and BAD_VALUE if failed
	*/
	int qbuf(camera_buffer_t *ubuffer, int bufferNum = 1, const Parameters settings = nullptr);

	/**
	* \brief Configure the device sensor input
	*
	*
	* \param inputConfig: the Output format/resolution of the isys
	*
	* \return OK if succeed and BAD_VALUE if failed
	*/
	int configureInput(const stream_t *inputConfig);

	/**
	* \brief Configure the streams, devices and post processor.
	*
	* Configure the streams according to the streamList info
	* Extra processor is needed if the format isn't supported in Psys output
	*
	* \param streamList: all the streams info
	*
	* \return OK if succeed and BAD_VALUE if failed
	*/
	int configure(stream_config_t *streamList);

	/**
	* \brief Set the parameters
	*
	* Merge the param to internal parameters and set them to 3A
	* and processor.
	*
	* \param param: the parameters need to set
	*
	* \return OK if succeed, other value indicates failed
	*/
	int setParameters(const Parameters& param);

	/**
	* \brief Get the parameters
	*
	* Get the internal parameters list
	*
	* \return OK if succeed, other value indicates failed
	*/
	int getParameters(Parameters& param, long sequence);

	void handleEvent(EventData eventData);

	void callbackRegister(const camera_callback_ops_t* callback);
	private:
	DISALLOW_COPY_AND_ASSIGN(CameraDevice);

	/**
	* \brief Reconfigure the streams, devices and post processor.
	*
	* \param streamList: all the streams info
	*
	* \return OK if succeed and BAD_VALUE if failed
	*/
	int reconfigure(stream_config_t *streamList);

	int startLocked();
	int stopLocked();
	int initDefaultParameters();
	std::shared_ptr<CameraBuffer> userBufferToCameraBuffer(Port port,
	camera_buffer_t *ubuffer);

	StreamSource* createBufferProducer();
	std::map<Port, stream_t> selectProducerConfig(const stream_config_t *streamList, int mcId);
	bool isProcessorNeeded(const stream_config_t *streamList, const stream_t &producerConfig);
	bool isStillDuringVideo(const stream_config_t *streamList);
	int analyzeStream(stream_config_t *streamList);
	int createStreams(stream_config_t *streamList);
	int bindStreams(stream_config_t *streamList);
	void deleteStreams();

	/**
	* Bind all event listeners with their source.
	*/
	void bindListeners();

	/**
	* Unbind all event listeners from their source.
	*/
	void unbindListeners();

	long fetchCaptureSettings(const Parameters * params);

	// The second phase of qbuf(), done in RequestThread
	int handleQueueBuffer(int bufferNum, camera_buffer_t **ubuffer, long sequence);

	// No lock protect for internal usage, should be protected by mDeviceLock from outside
	int configureL(stream_config_t *streamList, bool clean = true);
	int setParametersL(const Parameters& param);

	int registerBuffer(camera_buffer_t **ubuffer, int bufferNum);

	private:
	enum {
	DEVICE_UNINIT = 0,
	DEVICE_INIT,
	DEVICE_CONFIGURE, //means stream configured
	DEVICE_START,
	DEVICE_STOP,
	DEVICE_BUFFER_READY, //At least one buffer is queued to ISP
	} mState;

	// Guard for CameraDevice public API
	Mutex mDeviceLock;

	static const nsecs_t kWaitDuration = 5000000000; //5000ms

	// Pipeline elements
	CameraStream* mStreams[MAX_STREAM_NUMBER];
	std::map<int, Port> mStreamIdToPortMap;
	std::vector<int> mSortedStreamIds; // Used to save sorted stream ids with descending order.
	StreamSource *mProducer;

	ProcessorManager* mProcessorManager;
	std::vector<BufferQueue*> mProcessors;

	ParameterGenerator *mParamGenerator;

	LensHw *mLensCtrl;
	SensorHwCtrl *mSensorCtrl;
	SofSource* mSofSource;
	AiqUnitBase *m3AControl;

	//Internal used variable
	int mCameraId;
	int mStreamNum;
	Parameters mParameter;
	//The latest result parameters
	Parameters mResultParameter;
	bool mPerframeControlSupport;

	RequestThread* mRequestThread;
	IGraphConfigManager *mGCM;
	stream_t mInputConfig;
	camera_callback_ops_t *mCallback;
	};

	} //namespace icamera