| /* |
| * Copyright 2018 The Chromium OS Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef CAMERA_COMMON_JPEG_JPEG_ENCODE_ACCELERATOR_IMPL_H_ |
| #define CAMERA_COMMON_JPEG_JPEG_ENCODE_ACCELERATOR_IMPL_H_ |
| |
| #include <stdint.h> |
| #include <memory> |
| #include <unordered_map> |
| #include <vector> |
| |
| #include <base/memory/weak_ptr.h> |
| #include <base/memory/writable_shared_memory_region.h> |
| #include <base/threading/thread.h> |
| |
| #include "cros-camera/camera_mojo_channel_manager.h" |
| #include "cros-camera/future.h" |
| #include "cros-camera/jpeg_compressor.h" |
| #include "cros-camera/jpeg_encode_accelerator.h" |
| #include "mojo/cros_camera_service.mojom.h" |
| #include "mojo/gpu/jpeg_encode_accelerator.mojom.h" |
| |
| namespace cros { |
| |
| // Encapsulates a converter from JPEG to YU12 format. |
| // Before using this class, make sure mojo is initialized first. |
| class JpegEncodeAcceleratorImpl : public JpegEncodeAccelerator { |
| public: |
| explicit JpegEncodeAcceleratorImpl(CameraMojoChannelManager* mojo_manager); |
| JpegEncodeAcceleratorImpl(const JpegEncodeAcceleratorImpl&) = delete; |
| JpegEncodeAcceleratorImpl& operator=(const JpegEncodeAcceleratorImpl&) = |
| delete; |
| |
| ~JpegEncodeAcceleratorImpl() override; |
| |
| // JpegEncodeAccelerator implementation. |
| |
| bool Start() override; |
| |
| // To be deprecated. |
| int EncodeSync(int input_fd, |
| const uint8_t* input_buffer, |
| uint32_t input_buffer_size, |
| int32_t coded_size_width, |
| int32_t coded_size_height, |
| const uint8_t* exif_buffer, |
| uint32_t exif_buffer_size, |
| int output_fd, |
| uint32_t output_buffer_size, |
| uint32_t* output_data_size) override; |
| |
| int EncodeSync(uint32_t input_format, |
| const std::vector<JpegCompressor::DmaBufPlane>& input_planes, |
| const std::vector<JpegCompressor::DmaBufPlane>& output_planes, |
| const uint8_t* exif_buffer, |
| uint32_t exif_buffer_size, |
| int width, |
| int height, |
| uint32_t* output_data_size) override; |
| |
| private: |
| // IPCBridge wraps all the IPC-related calls. Most of its methods should/will |
| // be run on IPC thread. |
| class IPCBridge { |
| public: |
| IPCBridge(CameraMojoChannelManager* mojo_manager, |
| CancellationRelay* cancellation_relay); |
| |
| // It should only be triggered on IPC thread to ensure thread-safety. |
| ~IPCBridge(); |
| |
| // Initialize Mojo channel to GPU pcorss in chrome. |
| void Start(base::Callback<void(bool)> callback); |
| |
| // Destroy the instance. |
| void Destroy(); |
| |
| // Process encode request in IPC thread. |
| // Either |input_fd| or |input_buffer| has to be filled up. |
| void EncodeLegacy(int32_t task_id, |
| int input_fd, |
| const uint8_t* input_buffer, |
| uint32_t input_buffer_size, |
| int32_t coded_size_width, |
| int32_t coded_size_height, |
| const uint8_t* exif_buffer, |
| uint32_t exif_buffer_size, |
| int output_fd, |
| uint32_t output_buffer_size, |
| EncodeWithFDCallback callback); |
| |
| // Process encode request in IPC thread. |
| void Encode(int32_t task_id, |
| uint32_t input_format, |
| const std::vector<JpegCompressor::DmaBufPlane>& input_planes, |
| const std::vector<JpegCompressor::DmaBufPlane>& output_planes, |
| const uint8_t* exif_buffer, |
| uint32_t exif_buffer_size, |
| int coded_size_width, |
| int coded_size_height, |
| EncodeWithDmaBufCallback callback); |
| |
| // For synced Encode API. |
| void EncodeSyncCallback(base::Callback<void(int)> callback, |
| uint32_t* output_data_size, |
| int32_t task_id, |
| uint32_t output_size, |
| int status); |
| |
| // Gets a weak pointer of the IPCBridge. This method can be called on |
| // non-IPC thread. |
| base::WeakPtr<IPCBridge> GetWeakPtr(); |
| |
| // Return true if the mojo channel is ready to use. This method can be |
| // called on non-IPC thread. |
| bool IsReady(); |
| |
| private: |
| // Initialize the JpegEncodeAccelerator. |
| void Initialize(base::Callback<void(bool)> callback); |
| |
| // Error handler for JEA mojo channel. |
| void OnJpegEncodeAcceleratorError(); |
| |
| // Callback function for |jea_ptr_|->EncodeWithFD(). |
| void OnEncodeAck(EncodeWithFDCallback callback, |
| int32_t task_id, |
| uint32_t output_size, |
| cros::mojom::EncodeStatus status); |
| |
| // Callback function for |jea_ptr_|->EncodeWithDmaBuf(). |
| void OnEncodeDmaBufAck(EncodeWithDmaBufCallback callback, |
| uint32_t output_size, |
| cros::mojom::EncodeStatus status); |
| |
| // Camera Mojo channel manager. |
| // We use it to create JpegEncodeAccelerator Mojo channel. |
| CameraMojoChannelManager* mojo_manager_; |
| |
| // Used to cancel pending futures when error occurs. |
| CancellationRelay* cancellation_relay_; |
| |
| // The Mojo IPC task runner. |
| const scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_; |
| |
| // Pointer to local proxy of remote JpegEncodeAccelerator interface |
| // implementation. |
| // All the Mojo communication to |jea_ptr_| happens on |ipc_task_runner_|. |
| mojom::JpegEncodeAcceleratorPtr jea_ptr_; |
| |
| // A map from buffer id to input and exif shared memory. |
| // |input_shm_map_| and |exif_shm_map_| should only be accessed on |
| // |ipc_task_runner_|. |
| // Since the input buffer may be from DMA buffer, we need to prepare a |
| // shared memory for JpegEncodeAccelerator interface. We will send the |
| // handles of the shared memory to the remote process, so we need to keep |
| // the shared memory referenced until we receive EncodeAck. |
| |
| base::WeakPtrFactory<IPCBridge> weak_ptr_factory_{this}; |
| }; |
| |
| // The id for current encode task. |
| int32_t task_id_; |
| |
| // Mojo manager which is used for Mojo communication. |
| CameraMojoChannelManager* mojo_manager_; |
| |
| // Used to cancel pending futures when error occurs. |
| std::unique_ptr<CancellationRelay> cancellation_relay_; |
| |
| // The instance which deals with the IPC-related calls. It should always run |
| // and be deleted on IPC thread. |
| std::unique_ptr<IPCBridge> ipc_bridge_; |
| }; |
| |
| } // namespace cros |
| #endif // CAMERA_COMMON_JPEG_JPEG_ENCODE_ACCELERATOR_IMPL_H_ |