Parameters.h revision 9fc79c6fccc41255bb4f3538e2a21b01db8dc2dc
1/* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ANDROID_SERVERS_CAMERA_CAMERA2PARAMETERS_H 18#define ANDROID_SERVERS_CAMERA_CAMERA2PARAMETERS_H 19 20#include <system/graphics.h> 21 22#include <utils/Errors.h> 23#include <utils/Mutex.h> 24#include <utils/String8.h> 25#include <utils/Vector.h> 26#include <utils/KeyedVector.h> 27#include <camera/CameraParameters.h> 28#include <camera/CameraMetadata.h> 29 30namespace android { 31namespace camera2 { 32 33/** 34 * Current camera state; this is the full state of the Camera under the old 35 * camera API (contents of the CameraParameters object in a more-efficient 36 * format, plus other state). The enum values are mostly based off the 37 * corresponding camera2 enums, not the camera1 strings. A few are defined here 38 * if they don't cleanly map to camera2 values. 39 */ 40struct Parameters { 41 /** 42 * Parameters and other state 43 */ 44 int cameraId; 45 int cameraFacing; 46 47 int previewWidth, previewHeight; 48 int32_t previewFpsRange[2]; 49 int lastSetPreviewFps; // the last single FPS value seen in a set call 50 int previewFps; // deprecated, here only for tracking changes 51 int previewFormat; 52 53 int previewTransform; // set by CAMERA_CMD_SET_DISPLAY_ORIENTATION 54 55 int pictureWidth, pictureHeight; 56 57 int32_t jpegThumbSize[2]; 58 uint8_t jpegQuality, jpegThumbQuality; 59 int32_t jpegRotation; 60 61 bool gpsEnabled; 62 double gpsCoordinates[3]; 63 int64_t gpsTimestamp; 64 String8 gpsProcessingMethod; 65 66 uint8_t wbMode; 67 uint8_t effectMode; 68 uint8_t antibandingMode; 69 uint8_t sceneMode; 70 71 enum flashMode_t { 72 FLASH_MODE_OFF = 0, 73 FLASH_MODE_AUTO, 74 FLASH_MODE_ON, 75 FLASH_MODE_TORCH, 76 FLASH_MODE_RED_EYE = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE, 77 FLASH_MODE_INVALID = -1 78 } flashMode; 79 80 enum focusMode_t { 81 FOCUS_MODE_AUTO = ANDROID_CONTROL_AF_MODE_AUTO, 82 FOCUS_MODE_MACRO = ANDROID_CONTROL_AF_MODE_MACRO, 83 FOCUS_MODE_CONTINUOUS_VIDEO = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, 84 FOCUS_MODE_CONTINUOUS_PICTURE = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE, 85 FOCUS_MODE_EDOF = ANDROID_CONTROL_AF_MODE_EDOF, 86 FOCUS_MODE_INFINITY, 87 FOCUS_MODE_FIXED, 88 FOCUS_MODE_INVALID = -1 89 } focusMode; 90 91 uint8_t focusState; // Latest focus state from HAL 92 93 // For use with triggerAfWithAuto quirk 94 focusMode_t shadowFocusMode; 95 96 struct Area { 97 int left, top, right, bottom; 98 int weight; 99 Area() {} 100 Area(int left, int top, int right, int bottom, int weight): 101 left(left), top(top), right(right), bottom(bottom), 102 weight(weight) {} 103 bool isEmpty() const { 104 return (left == 0) && (top == 0) && (right == 0) && (bottom == 0); 105 } 106 }; 107 Vector<Area> focusingAreas; 108 109 struct Size { 110 int32_t width; 111 int32_t height; 112 }; 113 114 int32_t exposureCompensation; 115 bool autoExposureLock; 116 bool autoWhiteBalanceLock; 117 118 Vector<Area> meteringAreas; 119 120 int zoom; 121 122 int videoWidth, videoHeight; 123 124 bool recordingHint; 125 bool videoStabilization; 126 127 enum lightFxMode_t { 128 LIGHTFX_NONE = 0, 129 LIGHTFX_LOWLIGHT, 130 LIGHTFX_HDR 131 } lightFx; 132 133 CameraParameters params; 134 String8 paramsFlattened; 135 136 // These parameters are also part of the camera API-visible state, but not 137 // directly listed in Camera.Parameters 138 bool storeMetadataInBuffers; 139 bool playShutterSound; 140 bool enableFaceDetect; 141 142 bool enableFocusMoveMessages; 143 int afTriggerCounter; 144 int currentAfTriggerId; 145 bool afInMotion; 146 147 int precaptureTriggerCounter; 148 149 uint32_t previewCallbackFlags; 150 bool previewCallbackOneShot; 151 bool previewCallbackSurface; 152 153 bool zslMode; 154 155 // Overall camera state 156 enum State { 157 DISCONNECTED, 158 STOPPED, 159 WAITING_FOR_PREVIEW_WINDOW, 160 PREVIEW, 161 RECORD, 162 STILL_CAPTURE, 163 VIDEO_SNAPSHOT 164 } state; 165 166 // Number of zoom steps to simulate 167 static const unsigned int NUM_ZOOM_STEPS = 100; 168 // Max preview size allowed 169 static const unsigned int MAX_PREVIEW_WIDTH = 1920; 170 static const unsigned int MAX_PREVIEW_HEIGHT = 1080; 171 // Aspect ratio tolerance 172 static const float ASPECT_RATIO_TOLERANCE = 0.001; 173 174 // Full static camera info, object owned by someone else, such as 175 // Camera2Device. 176 const CameraMetadata *info; 177 178 // Fast-access static device information; this is a subset of the 179 // information available through the staticInfo() method, used for 180 // frequently-accessed values or values that have to be calculated from the 181 // static information. 182 struct DeviceInfo { 183 int32_t arrayWidth; 184 int32_t arrayHeight; 185 int32_t bestStillCaptureFpsRange[2]; 186 uint8_t bestFaceDetectMode; 187 int32_t maxFaces; 188 struct OverrideModes { 189 flashMode_t flashMode; 190 uint8_t wbMode; 191 focusMode_t focusMode; 192 OverrideModes(): 193 flashMode(FLASH_MODE_INVALID), 194 wbMode(ANDROID_CONTROL_AWB_MODE_OFF), 195 focusMode(FOCUS_MODE_INVALID) { 196 } 197 }; 198 DefaultKeyedVector<uint8_t, OverrideModes> sceneModeOverrides; 199 float minFocalLength; 200 bool useFlexibleYuv; 201 } fastInfo; 202 203 // Quirks information; these are short-lived flags to enable workarounds for 204 // incomplete HAL implementations 205 struct Quirks { 206 bool triggerAfWithAuto; 207 bool useZslFormat; 208 bool meteringCropRegion; 209 } quirks; 210 211 /** 212 * Parameter manipulation and setup methods 213 */ 214 215 Parameters(int cameraId, int cameraFacing); 216 ~Parameters(); 217 218 // Sets up default parameters 219 status_t initialize(const CameraMetadata *info); 220 221 // Build fast-access device static info from static info 222 status_t buildFastInfo(); 223 // Query for quirks from static info 224 status_t buildQuirks(); 225 226 // Get entry from camera static characteristics information. min/maxCount 227 // are used for error checking the number of values in the entry. 0 for 228 // max/minCount means to do no bounds check in that direction. In case of 229 // error, the entry data pointer is null and the count is 0. 230 camera_metadata_ro_entry_t staticInfo(uint32_t tag, 231 size_t minCount=0, size_t maxCount=0, bool required=true) const; 232 233 // Validate and update camera parameters based on new settings 234 status_t set(const String8 ¶mString); 235 236 // Retrieve the current settings 237 String8 get() const; 238 239 // Update passed-in request for common parameters 240 status_t updateRequest(CameraMetadata *request) const; 241 242 // Add/update JPEG entries in metadata 243 status_t updateRequestJpeg(CameraMetadata *request) const; 244 245 // Calculate the crop region rectangle based on current stream sizes 246 struct CropRegion { 247 float left; 248 float top; 249 float width; 250 float height; 251 252 enum Outputs { 253 OUTPUT_PREVIEW = 0x01, 254 OUTPUT_VIDEO = 0x02, 255 OUTPUT_JPEG_THUMBNAIL = 0x04, 256 OUTPUT_PICTURE = 0x08, 257 }; 258 }; 259 CropRegion calculateCropRegion(CropRegion::Outputs outputs) const; 260 261 // Calculate the field of view of the high-resolution JPEG capture 262 status_t calculatePictureFovs(float *horizFov, float *vertFov) const; 263 264 // Static methods for debugging and converting between camera1 and camera2 265 // parameters 266 267 static const char *getStateName(State state); 268 269 static int formatStringToEnum(const char *format); 270 static const char *formatEnumToString(int format); 271 272 static int wbModeStringToEnum(const char *wbMode); 273 static const char* wbModeEnumToString(uint8_t wbMode); 274 static int effectModeStringToEnum(const char *effectMode); 275 static int abModeStringToEnum(const char *abMode); 276 static int sceneModeStringToEnum(const char *sceneMode); 277 static flashMode_t flashModeStringToEnum(const char *flashMode); 278 static const char* flashModeEnumToString(flashMode_t flashMode); 279 static focusMode_t focusModeStringToEnum(const char *focusMode); 280 static const char* focusModeEnumToString(focusMode_t focusMode); 281 static lightFxMode_t lightFxStringToEnum(const char *lightFxMode); 282 283 static status_t parseAreas(const char *areasCStr, 284 Vector<Area> *areas); 285 286 enum AreaKind 287 { 288 AREA_KIND_FOCUS, 289 AREA_KIND_METERING 290 }; 291 status_t validateAreas(const Vector<Area> &areas, 292 size_t maxRegions, 293 AreaKind areaKind) const; 294 static bool boolFromString(const char *boolStr); 295 296 // Map from camera orientation + facing to gralloc transform enum 297 static int degToTransform(int degrees, bool mirror); 298 299 // API specifies FPS ranges are done in fixed point integer, with LSB = 0.001. 300 // Note that this doesn't apply to the (deprecated) single FPS value. 301 static const int kFpsToApiScale = 1000; 302 303 // Transform between (-1000,-1000)-(1000,1000) normalized coords from camera 304 // API and HAL2 (0,0)-(activePixelArray.width/height) coordinates 305 int arrayXToNormalized(int width) const; 306 int arrayYToNormalized(int height) const; 307 int normalizedXToArray(int x) const; 308 int normalizedYToArray(int y) const; 309 310 struct Range { 311 int min; 312 int max; 313 }; 314 315 int32_t fpsFromRange(int32_t min, int32_t max) const; 316 317private: 318 319 // Convert between HAL2 sensor array coordinates and 320 // viewfinder crop-region relative array coordinates 321 int cropXToArray(int x) const; 322 int cropYToArray(int y) const; 323 int arrayXToCrop(int x) const; 324 int arrayYToCrop(int y) const; 325 326 // Convert between viewfinder crop-region relative array coordinates 327 // and camera API (-1000,1000)-(1000,1000) normalized coords 328 int cropXToNormalized(int x) const; 329 int cropYToNormalized(int y) const; 330 int normalizedXToCrop(int x) const; 331 int normalizedYToCrop(int y) const; 332 333 Vector<Size> availablePreviewSizes; 334 // Get size list (that are no larger than limit) from static metadata. 335 status_t getFilteredPreviewSizes(Size limit, Vector<Size> *sizes); 336 // Get max size (from the size array) that matches the given aspect ratio. 337 Size getMaxSizeForRatio(float ratio, const int32_t* sizeArray, size_t count); 338}; 339 340// This class encapsulates the Parameters class so that it can only be accessed 341// by constructing a Lock object, which locks the SharedParameter's mutex. 342class SharedParameters { 343 public: 344 SharedParameters(int cameraId, int cameraFacing): 345 mParameters(cameraId, cameraFacing) { 346 } 347 348 template<typename S, typename P> 349 class BaseLock { 350 public: 351 BaseLock(S &p): 352 mParameters(p.mParameters), 353 mSharedParameters(p) { 354 mSharedParameters.mLock.lock(); 355 } 356 357 ~BaseLock() { 358 mSharedParameters.mLock.unlock(); 359 } 360 P &mParameters; 361 private: 362 // Disallow copying, default construction 363 BaseLock(); 364 BaseLock(const BaseLock &); 365 BaseLock &operator=(const BaseLock &); 366 S &mSharedParameters; 367 }; 368 typedef BaseLock<SharedParameters, Parameters> Lock; 369 typedef BaseLock<const SharedParameters, const Parameters> ReadLock; 370 371 // Access static info, read-only and immutable, so no lock needed 372 camera_metadata_ro_entry_t staticInfo(uint32_t tag, 373 size_t minCount=0, size_t maxCount=0) const { 374 return mParameters.staticInfo(tag, minCount, maxCount); 375 } 376 377 // Only use for dumping or other debugging 378 const Parameters &unsafeAccess() { 379 return mParameters; 380 } 381 private: 382 Parameters mParameters; 383 mutable Mutex mLock; 384}; 385 386 387}; // namespace camera2 388}; // namespace android 389 390#endif 391