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