You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
901 lines
36 KiB
901 lines
36 KiB
/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions are |
|
* met: |
|
* * Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* * Redistributions in binary form must reproduce the above |
|
* copyright notice, this list of conditions and the following |
|
* disclaimer in the documentation and/or other materials provided |
|
* with the distribution. |
|
* * Neither the name of The Linux Foundation nor the names of its |
|
* contributors may be used to endorse or promote products derived |
|
* from this software without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
* |
|
*/ |
|
|
|
#ifndef __QCAMERA3HARDWAREINTERFACE_H__ |
|
#define __QCAMERA3HARDWAREINTERFACE_H__ |
|
|
|
// System dependencies |
|
#include <CameraMetadata.h> |
|
#include <map> |
|
#include <mutex> |
|
#include <pthread.h> |
|
#include <utils/KeyedVector.h> |
|
#include <utils/List.h> |
|
// Camera dependencies |
|
#include "hardware/camera3.h" |
|
#include "QCamera3Channel.h" |
|
#include "QCamera3CropRegionMapper.h" |
|
#include "QCamera3HALHeader.h" |
|
#include "QCamera3Mem.h" |
|
#include "QCameraPerf.h" |
|
#include "QCameraCommon.h" |
|
#include "QCamera3VendorTags.h" |
|
#include "QCameraDualCamSettings.h" |
|
|
|
#include "EaselManagerClient.h" |
|
#include "HdrPlusClient.h" |
|
|
|
extern "C" { |
|
#include "mm_camera_interface.h" |
|
#include "mm_jpeg_interface.h" |
|
} |
|
|
|
using ::android::hardware::camera::common::V1_0::helper::CameraMetadata; |
|
using namespace android; |
|
|
|
namespace qcamera { |
|
|
|
#ifndef TRUE |
|
#define TRUE 1 |
|
#endif |
|
|
|
#ifndef FALSE |
|
#define FALSE 0 |
|
#endif |
|
|
|
/* Time related macros */ |
|
typedef int64_t nsecs_t; |
|
#define NSEC_PER_SEC 1000000000LLU |
|
#define NSEC_PER_USEC 1000LLU |
|
#define NSEC_PER_33MSEC 33000000LLU |
|
|
|
/*Orchestrate Macros */ |
|
#define EV_COMP_SETTLE_DELAY 2 |
|
#define GB_HDR_HALF_STEP_EV -6 |
|
#define GB_HDR_2X_STEP_EV 6 |
|
|
|
#define FRAME_REGISTER_LRU_SIZE 256 |
|
#define INTERNAL_FRAME_STARTING_NUMBER 800 |
|
#define EMPTY_FRAMEWORK_FRAME_NUMBER 0xFFFFFFFF |
|
|
|
typedef enum { |
|
SET_ENABLE, |
|
SET_CONTROLENABLE, |
|
SET_RELOAD_CHROMATIX, |
|
SET_STATUS, |
|
} optype_t; |
|
|
|
#define MODULE_ALL 0 |
|
|
|
extern volatile uint32_t gCamHal3LogLevel; |
|
|
|
class QCamera3MetadataChannel; |
|
class QCamera3PicChannel; |
|
class QCamera3HeapMemory; |
|
class QCamera3Exif; |
|
class ShutterDispatcher; |
|
class BufferDispatcher; |
|
|
|
typedef struct { |
|
camera3_stream_t *stream; |
|
camera3_stream_buffer_set_t buffer_set; |
|
stream_status_t status; |
|
int registered; |
|
QCamera3ProcessingChannel *channel; |
|
uint32_t id; // unique ID |
|
} stream_info_t; |
|
|
|
typedef struct { |
|
// Stream handle |
|
camera3_stream_t *stream; |
|
// Buffer handle |
|
buffer_handle_t *buffer; |
|
// Buffer status |
|
camera3_buffer_status_t bufStatus = CAMERA3_BUFFER_STATUS_OK; |
|
} PendingBufferInfo; |
|
|
|
typedef struct { |
|
// Frame number corresponding to request |
|
uint32_t frame_number; |
|
// Time when request queued into system |
|
nsecs_t timestamp; |
|
nsecs_t av_timestamp; |
|
List<PendingBufferInfo> mPendingBufferList; |
|
bool hdrplus; |
|
} PendingBuffersInRequest; |
|
|
|
class PendingBuffersMap { |
|
public: |
|
// Number of outstanding buffers at flush |
|
uint32_t numPendingBufsAtFlush; |
|
// List of pending buffers per request |
|
List<PendingBuffersInRequest> mPendingBuffersInRequest; |
|
uint32_t get_num_overall_buffers(); |
|
void removeBuf(buffer_handle_t *buffer); |
|
int32_t getBufErrStatus(buffer_handle_t *buffer); |
|
}; |
|
|
|
class FrameNumberRegistry { |
|
public: |
|
|
|
FrameNumberRegistry(); |
|
~FrameNumberRegistry(); |
|
int32_t allocStoreInternalFrameNumber(uint32_t frameworkFrameNumber, |
|
uint32_t &internalFrameNumber); |
|
int32_t generateStoreInternalFrameNumber(uint32_t &internalFrameNumber); |
|
int32_t freeInternalFrameNumber(uint32_t internalFrameNumber); |
|
int32_t getFrameworkFrameNumber(uint32_t internalFrameNumber, uint32_t &frameworkFrameNumber); |
|
void purgeOldEntriesLocked(); |
|
|
|
private: |
|
std::map<uint32_t, uint32_t> _register; |
|
uint32_t _nextFreeInternalNumber; |
|
Mutex mRegistryLock; |
|
}; |
|
|
|
class QCamera3HardwareInterface; |
|
|
|
/* |
|
* ShutterDispatcher class dispatches shutter callbacks in order of the frame |
|
* number. It will dispatch a shutter callback only after all shutter callbacks |
|
* of previous frames were dispatched. |
|
*/ |
|
class ShutterDispatcher { |
|
public: |
|
ShutterDispatcher(QCamera3HardwareInterface *parent); |
|
virtual ~ShutterDispatcher() = default; |
|
|
|
// Tell dispatch to expect a shutter for a frame number. |
|
void expectShutter(uint32_t frameNumber, bool isReprocess); |
|
// Mark a shutter callback for a frame ready. |
|
void markShutterReady(uint32_t frameNumber, uint64_t timestamp); |
|
// Discard a pending shutter for frame number. |
|
void clear(uint32_t frameNumber); |
|
// Discard all pending shutters. |
|
void clear(); |
|
|
|
private: |
|
struct Shutter { |
|
bool ready; // If the shutter is ready. |
|
uint64_t timestamp; // Timestamp of the shutter. |
|
Shutter() : ready(false), timestamp(0) {}; |
|
}; |
|
|
|
std::mutex mLock; |
|
|
|
// frame number -> shutter map. Protected by mLock. |
|
std::map<uint32_t, Shutter> mShutters; |
|
std::map<uint32_t, Shutter> mReprocessShutters; |
|
|
|
QCamera3HardwareInterface *mParent; |
|
}; |
|
|
|
/* |
|
* BufferDispatcher class dispatches output buffers in a stream in order of the |
|
* frame number. It will dispatch an output buffer in a stream only after all |
|
* previous output buffers in the same stream were dispatched. |
|
*/ |
|
class OutputBufferDispatcher { |
|
public: |
|
OutputBufferDispatcher(QCamera3HardwareInterface *parent); |
|
virtual ~OutputBufferDispatcher() = default; |
|
|
|
// Configure streams. |
|
status_t configureStreams(camera3_stream_configuration_t *streamList); |
|
// Tell dispatcher to expect a buffer for a stream for a frame number. |
|
status_t expectBuffer(uint32_t frameNumber, camera3_stream_t *stream); |
|
// Mark a buffer ready for a stream for a frame number. |
|
void markBufferReady(uint32_t frameNumber, const camera3_stream_buffer_t &buffer); |
|
// Discard all pending buffers. If clearConfiguredStreams is true, discard configured streams |
|
// as well. |
|
void clear(bool clearConfiguredStreams = true); |
|
|
|
private: |
|
struct Buffer { |
|
bool ready; // If the buffer is ready. |
|
camera3_stream_buffer_t buffer; |
|
Buffer() : ready(false), buffer({}) {}; |
|
}; |
|
|
|
std::mutex mLock; |
|
|
|
// A two-level map: stream -> (frame number -> buffer). Protected by mLock. |
|
std::map<camera3_stream_t*, std::map<uint32_t, Buffer>> mStreamBuffers; |
|
|
|
QCamera3HardwareInterface *mParent; |
|
}; |
|
|
|
class QCamera3HardwareInterface : public HdrPlusClientListener, |
|
public EaselManagerClientListener { |
|
public: |
|
/* static variable and functions accessed by camera service */ |
|
static camera3_device_ops_t mCameraOps; |
|
//Id of each session in bundle/link |
|
static uint32_t sessionId[MM_CAMERA_MAX_NUM_SENSORS]; |
|
static int initialize(const struct camera3_device *, |
|
const camera3_callback_ops_t *callback_ops); |
|
static int configure_streams(const struct camera3_device *, |
|
camera3_stream_configuration_t *stream_list); |
|
static const camera_metadata_t* construct_default_request_settings( |
|
const struct camera3_device *, int type); |
|
static int process_capture_request(const struct camera3_device *, |
|
camera3_capture_request_t *request); |
|
|
|
static void dump(const struct camera3_device *, int fd); |
|
static int flush(const struct camera3_device *); |
|
static int close_camera_device(struct hw_device_t* device); |
|
|
|
public: |
|
QCamera3HardwareInterface(uint32_t cameraId, |
|
const camera_module_callbacks_t *callbacks); |
|
virtual ~QCamera3HardwareInterface(); |
|
static void camEvtHandle(uint32_t camera_handle, mm_camera_event_t *evt, |
|
void *user_data); |
|
int openCamera(struct hw_device_t **hw_device); |
|
camera_metadata_t* translateCapabilityToMetadata(int type); |
|
|
|
typedef struct { |
|
camera3_stream_t *stream; |
|
bool need_metadata; |
|
bool meteringOnly; |
|
} InternalRequest; |
|
|
|
static int getCamInfo(uint32_t cameraId, struct camera_info *info); |
|
static cam_capability_t *getCapabilities(mm_camera_ops_t *ops, |
|
uint32_t cam_handle); |
|
static int initCapabilities(uint32_t cameraId); |
|
static int initStaticMetadata(uint32_t cameraId); |
|
static int initHdrPlusClientLocked(); |
|
static void makeTable(cam_dimension_t *dimTable, size_t size, |
|
size_t max_size, int32_t *sizeTable); |
|
static void makeFPSTable(cam_fps_range_t *fpsTable, size_t size, |
|
size_t max_size, int32_t *fpsRangesTable); |
|
static void makeOverridesList(cam_scene_mode_overrides_t *overridesTable, |
|
size_t size, size_t max_size, uint8_t *overridesList, |
|
uint8_t *supported_indexes, uint32_t camera_id); |
|
static size_t filterJpegSizes(int32_t *jpegSizes, int32_t *processedSizes, |
|
size_t processedSizesCnt, size_t maxCount, cam_rect_t active_array_size, |
|
uint8_t downscale_factor); |
|
static void convertToRegions(cam_rect_t rect, int32_t* region, int weight); |
|
static void convertFromRegions(cam_area_t &roi, const CameraMetadata &frame_settings, |
|
uint32_t tag); |
|
static bool resetIfNeededROI(cam_area_t* roi, const cam_crop_region_t* scalerCropRegion); |
|
static int32_t getSensorSensitivity(int32_t iso_mode); |
|
|
|
double computeNoiseModelEntryS(int32_t sensitivity); |
|
double computeNoiseModelEntryO(int32_t sensitivity); |
|
|
|
static void captureResultCb(mm_camera_super_buf_t *metadata, |
|
camera3_stream_buffer_t *buffer, uint32_t frame_number, |
|
bool isInputBuffer, void *userdata); |
|
|
|
int initialize(const camera3_callback_ops_t *callback_ops); |
|
int configureStreams(camera3_stream_configuration_t *stream_list); |
|
int configureStreamsPerfLocked(camera3_stream_configuration_t *stream_list); |
|
int processCaptureRequest(camera3_capture_request_t *request, |
|
List<InternalRequest> &internalReqs); |
|
int orchestrateRequest(camera3_capture_request_t *request); |
|
void orchestrateResult(camera3_capture_result_t *result); |
|
void orchestrateNotify(camera3_notify_msg_t *notify_msg); |
|
|
|
void dump(int fd); |
|
int flushPerf(); |
|
|
|
int setFrameParameters(camera3_capture_request_t *request, |
|
cam_stream_ID_t streamID, int blob_request, uint32_t snapshotStreamId); |
|
int32_t setReprocParameters(camera3_capture_request_t *request, |
|
metadata_buffer_t *reprocParam, uint32_t snapshotStreamId); |
|
int translateToHalMetadata(const camera3_capture_request_t *request, |
|
metadata_buffer_t *parm, uint32_t snapshotStreamId); |
|
int translateFwkMetadataToHalMetadata(const camera_metadata_t *frameworkMetadata, |
|
metadata_buffer_t *hal_metadata, uint32_t snapshotStreamId, int64_t minFrameDuration); |
|
camera_metadata_t* translateCbUrgentMetadataToResultMetadata ( |
|
metadata_buffer_t *metadata, bool lastUrgentMetadataInBatch, |
|
uint32_t frame_number, bool isJumpstartMetadata); |
|
camera_metadata_t* saveRequestSettings(const CameraMetadata& jpegMetadata, |
|
camera3_capture_request_t *request); |
|
int initParameters(); |
|
void deinitParameters(); |
|
QCamera3ReprocessChannel *addOfflineReprocChannel(const reprocess_config_t &config, |
|
QCamera3ProcessingChannel *inputChHandle); |
|
bool needRotationReprocess(); |
|
bool needJpegExifRotation(); |
|
bool needReprocess(cam_feature_mask_t postprocess_mask); |
|
bool needJpegRotation(); |
|
cam_denoise_process_type_t getWaveletDenoiseProcessPlate(); |
|
cam_denoise_process_type_t getTemporalDenoiseProcessPlate(); |
|
|
|
void captureResultCb(mm_camera_super_buf_t *metadata, |
|
camera3_stream_buffer_t *buffer, uint32_t frame_number, |
|
bool isInputBuffer); |
|
cam_dimension_t calcMaxJpegDim(); |
|
bool needOnlineRotation(); |
|
uint32_t getJpegQuality(); |
|
QCamera3Exif *getExifData(); |
|
mm_jpeg_exif_params_t get3AExifParams(); |
|
uint8_t getMobicatMask(); |
|
static void getFlashInfo(const int cameraId, |
|
bool& hasFlash, |
|
char (&flashNode)[QCAMERA_MAX_FILEPATH_LENGTH]); |
|
const char *getEepromVersionInfo(); |
|
const uint32_t *getLdafCalib(); |
|
const char *getEaselFwVersion(); |
|
void get3AVersion(cam_q3a_version_t &swVersion); |
|
static void setBufferErrorStatus(QCamera3Channel*, uint32_t frameNumber, |
|
camera3_buffer_status_t err, void *userdata); |
|
void setBufferErrorStatus(QCamera3Channel*, uint32_t frameNumber, |
|
camera3_buffer_status_t err); |
|
bool is60HzZone(); |
|
|
|
// Get dual camera related info |
|
bool isDeviceLinked() {return mIsDeviceLinked;} |
|
bool isMainCamera() {return mIsMainCamera;} |
|
uint32_t getSensorMountAngle(); |
|
const cam_related_system_calibration_data_t *getRelatedCalibrationData(); |
|
|
|
template <typename fwkType, typename halType> struct QCameraMap { |
|
fwkType fwk_name; |
|
halType hal_name; |
|
}; |
|
|
|
typedef struct { |
|
const char *const desc; |
|
cam_cds_mode_type_t val; |
|
} QCameraPropMap; |
|
|
|
private: |
|
|
|
// State transition conditions: |
|
// "\" means not applicable |
|
// "x" means not valid |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// | | CLOSED | OPENED | INITIALIZED | CONFIGURED | STARTED | ERROR | DEINIT | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// | CLOSED | \ | open | x | x | x | x | x | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// | OPENED | close | \ | initialize | x | x | error | x | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// |INITIALIZED | close | x | \ | configure | x | error | x | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// | CONFIGURED | close | x | x | configure | request | error | x | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// | STARTED | close | x | x | configure | \ | error | x | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// | ERROR | close | x | x | x | x | \ | any | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
// | DEINIT | close | x | x | x | x | x | \ | |
|
// +------------+----------+----------+-------------+------------+---------+-------+--------+ |
|
|
|
typedef enum { |
|
CLOSED, |
|
OPENED, |
|
INITIALIZED, |
|
CONFIGURED, |
|
STARTED, |
|
ERROR, |
|
DEINIT |
|
} State; |
|
|
|
int openCamera(); |
|
int closeCamera(); |
|
int flush(bool restartChannels, bool stopChannelImmediately = false); |
|
static size_t calcMaxJpegSize(uint32_t camera_id); |
|
cam_dimension_t getMaxRawSize(uint32_t camera_id); |
|
static void addStreamConfig(Vector<int32_t> &available_stream_configs, |
|
int32_t scalar_format, const cam_dimension_t &dim, |
|
int32_t config_type); |
|
|
|
int validateCaptureRequest(camera3_capture_request_t *request, |
|
List<InternalRequest> &internallyRequestedStreams); |
|
int validateStreamDimensions(camera3_stream_configuration_t *streamList); |
|
int validateStreamRotations(camera3_stream_configuration_t *streamList); |
|
int validateUsageFlags(const camera3_stream_configuration_t *streamList); |
|
int validateUsageFlagsForEis(const camera3_stream_configuration_t *streamList); |
|
void deriveMinFrameDuration(); |
|
void handleBuffersDuringFlushLock(camera3_stream_buffer_t *buffer); |
|
int64_t getMinFrameDuration(const camera3_capture_request_t *request); |
|
void handleMetadataWithLock(mm_camera_super_buf_t *metadata_buf, |
|
bool free_and_bufdone_meta_buf, |
|
bool lastUrgentMetadataInBatch, |
|
bool lastMetadataInBatch, |
|
bool *p_is_metabuf_queued); |
|
void handleBatchMetadata(mm_camera_super_buf_t *metadata_buf, |
|
bool free_and_bufdone_meta_buf); |
|
void handleBufferWithLock(camera3_stream_buffer_t *buffer, |
|
uint32_t frame_number); |
|
void handleInputBufferWithLock(uint32_t frame_number); |
|
// Handle pending results when a new result metadata of a frame is received. |
|
// metadata callbacks are invoked in the order of frame number. |
|
void handlePendingResultMetadataWithLock(uint32_t frameNumber, |
|
camera_metadata_t *resultMetadata); |
|
// Going through pending request list and send out result metadata for requests |
|
// that are ready. |
|
// frameNumber is the lastest frame whose result metadata is ready. |
|
// isLiveRequest is whether the frame belongs to a live request. |
|
void dispatchResultMetadataWithLock(uint32_t frameNumber, bool isLiveRequest); |
|
void handleDepthDataLocked(const cam_depth_data_t &depthData, |
|
uint32_t frameNumber, uint8_t valid); |
|
void notifyErrorFoPendingDepthData(QCamera3DepthChannel *depthCh); |
|
void unblockRequestIfNecessary(); |
|
void dumpMetadataToFile(tuning_params_t &meta, uint32_t &dumpFrameCount, |
|
bool enabled, const char *type, uint32_t frameNumber); |
|
static void getLogLevel(); |
|
static int32_t getPDStatIndex(cam_capability_t *caps); |
|
|
|
void cleanAndSortStreamInfo(); |
|
void extractJpegMetadata(CameraMetadata& jpegMetadata, |
|
const camera3_capture_request_t *request); |
|
|
|
bool isSupportChannelNeeded(camera3_stream_configuration_t *streamList, |
|
cam_stream_size_info_t stream_config_info); |
|
bool isHdrSnapshotRequest(camera3_capture_request *request); |
|
int32_t setMobicat(); |
|
|
|
int32_t getSensorModeInfo(cam_sensor_mode_info_t &sensorModeInfo); |
|
// Get information of the sensor mode that is currently selected. |
|
int32_t getCurrentSensorModeInfo(cam_sensor_mode_info_t &sensorModeInfo); |
|
int32_t setHalFpsRange(const CameraMetadata &settings, |
|
metadata_buffer_t *hal_metadata); |
|
int32_t extractSceneMode(const CameraMetadata &frame_settings, uint8_t metaMode, |
|
metadata_buffer_t *hal_metadata); |
|
int32_t setVideoHdrMode(metadata_buffer_t *hal_metadata, |
|
cam_video_hdr_mode_t vhdr); |
|
int32_t numOfSizesOnEncoder(const camera3_stream_configuration_t *streamList, |
|
const cam_dimension_t &maxViewfinderSize); |
|
|
|
void addToPPFeatureMask(int stream_format, uint32_t stream_idx); |
|
void updateFpsInPreviewBuffer(metadata_buffer_t *metadata, uint32_t frame_number); |
|
void updateTimeStampInPendingBuffers(uint32_t frameNumber, nsecs_t timestamp); |
|
|
|
void enablePowerHint(); |
|
void disablePowerHint(); |
|
int32_t dynamicUpdateMetaStreamInfo(); |
|
int32_t startAllChannels(); |
|
int32_t stopAllChannels(); |
|
int32_t notifyErrorForPendingRequests(); |
|
void notifyError(uint32_t frameNumber, |
|
camera3_error_msg_code_t errorCode); |
|
int32_t getReprocessibleOutputStreamId(uint32_t &id); |
|
int32_t handleCameraDeviceError(bool stopChannelImmediately = false); |
|
|
|
bool isOnEncoder(const cam_dimension_t max_viewfinder_size, |
|
uint32_t width, uint32_t height); |
|
void hdrPlusPerfLock(mm_camera_super_buf_t *metadata_buf); |
|
|
|
static bool supportBurstCapture(uint32_t cameraId); |
|
int32_t setBundleInfo(); |
|
int32_t setInstantAEC(const CameraMetadata &meta); |
|
|
|
static void convertLandmarks(cam_face_landmarks_info_t face, int32_t* landmarks); |
|
static void setInvalidLandmarks(int32_t* landmarks); |
|
|
|
static void setPAAFSupport(cam_feature_mask_t& feature_mask, |
|
cam_stream_type_t stream_type, |
|
cam_color_filter_arrangement_t filter_arrangement); |
|
int32_t setSensorHDR(metadata_buffer_t *hal_metadata, bool enable, |
|
bool isVideoHdrEnable = false); |
|
|
|
template <typename T> |
|
static void adjustBlackLevelForCFA(T input[BLACK_LEVEL_PATTERN_CNT], |
|
T output[BLACK_LEVEL_PATTERN_CNT], |
|
cam_color_filter_arrangement_t color_arrangement); |
|
|
|
int32_t startChannelLocked(); |
|
void stopChannelLocked(bool stopChannelImmediately); |
|
|
|
camera3_device_t mCameraDevice; |
|
uint32_t mCameraId; |
|
mm_camera_vtbl_t *mCameraHandle; |
|
bool mCameraInitialized; |
|
camera_metadata_t *mDefaultMetadata[CAMERA3_TEMPLATE_COUNT]; |
|
const camera3_callback_ops_t *mCallbackOps; |
|
|
|
QCamera3MetadataChannel *mMetadataChannel; |
|
QCamera3PicChannel *mPictureChannel; |
|
QCamera3RawChannel *mRawChannel; |
|
QCamera3SupportChannel *mSupportChannel; |
|
QCamera3SupportChannel *mAnalysisChannel; |
|
QCamera3RawDumpChannel *mRawDumpChannel; |
|
QCamera3HdrPlusRawSrcChannel *mHdrPlusRawSrcChannel; |
|
QCamera3RegularChannel *mDummyBatchChannel; |
|
QCamera3DepthChannel *mDepthChannel; |
|
cam_sensor_pd_data_t mDepthCloudMode; //Cache last configured mode |
|
QCameraPerfLockMgr mPerfLockMgr; |
|
|
|
uint32_t mChannelHandle; |
|
|
|
void saveExifParams(metadata_buffer_t *metadata); |
|
mm_jpeg_exif_params_t mExifParams; |
|
|
|
//First request yet to be processed after configureStreams |
|
bool mFirstConfiguration; |
|
bool mFlush; |
|
bool mFlushPerf; |
|
bool mEnableRawDump; |
|
bool mForceHdrSnapshot; |
|
QCamera3HeapMemory *mParamHeap; |
|
metadata_buffer_t* mParameters; |
|
metadata_buffer_t* mPrevParameters; |
|
CameraMetadata mCurJpegMeta; |
|
bool m_bIsVideo; |
|
bool m_bIs4KVideo; |
|
bool m_bEisSupportedSize; |
|
bool m_bEisEnable; |
|
bool m_bEis3PropertyEnabled; |
|
bool m_bEisSupported; |
|
bool m_bAVTimerEnabled; |
|
typedef struct { |
|
cam_dimension_t dim; |
|
int format; |
|
uint32_t usage; |
|
} InputStreamInfo; |
|
|
|
InputStreamInfo mInputStreamInfo; |
|
uint8_t m_MobicatMask; |
|
uint8_t m_bTnrEnabled; |
|
int8_t mSupportedFaceDetectMode; |
|
uint8_t m_bTnrPreview; |
|
uint8_t m_bSwTnrPreview; |
|
uint8_t m_bTnrVideo; |
|
uint8_t m_debug_avtimer; |
|
uint8_t m_bVideoHdrEnabled; |
|
uint8_t m_cacModeDisabled; |
|
uint8_t m_bForceInfinityAf; |
|
|
|
/* Data structure to store pending request */ |
|
typedef struct { |
|
camera3_stream_t *stream; |
|
camera3_stream_buffer_t *buffer; |
|
// metadata needs to be consumed by the corresponding stream |
|
// in order to generate the buffer. |
|
bool need_metadata; |
|
} RequestedBufferInfo; |
|
|
|
typedef struct { |
|
uint32_t frame_number; |
|
uint32_t num_buffers; |
|
int32_t request_id; |
|
List<RequestedBufferInfo> buffers; |
|
List<InternalRequest> internalRequestList; |
|
int blob_request; |
|
uint8_t bUseFirstPartial; // Use first available partial result in case of jumpstart. |
|
nsecs_t timestamp; |
|
nsecs_t expectedFrameDuration; |
|
camera3_stream_buffer_t *input_buffer; |
|
const camera_metadata_t *settings; |
|
const camera_metadata_t *resultMetadata; // Result metadata for this request. |
|
CameraMetadata jpegMetadata; |
|
uint8_t pipeline_depth; |
|
uint32_t partial_result_cnt; |
|
uint8_t capture_intent; |
|
uint8_t fwkCacMode; |
|
uint8_t hybrid_ae_enable; |
|
/* DevCamDebug metadata PendingRequestInfo */ |
|
uint8_t DevCamDebug_meta_enable; |
|
/* DevCamDebug metadata end */ |
|
|
|
bool focusStateSent = false; |
|
bool focusStateValid = false; |
|
uint8_t focusState = ANDROID_CONTROL_AF_STATE_INACTIVE; |
|
|
|
bool enableZsl; // If ZSL is enabled. |
|
bool hdrplus; // If this is an HDR+ request. |
|
uint8_t requestedLensShadingMapMode; // Lens shading map mode for this request. |
|
uint8_t requestedFaceDetectMode; // Face detect mode for this request. |
|
bool partialResultDropped; // Whether partial metadata is dropped. |
|
} PendingRequestInfo; |
|
typedef struct { |
|
uint32_t frame_number; |
|
uint32_t stream_ID; |
|
} PendingFrameDropInfo; |
|
|
|
class FrameNumberRegistry _orchestrationDb; |
|
typedef KeyedVector<uint32_t, Vector<PendingBufferInfo> > FlushMap; |
|
typedef List<QCamera3HardwareInterface::PendingRequestInfo>::iterator |
|
pendingRequestIterator; |
|
typedef List<QCamera3HardwareInterface::RequestedBufferInfo>::iterator |
|
pendingBufferIterator; |
|
|
|
List<PendingRequestInfo> mPendingRequestsList; |
|
List<PendingFrameDropInfo> mPendingFrameDropList; |
|
/* Use last frame number of the batch as key and first frame number of the |
|
* batch as value for that key */ |
|
KeyedVector<uint32_t, uint32_t> mPendingBatchMap; |
|
cam_stream_ID_t mBatchedStreamsArray; |
|
|
|
PendingBuffersMap mPendingBuffersMap; |
|
pthread_cond_t mRequestCond; |
|
uint32_t mPendingLiveRequest; |
|
bool mWokenUpByDaemon; |
|
int32_t mCurrentRequestId; |
|
cam_stream_size_info_t mStreamConfigInfo; |
|
|
|
ShutterDispatcher mShutterDispatcher; |
|
OutputBufferDispatcher mOutputBufferDispatcher; |
|
|
|
//mutex for serialized access to camera3_device_ops_t functions |
|
pthread_mutex_t mMutex; |
|
|
|
//condition used to signal flush after buffers have returned |
|
pthread_cond_t mBuffersCond; |
|
|
|
List<stream_info_t*> mStreamInfo; |
|
|
|
int64_t mMinProcessedFrameDuration; |
|
int64_t mMinJpegFrameDuration; |
|
int64_t mMinRawFrameDuration; |
|
nsecs_t mExpectedFrameDuration; |
|
nsecs_t mExpectedInflightDuration; |
|
static const nsecs_t kDefaultExpectedDuration = 100000000; // 100 ms |
|
|
|
uint32_t mMetaFrameCount; |
|
bool mUpdateDebugLevel; |
|
const camera_module_callbacks_t *mCallbacks; |
|
|
|
uint8_t mCaptureIntent; |
|
uint8_t mCacMode; |
|
// DevCamDebug metadata internal variable |
|
uint8_t mDevCamDebugMetaEnable; |
|
/* DevCamDebug metadata end */ |
|
|
|
metadata_buffer_t mReprocMeta; //scratch meta buffer |
|
/* 0: Not batch, non-zero: Number of image buffers in a batch */ |
|
uint8_t mBatchSize; |
|
// Used only in batch mode |
|
uint8_t mToBeQueuedVidBufs; |
|
// Fixed video fps |
|
float mHFRVideoFps; |
|
public: |
|
uint32_t mOpMode; |
|
bool mStreamConfig; |
|
QCameraCommon mCommon; |
|
private: |
|
uint32_t mFirstFrameNumberInBatch; |
|
camera3_stream_t mDummyBatchStream; |
|
bool mNeedSensorRestart; |
|
bool mPreviewStarted; |
|
uint32_t mMinInFlightRequests; |
|
uint32_t mMaxInFlightRequests; |
|
bool mPDSupported; |
|
int32_t mPDIndex; |
|
// Param to trigger instant AEC. |
|
bool mInstantAEC; |
|
// Param to know when to reset AEC |
|
bool mResetInstantAEC; |
|
// Frame number, untill which we need to drop the frames. |
|
uint32_t mInstantAECSettledFrameNumber; |
|
// Max number of frames, that HAL will hold without displaying, for instant AEC mode. |
|
uint8_t mAecSkipDisplayFrameBound; |
|
// Counter to keep track of number of frames that took for AEC convergence. |
|
uint8_t mInstantAecFrameIdxCount; |
|
/* sensor output size with current stream configuration */ |
|
QCamera3CropRegionMapper mCropRegionMapper; |
|
// Last lens shading map mode framework requsted. |
|
uint8_t mLastRequestedLensShadingMapMode; |
|
// Last face detect mode framework requsted. |
|
uint8_t mLastRequestedFaceDetectMode; |
|
|
|
cam_feature_mask_t mCurrFeatureState; |
|
/* Ldaf calibration data */ |
|
bool mLdafCalibExist; |
|
uint32_t mLdafCalib[2]; |
|
int32_t mLastCustIntentFrmNum; |
|
// Easel firmware version |
|
char mEaselFwVersion[FW_VER_SIZE]; |
|
bool mEaselFwUpdated; |
|
static const QCameraMap<camera_metadata_enum_android_control_effect_mode_t, |
|
cam_effect_mode_type> EFFECT_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_control_awb_mode_t, |
|
cam_wb_mode_type> WHITE_BALANCE_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_control_scene_mode_t, |
|
cam_scene_mode_type> SCENE_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_control_af_mode_t, |
|
cam_focus_mode_type> FOCUS_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_color_correction_aberration_mode_t, |
|
cam_aberration_mode_t> COLOR_ABERRATION_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_control_ae_antibanding_mode_t, |
|
cam_antibanding_mode_type> ANTIBANDING_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_lens_state_t, |
|
cam_af_lens_state_t> LENS_STATE_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_control_ae_mode_t, |
|
cam_flash_mode_t> AE_FLASH_MODE_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_flash_mode_t, |
|
cam_flash_mode_t> FLASH_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_statistics_face_detect_mode_t, |
|
cam_face_detect_mode_t> FACEDETECT_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_lens_info_focus_distance_calibration_t, |
|
cam_focus_calibration_t> FOCUS_CALIBRATION_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_sensor_test_pattern_mode_t, |
|
cam_test_pattern_mode_t> TEST_PATTERN_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_video_hdr_mode_t, |
|
cam_video_hdr_mode_t> VIDEO_HDR_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_sensor_reference_illuminant1_t, |
|
cam_illuminat_t> REFERENCE_ILLUMINANT_MAP[]; |
|
static const QCameraMap<int32_t, |
|
cam_hfr_mode_t> HFR_MODE_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_ir_mode_t, |
|
cam_ir_mode_type_t> IR_MODES_MAP[]; |
|
static const QCameraMap<qcamera3_ext_instant_aec_mode_t, |
|
cam_aec_convergence_type> INSTANT_AEC_MODES_MAP[]; |
|
static const QCameraMap<camera_metadata_enum_android_binning_correction_mode_t, |
|
cam_binning_correction_mode_t> BINNING_CORRECTION_MODES_MAP[]; |
|
static const QCameraMap<qcamera3_ext_exposure_meter_mode_t, |
|
cam_auto_exposure_mode_type> AEC_MODES_MAP[]; |
|
static const QCameraMap<qcamera3_ext_iso_mode_t, |
|
cam_iso_mode_type> ISO_MODES_MAP[]; |
|
static const QCameraPropMap CDS_MAP[]; |
|
|
|
pendingRequestIterator erasePendingRequest(pendingRequestIterator i); |
|
|
|
// Remove unrequested metadata due to Easel HDR+. |
|
void removeUnrequestedMetadata(pendingRequestIterator requestIter, |
|
camera_metadata_t *resultMetadata); |
|
|
|
//GPU library to read buffer padding details. |
|
void *lib_surface_utils; |
|
int (*LINK_get_surface_pixel_alignment)(); |
|
uint32_t mSurfaceStridePadding; |
|
|
|
bool mFirstMetadataCallback; |
|
void sendPartialMetadataWithLock(metadata_buffer_t *metadata, |
|
const pendingRequestIterator requestIter, |
|
bool lastUrgentMetadataInBatch, bool isJumpstartMetadata); |
|
|
|
camera_metadata_t* translateFromHalMetadata(metadata_buffer_t *metadata, |
|
const PendingRequestInfo& pendingRequest, |
|
/* DevCamDebug metadata end */ |
|
bool pprocDone, |
|
bool lastMetadataInBatch, |
|
const bool *enableZsl); |
|
|
|
State mState; |
|
//Dual camera related params |
|
bool mIsDeviceLinked; |
|
bool mIsMainCamera; |
|
uint8_t mLinkedCameraId; |
|
QCamera3HeapMemory *m_pDualCamCmdHeap; |
|
cam_dual_camera_cmd_info_t *m_pDualCamCmdPtr; |
|
cam_sync_related_sensors_event_info_t m_relCamSyncInfo; |
|
Mutex mFlushLock; |
|
bool m60HzZone; |
|
|
|
// Issue an additional RAW for every 10 requests to control RAW capture rate. Requesting RAW |
|
// too often will cause frame drops due to latency of sending RAW to HDR+ service. |
|
const static uint32_t kHdrPlusRawPeriod = 10; |
|
|
|
// Define a pending HDR+ request submitted to HDR+ service and not yet received by HAL. |
|
struct HdrPlusPendingRequest { |
|
// HDR+ stream ID -> output buffer to be filled by HDR+ client with an HDR+ processed frame. |
|
std::map<uint32_t, std::shared_ptr<mm_camera_buf_def_t>> outputBuffers; |
|
|
|
// HDR+ stream ID -> output buffers in camera framework's request. |
|
std::map<uint32_t, camera3_stream_buffer_t> frameworkOutputBuffers; |
|
|
|
// Settings in camera framework's request. |
|
std::shared_ptr<metadata_buffer_t> settings; |
|
}; |
|
|
|
// Fill pbcamera::StreamConfiguration based on the channel stream. |
|
status_t fillPbStreamConfig(pbcamera::StreamConfiguration *config, uint32_t pbStreamId, |
|
QCamera3Channel *channel, uint32_t streamIndex); |
|
|
|
// Open HDR+ client asynchronously. |
|
status_t openHdrPlusClientAsyncLocked(); |
|
|
|
// Enable HDR+ mode. Easel will start capturing ZSL buffers. |
|
status_t enableHdrPlusModeLocked(); |
|
|
|
// Disable HDR+ mode. Easel will stop capturing ZSL buffers. |
|
void disableHdrPlusModeLocked(); |
|
|
|
// Return if current session with configured streams is compatible with HDR+ mode. |
|
bool isSessionHdrPlusModeCompatible(); |
|
|
|
// Return if the request is compatible with HDR+. |
|
bool isRequestHdrPlusCompatible( |
|
const camera3_capture_request_t &request, const CameraMetadata &metadata); |
|
|
|
// Configure streams for HDR+. |
|
status_t configureHdrPlusStreamsLocked(); |
|
|
|
// Try to submit an HDR+ request. Returning true if an HDR+ request was submitted. Returning |
|
// false if it is not an HDR+ request or submitting an HDR+ request failed. Must be called with |
|
// gHdrPlusClientLock held. |
|
bool trySubmittingHdrPlusRequestLocked(HdrPlusPendingRequest *hdrPlusRequest, |
|
const camera3_capture_request_t &request, const CameraMetadata &metadata); |
|
|
|
// Abort an HDR+ request that was not submitted successfully in |
|
// trySubmittingHdrPlusRequestLocked. |
|
void abortPendingHdrplusRequest(HdrPlusPendingRequest *hdrPlusRequest); |
|
|
|
// Update HDR+ result metadata with the still capture's request settings. |
|
void updateHdrPlusResultMetadata(CameraMetadata &resultMetadata, |
|
std::shared_ptr<metadata_buffer_t> settings); |
|
|
|
// Wait until opening HDR+ client completes if it's being opened. |
|
void finishHdrPlusClientOpeningLocked(std::unique_lock<std::mutex> &lock); |
|
|
|
// Handle Easel error asynchronuously in another thread. |
|
void handleEaselFatalErrorAsync(); |
|
|
|
// Handle Easel error. |
|
void handleEaselFatalError(); |
|
|
|
// Easel manager client callbacks. |
|
void onEaselFatalError(std::string errMsg); |
|
|
|
// HDR+ client callbacks. |
|
void onOpened(std::unique_ptr<HdrPlusClient> client) override; |
|
void onOpenFailed(status_t err) override; |
|
void onFatalError() override; |
|
void onCaptureResult(pbcamera::CaptureResult *result, |
|
const camera_metadata_t &resultMetadata) override; |
|
void onFailedCaptureResult(pbcamera::CaptureResult *failedResult) override; |
|
void onShutter(uint32_t requestId, int64_t apSensorTimestampNs) override; |
|
void onNextCaptureReady(uint32_t requestId) override; |
|
void onPostview(uint32_t requestId, std::unique_ptr<std::vector<uint8_t>> postview, |
|
uint32_t width, uint32_t height, uint32_t stride, int32_t format) override; |
|
|
|
nsecs_t calculateMaxExpectedDuration(const camera_metadata_t *request); |
|
void getExpectedFrameDuration(const camera_metadata_t *request, nsecs_t *frameDuration); |
|
|
|
// Map from frame number to frame. Must be protected by mHdrPlusPendingRequestsLock. |
|
std::map<uint32_t, HdrPlusPendingRequest> mHdrPlusPendingRequests; |
|
Mutex mHdrPlusPendingRequestsLock; |
|
|
|
// If HDR+ mode is enabled i.e. if Easel is capturing ZSL buffers. |
|
bool mHdrPlusModeEnabled; |
|
|
|
// If ZSL is enabled (android.control.enableZsl). |
|
bool mZslEnabled; |
|
|
|
// If Easel MIPI has been started. |
|
bool mEaselMipiStarted; |
|
|
|
// If HAL provides RAW input buffers to Easel. This is just for prototyping. |
|
bool mIsApInputUsedForHdrPlus; |
|
|
|
// Current sensor mode information. |
|
cam_sensor_mode_info_t mSensorModeInfo; |
|
|
|
// If there is a capture request with preview intent since stream configuration. |
|
bool mFirstPreviewIntentSeen; |
|
|
|
bool m_bSensorHDREnabled; |
|
|
|
cam_trigger_t mAfTrigger; |
|
|
|
int32_t mSceneDistance; |
|
|
|
std::future<void> mEaselErrorFuture; |
|
}; |
|
|
|
}; // namespace qcamera |
|
|
|
#endif /* __QCAMERA2HARDWAREINTERFACE_H__ */
|
|
|