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