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