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