241 lines
11 KiB
C++
241 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2022 The Android Open Source Project
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef ANDROID_SERVERS_HIDLCAMERA3DEVICE_H
|
|
#define ANDROID_SERVERS_HIDLCAMERA3DEVICE_H
|
|
|
|
#include "../Camera3Device.h"
|
|
#include "HidlCamera3OutputUtils.h"
|
|
|
|
namespace android {
|
|
|
|
|
|
/**
|
|
* CameraDevice for HIDL HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher.
|
|
*/
|
|
class HidlCamera3Device :
|
|
virtual public hardware::camera::device::V3_5::ICameraDeviceCallback,
|
|
public Camera3Device {
|
|
public:
|
|
|
|
explicit HidlCamera3Device(const String8& id, bool overrideForPerfClass, bool overrideToPortrait,
|
|
bool legacyClient = false) : Camera3Device(id, overrideForPerfClass, overrideToPortrait,
|
|
legacyClient) { }
|
|
|
|
virtual ~HidlCamera3Device() {}
|
|
|
|
/**
|
|
* Helper functions to map between framework and HIDL values
|
|
*/
|
|
static hardware::graphics::common::V1_0::PixelFormat mapToPixelFormat(int frameworkFormat);
|
|
static hardware::camera::device::V3_2::DataspaceFlags mapToHidlDataspace(
|
|
android_dataspace dataSpace);
|
|
static hardware::camera::device::V3_2::BufferUsageFlags mapToConsumerUsage(uint64_t usage);
|
|
static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation(
|
|
camera_stream_rotation_t rotation);
|
|
// Returns a negative error code if the passed-in operation mode is not valid.
|
|
static status_t mapToStreamConfigurationMode(camera_stream_configuration_mode_t operationMode,
|
|
/*out*/ hardware::camera::device::V3_2::StreamConfigurationMode *mode);
|
|
static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat);
|
|
static android_dataspace mapToFrameworkDataspace(
|
|
hardware::camera::device::V3_2::DataspaceFlags);
|
|
static uint64_t mapConsumerToFrameworkUsage(
|
|
hardware::camera::device::V3_2::BufferUsageFlags usage);
|
|
static uint64_t mapProducerToFrameworkUsage(
|
|
hardware::camera::device::V3_2::BufferUsageFlags usage);
|
|
|
|
status_t initialize(sp<CameraProviderManager> manager, const String8& monitorTags) override;
|
|
|
|
/**
|
|
* Implementation of android::hardware::camera::device::V3_5::ICameraDeviceCallback
|
|
*/
|
|
|
|
hardware::Return<void> processCaptureResult_3_4(
|
|
const hardware::hidl_vec<
|
|
hardware::camera::device::V3_4::CaptureResult>& results) override;
|
|
hardware::Return<void> processCaptureResult(
|
|
const hardware::hidl_vec<
|
|
hardware::camera::device::V3_2::CaptureResult>& results) override;
|
|
hardware::Return<void> notify(
|
|
const hardware::hidl_vec<
|
|
hardware::camera::device::V3_2::NotifyMsg>& msgs) override;
|
|
|
|
hardware::Return<void> requestStreamBuffers(
|
|
const hardware::hidl_vec<
|
|
hardware::camera::device::V3_5::BufferRequest>& bufReqs,
|
|
requestStreamBuffers_cb _hidl_cb) override;
|
|
|
|
hardware::Return<void> returnStreamBuffers(
|
|
const hardware::hidl_vec<
|
|
hardware::camera::device::V3_2::StreamBuffer>& buffers) override;
|
|
|
|
// Handle one notify message
|
|
void notify(const hardware::camera::device::V3_2::NotifyMsg& msg);
|
|
|
|
status_t switchToOffline(const std::vector<int32_t>& streamsToKeep,
|
|
/*out*/ sp<CameraOfflineSessionBase>* session) override;
|
|
|
|
using RequestMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>;
|
|
|
|
class HidlHalInterface : public Camera3Device::HalInterface {
|
|
public:
|
|
HidlHalInterface(sp<hardware::camera::device::V3_2::ICameraDeviceSession> &session,
|
|
std::shared_ptr<RequestMetadataQueue> queue,
|
|
bool useHalBufManager, bool supportOfflineProcessing);
|
|
|
|
virtual IPCTransport getTransportType() const override { return IPCTransport::HIDL; }
|
|
// Returns true if constructed with a valid device or session, and not yet cleared
|
|
virtual bool valid() override;
|
|
|
|
// Reset this HalInterface object (does not call close())
|
|
virtual void clear() override;
|
|
|
|
// Calls into the HAL interface
|
|
|
|
// Caller takes ownership of requestTemplate
|
|
virtual status_t constructDefaultRequestSettings(camera_request_template templateId,
|
|
/*out*/ camera_metadata_t **requestTemplate) override;
|
|
|
|
virtual status_t configureStreams(const camera_metadata_t *sessionParams,
|
|
/*inout*/ camera_stream_configuration_t *config,
|
|
const std::vector<uint32_t>& bufferSizes) override;
|
|
|
|
// The injection camera configures the streams to hal.
|
|
virtual status_t configureInjectedStreams(
|
|
const camera_metadata_t* sessionParams,
|
|
/*inout*/ camera_stream_configuration_t* config,
|
|
const std::vector<uint32_t>& bufferSizes,
|
|
const CameraMetadata& cameraCharacteristics) override;
|
|
|
|
// When the call succeeds, the ownership of acquire fences in requests is transferred to
|
|
// HalInterface. More specifically, the current implementation will send the fence to
|
|
// HAL process and close the FD in cameraserver process. When the call fails, the ownership
|
|
// of the acquire fence still belongs to the caller.
|
|
virtual status_t processBatchCaptureRequests(
|
|
std::vector<camera_capture_request_t*>& requests,
|
|
/*out*/uint32_t* numRequestProcessed) override;
|
|
virtual status_t flush() override;
|
|
virtual status_t dump(int fd) override;
|
|
virtual status_t close() override;
|
|
|
|
virtual void signalPipelineDrain(const std::vector<int>& streamIds) override;
|
|
virtual bool isReconfigurationRequired(CameraMetadata& oldSessionParams,
|
|
CameraMetadata& newSessionParams) override;
|
|
|
|
virtual status_t repeatingRequestEnd(uint32_t frameNumber,
|
|
const std::vector<int32_t> &streamIds) override;
|
|
|
|
status_t switchToOffline(
|
|
const std::vector<int32_t>& streamsToKeep,
|
|
/*out*/hardware::camera::device::V3_6::CameraOfflineSessionInfo* offlineSessionInfo,
|
|
/*out*/sp<hardware::camera::device::V3_6::ICameraOfflineSession>* offlineSession,
|
|
/*out*/camera3::BufferRecords* bufferRecords);
|
|
|
|
private:
|
|
|
|
// Always valid
|
|
sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession;
|
|
// Valid if ICameraDeviceSession is @3.3 or newer
|
|
sp<hardware::camera::device::V3_3::ICameraDeviceSession> mHidlSession_3_3;
|
|
// Valid if ICameraDeviceSession is @3.4 or newer
|
|
sp<hardware::camera::device::V3_4::ICameraDeviceSession> mHidlSession_3_4;
|
|
// Valid if ICameraDeviceSession is @3.5 or newer
|
|
sp<hardware::camera::device::V3_5::ICameraDeviceSession> mHidlSession_3_5;
|
|
// Valid if ICameraDeviceSession is @3.6 or newer
|
|
sp<hardware::camera::device::V3_6::ICameraDeviceSession> mHidlSession_3_6;
|
|
// Valid if ICameraDeviceSession is @3.7 or newer
|
|
sp<hardware::camera::device::V3_7::ICameraDeviceSession> mHidlSession_3_7;
|
|
|
|
std::shared_ptr<RequestMetadataQueue> mRequestMetadataQueue;
|
|
|
|
// The output HIDL request still depends on input camera_capture_request_t
|
|
// Do not free input camera_capture_request_t before output HIDL request
|
|
status_t wrapAsHidlRequest(camera_capture_request_t* in,
|
|
/*out*/hardware::camera::device::V3_2::CaptureRequest* out,
|
|
/*out*/std::vector<native_handle_t*>* handlesCreated,
|
|
/*out*/std::vector<std::pair<int32_t, int32_t>>* inflightBuffers);
|
|
}; // class HidlHalInterface
|
|
|
|
class HidlRequestThread : public Camera3Device::RequestThread {
|
|
public:
|
|
HidlRequestThread(wp<Camera3Device> parent,
|
|
sp<camera3::StatusTracker> statusTracker,
|
|
sp<HalInterface> interface,
|
|
const Vector<int32_t>& sessionParamKeys,
|
|
bool useHalBufManager,
|
|
bool supportCameraMute,
|
|
bool overrideToPortrait);
|
|
|
|
status_t switchToOffline(
|
|
const std::vector<int32_t>& streamsToKeep,
|
|
/*out*/hardware::camera::device::V3_6::CameraOfflineSessionInfo* offlineSessionInfo,
|
|
/*out*/sp<hardware::camera::device::V3_6::ICameraOfflineSession>* offlineSession,
|
|
/*out*/camera3::BufferRecords* bufferRecords);
|
|
}; // class HidlRequestThread
|
|
|
|
class HidlCamera3DeviceInjectionMethods : public Camera3DeviceInjectionMethods {
|
|
public:
|
|
// Initialize the injection camera and generate an hal interface.
|
|
status_t injectionInitialize(
|
|
const String8& injectedCamId, sp<CameraProviderManager> manager,
|
|
const sp<
|
|
android::hardware::camera::device::V3_2 ::ICameraDeviceCallback>&
|
|
callback);
|
|
HidlCamera3DeviceInjectionMethods(wp<Camera3Device> parent) :
|
|
Camera3DeviceInjectionMethods(parent) { };
|
|
~HidlCamera3DeviceInjectionMethods() {}
|
|
private:
|
|
// Backup of the original camera hal result FMQ.
|
|
std::unique_ptr<ResultMetadataQueue> mBackupResultMetadataQueue;
|
|
|
|
// FMQ writes the result for the injection camera. Must be guarded by
|
|
// mProcessCaptureResultLock.
|
|
std::unique_ptr<ResultMetadataQueue> mInjectionResultMetadataQueue;
|
|
|
|
// Use injection camera hal interface to replace and backup original
|
|
// camera hal interface.
|
|
virtual status_t replaceHalInterface(sp<HalInterface> newHalInterface,
|
|
bool keepBackup) override;
|
|
};
|
|
|
|
private:
|
|
template<typename NotifyMsgType>
|
|
hardware::Return<void> notifyHelper(
|
|
const hardware::hidl_vec<NotifyMsgType>& msgs);
|
|
|
|
virtual status_t injectionCameraInitialize(const String8 &injectCamId,
|
|
sp<CameraProviderManager> manager) override;
|
|
|
|
virtual sp<RequestThread> createNewRequestThread(wp<Camera3Device> parent,
|
|
sp<camera3::StatusTracker> statusTracker,
|
|
sp<HalInterface> interface,
|
|
const Vector<int32_t>& sessionParamKeys,
|
|
bool useHalBufManager,
|
|
bool supportCameraMute,
|
|
bool overrideToPortrait) override;
|
|
|
|
virtual sp<Camera3DeviceInjectionMethods>
|
|
createCamera3DeviceInjectionMethods(wp<Camera3Device>) override;
|
|
|
|
// FMQ to write result on. Must be guarded by mProcessCaptureResultLock.
|
|
std::unique_ptr<ResultMetadataQueue> mResultMetadataQueue;
|
|
|
|
}; // class HidlCamera3Device
|
|
|
|
}; // namespace android
|
|
|
|
#endif
|