Parameters.cpp revision 1cebdb77323e4554a316b9c34bf36957b7dad5ae
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#define LOG_TAG "Camera2-Parameters" 18#define ATRACE_TAG ATRACE_TAG_CAMERA 19//#define LOG_NDEBUG 0 20 21#include <utils/Log.h> 22#include <utils/Trace.h> 23#include <utils/Vector.h> 24#include <utils/SortedVector.h> 25 26#include <math.h> 27#include <stdlib.h> 28#include <cutils/properties.h> 29 30#include "Parameters.h" 31#include "system/camera.h" 32 33namespace android { 34namespace camera2 { 35 36Parameters::Parameters(int cameraId, 37 int cameraFacing) : 38 cameraId(cameraId), 39 cameraFacing(cameraFacing), 40 info(NULL) { 41} 42 43Parameters::~Parameters() { 44} 45 46status_t Parameters::initialize(const CameraMetadata *info) { 47 status_t res; 48 49 if (info->entryCount() == 0) { 50 ALOGE("%s: No static information provided!", __FUNCTION__); 51 return BAD_VALUE; 52 } 53 Parameters::info = info; 54 55 res = buildFastInfo(); 56 if (res != OK) return res; 57 58 res = buildQuirks(); 59 if (res != OK) return res; 60 61 const Size MAX_PREVIEW_SIZE = { MAX_PREVIEW_WIDTH, MAX_PREVIEW_HEIGHT }; 62 res = getFilteredPreviewSizes(MAX_PREVIEW_SIZE, &availablePreviewSizes); 63 if (res != OK) return res; 64 65 // TODO: Pick more intelligently 66 previewWidth = availablePreviewSizes[0].width; 67 previewHeight = availablePreviewSizes[0].height; 68 videoWidth = previewWidth; 69 videoHeight = previewHeight; 70 71 params.setPreviewSize(previewWidth, previewHeight); 72 params.setVideoSize(videoWidth, videoHeight); 73 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, 74 String8::format("%dx%d", 75 previewWidth, previewHeight)); 76 { 77 String8 supportedPreviewSizes; 78 for (size_t i = 0; i < availablePreviewSizes.size(); i++) { 79 if (i != 0) supportedPreviewSizes += ","; 80 supportedPreviewSizes += String8::format("%dx%d", 81 availablePreviewSizes[i].width, 82 availablePreviewSizes[i].height); 83 } 84 ALOGV("Supported preview sizes are: %s", supportedPreviewSizes.string()); 85 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 86 supportedPreviewSizes); 87 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, 88 supportedPreviewSizes); 89 } 90 91 camera_metadata_ro_entry_t availableFpsRanges = 92 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 93 if (!availableFpsRanges.count) return NO_INIT; 94 95 previewFpsRange[0] = availableFpsRanges.data.i32[0]; 96 previewFpsRange[1] = availableFpsRanges.data.i32[1]; 97 98 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 99 String8::format("%d,%d", 100 previewFpsRange[0] * kFpsToApiScale, 101 previewFpsRange[1] * kFpsToApiScale)); 102 103 { 104 String8 supportedPreviewFpsRange; 105 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 106 if (i != 0) supportedPreviewFpsRange += ","; 107 supportedPreviewFpsRange += String8::format("(%d,%d)", 108 availableFpsRanges.data.i32[i] * kFpsToApiScale, 109 availableFpsRanges.data.i32[i+1] * kFpsToApiScale); 110 } 111 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 112 supportedPreviewFpsRange); 113 } 114 115 previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 116 params.set(CameraParameters::KEY_PREVIEW_FORMAT, 117 formatEnumToString(previewFormat)); // NV21 118 119 previewTransform = degToTransform(0, 120 cameraFacing == CAMERA_FACING_FRONT); 121 122 camera_metadata_ro_entry_t availableFormats = 123 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 124 125 { 126 String8 supportedPreviewFormats; 127 bool addComma = false; 128 for (size_t i=0; i < availableFormats.count; i++) { 129 if (addComma) supportedPreviewFormats += ","; 130 addComma = true; 131 switch (availableFormats.data.i32[i]) { 132 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 133 supportedPreviewFormats += 134 CameraParameters::PIXEL_FORMAT_YUV422SP; 135 break; 136 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 137 supportedPreviewFormats += 138 CameraParameters::PIXEL_FORMAT_YUV420SP; 139 break; 140 case HAL_PIXEL_FORMAT_YCbCr_422_I: 141 supportedPreviewFormats += 142 CameraParameters::PIXEL_FORMAT_YUV422I; 143 break; 144 case HAL_PIXEL_FORMAT_YV12: 145 supportedPreviewFormats += 146 CameraParameters::PIXEL_FORMAT_YUV420P; 147 break; 148 case HAL_PIXEL_FORMAT_RGB_565: 149 supportedPreviewFormats += 150 CameraParameters::PIXEL_FORMAT_RGB565; 151 break; 152 case HAL_PIXEL_FORMAT_RGBA_8888: 153 supportedPreviewFormats += 154 CameraParameters::PIXEL_FORMAT_RGBA8888; 155 break; 156 case HAL_PIXEL_FORMAT_YCbCr_420_888: 157 // Flexible YUV allows both YV12 and NV21 158 supportedPreviewFormats += 159 CameraParameters::PIXEL_FORMAT_YUV420P; 160 supportedPreviewFormats += ","; 161 supportedPreviewFormats += 162 CameraParameters::PIXEL_FORMAT_YUV420SP; 163 break; 164 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats 165 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 166 case HAL_PIXEL_FORMAT_RAW_SENSOR: 167 case HAL_PIXEL_FORMAT_BLOB: 168 addComma = false; 169 break; 170 171 default: 172 ALOGW("%s: Camera %d: Unknown preview format: %x", 173 __FUNCTION__, cameraId, availableFormats.data.i32[i]); 174 addComma = false; 175 break; 176 } 177 } 178 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 179 supportedPreviewFormats); 180 } 181 182 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but 183 // still have to do something sane for them 184 185 // NOTE: Not scaled like FPS range values are. 186 int previewFps = fpsFromRange(previewFpsRange[0], previewFpsRange[1]); 187 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE, 188 previewFps); 189 190 { 191 SortedVector<int32_t> sortedPreviewFrameRates; 192 193 String8 supportedPreviewFrameRates; 194 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 195 // from the [min, max] fps range use the max value 196 int fps = fpsFromRange(availableFpsRanges.data.i32[i], 197 availableFpsRanges.data.i32[i+1]); 198 199 // de-dupe frame rates 200 if (sortedPreviewFrameRates.indexOf(fps) == NAME_NOT_FOUND) { 201 sortedPreviewFrameRates.add(fps); 202 } 203 else { 204 continue; 205 } 206 207 if (sortedPreviewFrameRates.size() > 1) { 208 supportedPreviewFrameRates += ","; 209 } 210 211 supportedPreviewFrameRates += String8::format("%d", 212 fps); 213 214 ALOGV("%s: Supported preview frame rates: %s", 215 __FUNCTION__, supportedPreviewFrameRates.string()); 216 } 217 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 218 supportedPreviewFrameRates); 219 } 220 221 camera_metadata_ro_entry_t availableJpegSizes = 222 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2); 223 if (!availableJpegSizes.count) return NO_INIT; 224 225 // TODO: Pick maximum 226 pictureWidth = availableJpegSizes.data.i32[0]; 227 pictureHeight = availableJpegSizes.data.i32[1]; 228 229 params.setPictureSize(pictureWidth, 230 pictureHeight); 231 232 { 233 String8 supportedPictureSizes; 234 for (size_t i=0; i < availableJpegSizes.count; i += 2) { 235 if (i != 0) supportedPictureSizes += ","; 236 supportedPictureSizes += String8::format("%dx%d", 237 availableJpegSizes.data.i32[i], 238 availableJpegSizes.data.i32[i+1]); 239 } 240 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 241 supportedPictureSizes); 242 } 243 244 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 245 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 246 CameraParameters::PIXEL_FORMAT_JPEG); 247 248 camera_metadata_ro_entry_t availableJpegThumbnailSizes = 249 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 4); 250 if (!availableJpegThumbnailSizes.count) return NO_INIT; 251 252 // Pick the largest thumbnail size that matches still image aspect ratio. 253 ALOG_ASSERT(pictureWidth > 0 && pictureHeight > 0, 254 "Invalid picture size, %d x %d", pictureWidth, pictureHeight); 255 float picAspectRatio = static_cast<float>(pictureWidth) / pictureHeight; 256 Size thumbnailSize = 257 getMaxSizeForRatio( 258 picAspectRatio, 259 &availableJpegThumbnailSizes.data.i32[0], 260 availableJpegThumbnailSizes.count); 261 jpegThumbSize[0] = thumbnailSize.width; 262 jpegThumbSize[1] = thumbnailSize.height; 263 264 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 265 jpegThumbSize[0]); 266 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 267 jpegThumbSize[1]); 268 269 { 270 String8 supportedJpegThumbSizes; 271 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) { 272 if (i != 0) supportedJpegThumbSizes += ","; 273 supportedJpegThumbSizes += String8::format("%dx%d", 274 availableJpegThumbnailSizes.data.i32[i], 275 availableJpegThumbnailSizes.data.i32[i+1]); 276 } 277 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 278 supportedJpegThumbSizes); 279 } 280 281 jpegThumbQuality = 90; 282 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 283 jpegThumbQuality); 284 jpegQuality = 90; 285 params.set(CameraParameters::KEY_JPEG_QUALITY, 286 jpegQuality); 287 jpegRotation = 0; 288 params.set(CameraParameters::KEY_ROTATION, 289 jpegRotation); 290 291 gpsEnabled = false; 292 gpsCoordinates[0] = 0.0; 293 gpsCoordinates[1] = 0.0; 294 gpsCoordinates[2] = 0.0; 295 gpsTimestamp = 0; 296 gpsProcessingMethod = "unknown"; 297 // GPS fields in CameraParameters are not set by implementation 298 299 wbMode = ANDROID_CONTROL_AWB_MODE_AUTO; 300 params.set(CameraParameters::KEY_WHITE_BALANCE, 301 CameraParameters::WHITE_BALANCE_AUTO); 302 303 camera_metadata_ro_entry_t availableWhiteBalanceModes = 304 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 0, 0, false); 305 if (!availableWhiteBalanceModes.count) { 306 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 307 CameraParameters::WHITE_BALANCE_AUTO); 308 } else { 309 String8 supportedWhiteBalance; 310 bool addComma = false; 311 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) { 312 if (addComma) supportedWhiteBalance += ","; 313 addComma = true; 314 switch (availableWhiteBalanceModes.data.u8[i]) { 315 case ANDROID_CONTROL_AWB_MODE_AUTO: 316 supportedWhiteBalance += 317 CameraParameters::WHITE_BALANCE_AUTO; 318 break; 319 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT: 320 supportedWhiteBalance += 321 CameraParameters::WHITE_BALANCE_INCANDESCENT; 322 break; 323 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT: 324 supportedWhiteBalance += 325 CameraParameters::WHITE_BALANCE_FLUORESCENT; 326 break; 327 case ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT: 328 supportedWhiteBalance += 329 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 330 break; 331 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT: 332 supportedWhiteBalance += 333 CameraParameters::WHITE_BALANCE_DAYLIGHT; 334 break; 335 case ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT: 336 supportedWhiteBalance += 337 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 338 break; 339 case ANDROID_CONTROL_AWB_MODE_TWILIGHT: 340 supportedWhiteBalance += 341 CameraParameters::WHITE_BALANCE_TWILIGHT; 342 break; 343 case ANDROID_CONTROL_AWB_MODE_SHADE: 344 supportedWhiteBalance += 345 CameraParameters::WHITE_BALANCE_SHADE; 346 break; 347 // Skipping values not mappable to v1 API 348 case ANDROID_CONTROL_AWB_MODE_OFF: 349 addComma = false; 350 break; 351 default: 352 ALOGW("%s: Camera %d: Unknown white balance value: %d", 353 __FUNCTION__, cameraId, 354 availableWhiteBalanceModes.data.u8[i]); 355 addComma = false; 356 break; 357 } 358 } 359 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 360 supportedWhiteBalance); 361 } 362 363 effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 364 params.set(CameraParameters::KEY_EFFECT, 365 CameraParameters::EFFECT_NONE); 366 367 camera_metadata_ro_entry_t availableEffects = 368 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS, 0, 0, false); 369 if (!availableEffects.count) { 370 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, 371 CameraParameters::EFFECT_NONE); 372 } else { 373 String8 supportedEffects; 374 bool addComma = false; 375 for (size_t i=0; i < availableEffects.count; i++) { 376 if (addComma) supportedEffects += ","; 377 addComma = true; 378 switch (availableEffects.data.u8[i]) { 379 case ANDROID_CONTROL_EFFECT_MODE_OFF: 380 supportedEffects += 381 CameraParameters::EFFECT_NONE; 382 break; 383 case ANDROID_CONTROL_EFFECT_MODE_MONO: 384 supportedEffects += 385 CameraParameters::EFFECT_MONO; 386 break; 387 case ANDROID_CONTROL_EFFECT_MODE_NEGATIVE: 388 supportedEffects += 389 CameraParameters::EFFECT_NEGATIVE; 390 break; 391 case ANDROID_CONTROL_EFFECT_MODE_SOLARIZE: 392 supportedEffects += 393 CameraParameters::EFFECT_SOLARIZE; 394 break; 395 case ANDROID_CONTROL_EFFECT_MODE_SEPIA: 396 supportedEffects += 397 CameraParameters::EFFECT_SEPIA; 398 break; 399 case ANDROID_CONTROL_EFFECT_MODE_POSTERIZE: 400 supportedEffects += 401 CameraParameters::EFFECT_POSTERIZE; 402 break; 403 case ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD: 404 supportedEffects += 405 CameraParameters::EFFECT_WHITEBOARD; 406 break; 407 case ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD: 408 supportedEffects += 409 CameraParameters::EFFECT_BLACKBOARD; 410 break; 411 case ANDROID_CONTROL_EFFECT_MODE_AQUA: 412 supportedEffects += 413 CameraParameters::EFFECT_AQUA; 414 break; 415 default: 416 ALOGW("%s: Camera %d: Unknown effect value: %d", 417 __FUNCTION__, cameraId, availableEffects.data.u8[i]); 418 addComma = false; 419 break; 420 } 421 } 422 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects); 423 } 424 425 antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; 426 params.set(CameraParameters::KEY_ANTIBANDING, 427 CameraParameters::ANTIBANDING_AUTO); 428 429 camera_metadata_ro_entry_t availableAntibandingModes = 430 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 0, 0, false); 431 if (!availableAntibandingModes.count) { 432 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 433 CameraParameters::ANTIBANDING_OFF); 434 } else { 435 String8 supportedAntibanding; 436 bool addComma = false; 437 for (size_t i=0; i < availableAntibandingModes.count; i++) { 438 if (addComma) supportedAntibanding += ","; 439 addComma = true; 440 switch (availableAntibandingModes.data.u8[i]) { 441 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF: 442 supportedAntibanding += 443 CameraParameters::ANTIBANDING_OFF; 444 break; 445 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ: 446 supportedAntibanding += 447 CameraParameters::ANTIBANDING_50HZ; 448 break; 449 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ: 450 supportedAntibanding += 451 CameraParameters::ANTIBANDING_60HZ; 452 break; 453 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO: 454 supportedAntibanding += 455 CameraParameters::ANTIBANDING_AUTO; 456 break; 457 default: 458 ALOGW("%s: Camera %d: Unknown antibanding value: %d", 459 __FUNCTION__, cameraId, 460 availableAntibandingModes.data.u8[i]); 461 addComma = false; 462 break; 463 } 464 } 465 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 466 supportedAntibanding); 467 } 468 469 sceneMode = ANDROID_CONTROL_SCENE_MODE_DISABLED; 470 params.set(CameraParameters::KEY_SCENE_MODE, 471 CameraParameters::SCENE_MODE_AUTO); 472 473 camera_metadata_ro_entry_t availableSceneModes = 474 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 0, 0, false); 475 if (!availableSceneModes.count) { 476 params.remove(CameraParameters::KEY_SCENE_MODE); 477 } else { 478 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO); 479 bool addComma = true; 480 bool noSceneModes = false; 481 for (size_t i=0; i < availableSceneModes.count; i++) { 482 if (addComma) supportedSceneModes += ","; 483 addComma = true; 484 switch (availableSceneModes.data.u8[i]) { 485 case ANDROID_CONTROL_SCENE_MODE_DISABLED: 486 noSceneModes = true; 487 break; 488 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 489 // Not in old API 490 addComma = false; 491 break; 492 case ANDROID_CONTROL_SCENE_MODE_ACTION: 493 supportedSceneModes += 494 CameraParameters::SCENE_MODE_ACTION; 495 break; 496 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT: 497 supportedSceneModes += 498 CameraParameters::SCENE_MODE_PORTRAIT; 499 break; 500 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE: 501 supportedSceneModes += 502 CameraParameters::SCENE_MODE_LANDSCAPE; 503 break; 504 case ANDROID_CONTROL_SCENE_MODE_NIGHT: 505 supportedSceneModes += 506 CameraParameters::SCENE_MODE_NIGHT; 507 break; 508 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT: 509 supportedSceneModes += 510 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT; 511 break; 512 case ANDROID_CONTROL_SCENE_MODE_THEATRE: 513 supportedSceneModes += 514 CameraParameters::SCENE_MODE_THEATRE; 515 break; 516 case ANDROID_CONTROL_SCENE_MODE_BEACH: 517 supportedSceneModes += 518 CameraParameters::SCENE_MODE_BEACH; 519 break; 520 case ANDROID_CONTROL_SCENE_MODE_SNOW: 521 supportedSceneModes += 522 CameraParameters::SCENE_MODE_SNOW; 523 break; 524 case ANDROID_CONTROL_SCENE_MODE_SUNSET: 525 supportedSceneModes += 526 CameraParameters::SCENE_MODE_SUNSET; 527 break; 528 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO: 529 supportedSceneModes += 530 CameraParameters::SCENE_MODE_STEADYPHOTO; 531 break; 532 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS: 533 supportedSceneModes += 534 CameraParameters::SCENE_MODE_FIREWORKS; 535 break; 536 case ANDROID_CONTROL_SCENE_MODE_SPORTS: 537 supportedSceneModes += 538 CameraParameters::SCENE_MODE_SPORTS; 539 break; 540 case ANDROID_CONTROL_SCENE_MODE_PARTY: 541 supportedSceneModes += 542 CameraParameters::SCENE_MODE_PARTY; 543 break; 544 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT: 545 supportedSceneModes += 546 CameraParameters::SCENE_MODE_CANDLELIGHT; 547 break; 548 case ANDROID_CONTROL_SCENE_MODE_BARCODE: 549 supportedSceneModes += 550 CameraParameters::SCENE_MODE_BARCODE; 551 break; 552 default: 553 ALOGW("%s: Camera %d: Unknown scene mode value: %d", 554 __FUNCTION__, cameraId, 555 availableSceneModes.data.u8[i]); 556 addComma = false; 557 break; 558 } 559 } 560 if (!noSceneModes) { 561 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 562 supportedSceneModes); 563 } else { 564 params.remove(CameraParameters::KEY_SCENE_MODE); 565 } 566 } 567 568 bool isFlashAvailable = false; 569 camera_metadata_ro_entry_t flashAvailable = 570 staticInfo(ANDROID_FLASH_INFO_AVAILABLE, 0, 1, false); 571 if (flashAvailable.count) { 572 isFlashAvailable = flashAvailable.data.u8[0]; 573 } 574 575 camera_metadata_ro_entry_t availableAeModes = 576 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES, 0, 0, false); 577 578 if (isFlashAvailable) { 579 flashMode = Parameters::FLASH_MODE_OFF; 580 params.set(CameraParameters::KEY_FLASH_MODE, 581 CameraParameters::FLASH_MODE_OFF); 582 583 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF); 584 supportedFlashModes = supportedFlashModes + 585 "," + CameraParameters::FLASH_MODE_AUTO + 586 "," + CameraParameters::FLASH_MODE_ON + 587 "," + CameraParameters::FLASH_MODE_TORCH; 588 for (size_t i=0; i < availableAeModes.count; i++) { 589 if (availableAeModes.data.u8[i] == 590 ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE) { 591 supportedFlashModes = supportedFlashModes + "," + 592 CameraParameters::FLASH_MODE_RED_EYE; 593 break; 594 } 595 } 596 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 597 supportedFlashModes); 598 } else { 599 flashMode = Parameters::FLASH_MODE_OFF; 600 params.set(CameraParameters::KEY_FLASH_MODE, 601 CameraParameters::FLASH_MODE_OFF); 602 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 603 CameraParameters::FLASH_MODE_OFF); 604 } 605 606 camera_metadata_ro_entry_t minFocusDistance = 607 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 1, false); 608 609 camera_metadata_ro_entry_t availableAfModes = 610 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES, 0, 0, false); 611 612 if (!minFocusDistance.count || minFocusDistance.data.f[0] == 0) { 613 // Fixed-focus lens 614 focusMode = Parameters::FOCUS_MODE_FIXED; 615 params.set(CameraParameters::KEY_FOCUS_MODE, 616 CameraParameters::FOCUS_MODE_FIXED); 617 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 618 CameraParameters::FOCUS_MODE_FIXED); 619 } else { 620 focusMode = Parameters::FOCUS_MODE_AUTO; 621 params.set(CameraParameters::KEY_FOCUS_MODE, 622 CameraParameters::FOCUS_MODE_AUTO); 623 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_INFINITY); 624 bool addComma = true; 625 626 for (size_t i=0; i < availableAfModes.count; i++) { 627 if (addComma) supportedFocusModes += ","; 628 addComma = true; 629 switch (availableAfModes.data.u8[i]) { 630 case ANDROID_CONTROL_AF_MODE_AUTO: 631 supportedFocusModes += 632 CameraParameters::FOCUS_MODE_AUTO; 633 break; 634 case ANDROID_CONTROL_AF_MODE_MACRO: 635 supportedFocusModes += 636 CameraParameters::FOCUS_MODE_MACRO; 637 break; 638 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 639 supportedFocusModes += 640 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 641 break; 642 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 643 supportedFocusModes += 644 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 645 break; 646 case ANDROID_CONTROL_AF_MODE_EDOF: 647 supportedFocusModes += 648 CameraParameters::FOCUS_MODE_EDOF; 649 break; 650 // Not supported in old API 651 case ANDROID_CONTROL_AF_MODE_OFF: 652 addComma = false; 653 break; 654 default: 655 ALOGW("%s: Camera %d: Unknown AF mode value: %d", 656 __FUNCTION__, cameraId, availableAfModes.data.u8[i]); 657 addComma = false; 658 break; 659 } 660 } 661 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 662 supportedFocusModes); 663 } 664 focusState = ANDROID_CONTROL_AF_STATE_INACTIVE; 665 shadowFocusMode = FOCUS_MODE_INVALID; 666 667 camera_metadata_ro_entry_t max3aRegions = staticInfo(ANDROID_CONTROL_MAX_REGIONS, 668 Parameters::NUM_REGION, Parameters::NUM_REGION); 669 if (max3aRegions.count != Parameters::NUM_REGION) return NO_INIT; 670 671 int32_t maxNumFocusAreas = 0; 672 if (focusMode != Parameters::FOCUS_MODE_FIXED) { 673 maxNumFocusAreas = max3aRegions.data.i32[Parameters::REGION_AF]; 674 } 675 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, maxNumFocusAreas); 676 params.set(CameraParameters::KEY_FOCUS_AREAS, 677 "(0,0,0,0,0)"); 678 focusingAreas.clear(); 679 focusingAreas.add(Parameters::Area(0,0,0,0,0)); 680 681 camera_metadata_ro_entry_t availableFocalLengths = 682 staticInfo(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 0, 0, false); 683 if (!availableFocalLengths.count) return NO_INIT; 684 685 float minFocalLength = availableFocalLengths.data.f[0]; 686 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength); 687 688 float horizFov, vertFov; 689 res = calculatePictureFovs(&horizFov, &vertFov); 690 if (res != OK) { 691 ALOGE("%s: Can't calculate field of views!", __FUNCTION__); 692 return res; 693 } 694 695 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 696 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 697 698 exposureCompensation = 0; 699 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 700 exposureCompensation); 701 702 camera_metadata_ro_entry_t exposureCompensationRange = 703 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 2, 2); 704 if (!exposureCompensationRange.count) return NO_INIT; 705 706 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 707 exposureCompensationRange.data.i32[1]); 708 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 709 exposureCompensationRange.data.i32[0]); 710 711 camera_metadata_ro_entry_t exposureCompensationStep = 712 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_STEP, 1, 1); 713 if (!exposureCompensationStep.count) return NO_INIT; 714 715 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 716 (float)exposureCompensationStep.data.r[0].numerator / 717 exposureCompensationStep.data.r[0].denominator); 718 719 autoExposureLock = false; 720 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 721 CameraParameters::FALSE); 722 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 723 CameraParameters::TRUE); 724 725 autoWhiteBalanceLock = false; 726 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 727 CameraParameters::FALSE); 728 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 729 CameraParameters::TRUE); 730 731 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 732 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 733 max3aRegions.data.i32[Parameters::REGION_AE]); 734 params.set(CameraParameters::KEY_METERING_AREAS, 735 "(0,0,0,0,0)"); 736 737 zoom = 0; 738 params.set(CameraParameters::KEY_ZOOM, zoom); 739 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 740 741 camera_metadata_ro_entry_t maxDigitalZoom = 742 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, /*minCount*/1, /*maxCount*/1); 743 if (!maxDigitalZoom.count) return NO_INIT; 744 745 { 746 String8 zoomRatios; 747 float zoom = 1.f; 748 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 749 (NUM_ZOOM_STEPS-1); 750 bool addComma = false; 751 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 752 if (addComma) zoomRatios += ","; 753 addComma = true; 754 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 755 zoom += zoomIncrement; 756 } 757 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 758 } 759 760 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 761 CameraParameters::TRUE); 762 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 763 CameraParameters::FALSE); 764 765 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 766 "Infinity,Infinity,Infinity"); 767 768 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 769 fastInfo.maxFaces); 770 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 771 0); 772 773 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 774 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE); 775 776 recordingHint = false; 777 params.set(CameraParameters::KEY_RECORDING_HINT, 778 CameraParameters::FALSE); 779 780 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 781 CameraParameters::TRUE); 782 783 videoStabilization = false; 784 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 785 CameraParameters::FALSE); 786 787 camera_metadata_ro_entry_t availableVideoStabilizationModes = 788 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 0, 0, 789 false); 790 791 if (availableVideoStabilizationModes.count > 1) { 792 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 793 CameraParameters::TRUE); 794 } else { 795 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 796 CameraParameters::FALSE); 797 } 798 799 // Set up initial state for non-Camera.Parameters state variables 800 801 storeMetadataInBuffers = true; 802 playShutterSound = true; 803 enableFaceDetect = false; 804 805 enableFocusMoveMessages = false; 806 afTriggerCounter = 1; 807 afStateCounter = 0; 808 currentAfTriggerId = -1; 809 afInMotion = false; 810 811 precaptureTriggerCounter = 1; 812 813 takePictureCounter = 0; 814 815 previewCallbackFlags = 0; 816 previewCallbackOneShot = false; 817 previewCallbackSurface = false; 818 819 char value[PROPERTY_VALUE_MAX]; 820 property_get("camera.disable_zsl_mode", value, "0"); 821 if (!strcmp(value,"1")) { 822 ALOGI("Camera %d: Disabling ZSL mode", cameraId); 823 zslMode = false; 824 } else { 825 zslMode = true; 826 } 827 828 lightFx = LIGHTFX_NONE; 829 830 state = STOPPED; 831 832 paramsFlattened = params.flatten(); 833 834 return OK; 835} 836 837String8 Parameters::get() const { 838 return paramsFlattened; 839} 840 841status_t Parameters::buildFastInfo() { 842 843 camera_metadata_ro_entry_t activeArraySize = 844 staticInfo(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 2, 4); 845 if (!activeArraySize.count) return NO_INIT; 846 int32_t arrayWidth; 847 int32_t arrayHeight; 848 if (activeArraySize.count == 2) { 849 ALOGW("%s: Camera %d: activeArraySize is missing xmin/ymin!", 850 __FUNCTION__, cameraId); 851 arrayWidth = activeArraySize.data.i32[0]; 852 arrayHeight = activeArraySize.data.i32[1]; 853 } else if (activeArraySize.count == 4) { 854 arrayWidth = activeArraySize.data.i32[2]; 855 arrayHeight = activeArraySize.data.i32[3]; 856 } else return NO_INIT; 857 858 // We'll set the target FPS range for still captures to be as wide 859 // as possible to give the HAL maximum latitude for exposure selection 860 camera_metadata_ro_entry_t availableFpsRanges = 861 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 862 if (availableFpsRanges.count < 2 || availableFpsRanges.count % 2 != 0) { 863 return NO_INIT; 864 } 865 866 int32_t bestStillCaptureFpsRange[2] = { 867 availableFpsRanges.data.i32[0], availableFpsRanges.data.i32[1] 868 }; 869 int32_t curRange = 870 bestStillCaptureFpsRange[1] - bestStillCaptureFpsRange[0]; 871 for (size_t i = 2; i < availableFpsRanges.count; i += 2) { 872 int32_t nextRange = 873 availableFpsRanges.data.i32[i + 1] - 874 availableFpsRanges.data.i32[i]; 875 if ( (nextRange > curRange) || // Maximize size of FPS range first 876 (nextRange == curRange && // Then minimize low-end FPS 877 bestStillCaptureFpsRange[0] > availableFpsRanges.data.i32[i])) { 878 879 bestStillCaptureFpsRange[0] = availableFpsRanges.data.i32[i]; 880 bestStillCaptureFpsRange[1] = availableFpsRanges.data.i32[i + 1]; 881 curRange = nextRange; 882 } 883 } 884 885 camera_metadata_ro_entry_t availableFaceDetectModes = 886 staticInfo(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, 0, 0, 887 false); 888 889 uint8_t bestFaceDetectMode = 890 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; 891 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) { 892 switch (availableFaceDetectModes.data.u8[i]) { 893 case ANDROID_STATISTICS_FACE_DETECT_MODE_OFF: 894 break; 895 case ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE: 896 if (bestFaceDetectMode != 897 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL) { 898 bestFaceDetectMode = 899 ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE; 900 } 901 break; 902 case ANDROID_STATISTICS_FACE_DETECT_MODE_FULL: 903 bestFaceDetectMode = 904 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL; 905 break; 906 default: 907 ALOGE("%s: Camera %d: Unknown face detect mode %d:", 908 __FUNCTION__, cameraId, 909 availableFaceDetectModes.data.u8[i]); 910 return NO_INIT; 911 } 912 } 913 914 int32_t maxFaces = 0; 915 camera_metadata_ro_entry_t maxFacesDetected = 916 staticInfo(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 0, 1, false); 917 if (maxFacesDetected.count) { 918 maxFaces = maxFacesDetected.data.i32[0]; 919 } 920 921 camera_metadata_ro_entry_t availableSceneModes = 922 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 0, 0, false); 923 camera_metadata_ro_entry_t sceneModeOverrides = 924 staticInfo(ANDROID_CONTROL_SCENE_MODE_OVERRIDES, 0, 0, false); 925 camera_metadata_ro_entry_t minFocusDistance = 926 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 0, false); 927 bool fixedLens = minFocusDistance.count == 0 || 928 minFocusDistance.data.f[0] == 0; 929 930 camera_metadata_ro_entry_t availableFocalLengths = 931 staticInfo(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS); 932 if (!availableFocalLengths.count) return NO_INIT; 933 934 camera_metadata_ro_entry_t availableFormats = 935 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 936 if (!availableFormats.count) return NO_INIT; 937 938 939 if (sceneModeOverrides.count > 0) { 940 // sceneModeOverrides is defined to have 3 entries for each scene mode, 941 // which are AE, AWB, and AF override modes the HAL wants for that scene 942 // mode. 943 const size_t kModesPerSceneMode = 3; 944 if (sceneModeOverrides.count != 945 availableSceneModes.count * kModesPerSceneMode) { 946 ALOGE("%s: Camera %d: Scene mode override list is an " 947 "unexpected size: %zu (expected %zu)", __FUNCTION__, 948 cameraId, sceneModeOverrides.count, 949 availableSceneModes.count); 950 return NO_INIT; 951 } 952 for (size_t i = 0; i < availableSceneModes.count; i++) { 953 DeviceInfo::OverrideModes modes; 954 uint8_t aeMode = 955 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 0]; 956 switch(aeMode) { 957 case ANDROID_CONTROL_AE_MODE_ON: 958 modes.flashMode = FLASH_MODE_OFF; 959 break; 960 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH: 961 modes.flashMode = FLASH_MODE_AUTO; 962 break; 963 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH: 964 modes.flashMode = FLASH_MODE_ON; 965 break; 966 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: 967 modes.flashMode = FLASH_MODE_RED_EYE; 968 break; 969 default: 970 ALOGE("%s: Unknown override AE mode: %d", __FUNCTION__, 971 aeMode); 972 modes.flashMode = FLASH_MODE_INVALID; 973 break; 974 } 975 modes.wbMode = 976 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 1]; 977 uint8_t afMode = 978 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 2]; 979 switch(afMode) { 980 case ANDROID_CONTROL_AF_MODE_OFF: 981 modes.focusMode = fixedLens ? 982 FOCUS_MODE_FIXED : FOCUS_MODE_INFINITY; 983 break; 984 case ANDROID_CONTROL_AF_MODE_AUTO: 985 case ANDROID_CONTROL_AF_MODE_MACRO: 986 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 987 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 988 case ANDROID_CONTROL_AF_MODE_EDOF: 989 modes.focusMode = static_cast<focusMode_t>(afMode); 990 break; 991 default: 992 ALOGE("%s: Unknown override AF mode: %d", __FUNCTION__, 993 afMode); 994 modes.focusMode = FOCUS_MODE_INVALID; 995 break; 996 } 997 fastInfo.sceneModeOverrides.add(availableSceneModes.data.u8[i], 998 modes); 999 } 1000 } 1001 1002 fastInfo.arrayWidth = arrayWidth; 1003 fastInfo.arrayHeight = arrayHeight; 1004 fastInfo.bestStillCaptureFpsRange[0] = bestStillCaptureFpsRange[0]; 1005 fastInfo.bestStillCaptureFpsRange[1] = bestStillCaptureFpsRange[1]; 1006 fastInfo.bestFaceDetectMode = bestFaceDetectMode; 1007 fastInfo.maxFaces = maxFaces; 1008 1009 // Find smallest (widest-angle) focal length to use as basis of still 1010 // picture FOV reporting. 1011 fastInfo.minFocalLength = availableFocalLengths.data.f[0]; 1012 for (size_t i = 1; i < availableFocalLengths.count; i++) { 1013 if (fastInfo.minFocalLength > availableFocalLengths.data.f[i]) { 1014 fastInfo.minFocalLength = availableFocalLengths.data.f[i]; 1015 } 1016 } 1017 1018 // Check if the HAL supports HAL_PIXEL_FORMAT_YCbCr_420_888 1019 fastInfo.useFlexibleYuv = false; 1020 for (size_t i = 0; i < availableFormats.count; i++) { 1021 if (availableFormats.data.i32[i] == HAL_PIXEL_FORMAT_YCbCr_420_888) { 1022 fastInfo.useFlexibleYuv = true; 1023 break; 1024 } 1025 } 1026 ALOGV("Camera %d: Flexible YUV %s supported", 1027 cameraId, fastInfo.useFlexibleYuv ? "is" : "is not"); 1028 1029 return OK; 1030} 1031 1032status_t Parameters::buildQuirks() { 1033 camera_metadata_ro_entry_t entry; 1034 entry = info->find(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO); 1035 quirks.triggerAfWithAuto = (entry.count != 0 && entry.data.u8[0] == 1); 1036 ALOGV_IF(quirks.triggerAfWithAuto, "Camera %d: Quirk triggerAfWithAuto enabled", 1037 cameraId); 1038 1039 entry = info->find(ANDROID_QUIRKS_USE_ZSL_FORMAT); 1040 quirks.useZslFormat = (entry.count != 0 && entry.data.u8[0] == 1); 1041 ALOGV_IF(quirks.useZslFormat, "Camera %d: Quirk useZslFormat enabled", 1042 cameraId); 1043 1044 entry = info->find(ANDROID_QUIRKS_METERING_CROP_REGION); 1045 quirks.meteringCropRegion = (entry.count != 0 && entry.data.u8[0] == 1); 1046 ALOGV_IF(quirks.meteringCropRegion, "Camera %d: Quirk meteringCropRegion" 1047 " enabled", cameraId); 1048 1049 entry = info->find(ANDROID_QUIRKS_USE_PARTIAL_RESULT); 1050 quirks.partialResults = (entry.count != 0 && entry.data.u8[0] == 1); 1051 ALOGV_IF(quirks.partialResults, "Camera %d: Quirk usePartialResult" 1052 " enabled", cameraId); 1053 1054 return OK; 1055} 1056 1057camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag, 1058 size_t minCount, size_t maxCount, bool required) const { 1059 camera_metadata_ro_entry_t entry = info->find(tag); 1060 1061 if (CC_UNLIKELY( entry.count == 0 ) && required) { 1062 const char* tagSection = get_camera_metadata_section_name(tag); 1063 if (tagSection == NULL) tagSection = "<unknown>"; 1064 const char* tagName = get_camera_metadata_tag_name(tag); 1065 if (tagName == NULL) tagName = "<unknown>"; 1066 1067 ALOGE("Error finding static metadata entry '%s.%s' (%x)", 1068 tagSection, tagName, tag); 1069 } else if (CC_UNLIKELY( 1070 (minCount != 0 && entry.count < minCount) || 1071 (maxCount != 0 && entry.count > maxCount) ) ) { 1072 const char* tagSection = get_camera_metadata_section_name(tag); 1073 if (tagSection == NULL) tagSection = "<unknown>"; 1074 const char* tagName = get_camera_metadata_tag_name(tag); 1075 if (tagName == NULL) tagName = "<unknown>"; 1076 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 1077 "Expected between %zu and %zu values, but got %zu values", 1078 tagSection, tagName, tag, minCount, maxCount, entry.count); 1079 } 1080 1081 return entry; 1082} 1083 1084status_t Parameters::set(const String8& paramString) { 1085 status_t res; 1086 1087 CameraParameters newParams(paramString); 1088 1089 // TODO: Currently ignoring any changes to supposedly read-only parameters 1090 // such as supported preview sizes, etc. Should probably produce an error if 1091 // they're changed. 1092 1093 /** Extract and verify new parameters */ 1094 1095 size_t i; 1096 1097 Parameters validatedParams(*this); 1098 1099 // PREVIEW_SIZE 1100 newParams.getPreviewSize(&validatedParams.previewWidth, 1101 &validatedParams.previewHeight); 1102 1103 if (validatedParams.previewWidth != previewWidth || 1104 validatedParams.previewHeight != previewHeight) { 1105 if (state >= PREVIEW) { 1106 ALOGE("%s: Preview size cannot be updated when preview " 1107 "is active! (Currently %d x %d, requested %d x %d", 1108 __FUNCTION__, 1109 previewWidth, previewHeight, 1110 validatedParams.previewWidth, validatedParams.previewHeight); 1111 return BAD_VALUE; 1112 } 1113 for (i = 0; i < availablePreviewSizes.size(); i++) { 1114 if ((availablePreviewSizes[i].width == 1115 validatedParams.previewWidth) && 1116 (availablePreviewSizes[i].height == 1117 validatedParams.previewHeight)) break; 1118 } 1119 if (i == availablePreviewSizes.size()) { 1120 ALOGE("%s: Requested preview size %d x %d is not supported", 1121 __FUNCTION__, validatedParams.previewWidth, 1122 validatedParams.previewHeight); 1123 return BAD_VALUE; 1124 } 1125 } 1126 1127 // RECORDING_HINT (always supported) 1128 validatedParams.recordingHint = boolFromString( 1129 newParams.get(CameraParameters::KEY_RECORDING_HINT) ); 1130 bool recordingHintChanged = validatedParams.recordingHint != recordingHint; 1131 ALOGV_IF(recordingHintChanged, "%s: Recording hint changed to %d", 1132 __FUNCTION__, recordingHintChanged); 1133 1134 // PREVIEW_FPS_RANGE 1135 bool fpsRangeChanged = false; 1136 int32_t lastSetFpsRange[2]; 1137 1138 params.getPreviewFpsRange(&lastSetFpsRange[0], &lastSetFpsRange[1]); 1139 lastSetFpsRange[0] /= kFpsToApiScale; 1140 lastSetFpsRange[1] /= kFpsToApiScale; 1141 1142 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0], 1143 &validatedParams.previewFpsRange[1]); 1144 validatedParams.previewFpsRange[0] /= kFpsToApiScale; 1145 validatedParams.previewFpsRange[1] /= kFpsToApiScale; 1146 1147 // Compare the FPS range value from the last set() to the current set() 1148 // to determine if the client has changed it 1149 if (validatedParams.previewFpsRange[0] != lastSetFpsRange[0] || 1150 validatedParams.previewFpsRange[1] != lastSetFpsRange[1]) { 1151 1152 fpsRangeChanged = true; 1153 camera_metadata_ro_entry_t availablePreviewFpsRanges = 1154 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 1155 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) { 1156 if ((availablePreviewFpsRanges.data.i32[i] == 1157 validatedParams.previewFpsRange[0]) && 1158 (availablePreviewFpsRanges.data.i32[i+1] == 1159 validatedParams.previewFpsRange[1]) ) { 1160 break; 1161 } 1162 } 1163 if (i == availablePreviewFpsRanges.count) { 1164 ALOGE("%s: Requested preview FPS range %d - %d is not supported", 1165 __FUNCTION__, validatedParams.previewFpsRange[0], 1166 validatedParams.previewFpsRange[1]); 1167 return BAD_VALUE; 1168 } 1169 } 1170 1171 // PREVIEW_FORMAT 1172 validatedParams.previewFormat = 1173 formatStringToEnum(newParams.getPreviewFormat()); 1174 if (validatedParams.previewFormat != previewFormat) { 1175 if (state >= PREVIEW) { 1176 ALOGE("%s: Preview format cannot be updated when preview " 1177 "is active!", __FUNCTION__); 1178 return BAD_VALUE; 1179 } 1180 camera_metadata_ro_entry_t availableFormats = 1181 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 1182 // If using flexible YUV, always support NV21/YV12. Otherwise, check 1183 // HAL's list. 1184 if (! (fastInfo.useFlexibleYuv && 1185 (validatedParams.previewFormat == 1186 HAL_PIXEL_FORMAT_YCrCb_420_SP || 1187 validatedParams.previewFormat == 1188 HAL_PIXEL_FORMAT_YV12) ) ) { 1189 // Not using flexible YUV format, so check explicitly 1190 for (i = 0; i < availableFormats.count; i++) { 1191 if (availableFormats.data.i32[i] == 1192 validatedParams.previewFormat) break; 1193 } 1194 if (i == availableFormats.count) { 1195 ALOGE("%s: Requested preview format %s (0x%x) is not supported", 1196 __FUNCTION__, newParams.getPreviewFormat(), 1197 validatedParams.previewFormat); 1198 return BAD_VALUE; 1199 } 1200 } 1201 } 1202 1203 // PREVIEW_FRAME_RATE Deprecated, only use if the preview fps range is 1204 // unchanged this time. The single-value FPS is the same as the minimum of 1205 // the range. To detect whether the application has changed the value of 1206 // previewFps, compare against their last-set preview FPS. 1207 if (!fpsRangeChanged) { 1208 int previewFps = newParams.getPreviewFrameRate(); 1209 int lastSetPreviewFps = params.getPreviewFrameRate(); 1210 if (previewFps != lastSetPreviewFps || recordingHintChanged) { 1211 camera_metadata_ro_entry_t availableFrameRates = 1212 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES); 1213 /** 1214 * If recording hint is set, find the range that encompasses 1215 * previewFps with the largest min index. 1216 * 1217 * If recording hint is not set, find the range with previewFps 1218 * with the smallest min index. 1219 * 1220 * Either way, in case of multiple ranges, break the tie by 1221 * selecting the smaller range. 1222 */ 1223 1224 // all ranges which have previewFps 1225 Vector<Range> candidateRanges; 1226 for (i = 0; i < availableFrameRates.count; i+=2) { 1227 Range r = { 1228 availableFrameRates.data.i32[i], 1229 availableFrameRates.data.i32[i+1] 1230 }; 1231 1232 if (r.min <= previewFps && previewFps <= r.max) { 1233 candidateRanges.push(r); 1234 } 1235 } 1236 if (candidateRanges.isEmpty()) { 1237 ALOGE("%s: Requested preview frame rate %d is not supported", 1238 __FUNCTION__, previewFps); 1239 return BAD_VALUE; 1240 } 1241 // most applicable range with targetFps 1242 Range bestRange = candidateRanges[0]; 1243 for (i = 1; i < candidateRanges.size(); ++i) { 1244 Range r = candidateRanges[i]; 1245 1246 // Find by largest minIndex in recording mode 1247 if (validatedParams.recordingHint) { 1248 if (r.min > bestRange.min) { 1249 bestRange = r; 1250 } 1251 else if (r.min == bestRange.min && r.max < bestRange.max) { 1252 bestRange = r; 1253 } 1254 } 1255 // Find by smallest minIndex in preview mode 1256 else { 1257 if (r.min < bestRange.min) { 1258 bestRange = r; 1259 } 1260 else if (r.min == bestRange.min && r.max < bestRange.max) { 1261 bestRange = r; 1262 } 1263 } 1264 } 1265 1266 validatedParams.previewFpsRange[0] = 1267 bestRange.min; 1268 validatedParams.previewFpsRange[1] = 1269 bestRange.max; 1270 1271 ALOGV("%s: New preview FPS range: %d, %d, recordingHint = %d", 1272 __FUNCTION__, 1273 validatedParams.previewFpsRange[0], 1274 validatedParams.previewFpsRange[1], 1275 validatedParams.recordingHint); 1276 } 1277 } 1278 1279 // PICTURE_SIZE 1280 newParams.getPictureSize(&validatedParams.pictureWidth, 1281 &validatedParams.pictureHeight); 1282 if (validatedParams.pictureWidth == pictureWidth || 1283 validatedParams.pictureHeight == pictureHeight) { 1284 camera_metadata_ro_entry_t availablePictureSizes = 1285 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES); 1286 for (i = 0; i < availablePictureSizes.count; i+=2) { 1287 if ((availablePictureSizes.data.i32[i] == 1288 validatedParams.pictureWidth) && 1289 (availablePictureSizes.data.i32[i+1] == 1290 validatedParams.pictureHeight)) break; 1291 } 1292 if (i == availablePictureSizes.count) { 1293 ALOGE("%s: Requested picture size %d x %d is not supported", 1294 __FUNCTION__, validatedParams.pictureWidth, 1295 validatedParams.pictureHeight); 1296 return BAD_VALUE; 1297 } 1298 } 1299 1300 // JPEG_THUMBNAIL_WIDTH/HEIGHT 1301 validatedParams.jpegThumbSize[0] = 1302 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 1303 validatedParams.jpegThumbSize[1] = 1304 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 1305 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] || 1306 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) { 1307 camera_metadata_ro_entry_t availableJpegThumbSizes = 1308 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES); 1309 for (i = 0; i < availableJpegThumbSizes.count; i+=2) { 1310 if ((availableJpegThumbSizes.data.i32[i] == 1311 validatedParams.jpegThumbSize[0]) && 1312 (availableJpegThumbSizes.data.i32[i+1] == 1313 validatedParams.jpegThumbSize[1])) break; 1314 } 1315 if (i == availableJpegThumbSizes.count) { 1316 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported", 1317 __FUNCTION__, validatedParams.jpegThumbSize[0], 1318 validatedParams.jpegThumbSize[1]); 1319 return BAD_VALUE; 1320 } 1321 } 1322 1323 // JPEG_THUMBNAIL_QUALITY 1324 int quality = newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 1325 // also makes sure quality fits in uint8_t 1326 if (quality < 0 || quality > 100) { 1327 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported", 1328 __FUNCTION__, quality); 1329 return BAD_VALUE; 1330 } 1331 validatedParams.jpegThumbQuality = quality; 1332 1333 // JPEG_QUALITY 1334 quality = newParams.getInt(CameraParameters::KEY_JPEG_QUALITY); 1335 // also makes sure quality fits in uint8_t 1336 if (quality < 0 || quality > 100) { 1337 ALOGE("%s: Requested JPEG quality %d is not supported", 1338 __FUNCTION__, quality); 1339 return BAD_VALUE; 1340 } 1341 validatedParams.jpegQuality = quality; 1342 1343 // ROTATION 1344 validatedParams.jpegRotation = 1345 newParams.getInt(CameraParameters::KEY_ROTATION); 1346 if (validatedParams.jpegRotation != 0 && 1347 validatedParams.jpegRotation != 90 && 1348 validatedParams.jpegRotation != 180 && 1349 validatedParams.jpegRotation != 270) { 1350 ALOGE("%s: Requested picture rotation angle %d is not supported", 1351 __FUNCTION__, validatedParams.jpegRotation); 1352 return BAD_VALUE; 1353 } 1354 1355 // GPS 1356 1357 const char *gpsLatStr = 1358 newParams.get(CameraParameters::KEY_GPS_LATITUDE); 1359 if (gpsLatStr != NULL) { 1360 const char *gpsLongStr = 1361 newParams.get(CameraParameters::KEY_GPS_LONGITUDE); 1362 const char *gpsAltitudeStr = 1363 newParams.get(CameraParameters::KEY_GPS_ALTITUDE); 1364 const char *gpsTimeStr = 1365 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP); 1366 const char *gpsProcMethodStr = 1367 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 1368 if (gpsLongStr == NULL || 1369 gpsAltitudeStr == NULL || 1370 gpsTimeStr == NULL || 1371 gpsProcMethodStr == NULL) { 1372 ALOGE("%s: Incomplete set of GPS parameters provided", 1373 __FUNCTION__); 1374 return BAD_VALUE; 1375 } 1376 char *endPtr; 1377 errno = 0; 1378 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr); 1379 if (errno || endPtr == gpsLatStr) { 1380 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr); 1381 return BAD_VALUE; 1382 } 1383 errno = 0; 1384 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr); 1385 if (errno || endPtr == gpsLongStr) { 1386 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr); 1387 return BAD_VALUE; 1388 } 1389 errno = 0; 1390 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr); 1391 if (errno || endPtr == gpsAltitudeStr) { 1392 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__, 1393 gpsAltitudeStr); 1394 return BAD_VALUE; 1395 } 1396 errno = 0; 1397 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10); 1398 if (errno || endPtr == gpsTimeStr) { 1399 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr); 1400 return BAD_VALUE; 1401 } 1402 validatedParams.gpsProcessingMethod = gpsProcMethodStr; 1403 1404 validatedParams.gpsEnabled = true; 1405 } else { 1406 validatedParams.gpsEnabled = false; 1407 } 1408 1409 // EFFECT 1410 validatedParams.effectMode = effectModeStringToEnum( 1411 newParams.get(CameraParameters::KEY_EFFECT) ); 1412 if (validatedParams.effectMode != effectMode) { 1413 camera_metadata_ro_entry_t availableEffectModes = 1414 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 1415 for (i = 0; i < availableEffectModes.count; i++) { 1416 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break; 1417 } 1418 if (i == availableEffectModes.count) { 1419 ALOGE("%s: Requested effect mode \"%s\" is not supported", 1420 __FUNCTION__, 1421 newParams.get(CameraParameters::KEY_EFFECT) ); 1422 return BAD_VALUE; 1423 } 1424 } 1425 1426 // ANTIBANDING 1427 validatedParams.antibandingMode = abModeStringToEnum( 1428 newParams.get(CameraParameters::KEY_ANTIBANDING) ); 1429 if (validatedParams.antibandingMode != antibandingMode) { 1430 camera_metadata_ro_entry_t availableAbModes = 1431 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 1432 for (i = 0; i < availableAbModes.count; i++) { 1433 if (validatedParams.antibandingMode == availableAbModes.data.u8[i]) 1434 break; 1435 } 1436 if (i == availableAbModes.count) { 1437 ALOGE("%s: Requested antibanding mode \"%s\" is not supported", 1438 __FUNCTION__, 1439 newParams.get(CameraParameters::KEY_ANTIBANDING)); 1440 return BAD_VALUE; 1441 } 1442 } 1443 1444 // SCENE_MODE 1445 validatedParams.sceneMode = sceneModeStringToEnum( 1446 newParams.get(CameraParameters::KEY_SCENE_MODE) ); 1447 if (validatedParams.sceneMode != sceneMode && 1448 validatedParams.sceneMode != 1449 ANDROID_CONTROL_SCENE_MODE_DISABLED) { 1450 camera_metadata_ro_entry_t availableSceneModes = 1451 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 1452 for (i = 0; i < availableSceneModes.count; i++) { 1453 if (validatedParams.sceneMode == availableSceneModes.data.u8[i]) 1454 break; 1455 } 1456 if (i == availableSceneModes.count) { 1457 ALOGE("%s: Requested scene mode \"%s\" is not supported", 1458 __FUNCTION__, 1459 newParams.get(CameraParameters::KEY_SCENE_MODE)); 1460 return BAD_VALUE; 1461 } 1462 } 1463 bool sceneModeSet = 1464 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED; 1465 1466 // FLASH_MODE 1467 if (sceneModeSet) { 1468 validatedParams.flashMode = 1469 fastInfo.sceneModeOverrides. 1470 valueFor(validatedParams.sceneMode).flashMode; 1471 } else { 1472 validatedParams.flashMode = FLASH_MODE_INVALID; 1473 } 1474 if (validatedParams.flashMode == FLASH_MODE_INVALID) { 1475 validatedParams.flashMode = flashModeStringToEnum( 1476 newParams.get(CameraParameters::KEY_FLASH_MODE) ); 1477 } 1478 1479 if (validatedParams.flashMode != flashMode) { 1480 camera_metadata_ro_entry_t flashAvailable = 1481 staticInfo(ANDROID_FLASH_INFO_AVAILABLE, 1, 1); 1482 if (!flashAvailable.data.u8[0] && 1483 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) { 1484 ALOGE("%s: Requested flash mode \"%s\" is not supported: " 1485 "No flash on device", __FUNCTION__, 1486 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1487 return BAD_VALUE; 1488 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) { 1489 camera_metadata_ro_entry_t availableAeModes = 1490 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 1491 for (i = 0; i < availableAeModes.count; i++) { 1492 if (validatedParams.flashMode == availableAeModes.data.u8[i]) 1493 break; 1494 } 1495 if (i == availableAeModes.count) { 1496 ALOGE("%s: Requested flash mode \"%s\" is not supported", 1497 __FUNCTION__, 1498 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1499 return BAD_VALUE; 1500 } 1501 } else if (validatedParams.flashMode == -1) { 1502 ALOGE("%s: Requested flash mode \"%s\" is unknown", 1503 __FUNCTION__, 1504 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1505 return BAD_VALUE; 1506 } 1507 // Update in case of override 1508 newParams.set(CameraParameters::KEY_FLASH_MODE, 1509 flashModeEnumToString(validatedParams.flashMode)); 1510 } 1511 1512 // WHITE_BALANCE 1513 if (sceneModeSet) { 1514 validatedParams.wbMode = 1515 fastInfo.sceneModeOverrides. 1516 valueFor(validatedParams.sceneMode).wbMode; 1517 } else { 1518 validatedParams.wbMode = ANDROID_CONTROL_AWB_MODE_OFF; 1519 } 1520 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_MODE_OFF) { 1521 validatedParams.wbMode = wbModeStringToEnum( 1522 newParams.get(CameraParameters::KEY_WHITE_BALANCE) ); 1523 } 1524 if (validatedParams.wbMode != wbMode) { 1525 camera_metadata_ro_entry_t availableWbModes = 1526 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 0, 0, false); 1527 for (i = 0; i < availableWbModes.count; i++) { 1528 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break; 1529 } 1530 if (i == availableWbModes.count) { 1531 ALOGE("%s: Requested white balance mode %s is not supported", 1532 __FUNCTION__, 1533 newParams.get(CameraParameters::KEY_WHITE_BALANCE)); 1534 return BAD_VALUE; 1535 } 1536 // Update in case of override 1537 newParams.set(CameraParameters::KEY_WHITE_BALANCE, 1538 wbModeEnumToString(validatedParams.wbMode)); 1539 } 1540 1541 // FOCUS_MODE 1542 if (sceneModeSet) { 1543 validatedParams.focusMode = 1544 fastInfo.sceneModeOverrides. 1545 valueFor(validatedParams.sceneMode).focusMode; 1546 } else { 1547 validatedParams.focusMode = FOCUS_MODE_INVALID; 1548 } 1549 if (validatedParams.focusMode == FOCUS_MODE_INVALID) { 1550 validatedParams.focusMode = focusModeStringToEnum( 1551 newParams.get(CameraParameters::KEY_FOCUS_MODE) ); 1552 } 1553 if (validatedParams.focusMode != focusMode) { 1554 validatedParams.currentAfTriggerId = -1; 1555 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) { 1556 camera_metadata_ro_entry_t minFocusDistance = 1557 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 0, 1558 false); 1559 if (minFocusDistance.count && minFocusDistance.data.f[0] == 0) { 1560 ALOGE("%s: Requested focus mode \"%s\" is not available: " 1561 "fixed focus lens", 1562 __FUNCTION__, 1563 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1564 return BAD_VALUE; 1565 } else if (validatedParams.focusMode != 1566 Parameters::FOCUS_MODE_INFINITY) { 1567 camera_metadata_ro_entry_t availableFocusModes = 1568 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1569 for (i = 0; i < availableFocusModes.count; i++) { 1570 if (validatedParams.focusMode == 1571 availableFocusModes.data.u8[i]) break; 1572 } 1573 if (i == availableFocusModes.count) { 1574 ALOGE("%s: Requested focus mode \"%s\" is not supported", 1575 __FUNCTION__, 1576 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1577 return BAD_VALUE; 1578 } 1579 } 1580 } 1581 validatedParams.focusState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1582 // Always reset shadow focus mode to avoid reverting settings 1583 validatedParams.shadowFocusMode = FOCUS_MODE_INVALID; 1584 // Update in case of override 1585 newParams.set(CameraParameters::KEY_FOCUS_MODE, 1586 focusModeEnumToString(validatedParams.focusMode)); 1587 } else { 1588 validatedParams.currentAfTriggerId = currentAfTriggerId; 1589 } 1590 1591 // FOCUS_AREAS 1592 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS), 1593 &validatedParams.focusingAreas); 1594 size_t maxAfRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1595 Parameters::NUM_REGION, Parameters::NUM_REGION). 1596 data.i32[Parameters::REGION_AF]; 1597 if (res == OK) res = validateAreas(validatedParams.focusingAreas, 1598 maxAfRegions, AREA_KIND_FOCUS); 1599 if (res != OK) { 1600 ALOGE("%s: Requested focus areas are malformed: %s", 1601 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS)); 1602 return BAD_VALUE; 1603 } 1604 1605 // EXPOSURE_COMPENSATION 1606 validatedParams.exposureCompensation = 1607 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1608 camera_metadata_ro_entry_t exposureCompensationRange = 1609 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_RANGE); 1610 if ((validatedParams.exposureCompensation < 1611 exposureCompensationRange.data.i32[0]) || 1612 (validatedParams.exposureCompensation > 1613 exposureCompensationRange.data.i32[1])) { 1614 ALOGE("%s: Requested exposure compensation index is out of bounds: %d", 1615 __FUNCTION__, validatedParams.exposureCompensation); 1616 return BAD_VALUE; 1617 } 1618 1619 // AUTO_EXPOSURE_LOCK (always supported) 1620 validatedParams.autoExposureLock = boolFromString( 1621 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 1622 1623 // AUTO_WHITEBALANCE_LOCK (always supported) 1624 validatedParams.autoWhiteBalanceLock = boolFromString( 1625 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 1626 1627 // METERING_AREAS 1628 size_t maxAeRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1629 Parameters::NUM_REGION, Parameters::NUM_REGION). 1630 data.i32[Parameters::REGION_AE]; 1631 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS), 1632 &validatedParams.meteringAreas); 1633 if (res == OK) { 1634 res = validateAreas(validatedParams.meteringAreas, maxAeRegions, 1635 AREA_KIND_METERING); 1636 } 1637 if (res != OK) { 1638 ALOGE("%s: Requested metering areas are malformed: %s", 1639 __FUNCTION__, 1640 newParams.get(CameraParameters::KEY_METERING_AREAS)); 1641 return BAD_VALUE; 1642 } 1643 1644 // ZOOM 1645 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM); 1646 if (validatedParams.zoom < 0 1647 || validatedParams.zoom >= (int)NUM_ZOOM_STEPS) { 1648 ALOGE("%s: Requested zoom level %d is not supported", 1649 __FUNCTION__, validatedParams.zoom); 1650 return BAD_VALUE; 1651 } 1652 1653 // VIDEO_SIZE 1654 newParams.getVideoSize(&validatedParams.videoWidth, 1655 &validatedParams.videoHeight); 1656 if (validatedParams.videoWidth != videoWidth || 1657 validatedParams.videoHeight != videoHeight) { 1658 if (state == RECORD) { 1659 ALOGE("%s: Video size cannot be updated when recording is active!", 1660 __FUNCTION__); 1661 return BAD_VALUE; 1662 } 1663 for (i = 0; i < availablePreviewSizes.size(); i++) { 1664 if ((availablePreviewSizes[i].width == 1665 validatedParams.videoWidth) && 1666 (availablePreviewSizes[i].height == 1667 validatedParams.videoHeight)) break; 1668 } 1669 if (i == availablePreviewSizes.size()) { 1670 ALOGE("%s: Requested video size %d x %d is not supported", 1671 __FUNCTION__, validatedParams.videoWidth, 1672 validatedParams.videoHeight); 1673 return BAD_VALUE; 1674 } 1675 } 1676 1677 // VIDEO_STABILIZATION 1678 validatedParams.videoStabilization = boolFromString( 1679 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) ); 1680 camera_metadata_ro_entry_t availableVideoStabilizationModes = 1681 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 0, 0, 1682 false); 1683 if (validatedParams.videoStabilization && 1684 availableVideoStabilizationModes.count == 1) { 1685 ALOGE("%s: Video stabilization not supported", __FUNCTION__); 1686 } 1687 1688 // LIGHTFX 1689 validatedParams.lightFx = lightFxStringToEnum( 1690 newParams.get(CameraParameters::KEY_LIGHTFX)); 1691 1692 /** Update internal parameters */ 1693 1694 *this = validatedParams; 1695 1696 /** Update external parameters calculated from the internal ones */ 1697 1698 // HORIZONTAL/VERTICAL FIELD OF VIEW 1699 float horizFov, vertFov; 1700 res = calculatePictureFovs(&horizFov, &vertFov); 1701 if (res != OK) { 1702 ALOGE("%s: Can't calculate FOVs", __FUNCTION__); 1703 // continue so parameters are at least consistent 1704 } 1705 newParams.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, 1706 horizFov); 1707 newParams.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, 1708 vertFov); 1709 ALOGV("Current still picture FOV: %f x %f deg", horizFov, vertFov); 1710 1711 // Need to flatten again in case of overrides 1712 paramsFlattened = newParams.flatten(); 1713 params = newParams; 1714 1715 return OK; 1716} 1717 1718status_t Parameters::updateRequest(CameraMetadata *request) const { 1719 ATRACE_CALL(); 1720 status_t res; 1721 1722 /** 1723 * Mixin default important security values 1724 * - android.led.transmit = defaulted ON 1725 */ 1726 camera_metadata_ro_entry_t entry = staticInfo(ANDROID_LED_AVAILABLE_LEDS, 1727 /*minimumCount*/0, 1728 /*maximumCount*/0, 1729 /*required*/false); 1730 for(size_t i = 0; i < entry.count; ++i) { 1731 uint8_t led = entry.data.u8[i]; 1732 1733 switch(led) { 1734 // Transmit LED is unconditionally on when using 1735 // the android.hardware.Camera API 1736 case ANDROID_LED_AVAILABLE_LEDS_TRANSMIT: { 1737 uint8_t transmitDefault = ANDROID_LED_TRANSMIT_ON; 1738 res = request->update(ANDROID_LED_TRANSMIT, 1739 &transmitDefault, 1); 1740 if (res != OK) return res; 1741 break; 1742 } 1743 } 1744 } 1745 1746 /** 1747 * Construct metadata from parameters 1748 */ 1749 1750 uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; 1751 res = request->update(ANDROID_REQUEST_METADATA_MODE, 1752 &metadataMode, 1); 1753 if (res != OK) return res; 1754 1755 camera_metadata_entry_t intent = 1756 request->find(ANDROID_CONTROL_CAPTURE_INTENT); 1757 if (intent.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE) { 1758 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 1759 fastInfo.bestStillCaptureFpsRange, 2); 1760 } else { 1761 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 1762 previewFpsRange, 2); 1763 } 1764 if (res != OK) return res; 1765 1766 uint8_t reqWbLock = autoWhiteBalanceLock ? 1767 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF; 1768 res = request->update(ANDROID_CONTROL_AWB_LOCK, 1769 &reqWbLock, 1); 1770 1771 res = request->update(ANDROID_CONTROL_EFFECT_MODE, 1772 &effectMode, 1); 1773 if (res != OK) return res; 1774 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, 1775 &antibandingMode, 1); 1776 if (res != OK) return res; 1777 1778 // android.hardware.Camera requires that when face detect is enabled, the 1779 // camera is in a face-priority mode. HAL2 splits this into separate parts 1780 // (face detection statistics and face priority scene mode). Map from other 1781 // to the other. 1782 bool sceneModeActive = 1783 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_DISABLED; 1784 uint8_t reqControlMode = ANDROID_CONTROL_MODE_AUTO; 1785 if (enableFaceDetect || sceneModeActive) { 1786 reqControlMode = ANDROID_CONTROL_MODE_USE_SCENE_MODE; 1787 } 1788 res = request->update(ANDROID_CONTROL_MODE, 1789 &reqControlMode, 1); 1790 if (res != OK) return res; 1791 1792 uint8_t reqSceneMode = 1793 sceneModeActive ? sceneMode : 1794 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : 1795 (uint8_t)ANDROID_CONTROL_SCENE_MODE_DISABLED; 1796 res = request->update(ANDROID_CONTROL_SCENE_MODE, 1797 &reqSceneMode, 1); 1798 if (res != OK) return res; 1799 1800 uint8_t reqFlashMode = ANDROID_FLASH_MODE_OFF; 1801 uint8_t reqAeMode = ANDROID_CONTROL_AE_MODE_OFF; 1802 switch (flashMode) { 1803 case Parameters::FLASH_MODE_OFF: 1804 reqAeMode = ANDROID_CONTROL_AE_MODE_ON; break; 1805 case Parameters::FLASH_MODE_AUTO: 1806 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH; break; 1807 case Parameters::FLASH_MODE_ON: 1808 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH; break; 1809 case Parameters::FLASH_MODE_TORCH: 1810 reqAeMode = ANDROID_CONTROL_AE_MODE_ON; 1811 reqFlashMode = ANDROID_FLASH_MODE_TORCH; 1812 break; 1813 case Parameters::FLASH_MODE_RED_EYE: 1814 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE; break; 1815 default: 1816 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__, 1817 cameraId, flashMode); 1818 return BAD_VALUE; 1819 } 1820 res = request->update(ANDROID_FLASH_MODE, 1821 &reqFlashMode, 1); 1822 if (res != OK) return res; 1823 res = request->update(ANDROID_CONTROL_AE_MODE, 1824 &reqAeMode, 1); 1825 if (res != OK) return res; 1826 1827 uint8_t reqAeLock = autoExposureLock ? 1828 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF; 1829 res = request->update(ANDROID_CONTROL_AE_LOCK, 1830 &reqAeLock, 1); 1831 if (res != OK) return res; 1832 1833 res = request->update(ANDROID_CONTROL_AWB_MODE, 1834 &wbMode, 1); 1835 if (res != OK) return res; 1836 1837 float reqFocusDistance = 0; // infinity focus in diopters 1838 uint8_t reqFocusMode = ANDROID_CONTROL_AF_MODE_OFF; 1839 switch (focusMode) { 1840 case Parameters::FOCUS_MODE_AUTO: 1841 case Parameters::FOCUS_MODE_MACRO: 1842 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1843 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1844 case Parameters::FOCUS_MODE_EDOF: 1845 reqFocusMode = focusMode; 1846 break; 1847 case Parameters::FOCUS_MODE_INFINITY: 1848 case Parameters::FOCUS_MODE_FIXED: 1849 reqFocusMode = ANDROID_CONTROL_AF_MODE_OFF; 1850 break; 1851 default: 1852 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__, 1853 cameraId, focusMode); 1854 return BAD_VALUE; 1855 } 1856 res = request->update(ANDROID_LENS_FOCUS_DISTANCE, 1857 &reqFocusDistance, 1); 1858 if (res != OK) return res; 1859 res = request->update(ANDROID_CONTROL_AF_MODE, 1860 &reqFocusMode, 1); 1861 if (res != OK) return res; 1862 1863 size_t reqFocusingAreasSize = focusingAreas.size() * 5; 1864 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize]; 1865 for (size_t i = 0, j = 0; i < reqFocusingAreasSize; i += 5, j++) { 1866 if (focusingAreas[j].weight != 0) { 1867 reqFocusingAreas[i + 0] = 1868 normalizedXToArray(focusingAreas[j].left); 1869 reqFocusingAreas[i + 1] = 1870 normalizedYToArray(focusingAreas[j].top); 1871 reqFocusingAreas[i + 2] = 1872 normalizedXToArray(focusingAreas[j].right); 1873 reqFocusingAreas[i + 3] = 1874 normalizedYToArray(focusingAreas[j].bottom); 1875 } else { 1876 reqFocusingAreas[i + 0] = 0; 1877 reqFocusingAreas[i + 1] = 0; 1878 reqFocusingAreas[i + 2] = 0; 1879 reqFocusingAreas[i + 3] = 0; 1880 } 1881 reqFocusingAreas[i + 4] = focusingAreas[j].weight; 1882 } 1883 res = request->update(ANDROID_CONTROL_AF_REGIONS, 1884 reqFocusingAreas, reqFocusingAreasSize); 1885 if (res != OK) return res; 1886 delete[] reqFocusingAreas; 1887 1888 res = request->update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, 1889 &exposureCompensation, 1); 1890 if (res != OK) return res; 1891 1892 size_t reqMeteringAreasSize = meteringAreas.size() * 5; 1893 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize]; 1894 for (size_t i = 0, j = 0; i < reqMeteringAreasSize; i += 5, j++) { 1895 if (meteringAreas[j].weight != 0) { 1896 reqMeteringAreas[i + 0] = 1897 normalizedXToArray(meteringAreas[j].left); 1898 reqMeteringAreas[i + 1] = 1899 normalizedYToArray(meteringAreas[j].top); 1900 reqMeteringAreas[i + 2] = 1901 normalizedXToArray(meteringAreas[j].right); 1902 reqMeteringAreas[i + 3] = 1903 normalizedYToArray(meteringAreas[j].bottom); 1904 } else { 1905 reqMeteringAreas[i + 0] = 0; 1906 reqMeteringAreas[i + 1] = 0; 1907 reqMeteringAreas[i + 2] = 0; 1908 reqMeteringAreas[i + 3] = 0; 1909 } 1910 reqMeteringAreas[i + 4] = meteringAreas[j].weight; 1911 } 1912 res = request->update(ANDROID_CONTROL_AE_REGIONS, 1913 reqMeteringAreas, reqMeteringAreasSize); 1914 if (res != OK) return res; 1915 1916 // Set awb regions to be the same as the metering regions if allowed 1917 size_t maxAwbRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1918 Parameters::NUM_REGION, Parameters::NUM_REGION). 1919 data.i32[Parameters::REGION_AWB]; 1920 if (maxAwbRegions > 0) { 1921 if (maxAwbRegions >= meteringAreas.size()) { 1922 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 1923 reqMeteringAreas, reqMeteringAreasSize); 1924 } else { 1925 // Ensure the awb regions are zeroed if the region count is too high. 1926 int32_t zeroedAwbAreas[5] = {0, 0, 0, 0, 0}; 1927 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 1928 zeroedAwbAreas, sizeof(zeroedAwbAreas)/sizeof(int32_t)); 1929 } 1930 if (res != OK) return res; 1931 } 1932 1933 delete[] reqMeteringAreas; 1934 1935 /* don't include jpeg thumbnail size - it's valid for 1936 it to be set to (0,0), meaning 'no thumbnail' */ 1937 CropRegion crop = calculateCropRegion( (CropRegion::Outputs)( 1938 CropRegion::OUTPUT_PREVIEW | 1939 CropRegion::OUTPUT_VIDEO | 1940 CropRegion::OUTPUT_PICTURE )); 1941 int32_t reqCropRegion[4] = { 1942 static_cast<int32_t>(crop.left), 1943 static_cast<int32_t>(crop.top), 1944 static_cast<int32_t>(crop.width), 1945 static_cast<int32_t>(crop.height) 1946 }; 1947 res = request->update(ANDROID_SCALER_CROP_REGION, 1948 reqCropRegion, 4); 1949 if (res != OK) return res; 1950 1951 uint8_t reqVstabMode = videoStabilization ? 1952 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON : 1953 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; 1954 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 1955 &reqVstabMode, 1); 1956 if (res != OK) return res; 1957 1958 uint8_t reqFaceDetectMode = enableFaceDetect ? 1959 fastInfo.bestFaceDetectMode : 1960 (uint8_t)ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; 1961 res = request->update(ANDROID_STATISTICS_FACE_DETECT_MODE, 1962 &reqFaceDetectMode, 1); 1963 if (res != OK) return res; 1964 1965 return OK; 1966} 1967 1968status_t Parameters::updateRequestJpeg(CameraMetadata *request) const { 1969 status_t res; 1970 1971 res = request->update(ANDROID_JPEG_THUMBNAIL_SIZE, 1972 jpegThumbSize, 2); 1973 if (res != OK) return res; 1974 res = request->update(ANDROID_JPEG_THUMBNAIL_QUALITY, 1975 &jpegThumbQuality, 1); 1976 if (res != OK) return res; 1977 res = request->update(ANDROID_JPEG_QUALITY, 1978 &jpegQuality, 1); 1979 if (res != OK) return res; 1980 res = request->update( 1981 ANDROID_JPEG_ORIENTATION, 1982 &jpegRotation, 1); 1983 if (res != OK) return res; 1984 1985 if (gpsEnabled) { 1986 res = request->update( 1987 ANDROID_JPEG_GPS_COORDINATES, 1988 gpsCoordinates, 3); 1989 if (res != OK) return res; 1990 res = request->update( 1991 ANDROID_JPEG_GPS_TIMESTAMP, 1992 &gpsTimestamp, 1); 1993 if (res != OK) return res; 1994 res = request->update( 1995 ANDROID_JPEG_GPS_PROCESSING_METHOD, 1996 gpsProcessingMethod); 1997 if (res != OK) return res; 1998 } else { 1999 res = request->erase(ANDROID_JPEG_GPS_COORDINATES); 2000 if (res != OK) return res; 2001 res = request->erase(ANDROID_JPEG_GPS_TIMESTAMP); 2002 if (res != OK) return res; 2003 res = request->erase(ANDROID_JPEG_GPS_PROCESSING_METHOD); 2004 if (res != OK) return res; 2005 } 2006 return OK; 2007} 2008 2009 2010const char* Parameters::getStateName(State state) { 2011#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break; 2012 switch(state) { 2013 CASE_ENUM_TO_CHAR(DISCONNECTED) 2014 CASE_ENUM_TO_CHAR(STOPPED) 2015 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW) 2016 CASE_ENUM_TO_CHAR(PREVIEW) 2017 CASE_ENUM_TO_CHAR(RECORD) 2018 CASE_ENUM_TO_CHAR(STILL_CAPTURE) 2019 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT) 2020 default: 2021 return "Unknown state!"; 2022 break; 2023 } 2024#undef CASE_ENUM_TO_CHAR 2025} 2026 2027int Parameters::formatStringToEnum(const char *format) { 2028 return 2029 !format ? 2030 HAL_PIXEL_FORMAT_YCrCb_420_SP : 2031 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ? 2032 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16 2033 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ? 2034 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21 2035 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ? 2036 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2 2037 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ? 2038 HAL_PIXEL_FORMAT_YV12 : // YV12 2039 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ? 2040 HAL_PIXEL_FORMAT_RGB_565 : // RGB565 2041 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ? 2042 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888 2043 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ? 2044 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data 2045 -1; 2046} 2047 2048const char* Parameters::formatEnumToString(int format) { 2049 const char *fmt; 2050 switch(format) { 2051 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 2052 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 2053 break; 2054 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 2055 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 2056 break; 2057 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 2058 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 2059 break; 2060 case HAL_PIXEL_FORMAT_YV12: // YV12 2061 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 2062 break; 2063 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 2064 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 2065 break; 2066 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 2067 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 2068 break; 2069 case HAL_PIXEL_FORMAT_RAW_SENSOR: 2070 ALOGW("Raw sensor preview format requested."); 2071 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 2072 break; 2073 default: 2074 ALOGE("%s: Unknown preview format: %x", 2075 __FUNCTION__, format); 2076 fmt = NULL; 2077 break; 2078 } 2079 return fmt; 2080} 2081 2082int Parameters::wbModeStringToEnum(const char *wbMode) { 2083 return 2084 !wbMode ? 2085 ANDROID_CONTROL_AWB_MODE_AUTO : 2086 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ? 2087 ANDROID_CONTROL_AWB_MODE_AUTO : 2088 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ? 2089 ANDROID_CONTROL_AWB_MODE_INCANDESCENT : 2090 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ? 2091 ANDROID_CONTROL_AWB_MODE_FLUORESCENT : 2092 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ? 2093 ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT : 2094 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ? 2095 ANDROID_CONTROL_AWB_MODE_DAYLIGHT : 2096 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ? 2097 ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT : 2098 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ? 2099 ANDROID_CONTROL_AWB_MODE_TWILIGHT : 2100 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ? 2101 ANDROID_CONTROL_AWB_MODE_SHADE : 2102 -1; 2103} 2104 2105const char* Parameters::wbModeEnumToString(uint8_t wbMode) { 2106 switch (wbMode) { 2107 case ANDROID_CONTROL_AWB_MODE_AUTO: 2108 return CameraParameters::WHITE_BALANCE_AUTO; 2109 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT: 2110 return CameraParameters::WHITE_BALANCE_INCANDESCENT; 2111 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT: 2112 return CameraParameters::WHITE_BALANCE_FLUORESCENT; 2113 case ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT: 2114 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 2115 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT: 2116 return CameraParameters::WHITE_BALANCE_DAYLIGHT; 2117 case ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT: 2118 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 2119 case ANDROID_CONTROL_AWB_MODE_TWILIGHT: 2120 return CameraParameters::WHITE_BALANCE_TWILIGHT; 2121 case ANDROID_CONTROL_AWB_MODE_SHADE: 2122 return CameraParameters::WHITE_BALANCE_SHADE; 2123 default: 2124 ALOGE("%s: Unknown AWB mode enum: %d", 2125 __FUNCTION__, wbMode); 2126 return "unknown"; 2127 } 2128} 2129 2130int Parameters::effectModeStringToEnum(const char *effectMode) { 2131 return 2132 !effectMode ? 2133 ANDROID_CONTROL_EFFECT_MODE_OFF : 2134 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ? 2135 ANDROID_CONTROL_EFFECT_MODE_OFF : 2136 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ? 2137 ANDROID_CONTROL_EFFECT_MODE_MONO : 2138 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ? 2139 ANDROID_CONTROL_EFFECT_MODE_NEGATIVE : 2140 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ? 2141 ANDROID_CONTROL_EFFECT_MODE_SOLARIZE : 2142 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ? 2143 ANDROID_CONTROL_EFFECT_MODE_SEPIA : 2144 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ? 2145 ANDROID_CONTROL_EFFECT_MODE_POSTERIZE : 2146 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ? 2147 ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD : 2148 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ? 2149 ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD : 2150 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ? 2151 ANDROID_CONTROL_EFFECT_MODE_AQUA : 2152 -1; 2153} 2154 2155int Parameters::abModeStringToEnum(const char *abMode) { 2156 return 2157 !abMode ? 2158 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO : 2159 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ? 2160 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO : 2161 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ? 2162 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF : 2163 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ? 2164 ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ : 2165 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ? 2166 ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ : 2167 -1; 2168} 2169 2170int Parameters::sceneModeStringToEnum(const char *sceneMode) { 2171 return 2172 !sceneMode ? 2173 ANDROID_CONTROL_SCENE_MODE_DISABLED : 2174 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ? 2175 ANDROID_CONTROL_SCENE_MODE_DISABLED : 2176 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ? 2177 ANDROID_CONTROL_SCENE_MODE_ACTION : 2178 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ? 2179 ANDROID_CONTROL_SCENE_MODE_PORTRAIT : 2180 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ? 2181 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE : 2182 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ? 2183 ANDROID_CONTROL_SCENE_MODE_NIGHT : 2184 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ? 2185 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT : 2186 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ? 2187 ANDROID_CONTROL_SCENE_MODE_THEATRE : 2188 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ? 2189 ANDROID_CONTROL_SCENE_MODE_BEACH : 2190 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ? 2191 ANDROID_CONTROL_SCENE_MODE_SNOW : 2192 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ? 2193 ANDROID_CONTROL_SCENE_MODE_SUNSET : 2194 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ? 2195 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO : 2196 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ? 2197 ANDROID_CONTROL_SCENE_MODE_FIREWORKS : 2198 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ? 2199 ANDROID_CONTROL_SCENE_MODE_SPORTS : 2200 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ? 2201 ANDROID_CONTROL_SCENE_MODE_PARTY : 2202 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ? 2203 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT : 2204 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ? 2205 ANDROID_CONTROL_SCENE_MODE_BARCODE: 2206 -1; 2207} 2208 2209Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum( 2210 const char *flashMode) { 2211 return 2212 !flashMode ? 2213 Parameters::FLASH_MODE_INVALID : 2214 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ? 2215 Parameters::FLASH_MODE_OFF : 2216 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ? 2217 Parameters::FLASH_MODE_AUTO : 2218 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ? 2219 Parameters::FLASH_MODE_ON : 2220 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ? 2221 Parameters::FLASH_MODE_RED_EYE : 2222 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ? 2223 Parameters::FLASH_MODE_TORCH : 2224 Parameters::FLASH_MODE_INVALID; 2225} 2226 2227const char *Parameters::flashModeEnumToString(flashMode_t flashMode) { 2228 switch (flashMode) { 2229 case FLASH_MODE_OFF: 2230 return CameraParameters::FLASH_MODE_OFF; 2231 case FLASH_MODE_AUTO: 2232 return CameraParameters::FLASH_MODE_AUTO; 2233 case FLASH_MODE_ON: 2234 return CameraParameters::FLASH_MODE_ON; 2235 case FLASH_MODE_RED_EYE: 2236 return CameraParameters::FLASH_MODE_RED_EYE; 2237 case FLASH_MODE_TORCH: 2238 return CameraParameters::FLASH_MODE_TORCH; 2239 default: 2240 ALOGE("%s: Unknown flash mode enum %d", 2241 __FUNCTION__, flashMode); 2242 return "unknown"; 2243 } 2244} 2245 2246Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum( 2247 const char *focusMode) { 2248 return 2249 !focusMode ? 2250 Parameters::FOCUS_MODE_INVALID : 2251 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ? 2252 Parameters::FOCUS_MODE_AUTO : 2253 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ? 2254 Parameters::FOCUS_MODE_INFINITY : 2255 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ? 2256 Parameters::FOCUS_MODE_MACRO : 2257 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ? 2258 Parameters::FOCUS_MODE_FIXED : 2259 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ? 2260 Parameters::FOCUS_MODE_EDOF : 2261 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ? 2262 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO : 2263 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ? 2264 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE : 2265 Parameters::FOCUS_MODE_INVALID; 2266} 2267 2268const char *Parameters::focusModeEnumToString(focusMode_t focusMode) { 2269 switch (focusMode) { 2270 case FOCUS_MODE_AUTO: 2271 return CameraParameters::FOCUS_MODE_AUTO; 2272 case FOCUS_MODE_MACRO: 2273 return CameraParameters::FOCUS_MODE_MACRO; 2274 case FOCUS_MODE_CONTINUOUS_VIDEO: 2275 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 2276 case FOCUS_MODE_CONTINUOUS_PICTURE: 2277 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 2278 case FOCUS_MODE_EDOF: 2279 return CameraParameters::FOCUS_MODE_EDOF; 2280 case FOCUS_MODE_INFINITY: 2281 return CameraParameters::FOCUS_MODE_INFINITY; 2282 case FOCUS_MODE_FIXED: 2283 return CameraParameters::FOCUS_MODE_FIXED; 2284 default: 2285 ALOGE("%s: Unknown focus mode enum: %d", 2286 __FUNCTION__, focusMode); 2287 return "unknown"; 2288 } 2289} 2290 2291Parameters::Parameters::lightFxMode_t Parameters::lightFxStringToEnum( 2292 const char *lightFxMode) { 2293 return 2294 !lightFxMode ? 2295 Parameters::LIGHTFX_NONE : 2296 !strcmp(lightFxMode, CameraParameters::LIGHTFX_LOWLIGHT) ? 2297 Parameters::LIGHTFX_LOWLIGHT : 2298 !strcmp(lightFxMode, CameraParameters::LIGHTFX_HDR) ? 2299 Parameters::LIGHTFX_HDR : 2300 Parameters::LIGHTFX_NONE; 2301} 2302 2303status_t Parameters::parseAreas(const char *areasCStr, 2304 Vector<Parameters::Area> *areas) { 2305 static const size_t NUM_FIELDS = 5; 2306 areas->clear(); 2307 if (areasCStr == NULL) { 2308 // If no key exists, use default (0,0,0,0,0) 2309 areas->push(); 2310 return OK; 2311 } 2312 String8 areasStr(areasCStr); 2313 ssize_t areaStart = areasStr.find("(", 0) + 1; 2314 while (areaStart != 0) { 2315 const char* area = areasStr.string() + areaStart; 2316 char *numEnd; 2317 int vals[NUM_FIELDS]; 2318 for (size_t i = 0; i < NUM_FIELDS; i++) { 2319 errno = 0; 2320 vals[i] = strtol(area, &numEnd, 10); 2321 if (errno || numEnd == area) return BAD_VALUE; 2322 area = numEnd + 1; 2323 } 2324 areas->push(Parameters::Area( 2325 vals[0], vals[1], vals[2], vals[3], vals[4]) ); 2326 areaStart = areasStr.find("(", areaStart) + 1; 2327 } 2328 return OK; 2329} 2330 2331status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas, 2332 size_t maxRegions, 2333 AreaKind areaKind) const { 2334 // Definition of valid area can be found in 2335 // include/camera/CameraParameters.h 2336 if (areas.size() == 0) return BAD_VALUE; 2337 if (areas.size() == 1) { 2338 if (areas[0].left == 0 && 2339 areas[0].top == 0 && 2340 areas[0].right == 0 && 2341 areas[0].bottom == 0 && 2342 areas[0].weight == 0) { 2343 // Single (0,0,0,0,0) entry is always valid (== driver decides) 2344 return OK; 2345 } 2346 } 2347 2348 // fixed focus can only set (0,0,0,0,0) focus area 2349 if (areaKind == AREA_KIND_FOCUS && focusMode == FOCUS_MODE_FIXED) { 2350 return BAD_VALUE; 2351 } 2352 2353 if (areas.size() > maxRegions) { 2354 ALOGE("%s: Too many areas requested: %zu", 2355 __FUNCTION__, areas.size()); 2356 return BAD_VALUE; 2357 } 2358 2359 for (Vector<Parameters::Area>::const_iterator a = areas.begin(); 2360 a != areas.end(); a++) { 2361 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE; 2362 if (a->left < -1000 || a->left > 1000) return BAD_VALUE; 2363 if (a->top < -1000 || a->top > 1000) return BAD_VALUE; 2364 if (a->right < -1000 || a->right > 1000) return BAD_VALUE; 2365 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE; 2366 if (a->left >= a->right) return BAD_VALUE; 2367 if (a->top >= a->bottom) return BAD_VALUE; 2368 } 2369 return OK; 2370} 2371 2372bool Parameters::boolFromString(const char *boolStr) { 2373 return !boolStr ? false : 2374 !strcmp(boolStr, CameraParameters::TRUE) ? true : 2375 false; 2376} 2377 2378int Parameters::degToTransform(int degrees, bool mirror) { 2379 if (!mirror) { 2380 if (degrees == 0) return 0; 2381 else if (degrees == 90) return HAL_TRANSFORM_ROT_90; 2382 else if (degrees == 180) return HAL_TRANSFORM_ROT_180; 2383 else if (degrees == 270) return HAL_TRANSFORM_ROT_270; 2384 } else { // Do mirror (horizontal flip) 2385 if (degrees == 0) { // FLIP_H and ROT_0 2386 return HAL_TRANSFORM_FLIP_H; 2387 } else if (degrees == 90) { // FLIP_H and ROT_90 2388 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90; 2389 } else if (degrees == 180) { // FLIP_H and ROT_180 2390 return HAL_TRANSFORM_FLIP_V; 2391 } else if (degrees == 270) { // FLIP_H and ROT_270 2392 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90; 2393 } 2394 } 2395 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees); 2396 return -1; 2397} 2398 2399int Parameters::cropXToArray(int x) const { 2400 ALOG_ASSERT(x >= 0, "Crop-relative X coordinate = '%d' is out of bounds" 2401 "(lower = 0)", x); 2402 2403 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2404 ALOG_ASSERT(x < previewCrop.width, "Crop-relative X coordinate = '%d' " 2405 "is out of bounds (upper = %f)", x, previewCrop.width); 2406 2407 int ret = x + previewCrop.left; 2408 2409 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayWidth), 2410 "Calculated pixel array value X = '%d' is out of bounds (upper = %d)", 2411 ret, fastInfo.arrayWidth); 2412 return ret; 2413} 2414 2415int Parameters::cropYToArray(int y) const { 2416 ALOG_ASSERT(y >= 0, "Crop-relative Y coordinate = '%d' is out of bounds " 2417 "(lower = 0)", y); 2418 2419 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2420 ALOG_ASSERT(y < previewCrop.height, "Crop-relative Y coordinate = '%d' is " 2421 "out of bounds (upper = %f)", y, previewCrop.height); 2422 2423 int ret = y + previewCrop.top; 2424 2425 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayHeight), 2426 "Calculated pixel array value Y = '%d' is out of bounds (upper = %d)", 2427 ret, fastInfo.arrayHeight); 2428 2429 return ret; 2430 2431} 2432 2433int Parameters::normalizedXToCrop(int x) const { 2434 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2435 return (x + 1000) * (previewCrop.width - 1) / 2000; 2436} 2437 2438int Parameters::normalizedYToCrop(int y) const { 2439 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2440 return (y + 1000) * (previewCrop.height - 1) / 2000; 2441} 2442 2443int Parameters::arrayXToCrop(int x) const { 2444 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2445 return x - previewCrop.left; 2446} 2447 2448int Parameters::arrayYToCrop(int y) const { 2449 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2450 return y - previewCrop.top; 2451} 2452 2453int Parameters::cropXToNormalized(int x) const { 2454 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2455 return x * 2000 / (previewCrop.width - 1) - 1000; 2456} 2457 2458int Parameters::cropYToNormalized(int y) const { 2459 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW); 2460 return y * 2000 / (previewCrop.height - 1) - 1000; 2461} 2462 2463int Parameters::arrayXToNormalized(int width) const { 2464 int ret = cropXToNormalized(arrayXToCrop(width)); 2465 2466 ALOG_ASSERT(ret >= -1000, "Calculated normalized value out of " 2467 "lower bounds %d", ret); 2468 ALOG_ASSERT(ret <= 1000, "Calculated normalized value out of " 2469 "upper bounds %d", ret); 2470 2471 // Work-around for HAL pre-scaling the coordinates themselves 2472 if (quirks.meteringCropRegion) { 2473 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000; 2474 } 2475 2476 return ret; 2477} 2478 2479int Parameters::arrayYToNormalized(int height) const { 2480 int ret = cropYToNormalized(arrayYToCrop(height)); 2481 2482 ALOG_ASSERT(ret >= -1000, "Calculated normalized value out of lower bounds" 2483 " %d", ret); 2484 ALOG_ASSERT(ret <= 1000, "Calculated normalized value out of upper bounds" 2485 " %d", ret); 2486 2487 // Work-around for HAL pre-scaling the coordinates themselves 2488 if (quirks.meteringCropRegion) { 2489 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000; 2490 } 2491 2492 return ret; 2493} 2494 2495int Parameters::normalizedXToArray(int x) const { 2496 2497 // Work-around for HAL pre-scaling the coordinates themselves 2498 if (quirks.meteringCropRegion) { 2499 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000; 2500 } 2501 2502 return cropXToArray(normalizedXToCrop(x)); 2503} 2504 2505int Parameters::normalizedYToArray(int y) const { 2506 // Work-around for HAL pre-scaling the coordinates themselves 2507 if (quirks.meteringCropRegion) { 2508 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000; 2509 } 2510 2511 return cropYToArray(normalizedYToCrop(y)); 2512} 2513 2514status_t Parameters::getFilteredPreviewSizes(Size limit, Vector<Size> *sizes) { 2515 if (info == NULL) { 2516 ALOGE("%s: Static metadata is not initialized", __FUNCTION__); 2517 return NO_INIT; 2518 } 2519 if (sizes == NULL) { 2520 ALOGE("%s: Input size is null", __FUNCTION__); 2521 return BAD_VALUE; 2522 } 2523 2524 const size_t SIZE_COUNT = sizeof(Size) / sizeof(int); 2525 camera_metadata_ro_entry_t availableProcessedSizes = 2526 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, SIZE_COUNT); 2527 if (availableProcessedSizes.count < SIZE_COUNT) return BAD_VALUE; 2528 2529 Size previewSize; 2530 for (size_t i = 0; i < availableProcessedSizes.count; i += SIZE_COUNT) { 2531 previewSize.width = availableProcessedSizes.data.i32[i]; 2532 previewSize.height = availableProcessedSizes.data.i32[i+1]; 2533 // Need skip the preview sizes that are too large. 2534 if (previewSize.width <= limit.width && 2535 previewSize.height <= limit.height) { 2536 sizes->push(previewSize); 2537 } 2538 } 2539 if (sizes->isEmpty()) { 2540 ALOGE("generated preview size list is empty!!"); 2541 return BAD_VALUE; 2542 } 2543 return OK; 2544} 2545 2546Parameters::Size Parameters::getMaxSizeForRatio( 2547 float ratio, const int32_t* sizeArray, size_t count) { 2548 ALOG_ASSERT(sizeArray != NULL, "size array shouldn't be NULL"); 2549 ALOG_ASSERT(count >= 2 && count % 2 == 0, "count must be a positive even number"); 2550 2551 Size maxSize = {0, 0}; 2552 for (size_t i = 0; i < count; i += 2) { 2553 if (sizeArray[i] > 0 && sizeArray[i+1] > 0) { 2554 float curRatio = static_cast<float>(sizeArray[i]) / sizeArray[i+1]; 2555 if (fabs(curRatio - ratio) < ASPECT_RATIO_TOLERANCE && maxSize.width < sizeArray[i]) { 2556 maxSize.width = sizeArray[i]; 2557 maxSize.height = sizeArray[i+1]; 2558 } 2559 } 2560 } 2561 2562 if (maxSize.width == 0 || maxSize.height == 0) { 2563 maxSize.width = sizeArray[0]; 2564 maxSize.height = sizeArray[1]; 2565 ALOGW("Unable to find the size to match the given aspect ratio %f." 2566 "Fall back to %d x %d", ratio, maxSize.width, maxSize.height); 2567 } 2568 2569 return maxSize; 2570} 2571 2572Parameters::CropRegion Parameters::calculateCropRegion( 2573 Parameters::CropRegion::Outputs outputs) const { 2574 2575 float zoomLeft, zoomTop, zoomWidth, zoomHeight; 2576 2577 // Need to convert zoom index into a crop rectangle. The rectangle is 2578 // chosen to maximize its area on the sensor 2579 2580 camera_metadata_ro_entry_t maxDigitalZoom = 2581 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM); 2582 // For each zoom step by how many pixels more do we change the zoom 2583 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) / 2584 (NUM_ZOOM_STEPS-1); 2585 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w) 2586 // via interpolating zoom step into a zoom ratio 2587 float zoomRatio = 1 + zoomIncrement * zoom; 2588 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]), 2589 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f", 2590 maxDigitalZoom.data.f[0], zoomRatio); 2591 2592 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, " 2593 "previewHeight=%d, activeWidth=%d, activeHeight=%d", 2594 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth, 2595 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight); 2596 2597 /* 2598 * Assumption: On the HAL side each stream buffer calculates its crop 2599 * rectangle as follows: 2600 * cropRect = (zoomLeft, zoomRight, 2601 * zoomWidth, zoomHeight * zoomWidth / outputWidth); 2602 * 2603 * Note that if zoomWidth > bufferWidth, the new cropHeight > zoomHeight 2604 * (we can then get into trouble if the cropHeight > arrayHeight). 2605 * By selecting the zoomRatio based on the smallest outputRatio, we 2606 * guarantee this will never happen. 2607 */ 2608 2609 // Enumerate all possible output sizes, select the one with the smallest 2610 // aspect ratio 2611 float minOutputWidth, minOutputHeight, minOutputRatio; 2612 { 2613 float outputSizes[][2] = { 2614 { static_cast<float>(previewWidth), 2615 static_cast<float>(previewHeight) }, 2616 { static_cast<float>(videoWidth), 2617 static_cast<float>(videoHeight) }, 2618 { static_cast<float>(jpegThumbSize[0]), 2619 static_cast<float>(jpegThumbSize[1]) }, 2620 { static_cast<float>(pictureWidth), 2621 static_cast<float>(pictureHeight) }, 2622 }; 2623 2624 minOutputWidth = outputSizes[0][0]; 2625 minOutputHeight = outputSizes[0][1]; 2626 minOutputRatio = minOutputWidth / minOutputHeight; 2627 for (unsigned int i = 0; 2628 i < sizeof(outputSizes) / sizeof(outputSizes[0]); 2629 ++i) { 2630 2631 // skip over outputs we don't want to consider for the crop region 2632 if ( !((1 << i) & outputs) ) { 2633 continue; 2634 } 2635 2636 float outputWidth = outputSizes[i][0]; 2637 float outputHeight = outputSizes[i][1]; 2638 float outputRatio = outputWidth / outputHeight; 2639 2640 if (minOutputRatio > outputRatio) { 2641 minOutputRatio = outputRatio; 2642 minOutputWidth = outputWidth; 2643 minOutputHeight = outputHeight; 2644 } 2645 2646 // and then use this output ratio instead of preview output ratio 2647 ALOGV("Enumerating output ratio %f = %f / %f, min is %f", 2648 outputRatio, outputWidth, outputHeight, minOutputRatio); 2649 } 2650 } 2651 2652 /* Ensure that the width/height never go out of bounds 2653 * by scaling across a diffent dimension if an out-of-bounds 2654 * possibility exists. 2655 * 2656 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by 2657 * calculating the zoomWidth from zoomHeight we'll actually get a 2658 * zoomheight > arrayheight 2659 */ 2660 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight; 2661 if (minOutputRatio >= arrayRatio) { 2662 // Adjust the height based on the width 2663 zoomWidth = fastInfo.arrayWidth / zoomRatio; 2664 zoomHeight = zoomWidth * 2665 minOutputHeight / minOutputWidth; 2666 2667 } else { 2668 // Adjust the width based on the height 2669 zoomHeight = fastInfo.arrayHeight / zoomRatio; 2670 zoomWidth = zoomHeight * 2671 minOutputWidth / minOutputHeight; 2672 } 2673 // centering the zoom area within the active area 2674 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2; 2675 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2; 2676 2677 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d", 2678 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom); 2679 2680 2681 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight }; 2682 return crop; 2683} 2684 2685status_t Parameters::calculatePictureFovs(float *horizFov, float *vertFov) 2686 const { 2687 camera_metadata_ro_entry_t sensorSize = 2688 staticInfo(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 2, 2); 2689 if (!sensorSize.count) return NO_INIT; 2690 2691 float arrayAspect = static_cast<float>(fastInfo.arrayWidth) / 2692 fastInfo.arrayHeight; 2693 float stillAspect = static_cast<float>(pictureWidth) / pictureHeight; 2694 ALOGV("Array aspect: %f, still aspect: %f", arrayAspect, stillAspect); 2695 2696 // The crop factors from the full sensor array to the still picture crop 2697 // region 2698 float horizCropFactor = 1.f; 2699 float vertCropFactor = 1.f; 2700 2701 /** 2702 * Need to calculate the still image field of view based on the total pixel 2703 * array field of view, and the relative aspect ratios of the pixel array 2704 * and output streams. 2705 * 2706 * Special treatment for quirky definition of crop region and relative 2707 * stream cropping. 2708 */ 2709 if (quirks.meteringCropRegion) { 2710 // Use max of preview and video as first crop 2711 float previewAspect = static_cast<float>(previewWidth) / previewHeight; 2712 float videoAspect = static_cast<float>(videoWidth) / videoHeight; 2713 if (videoAspect > previewAspect) { 2714 previewAspect = videoAspect; 2715 } 2716 // First crop sensor to preview aspect ratio 2717 if (arrayAspect < previewAspect) { 2718 vertCropFactor = arrayAspect / previewAspect; 2719 } else { 2720 horizCropFactor = previewAspect / arrayAspect; 2721 } 2722 // Second crop to still aspect ratio 2723 if (stillAspect < previewAspect) { 2724 horizCropFactor *= stillAspect / previewAspect; 2725 } else { 2726 vertCropFactor *= previewAspect / stillAspect; 2727 } 2728 } else { 2729 /** 2730 * Crop are just a function of just the still/array relative aspect 2731 * ratios. Since each stream will maximize its area within the crop 2732 * region, and for FOV we assume a full-sensor crop region, we only ever 2733 * crop the FOV either vertically or horizontally, never both. 2734 */ 2735 horizCropFactor = (arrayAspect > stillAspect) ? 2736 (stillAspect / arrayAspect) : 1.f; 2737 vertCropFactor = (arrayAspect < stillAspect) ? 2738 (arrayAspect / stillAspect) : 1.f; 2739 } 2740 ALOGV("Horiz crop factor: %f, vert crop fact: %f", 2741 horizCropFactor, vertCropFactor); 2742 /** 2743 * Basic field of view formula is: 2744 * angle of view = 2 * arctangent ( d / 2f ) 2745 * where d is the physical sensor dimension of interest, and f is 2746 * the focal length. This only applies to rectilinear sensors, for focusing 2747 * at distances >> f, etc. 2748 */ 2749 if (horizFov != NULL) { 2750 *horizFov = 180 / M_PI * 2 * 2751 atanf(horizCropFactor * sensorSize.data.f[0] / 2752 (2 * fastInfo.minFocalLength)); 2753 } 2754 if (vertFov != NULL) { 2755 *vertFov = 180 / M_PI * 2 * 2756 atanf(vertCropFactor * sensorSize.data.f[1] / 2757 (2 * fastInfo.minFocalLength)); 2758 } 2759 return OK; 2760} 2761 2762int32_t Parameters::fpsFromRange(int32_t /*min*/, int32_t max) const { 2763 return max; 2764} 2765 2766}; // namespace camera2 2767}; // namespace android 2768