| /* Copyright 2022 The ChromiumOS Authors |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef CAMERA_HAL_FAKE_REQUEST_HANDLER_H_ |
| #define CAMERA_HAL_FAKE_REQUEST_HANDLER_H_ |
| |
| #include <memory> |
| #include <vector> |
| |
| #include <base/containers/flat_map.h> |
| #include <base/task/sequenced_task_runner.h> |
| #include <camera/camera_metadata.h> |
| #include <hardware/camera3.h> |
| |
| #include "hal/fake/capture_request.h" |
| #include "hal/fake/fake_stream.h" |
| #include "hal/fake/hal_spec.h" |
| |
| namespace cros { |
| // RequestHandler handles all capture request on a dedicated thread, and all |
| // the methods run on the same thread. |
| class RequestHandler { |
| public: |
| // Does not take ownership of |spec|, and the passed in |spec| must outlive |
| // this object. |
| RequestHandler(const int id, |
| const camera3_callback_ops_t* callback_ops, |
| const android::CameraMetadata& static_metadata, |
| const scoped_refptr<base::SequencedTaskRunner>& task_runner, |
| const CameraSpec& spec); |
| ~RequestHandler(); |
| |
| // Handle one request. |
| void HandleRequest(std::unique_ptr<CaptureRequest> request); |
| |
| // Handle flush request. This function can be called on any thread. |
| void HandleFlush(base::OnceCallback<void()> callback); |
| |
| // Start streaming and calls callback with whether the operation succeed. |
| void StreamOn(const std::vector<camera3_stream_t*>& streams, |
| base::OnceCallback<void(bool)> callback); |
| |
| // Stop streaming and calls callback with whether the operation succeed. |
| void StreamOff(base::OnceCallback<void(bool)> callback); |
| |
| private: |
| // Start streaming implementation. |
| bool StreamOnImpl(const std::vector<camera3_stream_t*>& streams); |
| |
| // Stop streaming implementation. |
| bool StreamOffImpl(); |
| |
| // Do not wait buffer sync for aborted requests. |
| void AbortGrallocBufferSync(CaptureRequest& request); |
| |
| // Handle aborted request. |
| void HandleAbortedRequest(CaptureRequest& request); |
| |
| // Notify shutter event. |
| void NotifyShutter(uint32_t frame_number, uint64_t timestamp); |
| |
| // Notify request error event. |
| void NotifyRequestError(uint32_t frame_number); |
| |
| // Fill one result buffer. |
| bool FillResultBuffer(camera3_stream_buffer_t& buffer); |
| |
| // Used to notify caller that all requests are handled. |
| void FlushDone(base::OnceCallback<void()> callback); |
| |
| // id of the camera device. |
| const int id_; |
| |
| // Methods used to call back into the framework. |
| const camera3_callback_ops_t* callback_ops_; |
| |
| // Task runner for request thread. |
| const scoped_refptr<base::SequencedTaskRunner> task_runner_; |
| |
| // Map from stream config to fake stream. |
| base::flat_map<camera3_stream_t*, std::unique_ptr<FakeStream>> fake_streams_; |
| |
| // Camera static characteristics. |
| const android::CameraMetadata static_metadata_; |
| |
| // Spec for the camera. |
| CameraSpec spec_; |
| |
| // Timestamp for last response. |
| uint64_t last_response_timestamp_ = 0; |
| |
| // Used to notify that flush is called from framework. |
| bool flush_started_ GUARDED_BY(flush_lock_) = false; |
| |
| // Used to guard |flush_started_|. |
| base::Lock flush_lock_; |
| }; |
| } // namespace cros |
| |
| #endif // CAMERA_HAL_FAKE_REQUEST_HANDLER_H_ |