1 files changed, 61 insertions, 65 deletions

diff --git a/src/android/camera_device.h b/src/android/camera_device.h
index 1837748d..089a6204 100644
--- a/src/android/camera_device.h
+++ b/src/android/camera_device.h
@@ -9,65 +9,52 @@
 
 #include <map>
 #include <memory>
-#include <tuple>
+#include <mutex>
 #include <vector>
 
 #include <hardware/camera3.h>
 
-#include <libcamera/buffer.h>
+#include <libcamera/base/class.h>
+#include <libcamera/base/log.h>
+#include <libcamera/base/message.h>
+#include <libcamera/base/thread.h>
+
 #include <libcamera/camera.h>
-#include <libcamera/geometry.h>
+#include <libcamera/framebuffer.h>
 #include <libcamera/request.h>
 #include <libcamera/stream.h>
 
-#include "libcamera/internal/log.h"
-#include "libcamera/internal/message.h"
+#include "libcamera/internal/framebuffer.h"
 
+#include "camera_capabilities.h"
+#include "camera_metadata.h"
+#include "camera_stream.h"
+#include "camera_worker.h"
 #include "jpeg/encoder.h"
 
-class CameraMetadata;
-
-class CameraStream
-{
-public:
-	CameraStream(libcamera::PixelFormat format, libcamera::Size size,
-		     unsigned int index, Encoder *encoder = nullptr);
-
-	const libcamera::PixelFormat &format() const { return format_; }
-	const libcamera::Size &size() const { return size_; }
-	unsigned int index() const { return index_; }
-	Encoder *encoder() const { return encoder_.get(); }
-
-private:
-	libcamera::PixelFormat format_;
-	libcamera::Size size_;
-	/*
-	 * The index of the libcamera StreamConfiguration as added during
-	 * configureStreams(). A single libcamera Stream may be used to deliver
-	 * one or more streams to the Android framework.
-	 */
-	unsigned int index_;
-	std::unique_ptr<Encoder> encoder_;
-};
-
+struct CameraConfigData;
 class CameraDevice : protected libcamera::Loggable
 {
 public:
-	static std::shared_ptr<CameraDevice> create(unsigned int id,
-						    const std::shared_ptr<libcamera::Camera> &cam);
+	static std::unique_ptr<CameraDevice> create(unsigned int id,
+						    std::shared_ptr<libcamera::Camera> cam);
 	~CameraDevice();
 
-	int initialize();
+	int initialize(const CameraConfigData *cameraConfigData);
 
 	int open(const hw_module_t *hardwareModule);
 	void close();
+	void flush();
 
 	unsigned int id() const { return id_; }
 	camera3_device_t *camera3Device() { return &camera3Device_; }
-	const libcamera::Camera *camera() const { return camera_.get(); }
+	const std::shared_ptr<libcamera::Camera> &camera() const { return camera_; }
 
+	const std::string &maker() const { return maker_; }
+	const std::string &model() const { return model_; }
 	int facing() const { return facing_; }
 	int orientation() const { return orientation_; }
+	unsigned int maxJpegBufferSize() const;
 
 	void setCallbacks(const camera3_callback_ops_t *callbacks);
 	const camera_metadata_t *getStaticMetadata();
@@ -80,60 +67,69 @@ protected:
 	std::string logPrefix() const override;
 
 private:
-	CameraDevice(unsigned int id, const std::shared_ptr<libcamera::Camera> &camera);
+	LIBCAMERA_DISABLE_COPY_AND_MOVE(CameraDevice)
+
+	CameraDevice(unsigned int id, std::shared_ptr<libcamera::Camera> camera);
 
 	struct Camera3RequestDescriptor {
-		Camera3RequestDescriptor(unsigned int frameNumber,
-					 unsigned int numBuffers);
-		~Camera3RequestDescriptor();
-
-		uint32_t frameNumber;
-		uint32_t numBuffers;
-		camera3_stream_buffer_t *buffers;
-		std::vector<std::unique_ptr<libcamera::FrameBuffer>> frameBuffers;
+		Camera3RequestDescriptor() = default;
+		~Camera3RequestDescriptor() = default;
+		Camera3RequestDescriptor(libcamera::Camera *camera,
+					 const camera3_capture_request_t *camera3Request);
+		Camera3RequestDescriptor &operator=(Camera3RequestDescriptor &&) = default;
+
+		uint32_t frameNumber_ = 0;
+		std::vector<camera3_stream_buffer_t> buffers_;
+		std::vector<std::unique_ptr<libcamera::FrameBuffer>> frameBuffers_;
+		CameraMetadata settings_;
+		std::unique_ptr<CaptureRequest> request_;
 	};
 
-	struct Camera3StreamConfiguration {
-		libcamera::Size resolution;
-		int androidFormat;
+	enum class State {
+		Stopped,
+		Flushing,
+		Running,
 	};
 
-	int initializeStreamConfigurations();
-	std::vector<libcamera::Size>
-	getYUVResolutions(libcamera::CameraConfiguration *cameraConfig,
-			  const libcamera::PixelFormat &pixelFormat,
-			  const std::vector<libcamera::Size> &resolutions);
-	std::vector<libcamera::Size>
-	getRawResolutions(const libcamera::PixelFormat &pixelFormat);
+	void stop();
 
-	std::tuple<uint32_t, uint32_t> calculateStaticMetadataSize();
 	libcamera::FrameBuffer *createFrameBuffer(const buffer_handle_t camera3buffer);
+	void abortRequest(camera3_capture_request_t *request);
+	bool isValidRequest(camera3_capture_request_t *request) const;
 	void notifyShutter(uint32_t frameNumber, uint64_t timestamp);
-	void notifyError(uint32_t frameNumber, camera3_stream_t *stream);
-	CameraMetadata *requestTemplatePreview();
-	libcamera::PixelFormat toPixelFormat(int format);
-	std::unique_ptr<CameraMetadata> getResultMetadata(int frame_number,
-							  int64_t timestamp);
+	void notifyError(uint32_t frameNumber, camera3_stream_t *stream,
+			 camera3_error_msg_code code);
+	int processControls(Camera3RequestDescriptor *descriptor);
+	std::unique_ptr<CameraMetadata> getResultMetadata(
+		const Camera3RequestDescriptor &descriptor) const;
 
 	unsigned int id_;
 	camera3_device_t camera3Device_;
 
-	bool running_;
+	CameraWorker worker_;
+
+	libcamera::Mutex stateMutex_; /* Protects access to the camera state. */
+	State state_;
+
 	std::shared_ptr<libcamera::Camera> camera_;
 	std::unique_ptr<libcamera::CameraConfiguration> config_;
+	CameraCapabilities capabilities_;
 
-	CameraMetadata *staticMetadata_;
-	std::map<unsigned int, const CameraMetadata *> requestTemplates_;
+	std::map<unsigned int, std::unique_ptr<CameraMetadata>> requestTemplates_;
 	const camera3_callback_ops_t *callbacks_;
 
-	std::vector<Camera3StreamConfiguration> streamConfigurations_;
-	std::map<int, libcamera::PixelFormat> formatsMap_;
 	std::vector<CameraStream> streams_;
 
+	libcamera::Mutex descriptorsMutex_; /* Protects descriptors_. */
+	std::map<uint64_t, Camera3RequestDescriptor> descriptors_;
+
+	std::string maker_;
+	std::string model_;
+
 	int facing_;
 	int orientation_;
 
-	unsigned int maxJpegBufferSize_;
+	CameraMetadata lastSettings_;
 };
 
 #endif /* __ANDROID_CAMERA_DEVICE_H__ */