dc89a99bdd
Issue: Diplay freeze observed sometimes, if there is any suspend/resume of the device. The issue found to be with differences in the timesources used by display and camera for timestamp calculation. Fix: Measure the clock offset between BOOTTIME and MONOTONIC. The clock domain source for ISP is BOOTTIME and for display, it is MONOTONIC. The offset is used to convert from clock domain of camera to display. Added following set prop to switch between camera time sources. persist.camera.time.monotonic <value> Default value is 1. value 0 indicates Boot time from camera. value 1 indicates Monotonic time from camera. Change-Id: I733aa17e89ccaa7f5ea6d2eae5e1cd6428c81a85 CRs-Fixed: 1005906
507 lines
20 KiB
C++
507 lines
20 KiB
C++
/* 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 <pthread.h>
|
|
#include <utils/KeyedVector.h>
|
|
#include <utils/List.h>
|
|
#include "CameraMetadata.h"
|
|
|
|
// Camera dependencies
|
|
#include "camera3.h"
|
|
#include "QCamera3Channel.h"
|
|
#include "QCamera3CropRegionMapper.h"
|
|
#include "QCamera3HALHeader.h"
|
|
#include "QCamera3Mem.h"
|
|
#include "QCameraPerf.h"
|
|
|
|
extern "C" {
|
|
#include "mm_camera_interface.h"
|
|
#include "mm_jpeg_interface.h"
|
|
}
|
|
|
|
using namespace android;
|
|
|
|
namespace qcamera {
|
|
|
|
using ::android::hardware::camera::common::V1_0::helper::CameraMetadata;
|
|
|
|
#ifndef TRUE
|
|
#define TRUE 1
|
|
#endif
|
|
|
|
#ifndef FALSE
|
|
#define FALSE 0
|
|
#endif
|
|
|
|
/* Time related macros */
|
|
#define NSEC_PER_SEC 1000000000LLU
|
|
#define NSEC_PER_USEC 1000LLU
|
|
#define NSEC_PER_33MSEC 33000000LLU
|
|
|
|
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;
|
|
|
|
typedef struct {
|
|
camera3_stream_t *stream;
|
|
camera3_stream_buffer_set_t buffer_set;
|
|
stream_status_t status;
|
|
int registered;
|
|
QCamera3ProcessingChannel *channel;
|
|
} stream_info_t;
|
|
|
|
class QCamera3HardwareInterface {
|
|
public:
|
|
/* static variable and functions accessed by camera service */
|
|
static camera3_device_ops_t mCameraOps;
|
|
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);
|
|
|
|
static int getCamInfo(uint32_t cameraId, struct camera_info *info);
|
|
static int initCapabilities(uint32_t cameraId);
|
|
static int initStaticMetadata(uint32_t cameraId);
|
|
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 camera_metadata_t *settings,
|
|
uint32_t tag);
|
|
static bool resetIfNeededROI(cam_area_t* roi, const cam_crop_region_t* scalerCropRegion);
|
|
static void convertLandmarks(cam_face_landmarks_info_t face, int32_t* landmarks);
|
|
static int32_t getScalarFormat(int32_t format);
|
|
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);
|
|
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);
|
|
camera_metadata_t* translateCbUrgentMetadataToResultMetadata (
|
|
metadata_buffer_t *metadata);
|
|
camera_metadata_t* translateFromHalMetadata(metadata_buffer_t *metadata,
|
|
nsecs_t timestamp, int32_t request_id,
|
|
const CameraMetadata& jpegMetadata, uint8_t pipeline_depth,
|
|
uint8_t capture_intent, bool pprocDone, uint8_t fwk_cacMode);
|
|
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 needReprocess(uint32_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();
|
|
void get3AVersion(cam_q3a_version_t &swVersion);
|
|
|
|
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);
|
|
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);
|
|
int validateStreamDimensions(camera3_stream_configuration_t *streamList);
|
|
int validateStreamRotations(camera3_stream_configuration_t *streamList);
|
|
void deriveMinFrameDuration();
|
|
int32_t handlePendingReprocResults(uint32_t frame_number);
|
|
int64_t getMinFrameDuration(const camera3_capture_request_t *request);
|
|
void handleMetadataWithLock(mm_camera_super_buf_t *metadata_buf,
|
|
bool free_and_bufdone_meta_buf);
|
|
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);
|
|
void unblockRequestIfNecessary();
|
|
void dumpMetadataToFile(tuning_params_t &meta, uint32_t &dumpFrameCount,
|
|
bool enabled, const char *type, uint32_t frameNumber);
|
|
static void getLogLevel();
|
|
|
|
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);
|
|
int32_t setMobicat();
|
|
|
|
int32_t getSensorOutputSize(cam_dimension_t &sensor_dim);
|
|
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 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 enablePowerHint();
|
|
void disablePowerHint();
|
|
int32_t dynamicUpdateMetaStreamInfo();
|
|
int32_t startAllChannels();
|
|
int32_t stopAllChannels();
|
|
int32_t notifyErrorForPendingRequests();
|
|
int32_t getReprocessibleOutputStreamId(uint32_t &id);
|
|
int32_t handleCameraDeviceError();
|
|
nsecs_t getBootToMonoTimeOffset();
|
|
|
|
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();
|
|
|
|
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;
|
|
QCamera3RegularChannel *mDummyBatchChannel;
|
|
QCameraPerfLock m_perfLock;
|
|
|
|
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;
|
|
QCamera3HeapMemory *mParamHeap;
|
|
metadata_buffer_t* mParameters;
|
|
metadata_buffer_t* mPrevParameters;
|
|
CameraMetadata mCurJpegMeta;
|
|
bool m_bIsVideo;
|
|
bool m_bIs4KVideo;
|
|
bool m_bEisSupportedSize;
|
|
bool m_bEisEnable;
|
|
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_bTnrVideo;
|
|
|
|
/* 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;
|
|
int blob_request;
|
|
uint8_t bUrgentReceived;
|
|
nsecs_t timestamp;
|
|
camera3_stream_buffer_t *input_buffer;
|
|
const camera_metadata_t *settings;
|
|
CameraMetadata jpegMetadata;
|
|
uint8_t pipeline_depth;
|
|
uint32_t partial_result_cnt;
|
|
uint8_t capture_intent;
|
|
uint8_t fwkCacMode;
|
|
bool shutter_notified;
|
|
} PendingRequestInfo;
|
|
typedef struct {
|
|
uint32_t frame_number;
|
|
uint32_t stream_ID;
|
|
} PendingFrameDropInfo;
|
|
|
|
// Store the Pending buffers for Flushing
|
|
typedef struct {
|
|
// Frame number pertaining to the buffer
|
|
uint32_t frame_number;
|
|
camera3_stream_t *stream;
|
|
// Buffer handle
|
|
buffer_handle_t *buffer;
|
|
|
|
} PendingBufferInfo;
|
|
|
|
typedef struct {
|
|
// Total number of buffer requests pending
|
|
uint32_t num_buffers;
|
|
// List of pending buffers
|
|
List<PendingBufferInfo> mPendingBufferList;
|
|
} PendingBuffersMap;
|
|
|
|
typedef struct {
|
|
camera3_notify_msg_t notify_msg;
|
|
camera3_stream_buffer_t buffer;
|
|
uint32_t frame_number;
|
|
} PendingReprocessResult;
|
|
|
|
typedef KeyedVector<uint32_t, Vector<PendingBufferInfo> > FlushMap;
|
|
typedef List<QCamera3HardwareInterface::PendingRequestInfo>::iterator
|
|
pendingRequestIterator;
|
|
typedef List<QCamera3HardwareInterface::RequestedBufferInfo>::iterator
|
|
pendingBufferIterator;
|
|
|
|
List<PendingReprocessResult> mPendingReprocessResultList;
|
|
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;
|
|
|
|
PendingBuffersMap mPendingBuffersMap;
|
|
pthread_cond_t mRequestCond;
|
|
uint32_t mPendingLiveRequest;
|
|
bool mWokenUpByDaemon;
|
|
int32_t mCurrentRequestId;
|
|
cam_stream_size_info_t mStreamConfigInfo;
|
|
|
|
//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;
|
|
|
|
uint32_t mMetaFrameCount;
|
|
bool mUpdateDebugLevel;
|
|
const camera_module_callbacks_t *mCallbacks;
|
|
|
|
uint8_t mCaptureIntent;
|
|
uint8_t mCacMode;
|
|
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;
|
|
uint8_t mOpMode;
|
|
uint32_t mFirstFrameNumberInBatch;
|
|
camera3_stream_t mDummyBatchStream;
|
|
bool mNeedSensorRestart;
|
|
|
|
/* sensor output size with current stream configuration */
|
|
QCamera3CropRegionMapper mCropRegionMapper;
|
|
|
|
/* Ldaf calibration data */
|
|
bool mLdafCalibExist;
|
|
uint32_t mLdafCalib[2];
|
|
bool mPowerHintEnabled;
|
|
int32_t mLastCustIntentFrmNum;
|
|
|
|
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_sensor_reference_illuminant1_t,
|
|
cam_illuminat_t> REFERENCE_ILLUMINANT_MAP[];
|
|
static const QCameraMap<int32_t,
|
|
cam_hfr_mode_t> HFR_MODE_MAP[];
|
|
|
|
static const QCameraPropMap CDS_MAP[];
|
|
|
|
pendingRequestIterator erasePendingRequest(pendingRequestIterator i);
|
|
//GPU library to read buffer padding details.
|
|
void *lib_surface_utils;
|
|
int (*LINK_get_surface_pixel_alignment)();
|
|
uint32_t mSurfaceStridePadding;
|
|
|
|
State mState;
|
|
//The offset between BOOTTIME and MONOTONIC timestamps
|
|
nsecs_t mBootToMonoTimestampOffset;
|
|
bool mUseAVTimer;
|
|
};
|
|
|
|
}; // namespace qcamera
|
|
|
|
#endif /* __QCAMERA2HARDWAREINTERFACE_H__ */
|