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 30 namespace android { 31 namespace 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 */ 40 struct 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 previewFps; // deprecated, here only for tracking changes 50 int previewFormat; 51 52 int previewTransform; // set by CAMERA_CMD_SET_DISPLAY_ORIENTATION 53 54 int pictureWidth, pictureHeight; 55 56 int32_t jpegThumbSize[2]; 57 uint8_t jpegQuality, jpegThumbQuality; 58 int32_t jpegRotation; 59 60 bool gpsEnabled; 61 double gpsCoordinates[3]; 62 int64_t gpsTimestamp; 63 String8 gpsProcessingMethod; 64 65 uint8_t wbMode; 66 uint8_t effectMode; 67 uint8_t antibandingMode; 68 uint8_t sceneMode; 69 70 enum flashMode_t { 71 FLASH_MODE_OFF = 0, 72 FLASH_MODE_AUTO, 73 FLASH_MODE_ON, 74 FLASH_MODE_TORCH, 75 FLASH_MODE_RED_EYE = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE, 76 FLASH_MODE_INVALID = -1 77 } flashMode; 78 79 enum focusMode_t { 80 FOCUS_MODE_AUTO = ANDROID_CONTROL_AF_MODE_AUTO, 81 FOCUS_MODE_MACRO = ANDROID_CONTROL_AF_MODE_MACRO, 82 FOCUS_MODE_CONTINUOUS_VIDEO = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, 83 FOCUS_MODE_CONTINUOUS_PICTURE = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE, 84 FOCUS_MODE_EDOF = ANDROID_CONTROL_AF_MODE_EDOF, 85 FOCUS_MODE_INFINITY, 86 FOCUS_MODE_FIXED, 87 FOCUS_MODE_INVALID = -1 88 } focusMode; 89 90 uint8_t focusState; // Latest focus state from HAL 91 92 // For use with triggerAfWithAuto quirk 93 focusMode_t shadowFocusMode; 94 95 struct Area { 96 int left, top, right, bottom; 97 int weight; AreaParameters::Area98 Area() {} AreaParameters::Area99 Area(int left, int top, int right, int bottom, int weight): 100 left(left), top(top), right(right), bottom(bottom), 101 weight(weight) {} isEmptyParameters::Area102 bool isEmpty() const { 103 return (left == 0) && (top == 0) && (right == 0) && (bottom == 0); 104 } 105 }; 106 Vector<Area> focusingAreas; 107 108 int32_t exposureCompensation; 109 bool autoExposureLock; 110 bool autoWhiteBalanceLock; 111 112 Vector<Area> meteringAreas; 113 114 int zoom; 115 116 int videoWidth, videoHeight; 117 118 bool recordingHint; 119 bool videoStabilization; 120 121 enum lightFxMode_t { 122 LIGHTFX_NONE = 0, 123 LIGHTFX_LOWLIGHT, 124 LIGHTFX_HDR 125 } lightFx; 126 127 CameraParameters params; 128 String8 paramsFlattened; 129 130 // These parameters are also part of the camera API-visible state, but not 131 // directly listed in Camera.Parameters 132 bool storeMetadataInBuffers; 133 bool playShutterSound; 134 bool enableFaceDetect; 135 136 bool enableFocusMoveMessages; 137 int afTriggerCounter; 138 int currentAfTriggerId; 139 bool afInMotion; 140 141 int precaptureTriggerCounter; 142 143 uint32_t previewCallbackFlags; 144 bool previewCallbackOneShot; 145 146 bool zslMode; 147 148 // Overall camera state 149 enum State { 150 DISCONNECTED, 151 STOPPED, 152 WAITING_FOR_PREVIEW_WINDOW, 153 PREVIEW, 154 RECORD, 155 STILL_CAPTURE, 156 VIDEO_SNAPSHOT 157 } state; 158 159 // Number of zoom steps to simulate 160 static const unsigned int NUM_ZOOM_STEPS = 100; 161 162 // Full static camera info, object owned by someone else, such as 163 // Camera2Device. 164 const CameraMetadata *info; 165 166 // Fast-access static device information; this is a subset of the 167 // information available through the staticInfo() method, used for 168 // frequently-accessed values or values that have to be calculated from the 169 // static information. 170 struct DeviceInfo { 171 int32_t arrayWidth; 172 int32_t arrayHeight; 173 uint8_t bestFaceDetectMode; 174 int32_t maxFaces; 175 struct OverrideModes { 176 flashMode_t flashMode; 177 uint8_t wbMode; 178 focusMode_t focusMode; OverrideModesParameters::DeviceInfo::OverrideModes179 OverrideModes(): 180 flashMode(FLASH_MODE_INVALID), 181 wbMode(ANDROID_CONTROL_AWB_MODE_OFF), 182 focusMode(FOCUS_MODE_INVALID) { 183 } 184 }; 185 DefaultKeyedVector<uint8_t, OverrideModes> sceneModeOverrides; 186 float minFocalLength; 187 bool useFlexibleYuv; 188 } fastInfo; 189 190 // Quirks information; these are short-lived flags to enable workarounds for 191 // incomplete HAL implementations 192 struct Quirks { 193 bool triggerAfWithAuto; 194 bool useZslFormat; 195 bool meteringCropRegion; 196 } quirks; 197 198 /** 199 * Parameter manipulation and setup methods 200 */ 201 202 Parameters(int cameraId, int cameraFacing); 203 ~Parameters(); 204 205 // Sets up default parameters 206 status_t initialize(const CameraMetadata *info); 207 208 // Build fast-access device static info from static info 209 status_t buildFastInfo(); 210 // Query for quirks from static info 211 status_t buildQuirks(); 212 213 // Get entry from camera static characteristics information. min/maxCount 214 // are used for error checking the number of values in the entry. 0 for 215 // max/minCount means to do no bounds check in that direction. In case of 216 // error, the entry data pointer is null and the count is 0. 217 camera_metadata_ro_entry_t staticInfo(uint32_t tag, 218 size_t minCount=0, size_t maxCount=0, bool required=true) const; 219 220 // Validate and update camera parameters based on new settings 221 status_t set(const String8 ¶mString); 222 223 // Retrieve the current settings 224 String8 get() const; 225 226 // Update passed-in request for common parameters 227 status_t updateRequest(CameraMetadata *request) const; 228 229 // Add/update JPEG entries in metadata 230 status_t updateRequestJpeg(CameraMetadata *request) const; 231 232 // Calculate the crop region rectangle based on current stream sizes 233 struct CropRegion { 234 float left; 235 float top; 236 float width; 237 float height; 238 239 enum Outputs { 240 OUTPUT_PREVIEW = 0x01, 241 OUTPUT_VIDEO = 0x02, 242 OUTPUT_JPEG_THUMBNAIL = 0x04, 243 OUTPUT_PICTURE = 0x08, 244 }; 245 }; 246 CropRegion calculateCropRegion(CropRegion::Outputs outputs) const; 247 248 // Calculate the field of view of the high-resolution JPEG capture 249 status_t calculatePictureFovs(float *horizFov, float *vertFov) const; 250 251 // Static methods for debugging and converting between camera1 and camera2 252 // parameters 253 254 static const char *getStateName(State state); 255 256 static int formatStringToEnum(const char *format); 257 static const char *formatEnumToString(int format); 258 259 static int wbModeStringToEnum(const char *wbMode); 260 static const char* wbModeEnumToString(uint8_t wbMode); 261 static int effectModeStringToEnum(const char *effectMode); 262 static int abModeStringToEnum(const char *abMode); 263 static int sceneModeStringToEnum(const char *sceneMode); 264 static flashMode_t flashModeStringToEnum(const char *flashMode); 265 static const char* flashModeEnumToString(flashMode_t flashMode); 266 static focusMode_t focusModeStringToEnum(const char *focusMode); 267 static const char* focusModeEnumToString(focusMode_t focusMode); 268 static lightFxMode_t lightFxStringToEnum(const char *lightFxMode); 269 270 static status_t parseAreas(const char *areasCStr, 271 Vector<Area> *areas); 272 273 enum AreaKind 274 { 275 AREA_KIND_FOCUS, 276 AREA_KIND_METERING 277 }; 278 status_t validateAreas(const Vector<Area> &areas, 279 size_t maxRegions, 280 AreaKind areaKind) const; 281 static bool boolFromString(const char *boolStr); 282 283 // Map from camera orientation + facing to gralloc transform enum 284 static int degToTransform(int degrees, bool mirror); 285 286 // API specifies FPS ranges are done in fixed point integer, with LSB = 0.001. 287 // Note that this doesn't apply to the (deprecated) single FPS value. 288 static const int kFpsToApiScale = 1000; 289 290 // Transform between (-1000,-1000)-(1000,1000) normalized coords from camera 291 // API and HAL2 (0,0)-(activePixelArray.width/height) coordinates 292 int arrayXToNormalized(int width) const; 293 int arrayYToNormalized(int height) const; 294 int normalizedXToArray(int x) const; 295 int normalizedYToArray(int y) const; 296 297 struct Range { 298 int min; 299 int max; 300 }; 301 302 int32_t fpsFromRange(int32_t min, int32_t max) const; 303 304 private: 305 306 // Convert between HAL2 sensor array coordinates and 307 // viewfinder crop-region relative array coordinates 308 int cropXToArray(int x) const; 309 int cropYToArray(int y) const; 310 int arrayXToCrop(int x) const; 311 int arrayYToCrop(int y) const; 312 313 // Convert between viewfinder crop-region relative array coordinates 314 // and camera API (-1000,1000)-(1000,1000) normalized coords 315 int cropXToNormalized(int x) const; 316 int cropYToNormalized(int y) const; 317 int normalizedXToCrop(int x) const; 318 int normalizedYToCrop(int y) const; 319 }; 320 321 // This class encapsulates the Parameters class so that it can only be accessed 322 // by constructing a Lock object, which locks the SharedParameter's mutex. 323 class SharedParameters { 324 public: SharedParameters(int cameraId,int cameraFacing)325 SharedParameters(int cameraId, int cameraFacing): 326 mParameters(cameraId, cameraFacing) { 327 } 328 329 template<typename S, typename P> 330 class BaseLock { 331 public: BaseLock(S & p)332 BaseLock(S &p): 333 mParameters(p.mParameters), 334 mSharedParameters(p) { 335 mSharedParameters.mLock.lock(); 336 } 337 ~BaseLock()338 ~BaseLock() { 339 mSharedParameters.mLock.unlock(); 340 } 341 P &mParameters; 342 private: 343 // Disallow copying, default construction 344 BaseLock(); 345 BaseLock(const BaseLock &); 346 BaseLock &operator=(const BaseLock &); 347 S &mSharedParameters; 348 }; 349 typedef BaseLock<SharedParameters, Parameters> Lock; 350 typedef BaseLock<const SharedParameters, const Parameters> ReadLock; 351 352 // Access static info, read-only and immutable, so no lock needed 353 camera_metadata_ro_entry_t staticInfo(uint32_t tag, 354 size_t minCount=0, size_t maxCount=0) const { 355 return mParameters.staticInfo(tag, minCount, maxCount); 356 } 357 358 // Only use for dumping or other debugging unsafeAccess()359 const Parameters &unsafeAccess() { 360 return mParameters; 361 } 362 private: 363 Parameters mParameters; 364 mutable Mutex mLock; 365 }; 366 367 368 }; // namespace camera2 369 }; // namespace android 370 371 #endif 372