Parameters.cpp revision e382ee28709b83264a46b09e8f766c5ef42efa35
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 24#include <math.h> 25#include <stdlib.h> 26#include <cutils/properties.h> 27 28#include "Parameters.h" 29#include "system/camera.h" 30 31namespace android { 32namespace camera2 { 33 34Parameters::Parameters(int cameraId, 35 int cameraFacing) : 36 cameraId(cameraId), 37 cameraFacing(cameraFacing), 38 info(NULL) { 39} 40 41Parameters::~Parameters() { 42} 43 44status_t Parameters::initialize(const CameraMetadata *info) { 45 status_t res; 46 47 if (info->entryCount() == 0) { 48 ALOGE("%s: No static information provided!", __FUNCTION__); 49 return BAD_VALUE; 50 } 51 Parameters::info = info; 52 53 res = buildFastInfo(); 54 if (res != OK) return res; 55 56 res = buildQuirks(); 57 if (res != OK) return res; 58 59 camera_metadata_ro_entry_t availableProcessedSizes = 60 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2); 61 if (!availableProcessedSizes.count) return NO_INIT; 62 63 // TODO: Pick more intelligently 64 previewWidth = availableProcessedSizes.data.i32[0]; 65 previewHeight = availableProcessedSizes.data.i32[1]; 66 videoWidth = previewWidth; 67 videoHeight = previewHeight; 68 69 params.setPreviewSize(previewWidth, previewHeight); 70 params.setVideoSize(videoWidth, videoHeight); 71 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, 72 String8::format("%dx%d", 73 previewWidth, previewHeight)); 74 { 75 String8 supportedPreviewSizes; 76 for (size_t i=0; i < availableProcessedSizes.count; i += 2) { 77 if (i != 0) supportedPreviewSizes += ","; 78 supportedPreviewSizes += String8::format("%dx%d", 79 availableProcessedSizes.data.i32[i], 80 availableProcessedSizes.data.i32[i+1]); 81 } 82 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 83 supportedPreviewSizes); 84 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, 85 supportedPreviewSizes); 86 } 87 88 camera_metadata_ro_entry_t availableFpsRanges = 89 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 90 if (!availableFpsRanges.count) return NO_INIT; 91 92 previewFpsRange[0] = availableFpsRanges.data.i32[0]; 93 previewFpsRange[1] = availableFpsRanges.data.i32[1]; 94 95 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 96 String8::format("%d,%d", 97 previewFpsRange[0] * kFpsToApiScale, 98 previewFpsRange[1] * kFpsToApiScale)); 99 100 { 101 String8 supportedPreviewFpsRange; 102 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 103 if (i != 0) supportedPreviewFpsRange += ","; 104 supportedPreviewFpsRange += String8::format("(%d,%d)", 105 availableFpsRanges.data.i32[i] * kFpsToApiScale, 106 availableFpsRanges.data.i32[i+1] * kFpsToApiScale); 107 } 108 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 109 supportedPreviewFpsRange); 110 } 111 112 previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 113 params.set(CameraParameters::KEY_PREVIEW_FORMAT, 114 formatEnumToString(previewFormat)); // NV21 115 116 previewTransform = degToTransform(0, 117 cameraFacing == CAMERA_FACING_FRONT); 118 119 camera_metadata_ro_entry_t availableFormats = 120 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 121 122 { 123 String8 supportedPreviewFormats; 124 bool addComma = false; 125 for (size_t i=0; i < availableFormats.count; i++) { 126 if (addComma) supportedPreviewFormats += ","; 127 addComma = true; 128 switch (availableFormats.data.i32[i]) { 129 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 130 supportedPreviewFormats += 131 CameraParameters::PIXEL_FORMAT_YUV422SP; 132 break; 133 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 134 supportedPreviewFormats += 135 CameraParameters::PIXEL_FORMAT_YUV420SP; 136 break; 137 case HAL_PIXEL_FORMAT_YCbCr_422_I: 138 supportedPreviewFormats += 139 CameraParameters::PIXEL_FORMAT_YUV422I; 140 break; 141 case HAL_PIXEL_FORMAT_YV12: 142 supportedPreviewFormats += 143 CameraParameters::PIXEL_FORMAT_YUV420P; 144 break; 145 case HAL_PIXEL_FORMAT_RGB_565: 146 supportedPreviewFormats += 147 CameraParameters::PIXEL_FORMAT_RGB565; 148 break; 149 case HAL_PIXEL_FORMAT_RGBA_8888: 150 supportedPreviewFormats += 151 CameraParameters::PIXEL_FORMAT_RGBA8888; 152 break; 153 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats 154 case HAL_PIXEL_FORMAT_RAW_SENSOR: 155 case HAL_PIXEL_FORMAT_BLOB: 156 addComma = false; 157 break; 158 159 default: 160 ALOGW("%s: Camera %d: Unknown preview format: %x", 161 __FUNCTION__, cameraId, availableFormats.data.i32[i]); 162 addComma = false; 163 break; 164 } 165 } 166 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 167 supportedPreviewFormats); 168 } 169 170 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but 171 // still have to do something sane for them 172 173 // NOTE: Not scaled like FPS range values are. 174 previewFps = previewFpsRange[0]; 175 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE, 176 previewFpsRange[0]); 177 178 { 179 String8 supportedPreviewFrameRates; 180 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 181 if (i != 0) supportedPreviewFrameRates += ","; 182 supportedPreviewFrameRates += String8::format("%d", 183 availableFpsRanges.data.i32[i]); 184 } 185 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 186 supportedPreviewFrameRates); 187 } 188 189 camera_metadata_ro_entry_t availableJpegSizes = 190 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2); 191 if (!availableJpegSizes.count) return NO_INIT; 192 193 // TODO: Pick maximum 194 pictureWidth = availableJpegSizes.data.i32[0]; 195 pictureHeight = availableJpegSizes.data.i32[1]; 196 197 params.setPictureSize(pictureWidth, 198 pictureHeight); 199 200 { 201 String8 supportedPictureSizes; 202 for (size_t i=0; i < availableJpegSizes.count; i += 2) { 203 if (i != 0) supportedPictureSizes += ","; 204 supportedPictureSizes += String8::format("%dx%d", 205 availableJpegSizes.data.i32[i], 206 availableJpegSizes.data.i32[i+1]); 207 } 208 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 209 supportedPictureSizes); 210 } 211 212 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 213 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 214 CameraParameters::PIXEL_FORMAT_JPEG); 215 216 camera_metadata_ro_entry_t availableJpegThumbnailSizes = 217 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 4); 218 if (!availableJpegThumbnailSizes.count) return NO_INIT; 219 220 // TODO: Pick default thumbnail size sensibly 221 jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0]; 222 jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1]; 223 224 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 225 jpegThumbSize[0]); 226 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 227 jpegThumbSize[1]); 228 229 { 230 String8 supportedJpegThumbSizes; 231 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) { 232 if (i != 0) supportedJpegThumbSizes += ","; 233 supportedJpegThumbSizes += String8::format("%dx%d", 234 availableJpegThumbnailSizes.data.i32[i], 235 availableJpegThumbnailSizes.data.i32[i+1]); 236 } 237 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 238 supportedJpegThumbSizes); 239 } 240 241 jpegThumbQuality = 90; 242 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 243 jpegThumbQuality); 244 jpegQuality = 90; 245 params.set(CameraParameters::KEY_JPEG_QUALITY, 246 jpegQuality); 247 jpegRotation = 0; 248 params.set(CameraParameters::KEY_ROTATION, 249 jpegRotation); 250 251 gpsEnabled = false; 252 gpsProcessingMethod = "unknown"; 253 // GPS fields in CameraParameters are not set by implementation 254 255 wbMode = ANDROID_CONTROL_AWB_AUTO; 256 params.set(CameraParameters::KEY_WHITE_BALANCE, 257 CameraParameters::WHITE_BALANCE_AUTO); 258 259 camera_metadata_ro_entry_t availableWhiteBalanceModes = 260 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 261 { 262 String8 supportedWhiteBalance; 263 bool addComma = false; 264 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) { 265 if (addComma) supportedWhiteBalance += ","; 266 addComma = true; 267 switch (availableWhiteBalanceModes.data.u8[i]) { 268 case ANDROID_CONTROL_AWB_AUTO: 269 supportedWhiteBalance += 270 CameraParameters::WHITE_BALANCE_AUTO; 271 break; 272 case ANDROID_CONTROL_AWB_INCANDESCENT: 273 supportedWhiteBalance += 274 CameraParameters::WHITE_BALANCE_INCANDESCENT; 275 break; 276 case ANDROID_CONTROL_AWB_FLUORESCENT: 277 supportedWhiteBalance += 278 CameraParameters::WHITE_BALANCE_FLUORESCENT; 279 break; 280 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT: 281 supportedWhiteBalance += 282 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 283 break; 284 case ANDROID_CONTROL_AWB_DAYLIGHT: 285 supportedWhiteBalance += 286 CameraParameters::WHITE_BALANCE_DAYLIGHT; 287 break; 288 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT: 289 supportedWhiteBalance += 290 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 291 break; 292 case ANDROID_CONTROL_AWB_TWILIGHT: 293 supportedWhiteBalance += 294 CameraParameters::WHITE_BALANCE_TWILIGHT; 295 break; 296 case ANDROID_CONTROL_AWB_SHADE: 297 supportedWhiteBalance += 298 CameraParameters::WHITE_BALANCE_SHADE; 299 break; 300 // Skipping values not mappable to v1 API 301 case ANDROID_CONTROL_AWB_OFF: 302 addComma = false; 303 break; 304 default: 305 ALOGW("%s: Camera %d: Unknown white balance value: %d", 306 __FUNCTION__, cameraId, 307 availableWhiteBalanceModes.data.u8[i]); 308 addComma = false; 309 break; 310 } 311 } 312 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 313 supportedWhiteBalance); 314 } 315 316 effectMode = ANDROID_CONTROL_EFFECT_OFF; 317 params.set(CameraParameters::KEY_EFFECT, 318 CameraParameters::EFFECT_NONE); 319 320 camera_metadata_ro_entry_t availableEffects = 321 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 322 if (!availableEffects.count) return NO_INIT; 323 { 324 String8 supportedEffects; 325 bool addComma = false; 326 for (size_t i=0; i < availableEffects.count; i++) { 327 if (addComma) supportedEffects += ","; 328 addComma = true; 329 switch (availableEffects.data.u8[i]) { 330 case ANDROID_CONTROL_EFFECT_OFF: 331 supportedEffects += 332 CameraParameters::EFFECT_NONE; 333 break; 334 case ANDROID_CONTROL_EFFECT_MONO: 335 supportedEffects += 336 CameraParameters::EFFECT_MONO; 337 break; 338 case ANDROID_CONTROL_EFFECT_NEGATIVE: 339 supportedEffects += 340 CameraParameters::EFFECT_NEGATIVE; 341 break; 342 case ANDROID_CONTROL_EFFECT_SOLARIZE: 343 supportedEffects += 344 CameraParameters::EFFECT_SOLARIZE; 345 break; 346 case ANDROID_CONTROL_EFFECT_SEPIA: 347 supportedEffects += 348 CameraParameters::EFFECT_SEPIA; 349 break; 350 case ANDROID_CONTROL_EFFECT_POSTERIZE: 351 supportedEffects += 352 CameraParameters::EFFECT_POSTERIZE; 353 break; 354 case ANDROID_CONTROL_EFFECT_WHITEBOARD: 355 supportedEffects += 356 CameraParameters::EFFECT_WHITEBOARD; 357 break; 358 case ANDROID_CONTROL_EFFECT_BLACKBOARD: 359 supportedEffects += 360 CameraParameters::EFFECT_BLACKBOARD; 361 break; 362 case ANDROID_CONTROL_EFFECT_AQUA: 363 supportedEffects += 364 CameraParameters::EFFECT_AQUA; 365 break; 366 default: 367 ALOGW("%s: Camera %d: Unknown effect value: %d", 368 __FUNCTION__, cameraId, availableEffects.data.u8[i]); 369 addComma = false; 370 break; 371 } 372 } 373 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects); 374 } 375 376 antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO; 377 params.set(CameraParameters::KEY_ANTIBANDING, 378 CameraParameters::ANTIBANDING_AUTO); 379 380 camera_metadata_ro_entry_t availableAntibandingModes = 381 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 382 if (!availableAntibandingModes.count) return NO_INIT; 383 { 384 String8 supportedAntibanding; 385 bool addComma = false; 386 for (size_t i=0; i < availableAntibandingModes.count; i++) { 387 if (addComma) supportedAntibanding += ","; 388 addComma = true; 389 switch (availableAntibandingModes.data.u8[i]) { 390 case ANDROID_CONTROL_AE_ANTIBANDING_OFF: 391 supportedAntibanding += 392 CameraParameters::ANTIBANDING_OFF; 393 break; 394 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ: 395 supportedAntibanding += 396 CameraParameters::ANTIBANDING_50HZ; 397 break; 398 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ: 399 supportedAntibanding += 400 CameraParameters::ANTIBANDING_60HZ; 401 break; 402 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO: 403 supportedAntibanding += 404 CameraParameters::ANTIBANDING_AUTO; 405 break; 406 default: 407 ALOGW("%s: Camera %d: Unknown antibanding value: %d", 408 __FUNCTION__, cameraId, 409 availableAntibandingModes.data.u8[i]); 410 addComma = false; 411 break; 412 } 413 } 414 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 415 supportedAntibanding); 416 } 417 418 sceneMode = ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 419 params.set(CameraParameters::KEY_SCENE_MODE, 420 CameraParameters::SCENE_MODE_AUTO); 421 422 camera_metadata_ro_entry_t availableSceneModes = 423 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 424 if (!availableSceneModes.count) return NO_INIT; 425 { 426 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO); 427 bool addComma = true; 428 bool noSceneModes = false; 429 for (size_t i=0; i < availableSceneModes.count; i++) { 430 if (addComma) supportedSceneModes += ","; 431 addComma = true; 432 switch (availableSceneModes.data.u8[i]) { 433 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 434 noSceneModes = true; 435 break; 436 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 437 // Not in old API 438 addComma = false; 439 break; 440 case ANDROID_CONTROL_SCENE_MODE_ACTION: 441 supportedSceneModes += 442 CameraParameters::SCENE_MODE_ACTION; 443 break; 444 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT: 445 supportedSceneModes += 446 CameraParameters::SCENE_MODE_PORTRAIT; 447 break; 448 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE: 449 supportedSceneModes += 450 CameraParameters::SCENE_MODE_LANDSCAPE; 451 break; 452 case ANDROID_CONTROL_SCENE_MODE_NIGHT: 453 supportedSceneModes += 454 CameraParameters::SCENE_MODE_NIGHT; 455 break; 456 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT: 457 supportedSceneModes += 458 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT; 459 break; 460 case ANDROID_CONTROL_SCENE_MODE_THEATRE: 461 supportedSceneModes += 462 CameraParameters::SCENE_MODE_THEATRE; 463 break; 464 case ANDROID_CONTROL_SCENE_MODE_BEACH: 465 supportedSceneModes += 466 CameraParameters::SCENE_MODE_BEACH; 467 break; 468 case ANDROID_CONTROL_SCENE_MODE_SNOW: 469 supportedSceneModes += 470 CameraParameters::SCENE_MODE_SNOW; 471 break; 472 case ANDROID_CONTROL_SCENE_MODE_SUNSET: 473 supportedSceneModes += 474 CameraParameters::SCENE_MODE_SUNSET; 475 break; 476 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO: 477 supportedSceneModes += 478 CameraParameters::SCENE_MODE_STEADYPHOTO; 479 break; 480 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS: 481 supportedSceneModes += 482 CameraParameters::SCENE_MODE_FIREWORKS; 483 break; 484 case ANDROID_CONTROL_SCENE_MODE_SPORTS: 485 supportedSceneModes += 486 CameraParameters::SCENE_MODE_SPORTS; 487 break; 488 case ANDROID_CONTROL_SCENE_MODE_PARTY: 489 supportedSceneModes += 490 CameraParameters::SCENE_MODE_PARTY; 491 break; 492 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT: 493 supportedSceneModes += 494 CameraParameters::SCENE_MODE_CANDLELIGHT; 495 break; 496 case ANDROID_CONTROL_SCENE_MODE_BARCODE: 497 supportedSceneModes += 498 CameraParameters::SCENE_MODE_BARCODE; 499 break; 500 default: 501 ALOGW("%s: Camera %d: Unknown scene mode value: %d", 502 __FUNCTION__, cameraId, 503 availableSceneModes.data.u8[i]); 504 addComma = false; 505 break; 506 } 507 } 508 if (!noSceneModes) { 509 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 510 supportedSceneModes); 511 } 512 } 513 514 camera_metadata_ro_entry_t flashAvailable = 515 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 516 if (!flashAvailable.count) return NO_INIT; 517 518 camera_metadata_ro_entry_t availableAeModes = 519 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 520 if (!availableAeModes.count) return NO_INIT; 521 522 if (flashAvailable.data.u8[0]) { 523 flashMode = Parameters::FLASH_MODE_AUTO; 524 params.set(CameraParameters::KEY_FLASH_MODE, 525 CameraParameters::FLASH_MODE_AUTO); 526 527 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF); 528 supportedFlashModes = supportedFlashModes + 529 "," + CameraParameters::FLASH_MODE_AUTO + 530 "," + CameraParameters::FLASH_MODE_ON + 531 "," + CameraParameters::FLASH_MODE_TORCH; 532 for (size_t i=0; i < availableAeModes.count; i++) { 533 if (availableAeModes.data.u8[i] == 534 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) { 535 supportedFlashModes = supportedFlashModes + "," + 536 CameraParameters::FLASH_MODE_RED_EYE; 537 break; 538 } 539 } 540 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 541 supportedFlashModes); 542 } else { 543 flashMode = Parameters::FLASH_MODE_OFF; 544 params.set(CameraParameters::KEY_FLASH_MODE, 545 CameraParameters::FLASH_MODE_OFF); 546 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 547 CameraParameters::FLASH_MODE_OFF); 548 } 549 550 camera_metadata_ro_entry_t minFocusDistance = 551 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1); 552 if (!minFocusDistance.count) return NO_INIT; 553 554 camera_metadata_ro_entry_t availableAfModes = 555 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 556 if (!availableAfModes.count) return NO_INIT; 557 558 if (minFocusDistance.data.f[0] == 0) { 559 // Fixed-focus lens 560 focusMode = Parameters::FOCUS_MODE_FIXED; 561 params.set(CameraParameters::KEY_FOCUS_MODE, 562 CameraParameters::FOCUS_MODE_FIXED); 563 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 564 CameraParameters::FOCUS_MODE_FIXED); 565 } else { 566 focusMode = Parameters::FOCUS_MODE_AUTO; 567 params.set(CameraParameters::KEY_FOCUS_MODE, 568 CameraParameters::FOCUS_MODE_AUTO); 569 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_INFINITY); 570 bool addComma = true; 571 572 for (size_t i=0; i < availableAfModes.count; i++) { 573 if (addComma) supportedFocusModes += ","; 574 addComma = true; 575 switch (availableAfModes.data.u8[i]) { 576 case ANDROID_CONTROL_AF_AUTO: 577 supportedFocusModes += 578 CameraParameters::FOCUS_MODE_AUTO; 579 break; 580 case ANDROID_CONTROL_AF_MACRO: 581 supportedFocusModes += 582 CameraParameters::FOCUS_MODE_MACRO; 583 break; 584 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO: 585 supportedFocusModes += 586 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 587 break; 588 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE: 589 supportedFocusModes += 590 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 591 break; 592 case ANDROID_CONTROL_AF_EDOF: 593 supportedFocusModes += 594 CameraParameters::FOCUS_MODE_EDOF; 595 break; 596 // Not supported in old API 597 case ANDROID_CONTROL_AF_OFF: 598 addComma = false; 599 break; 600 default: 601 ALOGW("%s: Camera %d: Unknown AF mode value: %d", 602 __FUNCTION__, cameraId, availableAfModes.data.u8[i]); 603 addComma = false; 604 break; 605 } 606 } 607 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 608 supportedFocusModes); 609 } 610 611 camera_metadata_ro_entry_t max3aRegions = 612 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1); 613 if (!max3aRegions.count) return NO_INIT; 614 615 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, 616 max3aRegions.data.i32[0]); 617 params.set(CameraParameters::KEY_FOCUS_AREAS, 618 "(0,0,0,0,0)"); 619 focusingAreas.clear(); 620 focusingAreas.add(Parameters::Area(0,0,0,0,0)); 621 622 camera_metadata_ro_entry_t availableFocalLengths = 623 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS); 624 if (!availableFocalLengths.count) return NO_INIT; 625 626 float minFocalLength = availableFocalLengths.data.f[0]; 627 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength); 628 629 camera_metadata_ro_entry_t sensorSize = 630 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2); 631 if (!sensorSize.count) return NO_INIT; 632 633 // The fields of view here assume infinity focus, maximum wide angle 634 float horizFov = 180 / M_PI * 635 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength)); 636 float vertFov = 180 / M_PI * 637 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength)); 638 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 639 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 640 641 exposureCompensation = 0; 642 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 643 exposureCompensation); 644 645 camera_metadata_ro_entry_t exposureCompensationRange = 646 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2); 647 if (!exposureCompensationRange.count) return NO_INIT; 648 649 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 650 exposureCompensationRange.data.i32[1]); 651 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 652 exposureCompensationRange.data.i32[0]); 653 654 camera_metadata_ro_entry_t exposureCompensationStep = 655 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1); 656 if (!exposureCompensationStep.count) return NO_INIT; 657 658 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 659 (float)exposureCompensationStep.data.r[0].numerator / 660 exposureCompensationStep.data.r[0].denominator); 661 662 autoExposureLock = false; 663 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 664 CameraParameters::FALSE); 665 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 666 CameraParameters::TRUE); 667 668 autoWhiteBalanceLock = false; 669 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 670 CameraParameters::FALSE); 671 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 672 CameraParameters::TRUE); 673 674 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 675 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 676 max3aRegions.data.i32[0]); 677 params.set(CameraParameters::KEY_METERING_AREAS, 678 "(0,0,0,0,0)"); 679 680 zoom = 0; 681 params.set(CameraParameters::KEY_ZOOM, zoom); 682 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 683 684 camera_metadata_ro_entry_t maxDigitalZoom = 685 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, /*minCount*/1, /*maxCount*/1); 686 if (!maxDigitalZoom.count) return NO_INIT; 687 688 { 689 String8 zoomRatios; 690 float zoom = 1.f; 691 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 692 (NUM_ZOOM_STEPS-1); 693 bool addComma = false; 694 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 695 if (addComma) zoomRatios += ","; 696 addComma = true; 697 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 698 zoom += zoomIncrement; 699 } 700 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 701 } 702 703 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 704 CameraParameters::TRUE); 705 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 706 CameraParameters::TRUE); 707 708 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 709 "Infinity,Infinity,Infinity"); 710 711 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 712 fastInfo.maxFaces); 713 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 714 0); 715 716 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 717 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE); 718 719 params.set(CameraParameters::KEY_RECORDING_HINT, 720 CameraParameters::FALSE); 721 722 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 723 CameraParameters::TRUE); 724 725 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 726 CameraParameters::FALSE); 727 728 camera_metadata_ro_entry_t availableVideoStabilizationModes = 729 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 730 if (!availableVideoStabilizationModes.count) return NO_INIT; 731 732 if (availableVideoStabilizationModes.count > 1) { 733 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 734 CameraParameters::TRUE); 735 } else { 736 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 737 CameraParameters::FALSE); 738 } 739 740 // Set up initial state for non-Camera.Parameters state variables 741 742 storeMetadataInBuffers = true; 743 playShutterSound = true; 744 enableFaceDetect = false; 745 746 enableFocusMoveMessages = false; 747 afTriggerCounter = 1; 748 currentAfTriggerId = -1; 749 750 precaptureTriggerCounter = 1; 751 752 previewCallbackFlags = 0; 753 754 char value[PROPERTY_VALUE_MAX]; 755 property_get("camera.disable_zsl_mode", value, "0"); 756 if (!strcmp(value,"1")) { 757 ALOGI("Camera %d: Disabling ZSL mode", cameraId); 758 zslMode = false; 759 } else { 760 zslMode = true; 761 } 762 763 lightFx = LIGHTFX_NONE; 764 765 state = STOPPED; 766 767 paramsFlattened = params.flatten(); 768 769 return OK; 770} 771 772String8 Parameters::get() const { 773 return paramsFlattened; 774} 775 776status_t Parameters::buildFastInfo() { 777 778 camera_metadata_ro_entry_t activeArraySize = 779 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2); 780 if (!activeArraySize.count) return NO_INIT; 781 int32_t arrayWidth = activeArraySize.data.i32[0]; 782 int32_t arrayHeight = activeArraySize.data.i32[1]; 783 784 camera_metadata_ro_entry_t availableFaceDetectModes = 785 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES); 786 if (!availableFaceDetectModes.count) return NO_INIT; 787 788 uint8_t bestFaceDetectMode = 789 ANDROID_STATS_FACE_DETECTION_OFF; 790 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) { 791 switch (availableFaceDetectModes.data.u8[i]) { 792 case ANDROID_STATS_FACE_DETECTION_OFF: 793 break; 794 case ANDROID_STATS_FACE_DETECTION_SIMPLE: 795 if (bestFaceDetectMode != 796 ANDROID_STATS_FACE_DETECTION_FULL) { 797 bestFaceDetectMode = 798 ANDROID_STATS_FACE_DETECTION_SIMPLE; 799 } 800 break; 801 case ANDROID_STATS_FACE_DETECTION_FULL: 802 bestFaceDetectMode = 803 ANDROID_STATS_FACE_DETECTION_FULL; 804 break; 805 default: 806 ALOGE("%s: Camera %d: Unknown face detect mode %d:", 807 __FUNCTION__, cameraId, 808 availableFaceDetectModes.data.u8[i]); 809 return NO_INIT; 810 } 811 } 812 813 camera_metadata_ro_entry_t maxFacesDetected = 814 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1); 815 if (!maxFacesDetected.count) return NO_INIT; 816 817 int32_t maxFaces = maxFacesDetected.data.i32[0]; 818 819 camera_metadata_ro_entry_t availableSceneModes = 820 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 821 camera_metadata_ro_entry_t sceneModeOverrides = 822 staticInfo(ANDROID_CONTROL_SCENE_MODE_OVERRIDES); 823 camera_metadata_ro_entry_t minFocusDistance = 824 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE); 825 bool fixedLens = (minFocusDistance.data.f[0] == 0); 826 827 if (sceneModeOverrides.count > 0) { 828 // sceneModeOverrides is defined to have 3 entries for each scene mode, 829 // which are AE, AWB, and AF override modes the HAL wants for that scene 830 // mode. 831 const size_t kModesPerSceneMode = 3; 832 if (sceneModeOverrides.count != 833 availableSceneModes.count * kModesPerSceneMode) { 834 ALOGE("%s: Camera %d: Scene mode override list is an " 835 "unexpected size: %d (expected %d)", __FUNCTION__, 836 cameraId, sceneModeOverrides.count, 837 availableSceneModes.count); 838 return NO_INIT; 839 } 840 for (size_t i = 0; i < availableSceneModes.count; i++) { 841 DeviceInfo::OverrideModes modes; 842 uint8_t aeMode = 843 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 0]; 844 switch(aeMode) { 845 case ANDROID_CONTROL_AE_ON: 846 modes.flashMode = FLASH_MODE_OFF; 847 break; 848 case ANDROID_CONTROL_AE_ON_AUTO_FLASH: 849 modes.flashMode = FLASH_MODE_AUTO; 850 break; 851 case ANDROID_CONTROL_AE_ON_ALWAYS_FLASH: 852 modes.flashMode = FLASH_MODE_ON; 853 break; 854 case ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE: 855 modes.flashMode = FLASH_MODE_RED_EYE; 856 break; 857 default: 858 ALOGE("%s: Unknown override AE mode: %d", __FUNCTION__, 859 aeMode); 860 modes.flashMode = FLASH_MODE_INVALID; 861 break; 862 } 863 modes.wbMode = 864 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 1]; 865 uint8_t afMode = 866 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 2]; 867 switch(afMode) { 868 case ANDROID_CONTROL_AF_OFF: 869 modes.focusMode = fixedLens ? 870 FOCUS_MODE_FIXED : FOCUS_MODE_INFINITY; 871 break; 872 case ANDROID_CONTROL_AF_AUTO: 873 case ANDROID_CONTROL_AF_MACRO: 874 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO: 875 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE: 876 case ANDROID_CONTROL_AF_EDOF: 877 modes.focusMode = static_cast<focusMode_t>(afMode); 878 break; 879 default: 880 ALOGE("%s: Unknown override AF mode: %d", __FUNCTION__, 881 afMode); 882 modes.focusMode = FOCUS_MODE_INVALID; 883 break; 884 } 885 fastInfo.sceneModeOverrides.add(availableSceneModes.data.u8[i], 886 modes); 887 } 888 } 889 890 fastInfo.arrayWidth = arrayWidth; 891 fastInfo.arrayHeight = arrayHeight; 892 fastInfo.bestFaceDetectMode = bestFaceDetectMode; 893 fastInfo.maxFaces = maxFaces; 894 return OK; 895} 896 897status_t Parameters::buildQuirks() { 898 camera_metadata_ro_entry_t entry; 899 entry = info->find(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO); 900 quirks.triggerAfWithAuto = (entry.count != 0 && entry.data.u8[0] == 1); 901 ALOGV_IF(quirks.triggerAfWithAuto, "Camera %d: Quirk triggerAfWithAuto enabled", 902 cameraId); 903 904 entry = info->find(ANDROID_QUIRKS_USE_ZSL_FORMAT); 905 quirks.useZslFormat = (entry.count != 0 && entry.data.u8[0] == 1); 906 ALOGV_IF(quirks.useZslFormat, "Camera %d: Quirk useZslFormat enabled", 907 cameraId); 908 909 return OK; 910} 911 912camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag, 913 size_t minCount, size_t maxCount) const { 914 status_t res; 915 camera_metadata_ro_entry_t entry = info->find(tag); 916 917 if (CC_UNLIKELY( entry.count == 0 )) { 918 const char* tagSection = get_camera_metadata_section_name(tag); 919 if (tagSection == NULL) tagSection = "<unknown>"; 920 const char* tagName = get_camera_metadata_tag_name(tag); 921 if (tagName == NULL) tagName = "<unknown>"; 922 923 ALOGE("Error finding static metadata entry '%s.%s' (%x)", 924 tagSection, tagName, tag); 925 } else if (CC_UNLIKELY( 926 (minCount != 0 && entry.count < minCount) || 927 (maxCount != 0 && entry.count > maxCount) ) ) { 928 const char* tagSection = get_camera_metadata_section_name(tag); 929 if (tagSection == NULL) tagSection = "<unknown>"; 930 const char* tagName = get_camera_metadata_tag_name(tag); 931 if (tagName == NULL) tagName = "<unknown>"; 932 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 933 "Expected between %d and %d values, but got %d values", 934 tagSection, tagName, tag, minCount, maxCount, entry.count); 935 } 936 937 return entry; 938} 939 940status_t Parameters::set(const String8& paramString) { 941 status_t res; 942 943 CameraParameters newParams(paramString); 944 945 // TODO: Currently ignoring any changes to supposedly read-only parameters 946 // such as supported preview sizes, etc. Should probably produce an error if 947 // they're changed. 948 949 /** Extract and verify new parameters */ 950 951 size_t i; 952 953 Parameters validatedParams(*this); 954 955 // PREVIEW_SIZE 956 newParams.getPreviewSize(&validatedParams.previewWidth, 957 &validatedParams.previewHeight); 958 959 if (validatedParams.previewWidth != previewWidth || 960 validatedParams.previewHeight != previewHeight) { 961 if (state >= PREVIEW) { 962 ALOGE("%s: Preview size cannot be updated when preview " 963 "is active! (Currently %d x %d, requested %d x %d", 964 __FUNCTION__, 965 previewWidth, previewHeight, 966 validatedParams.previewWidth, validatedParams.previewHeight); 967 return BAD_VALUE; 968 } 969 camera_metadata_ro_entry_t availablePreviewSizes = 970 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 971 for (i = 0; i < availablePreviewSizes.count; i += 2 ) { 972 if ((availablePreviewSizes.data.i32[i] == 973 validatedParams.previewWidth) && 974 (availablePreviewSizes.data.i32[i+1] == 975 validatedParams.previewHeight)) break; 976 } 977 if (i == availablePreviewSizes.count) { 978 ALOGE("%s: Requested preview size %d x %d is not supported", 979 __FUNCTION__, validatedParams.previewWidth, 980 validatedParams.previewHeight); 981 return BAD_VALUE; 982 } 983 } 984 985 // PREVIEW_FPS_RANGE 986 bool fpsRangeChanged = false; 987 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0], 988 &validatedParams.previewFpsRange[1]); 989 validatedParams.previewFpsRange[0] /= kFpsToApiScale; 990 validatedParams.previewFpsRange[1] /= kFpsToApiScale; 991 992 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] || 993 validatedParams.previewFpsRange[1] != previewFpsRange[1]) { 994 fpsRangeChanged = true; 995 camera_metadata_ro_entry_t availablePreviewFpsRanges = 996 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 997 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) { 998 if ((availablePreviewFpsRanges.data.i32[i] == 999 validatedParams.previewFpsRange[0]) && 1000 (availablePreviewFpsRanges.data.i32[i+1] == 1001 validatedParams.previewFpsRange[1]) ) { 1002 break; 1003 } 1004 } 1005 if (i == availablePreviewFpsRanges.count) { 1006 ALOGE("%s: Requested preview FPS range %d - %d is not supported", 1007 __FUNCTION__, validatedParams.previewFpsRange[0], 1008 validatedParams.previewFpsRange[1]); 1009 return BAD_VALUE; 1010 } 1011 validatedParams.previewFps = validatedParams.previewFpsRange[0]; 1012 newParams.setPreviewFrameRate(validatedParams.previewFps); 1013 } 1014 1015 // PREVIEW_FORMAT 1016 validatedParams.previewFormat = 1017 formatStringToEnum(newParams.getPreviewFormat()); 1018 if (validatedParams.previewFormat != previewFormat) { 1019 if (state >= PREVIEW) { 1020 ALOGE("%s: Preview format cannot be updated when preview " 1021 "is active!", __FUNCTION__); 1022 return BAD_VALUE; 1023 } 1024 camera_metadata_ro_entry_t availableFormats = 1025 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 1026 for (i = 0; i < availableFormats.count; i++) { 1027 if (availableFormats.data.i32[i] == validatedParams.previewFormat) 1028 break; 1029 } 1030 if (i == availableFormats.count) { 1031 ALOGE("%s: Requested preview format %s (0x%x) is not supported", 1032 __FUNCTION__, newParams.getPreviewFormat(), 1033 validatedParams.previewFormat); 1034 return BAD_VALUE; 1035 } 1036 } 1037 1038 // PREVIEW_FRAME_RATE 1039 // Deprecated, only use if the preview fps range is unchanged this time. 1040 // The single-value FPS is the same as the minimum of the range. 1041 if (!fpsRangeChanged) { 1042 validatedParams.previewFps = newParams.getPreviewFrameRate(); 1043 if (validatedParams.previewFps != previewFps) { 1044 camera_metadata_ro_entry_t availableFrameRates = 1045 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES); 1046 for (i = 0; i < availableFrameRates.count; i+=2) { 1047 if (availableFrameRates.data.i32[i] == 1048 validatedParams.previewFps) break; 1049 } 1050 if (i == availableFrameRates.count) { 1051 ALOGE("%s: Requested preview frame rate %d is not supported", 1052 __FUNCTION__, validatedParams.previewFps); 1053 return BAD_VALUE; 1054 } 1055 validatedParams.previewFpsRange[0] = 1056 availableFrameRates.data.i32[i]; 1057 validatedParams.previewFpsRange[1] = 1058 availableFrameRates.data.i32[i+1]; 1059 } 1060 } 1061 1062 // PICTURE_SIZE 1063 newParams.getPictureSize(&validatedParams.pictureWidth, 1064 &validatedParams.pictureHeight); 1065 if (validatedParams.pictureWidth == pictureWidth || 1066 validatedParams.pictureHeight == pictureHeight) { 1067 camera_metadata_ro_entry_t availablePictureSizes = 1068 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES); 1069 for (i = 0; i < availablePictureSizes.count; i+=2) { 1070 if ((availablePictureSizes.data.i32[i] == 1071 validatedParams.pictureWidth) && 1072 (availablePictureSizes.data.i32[i+1] == 1073 validatedParams.pictureHeight)) break; 1074 } 1075 if (i == availablePictureSizes.count) { 1076 ALOGE("%s: Requested picture size %d x %d is not supported", 1077 __FUNCTION__, validatedParams.pictureWidth, 1078 validatedParams.pictureHeight); 1079 return BAD_VALUE; 1080 } 1081 } 1082 1083 // JPEG_THUMBNAIL_WIDTH/HEIGHT 1084 validatedParams.jpegThumbSize[0] = 1085 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 1086 validatedParams.jpegThumbSize[1] = 1087 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 1088 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] || 1089 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) { 1090 camera_metadata_ro_entry_t availableJpegThumbSizes = 1091 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES); 1092 for (i = 0; i < availableJpegThumbSizes.count; i+=2) { 1093 if ((availableJpegThumbSizes.data.i32[i] == 1094 validatedParams.jpegThumbSize[0]) && 1095 (availableJpegThumbSizes.data.i32[i+1] == 1096 validatedParams.jpegThumbSize[1])) break; 1097 } 1098 if (i == availableJpegThumbSizes.count) { 1099 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported", 1100 __FUNCTION__, validatedParams.jpegThumbSize[0], 1101 validatedParams.jpegThumbSize[1]); 1102 return BAD_VALUE; 1103 } 1104 } 1105 1106 // JPEG_THUMBNAIL_QUALITY 1107 validatedParams.jpegThumbQuality = 1108 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 1109 if (validatedParams.jpegThumbQuality < 0 || 1110 validatedParams.jpegThumbQuality > 100) { 1111 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported", 1112 __FUNCTION__, validatedParams.jpegThumbQuality); 1113 return BAD_VALUE; 1114 } 1115 1116 // JPEG_QUALITY 1117 validatedParams.jpegQuality = 1118 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY); 1119 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) { 1120 ALOGE("%s: Requested JPEG quality %d is not supported", 1121 __FUNCTION__, validatedParams.jpegQuality); 1122 return BAD_VALUE; 1123 } 1124 1125 // ROTATION 1126 validatedParams.jpegRotation = 1127 newParams.getInt(CameraParameters::KEY_ROTATION); 1128 if (validatedParams.jpegRotation != 0 && 1129 validatedParams.jpegRotation != 90 && 1130 validatedParams.jpegRotation != 180 && 1131 validatedParams.jpegRotation != 270) { 1132 ALOGE("%s: Requested picture rotation angle %d is not supported", 1133 __FUNCTION__, validatedParams.jpegRotation); 1134 return BAD_VALUE; 1135 } 1136 1137 // GPS 1138 1139 const char *gpsLatStr = 1140 newParams.get(CameraParameters::KEY_GPS_LATITUDE); 1141 if (gpsLatStr != NULL) { 1142 const char *gpsLongStr = 1143 newParams.get(CameraParameters::KEY_GPS_LONGITUDE); 1144 const char *gpsAltitudeStr = 1145 newParams.get(CameraParameters::KEY_GPS_ALTITUDE); 1146 const char *gpsTimeStr = 1147 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP); 1148 const char *gpsProcMethodStr = 1149 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 1150 if (gpsLongStr == NULL || 1151 gpsAltitudeStr == NULL || 1152 gpsTimeStr == NULL || 1153 gpsProcMethodStr == NULL) { 1154 ALOGE("%s: Incomplete set of GPS parameters provided", 1155 __FUNCTION__); 1156 return BAD_VALUE; 1157 } 1158 char *endPtr; 1159 errno = 0; 1160 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr); 1161 if (errno || endPtr == gpsLatStr) { 1162 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr); 1163 return BAD_VALUE; 1164 } 1165 errno = 0; 1166 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr); 1167 if (errno || endPtr == gpsLongStr) { 1168 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr); 1169 return BAD_VALUE; 1170 } 1171 errno = 0; 1172 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr); 1173 if (errno || endPtr == gpsAltitudeStr) { 1174 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__, 1175 gpsAltitudeStr); 1176 return BAD_VALUE; 1177 } 1178 errno = 0; 1179 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10); 1180 if (errno || endPtr == gpsTimeStr) { 1181 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr); 1182 return BAD_VALUE; 1183 } 1184 validatedParams.gpsProcessingMethod = gpsProcMethodStr; 1185 1186 validatedParams.gpsEnabled = true; 1187 } else { 1188 validatedParams.gpsEnabled = false; 1189 } 1190 1191 // EFFECT 1192 validatedParams.effectMode = effectModeStringToEnum( 1193 newParams.get(CameraParameters::KEY_EFFECT) ); 1194 if (validatedParams.effectMode != effectMode) { 1195 camera_metadata_ro_entry_t availableEffectModes = 1196 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 1197 for (i = 0; i < availableEffectModes.count; i++) { 1198 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break; 1199 } 1200 if (i == availableEffectModes.count) { 1201 ALOGE("%s: Requested effect mode \"%s\" is not supported", 1202 __FUNCTION__, 1203 newParams.get(CameraParameters::KEY_EFFECT) ); 1204 return BAD_VALUE; 1205 } 1206 } 1207 1208 // ANTIBANDING 1209 validatedParams.antibandingMode = abModeStringToEnum( 1210 newParams.get(CameraParameters::KEY_ANTIBANDING) ); 1211 if (validatedParams.antibandingMode != antibandingMode) { 1212 camera_metadata_ro_entry_t availableAbModes = 1213 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 1214 for (i = 0; i < availableAbModes.count; i++) { 1215 if (validatedParams.antibandingMode == availableAbModes.data.u8[i]) 1216 break; 1217 } 1218 if (i == availableAbModes.count) { 1219 ALOGE("%s: Requested antibanding mode \"%s\" is not supported", 1220 __FUNCTION__, 1221 newParams.get(CameraParameters::KEY_ANTIBANDING)); 1222 return BAD_VALUE; 1223 } 1224 } 1225 1226 // SCENE_MODE 1227 validatedParams.sceneMode = sceneModeStringToEnum( 1228 newParams.get(CameraParameters::KEY_SCENE_MODE) ); 1229 if (validatedParams.sceneMode != sceneMode && 1230 validatedParams.sceneMode != 1231 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) { 1232 camera_metadata_ro_entry_t availableSceneModes = 1233 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 1234 for (i = 0; i < availableSceneModes.count; i++) { 1235 if (validatedParams.sceneMode == availableSceneModes.data.u8[i]) 1236 break; 1237 } 1238 if (i == availableSceneModes.count) { 1239 ALOGE("%s: Requested scene mode \"%s\" is not supported", 1240 __FUNCTION__, 1241 newParams.get(CameraParameters::KEY_SCENE_MODE)); 1242 return BAD_VALUE; 1243 } 1244 } 1245 bool sceneModeSet = 1246 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 1247 1248 // FLASH_MODE 1249 if (sceneModeSet) { 1250 validatedParams.flashMode = 1251 fastInfo.sceneModeOverrides. 1252 valueFor(validatedParams.sceneMode).flashMode; 1253 } else { 1254 validatedParams.flashMode = FLASH_MODE_INVALID; 1255 } 1256 if (validatedParams.flashMode == FLASH_MODE_INVALID) { 1257 validatedParams.flashMode = flashModeStringToEnum( 1258 newParams.get(CameraParameters::KEY_FLASH_MODE) ); 1259 } 1260 1261 if (validatedParams.flashMode != flashMode) { 1262 camera_metadata_ro_entry_t flashAvailable = 1263 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 1264 if (!flashAvailable.data.u8[0] && 1265 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) { 1266 ALOGE("%s: Requested flash mode \"%s\" is not supported: " 1267 "No flash on device", __FUNCTION__, 1268 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1269 return BAD_VALUE; 1270 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) { 1271 camera_metadata_ro_entry_t availableAeModes = 1272 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 1273 for (i = 0; i < availableAeModes.count; i++) { 1274 if (validatedParams.flashMode == availableAeModes.data.u8[i]) 1275 break; 1276 } 1277 if (i == availableAeModes.count) { 1278 ALOGE("%s: Requested flash mode \"%s\" is not supported", 1279 __FUNCTION__, 1280 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1281 return BAD_VALUE; 1282 } 1283 } else if (validatedParams.flashMode == -1) { 1284 ALOGE("%s: Requested flash mode \"%s\" is unknown", 1285 __FUNCTION__, 1286 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1287 return BAD_VALUE; 1288 } 1289 // Update in case of override 1290 newParams.set(CameraParameters::KEY_FLASH_MODE, 1291 flashModeEnumToString(validatedParams.flashMode)); 1292 } 1293 1294 // WHITE_BALANCE 1295 if (sceneModeSet) { 1296 validatedParams.wbMode = 1297 fastInfo.sceneModeOverrides. 1298 valueFor(validatedParams.sceneMode).wbMode; 1299 } else { 1300 validatedParams.wbMode = ANDROID_CONTROL_AWB_OFF; 1301 } 1302 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_OFF) { 1303 validatedParams.wbMode = wbModeStringToEnum( 1304 newParams.get(CameraParameters::KEY_WHITE_BALANCE) ); 1305 } 1306 if (validatedParams.wbMode != wbMode) { 1307 camera_metadata_ro_entry_t availableWbModes = 1308 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 1309 for (i = 0; i < availableWbModes.count; i++) { 1310 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break; 1311 } 1312 if (i == availableWbModes.count) { 1313 ALOGE("%s: Requested white balance mode %s is not supported", 1314 __FUNCTION__, 1315 newParams.get(CameraParameters::KEY_WHITE_BALANCE)); 1316 return BAD_VALUE; 1317 } 1318 // Update in case of override 1319 newParams.set(CameraParameters::KEY_WHITE_BALANCE, 1320 wbModeEnumToString(validatedParams.wbMode)); 1321 } 1322 1323 // FOCUS_MODE 1324 if (sceneModeSet) { 1325 validatedParams.focusMode = 1326 fastInfo.sceneModeOverrides. 1327 valueFor(validatedParams.sceneMode).focusMode; 1328 } else { 1329 validatedParams.focusMode = FOCUS_MODE_INVALID; 1330 } 1331 if (validatedParams.focusMode == FOCUS_MODE_INVALID) { 1332 validatedParams.focusMode = focusModeStringToEnum( 1333 newParams.get(CameraParameters::KEY_FOCUS_MODE) ); 1334 } 1335 if (validatedParams.focusMode != focusMode) { 1336 validatedParams.currentAfTriggerId = -1; 1337 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) { 1338 camera_metadata_ro_entry_t minFocusDistance = 1339 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE); 1340 if (minFocusDistance.data.f[0] == 0) { 1341 ALOGE("%s: Requested focus mode \"%s\" is not available: " 1342 "fixed focus lens", 1343 __FUNCTION__, 1344 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1345 return BAD_VALUE; 1346 } else if (validatedParams.focusMode != 1347 Parameters::FOCUS_MODE_INFINITY) { 1348 camera_metadata_ro_entry_t availableFocusModes = 1349 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1350 for (i = 0; i < availableFocusModes.count; i++) { 1351 if (validatedParams.focusMode == 1352 availableFocusModes.data.u8[i]) break; 1353 } 1354 if (i == availableFocusModes.count) { 1355 ALOGE("%s: Requested focus mode \"%s\" is not supported", 1356 __FUNCTION__, 1357 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1358 return BAD_VALUE; 1359 } 1360 } 1361 } 1362 // Update in case of override 1363 newParams.set(CameraParameters::KEY_FOCUS_MODE, 1364 focusModeEnumToString(validatedParams.focusMode)); 1365 } else { 1366 validatedParams.currentAfTriggerId = currentAfTriggerId; 1367 } 1368 1369 // FOCUS_AREAS 1370 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS), 1371 &validatedParams.focusingAreas); 1372 size_t max3aRegions = 1373 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0]; 1374 if (res == OK) res = validateAreas(validatedParams.focusingAreas, 1375 max3aRegions); 1376 if (res != OK) { 1377 ALOGE("%s: Requested focus areas are malformed: %s", 1378 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS)); 1379 return BAD_VALUE; 1380 } 1381 1382 // EXPOSURE_COMPENSATION 1383 validatedParams.exposureCompensation = 1384 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1385 camera_metadata_ro_entry_t exposureCompensationRange = 1386 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE); 1387 if ((validatedParams.exposureCompensation < 1388 exposureCompensationRange.data.i32[0]) || 1389 (validatedParams.exposureCompensation > 1390 exposureCompensationRange.data.i32[1])) { 1391 ALOGE("%s: Requested exposure compensation index is out of bounds: %d", 1392 __FUNCTION__, validatedParams.exposureCompensation); 1393 return BAD_VALUE; 1394 } 1395 1396 // AUTO_EXPOSURE_LOCK (always supported) 1397 validatedParams.autoExposureLock = boolFromString( 1398 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 1399 1400 // AUTO_WHITEBALANCE_LOCK (always supported) 1401 validatedParams.autoWhiteBalanceLock = boolFromString( 1402 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 1403 1404 // METERING_AREAS 1405 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS), 1406 &validatedParams.meteringAreas); 1407 if (res == OK) { 1408 res = validateAreas(validatedParams.meteringAreas, max3aRegions); 1409 } 1410 if (res != OK) { 1411 ALOGE("%s: Requested metering areas are malformed: %s", 1412 __FUNCTION__, 1413 newParams.get(CameraParameters::KEY_METERING_AREAS)); 1414 return BAD_VALUE; 1415 } 1416 1417 // ZOOM 1418 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM); 1419 if (validatedParams.zoom < 0 || validatedParams.zoom > (int)NUM_ZOOM_STEPS) { 1420 ALOGE("%s: Requested zoom level %d is not supported", 1421 __FUNCTION__, validatedParams.zoom); 1422 return BAD_VALUE; 1423 } 1424 1425 // VIDEO_SIZE 1426 newParams.getVideoSize(&validatedParams.videoWidth, 1427 &validatedParams.videoHeight); 1428 if (validatedParams.videoWidth != videoWidth || 1429 validatedParams.videoHeight != videoHeight) { 1430 if (state == RECORD) { 1431 ALOGE("%s: Video size cannot be updated when recording is active!", 1432 __FUNCTION__); 1433 return BAD_VALUE; 1434 } 1435 camera_metadata_ro_entry_t availableVideoSizes = 1436 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 1437 for (i = 0; i < availableVideoSizes.count; i += 2 ) { 1438 if ((availableVideoSizes.data.i32[i] == 1439 validatedParams.videoWidth) && 1440 (availableVideoSizes.data.i32[i+1] == 1441 validatedParams.videoHeight)) break; 1442 } 1443 if (i == availableVideoSizes.count) { 1444 ALOGE("%s: Requested video size %d x %d is not supported", 1445 __FUNCTION__, validatedParams.videoWidth, 1446 validatedParams.videoHeight); 1447 return BAD_VALUE; 1448 } 1449 } 1450 1451 // RECORDING_HINT (always supported) 1452 validatedParams.recordingHint = boolFromString( 1453 newParams.get(CameraParameters::KEY_RECORDING_HINT) ); 1454 1455 // VIDEO_STABILIZATION 1456 validatedParams.videoStabilization = boolFromString( 1457 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) ); 1458 camera_metadata_ro_entry_t availableVideoStabilizationModes = 1459 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 1460 if (validatedParams.videoStabilization && 1461 availableVideoStabilizationModes.count == 1) { 1462 ALOGE("%s: Video stabilization not supported", __FUNCTION__); 1463 } 1464 1465 /** Update internal parameters */ 1466 1467 *this = validatedParams; 1468 1469 // Need to flatten again in case of overrides 1470 paramsFlattened = newParams.flatten(); 1471 params = newParams; 1472 1473 return OK; 1474} 1475 1476status_t Parameters::updateRequest(CameraMetadata *request) const { 1477 ATRACE_CALL(); 1478 status_t res; 1479 1480 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL; 1481 res = request->update(ANDROID_REQUEST_METADATA_MODE, 1482 &metadataMode, 1); 1483 if (res != OK) return res; 1484 1485 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 1486 previewFpsRange, 2); 1487 if (res != OK) return res; 1488 1489 uint8_t reqWbLock = autoWhiteBalanceLock ? 1490 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF; 1491 res = request->update(ANDROID_CONTROL_AWB_LOCK, 1492 &reqWbLock, 1); 1493 1494 res = request->update(ANDROID_CONTROL_EFFECT_MODE, 1495 &effectMode, 1); 1496 if (res != OK) return res; 1497 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, 1498 &antibandingMode, 1); 1499 if (res != OK) return res; 1500 1501 // android.hardware.Camera requires that when face detect is enabled, the 1502 // camera is in a face-priority mode. HAL2 splits this into separate parts 1503 // (face detection statistics and face priority scene mode). Map from other 1504 // to the other. 1505 bool sceneModeActive = 1506 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 1507 uint8_t reqControlMode = ANDROID_CONTROL_AUTO; 1508 if (enableFaceDetect || sceneModeActive) { 1509 reqControlMode = ANDROID_CONTROL_USE_SCENE_MODE; 1510 } 1511 res = request->update(ANDROID_CONTROL_MODE, 1512 &reqControlMode, 1); 1513 if (res != OK) return res; 1514 1515 uint8_t reqSceneMode = 1516 sceneModeActive ? sceneMode : 1517 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : 1518 (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 1519 res = request->update(ANDROID_CONTROL_SCENE_MODE, 1520 &reqSceneMode, 1); 1521 if (res != OK) return res; 1522 1523 uint8_t reqFlashMode = ANDROID_FLASH_OFF; 1524 uint8_t reqAeMode = ANDROID_CONTROL_AE_OFF; 1525 switch (flashMode) { 1526 case Parameters::FLASH_MODE_OFF: 1527 reqAeMode = ANDROID_CONTROL_AE_ON; break; 1528 case Parameters::FLASH_MODE_AUTO: 1529 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break; 1530 case Parameters::FLASH_MODE_ON: 1531 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break; 1532 case Parameters::FLASH_MODE_TORCH: 1533 reqAeMode = ANDROID_CONTROL_AE_ON; 1534 reqFlashMode = ANDROID_FLASH_TORCH; 1535 break; 1536 case Parameters::FLASH_MODE_RED_EYE: 1537 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break; 1538 default: 1539 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__, 1540 cameraId, flashMode); 1541 return BAD_VALUE; 1542 } 1543 res = request->update(ANDROID_FLASH_MODE, 1544 &reqFlashMode, 1); 1545 if (res != OK) return res; 1546 res = request->update(ANDROID_CONTROL_AE_MODE, 1547 &reqAeMode, 1); 1548 if (res != OK) return res; 1549 1550 uint8_t reqAeLock = autoExposureLock ? 1551 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF; 1552 res = request->update(ANDROID_CONTROL_AE_LOCK, 1553 &reqAeLock, 1); 1554 if (res != OK) return res; 1555 1556 res = request->update(ANDROID_CONTROL_AWB_MODE, 1557 &wbMode, 1); 1558 if (res != OK) return res; 1559 1560 float reqFocusDistance = 0; // infinity focus in diopters 1561 uint8_t reqFocusMode = ANDROID_CONTROL_AF_OFF; 1562 switch (focusMode) { 1563 case Parameters::FOCUS_MODE_AUTO: 1564 case Parameters::FOCUS_MODE_MACRO: 1565 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1566 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1567 case Parameters::FOCUS_MODE_EDOF: 1568 reqFocusMode = focusMode; 1569 break; 1570 case Parameters::FOCUS_MODE_INFINITY: 1571 case Parameters::FOCUS_MODE_FIXED: 1572 reqFocusMode = ANDROID_CONTROL_AF_OFF; 1573 break; 1574 default: 1575 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__, 1576 cameraId, focusMode); 1577 return BAD_VALUE; 1578 } 1579 res = request->update(ANDROID_LENS_FOCUS_DISTANCE, 1580 &reqFocusDistance, 1); 1581 if (res != OK) return res; 1582 res = request->update(ANDROID_CONTROL_AF_MODE, 1583 &reqFocusMode, 1); 1584 if (res != OK) return res; 1585 1586 size_t reqFocusingAreasSize = focusingAreas.size() * 5; 1587 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize]; 1588 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) { 1589 if (focusingAreas[i].weight != 0) { 1590 reqFocusingAreas[i + 0] = 1591 normalizedXToArray(focusingAreas[i].left); 1592 reqFocusingAreas[i + 1] = 1593 normalizedYToArray(focusingAreas[i].top); 1594 reqFocusingAreas[i + 2] = 1595 normalizedXToArray(focusingAreas[i].right); 1596 reqFocusingAreas[i + 3] = 1597 normalizedYToArray(focusingAreas[i].bottom); 1598 } else { 1599 reqFocusingAreas[i + 0] = 0; 1600 reqFocusingAreas[i + 1] = 0; 1601 reqFocusingAreas[i + 2] = 0; 1602 reqFocusingAreas[i + 3] = 0; 1603 } 1604 reqFocusingAreas[i + 4] = focusingAreas[i].weight; 1605 } 1606 res = request->update(ANDROID_CONTROL_AF_REGIONS, 1607 reqFocusingAreas, reqFocusingAreasSize); 1608 if (res != OK) return res; 1609 delete[] reqFocusingAreas; 1610 1611 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION, 1612 &exposureCompensation, 1); 1613 if (res != OK) return res; 1614 1615 size_t reqMeteringAreasSize = meteringAreas.size() * 5; 1616 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize]; 1617 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) { 1618 if (meteringAreas[i].weight != 0) { 1619 reqMeteringAreas[i + 0] = 1620 normalizedXToArray(meteringAreas[i].left); 1621 reqMeteringAreas[i + 1] = 1622 normalizedYToArray(meteringAreas[i].top); 1623 reqMeteringAreas[i + 2] = 1624 normalizedXToArray(meteringAreas[i].right); 1625 reqMeteringAreas[i + 3] = 1626 normalizedYToArray(meteringAreas[i].bottom); 1627 } else { 1628 reqMeteringAreas[i + 0] = 0; 1629 reqMeteringAreas[i + 1] = 0; 1630 reqMeteringAreas[i + 2] = 0; 1631 reqMeteringAreas[i + 3] = 0; 1632 } 1633 reqMeteringAreas[i + 4] = meteringAreas[i].weight; 1634 } 1635 res = request->update(ANDROID_CONTROL_AE_REGIONS, 1636 reqMeteringAreas, reqMeteringAreasSize); 1637 if (res != OK) return res; 1638 1639 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 1640 reqMeteringAreas, reqMeteringAreasSize); 1641 if (res != OK) return res; 1642 delete[] reqMeteringAreas; 1643 1644 CropRegion crop = calculateCropRegion(); 1645 int32_t reqCropRegion[3] = { crop.left, crop.top, crop.width }; 1646 res = request->update(ANDROID_SCALER_CROP_REGION, 1647 reqCropRegion, 3); 1648 if (res != OK) return res; 1649 1650 uint8_t reqVstabMode = videoStabilization ? 1651 ANDROID_CONTROL_VIDEO_STABILIZATION_ON : 1652 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF; 1653 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 1654 &reqVstabMode, 1); 1655 if (res != OK) return res; 1656 1657 uint8_t reqFaceDetectMode = enableFaceDetect ? 1658 fastInfo.bestFaceDetectMode : 1659 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF; 1660 res = request->update(ANDROID_STATS_FACE_DETECT_MODE, 1661 &reqFaceDetectMode, 1); 1662 if (res != OK) return res; 1663 1664 return OK; 1665} 1666 1667const char* Parameters::getStateName(State state) { 1668#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break; 1669 switch(state) { 1670 CASE_ENUM_TO_CHAR(DISCONNECTED) 1671 CASE_ENUM_TO_CHAR(STOPPED) 1672 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW) 1673 CASE_ENUM_TO_CHAR(PREVIEW) 1674 CASE_ENUM_TO_CHAR(RECORD) 1675 CASE_ENUM_TO_CHAR(STILL_CAPTURE) 1676 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT) 1677 default: 1678 return "Unknown state!"; 1679 break; 1680 } 1681#undef CASE_ENUM_TO_CHAR 1682} 1683 1684int Parameters::formatStringToEnum(const char *format) { 1685 return 1686 !format ? 1687 HAL_PIXEL_FORMAT_YCrCb_420_SP : 1688 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ? 1689 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16 1690 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ? 1691 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21 1692 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ? 1693 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2 1694 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ? 1695 HAL_PIXEL_FORMAT_YV12 : // YV12 1696 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ? 1697 HAL_PIXEL_FORMAT_RGB_565 : // RGB565 1698 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ? 1699 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888 1700 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ? 1701 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data 1702 -1; 1703} 1704 1705const char* Parameters::formatEnumToString(int format) { 1706 const char *fmt; 1707 switch(format) { 1708 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1709 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 1710 break; 1711 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1712 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 1713 break; 1714 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1715 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 1716 break; 1717 case HAL_PIXEL_FORMAT_YV12: // YV12 1718 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 1719 break; 1720 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 1721 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 1722 break; 1723 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 1724 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 1725 break; 1726 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1727 ALOGW("Raw sensor preview format requested."); 1728 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 1729 break; 1730 default: 1731 ALOGE("%s: Unknown preview format: %x", 1732 __FUNCTION__, format); 1733 fmt = NULL; 1734 break; 1735 } 1736 return fmt; 1737} 1738 1739int Parameters::wbModeStringToEnum(const char *wbMode) { 1740 return 1741 !wbMode ? 1742 ANDROID_CONTROL_AWB_AUTO : 1743 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ? 1744 ANDROID_CONTROL_AWB_AUTO : 1745 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ? 1746 ANDROID_CONTROL_AWB_INCANDESCENT : 1747 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ? 1748 ANDROID_CONTROL_AWB_FLUORESCENT : 1749 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ? 1750 ANDROID_CONTROL_AWB_WARM_FLUORESCENT : 1751 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ? 1752 ANDROID_CONTROL_AWB_DAYLIGHT : 1753 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ? 1754 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT : 1755 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ? 1756 ANDROID_CONTROL_AWB_TWILIGHT : 1757 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ? 1758 ANDROID_CONTROL_AWB_SHADE : 1759 -1; 1760} 1761 1762const char* Parameters::wbModeEnumToString(uint8_t wbMode) { 1763 switch (wbMode) { 1764 case ANDROID_CONTROL_AWB_AUTO: 1765 return CameraParameters::WHITE_BALANCE_AUTO; 1766 case ANDROID_CONTROL_AWB_INCANDESCENT: 1767 return CameraParameters::WHITE_BALANCE_INCANDESCENT; 1768 case ANDROID_CONTROL_AWB_FLUORESCENT: 1769 return CameraParameters::WHITE_BALANCE_FLUORESCENT; 1770 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT: 1771 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 1772 case ANDROID_CONTROL_AWB_DAYLIGHT: 1773 return CameraParameters::WHITE_BALANCE_DAYLIGHT; 1774 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT: 1775 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 1776 case ANDROID_CONTROL_AWB_TWILIGHT: 1777 return CameraParameters::WHITE_BALANCE_TWILIGHT; 1778 case ANDROID_CONTROL_AWB_SHADE: 1779 return CameraParameters::WHITE_BALANCE_SHADE; 1780 default: 1781 ALOGE("%s: Unknown AWB mode enum: %d", 1782 __FUNCTION__, wbMode); 1783 return "unknown"; 1784 } 1785} 1786 1787int Parameters::effectModeStringToEnum(const char *effectMode) { 1788 return 1789 !effectMode ? 1790 ANDROID_CONTROL_EFFECT_OFF : 1791 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ? 1792 ANDROID_CONTROL_EFFECT_OFF : 1793 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ? 1794 ANDROID_CONTROL_EFFECT_MONO : 1795 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ? 1796 ANDROID_CONTROL_EFFECT_NEGATIVE : 1797 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ? 1798 ANDROID_CONTROL_EFFECT_SOLARIZE : 1799 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ? 1800 ANDROID_CONTROL_EFFECT_SEPIA : 1801 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ? 1802 ANDROID_CONTROL_EFFECT_POSTERIZE : 1803 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ? 1804 ANDROID_CONTROL_EFFECT_WHITEBOARD : 1805 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ? 1806 ANDROID_CONTROL_EFFECT_BLACKBOARD : 1807 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ? 1808 ANDROID_CONTROL_EFFECT_AQUA : 1809 -1; 1810} 1811 1812int Parameters::abModeStringToEnum(const char *abMode) { 1813 return 1814 !abMode ? 1815 ANDROID_CONTROL_AE_ANTIBANDING_AUTO : 1816 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ? 1817 ANDROID_CONTROL_AE_ANTIBANDING_AUTO : 1818 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ? 1819 ANDROID_CONTROL_AE_ANTIBANDING_OFF : 1820 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ? 1821 ANDROID_CONTROL_AE_ANTIBANDING_50HZ : 1822 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ? 1823 ANDROID_CONTROL_AE_ANTIBANDING_60HZ : 1824 -1; 1825} 1826 1827int Parameters::sceneModeStringToEnum(const char *sceneMode) { 1828 return 1829 !sceneMode ? 1830 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED : 1831 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ? 1832 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED : 1833 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ? 1834 ANDROID_CONTROL_SCENE_MODE_ACTION : 1835 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ? 1836 ANDROID_CONTROL_SCENE_MODE_PORTRAIT : 1837 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ? 1838 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE : 1839 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ? 1840 ANDROID_CONTROL_SCENE_MODE_NIGHT : 1841 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ? 1842 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT : 1843 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ? 1844 ANDROID_CONTROL_SCENE_MODE_THEATRE : 1845 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ? 1846 ANDROID_CONTROL_SCENE_MODE_BEACH : 1847 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ? 1848 ANDROID_CONTROL_SCENE_MODE_SNOW : 1849 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ? 1850 ANDROID_CONTROL_SCENE_MODE_SUNSET : 1851 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ? 1852 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO : 1853 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ? 1854 ANDROID_CONTROL_SCENE_MODE_FIREWORKS : 1855 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ? 1856 ANDROID_CONTROL_SCENE_MODE_SPORTS : 1857 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ? 1858 ANDROID_CONTROL_SCENE_MODE_PARTY : 1859 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ? 1860 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT : 1861 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ? 1862 ANDROID_CONTROL_SCENE_MODE_BARCODE: 1863 -1; 1864} 1865 1866Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum( 1867 const char *flashMode) { 1868 return 1869 !flashMode ? 1870 Parameters::FLASH_MODE_INVALID : 1871 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ? 1872 Parameters::FLASH_MODE_OFF : 1873 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ? 1874 Parameters::FLASH_MODE_AUTO : 1875 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ? 1876 Parameters::FLASH_MODE_ON : 1877 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ? 1878 Parameters::FLASH_MODE_RED_EYE : 1879 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ? 1880 Parameters::FLASH_MODE_TORCH : 1881 Parameters::FLASH_MODE_INVALID; 1882} 1883 1884const char *Parameters::flashModeEnumToString(flashMode_t flashMode) { 1885 switch (flashMode) { 1886 case FLASH_MODE_OFF: 1887 return CameraParameters::FLASH_MODE_OFF; 1888 case FLASH_MODE_AUTO: 1889 return CameraParameters::FLASH_MODE_AUTO; 1890 case FLASH_MODE_ON: 1891 return CameraParameters::FLASH_MODE_ON; 1892 case FLASH_MODE_RED_EYE: 1893 return CameraParameters::FLASH_MODE_RED_EYE; 1894 case FLASH_MODE_TORCH: 1895 return CameraParameters::FLASH_MODE_TORCH; 1896 default: 1897 ALOGE("%s: Unknown flash mode enum %d", 1898 __FUNCTION__, flashMode); 1899 return "unknown"; 1900 } 1901} 1902 1903Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum( 1904 const char *focusMode) { 1905 return 1906 !focusMode ? 1907 Parameters::FOCUS_MODE_INVALID : 1908 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ? 1909 Parameters::FOCUS_MODE_AUTO : 1910 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ? 1911 Parameters::FOCUS_MODE_INFINITY : 1912 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ? 1913 Parameters::FOCUS_MODE_MACRO : 1914 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ? 1915 Parameters::FOCUS_MODE_FIXED : 1916 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ? 1917 Parameters::FOCUS_MODE_EDOF : 1918 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ? 1919 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO : 1920 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ? 1921 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE : 1922 Parameters::FOCUS_MODE_INVALID; 1923} 1924 1925const char *Parameters::focusModeEnumToString(focusMode_t focusMode) { 1926 switch (focusMode) { 1927 case FOCUS_MODE_AUTO: 1928 return CameraParameters::FOCUS_MODE_AUTO; 1929 case FOCUS_MODE_MACRO: 1930 return CameraParameters::FOCUS_MODE_MACRO; 1931 case FOCUS_MODE_CONTINUOUS_VIDEO: 1932 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 1933 case FOCUS_MODE_CONTINUOUS_PICTURE: 1934 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 1935 case FOCUS_MODE_EDOF: 1936 return CameraParameters::FOCUS_MODE_EDOF; 1937 case FOCUS_MODE_INFINITY: 1938 return CameraParameters::FOCUS_MODE_INFINITY; 1939 case FOCUS_MODE_FIXED: 1940 return CameraParameters::FOCUS_MODE_FIXED; 1941 default: 1942 ALOGE("%s: Unknown focus mode enum: %d", 1943 __FUNCTION__, focusMode); 1944 return "unknown"; 1945 } 1946} 1947 1948status_t Parameters::parseAreas(const char *areasCStr, 1949 Vector<Parameters::Area> *areas) { 1950 static const size_t NUM_FIELDS = 5; 1951 areas->clear(); 1952 if (areasCStr == NULL) { 1953 // If no key exists, use default (0,0,0,0,0) 1954 areas->push(); 1955 return OK; 1956 } 1957 String8 areasStr(areasCStr); 1958 ssize_t areaStart = areasStr.find("(", 0) + 1; 1959 while (areaStart != 0) { 1960 const char* area = areasStr.string() + areaStart; 1961 char *numEnd; 1962 int vals[NUM_FIELDS]; 1963 for (size_t i = 0; i < NUM_FIELDS; i++) { 1964 errno = 0; 1965 vals[i] = strtol(area, &numEnd, 10); 1966 if (errno || numEnd == area) return BAD_VALUE; 1967 area = numEnd + 1; 1968 } 1969 areas->push(Parameters::Area( 1970 vals[0], vals[1], vals[2], vals[3], vals[4]) ); 1971 areaStart = areasStr.find("(", areaStart) + 1; 1972 } 1973 return OK; 1974} 1975 1976status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas, 1977 size_t maxRegions) { 1978 // Definition of valid area can be found in 1979 // include/camera/CameraParameters.h 1980 if (areas.size() == 0) return BAD_VALUE; 1981 if (areas.size() == 1) { 1982 if (areas[0].left == 0 && 1983 areas[0].top == 0 && 1984 areas[0].right == 0 && 1985 areas[0].bottom == 0 && 1986 areas[0].weight == 0) { 1987 // Single (0,0,0,0,0) entry is always valid (== driver decides) 1988 return OK; 1989 } 1990 } 1991 if (areas.size() > maxRegions) { 1992 ALOGE("%s: Too many areas requested: %d", 1993 __FUNCTION__, areas.size()); 1994 return BAD_VALUE; 1995 } 1996 1997 for (Vector<Parameters::Area>::const_iterator a = areas.begin(); 1998 a != areas.end(); a++) { 1999 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE; 2000 if (a->left < -1000 || a->left > 1000) return BAD_VALUE; 2001 if (a->top < -1000 || a->top > 1000) return BAD_VALUE; 2002 if (a->right < -1000 || a->right > 1000) return BAD_VALUE; 2003 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE; 2004 if (a->left >= a->right) return BAD_VALUE; 2005 if (a->top >= a->bottom) return BAD_VALUE; 2006 } 2007 return OK; 2008} 2009 2010bool Parameters::boolFromString(const char *boolStr) { 2011 return !boolStr ? false : 2012 !strcmp(boolStr, CameraParameters::TRUE) ? true : 2013 false; 2014} 2015 2016int Parameters::degToTransform(int degrees, bool mirror) { 2017 if (!mirror) { 2018 if (degrees == 0) return 0; 2019 else if (degrees == 90) return HAL_TRANSFORM_ROT_90; 2020 else if (degrees == 180) return HAL_TRANSFORM_ROT_180; 2021 else if (degrees == 270) return HAL_TRANSFORM_ROT_270; 2022 } else { // Do mirror (horizontal flip) 2023 if (degrees == 0) { // FLIP_H and ROT_0 2024 return HAL_TRANSFORM_FLIP_H; 2025 } else if (degrees == 90) { // FLIP_H and ROT_90 2026 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90; 2027 } else if (degrees == 180) { // FLIP_H and ROT_180 2028 return HAL_TRANSFORM_FLIP_V; 2029 } else if (degrees == 270) { // FLIP_H and ROT_270 2030 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90; 2031 } 2032 } 2033 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees); 2034 return -1; 2035} 2036 2037int Parameters::arrayXToNormalized(int width) const { 2038 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000; 2039} 2040 2041int Parameters::arrayYToNormalized(int height) const { 2042 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000; 2043} 2044 2045int Parameters::normalizedXToArray(int x) const { 2046 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000; 2047} 2048 2049int Parameters::normalizedYToArray(int y) const { 2050 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000; 2051} 2052 2053Parameters::CropRegion Parameters::calculateCropRegion(void) const { 2054 2055 float zoomLeft, zoomTop, zoomWidth, zoomHeight; 2056 2057 // Need to convert zoom index into a crop rectangle. The rectangle is 2058 // chosen to maximize its area on the sensor 2059 2060 camera_metadata_ro_entry_t maxDigitalZoom = 2061 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM); 2062 // For each zoom step by how many pixels more do we change the zoom 2063 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) / 2064 (NUM_ZOOM_STEPS-1); 2065 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w) 2066 // via interpolating zoom step into a zoom ratio 2067 float zoomRatio = 1 + zoomIncrement * zoom; 2068 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]), 2069 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f", 2070 maxDigitalZoom.data.f[0], zoomRatio); 2071 2072 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, " 2073 "previewHeight=%d, activeWidth=%d, activeHeight=%d", 2074 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth, 2075 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight); 2076 2077 /* 2078 * Assumption: On the HAL side each stream buffer calculates its crop 2079 * rectangle as follows: 2080 * cropRect = (zoomLeft, zoomRight, 2081 * zoomWidth, zoomHeight * zoomWidth / outputWidth); 2082 * 2083 * Note that if zoomWidth > bufferWidth, the new cropHeight > zoomHeight 2084 * (we can then get into trouble if the cropHeight > arrayHeight). 2085 * By selecting the zoomRatio based on the smallest outputRatio, we 2086 * guarantee this will never happen. 2087 */ 2088 2089 // Enumerate all possible output sizes, select the one with the smallest 2090 // aspect ratio 2091 float minOutputWidth, minOutputHeight, minOutputRatio; 2092 { 2093 float outputSizes[][2] = { 2094 { previewWidth, previewHeight }, 2095 { videoWidth, videoHeight }, 2096 /* don't include jpeg thumbnail size - it's valid for 2097 it to be set to (0,0), meaning 'no thumbnail' */ 2098 // { jpegThumbSize[0], jpegThumbSize[1] }, 2099 { pictureWidth, pictureHeight }, 2100 }; 2101 2102 minOutputWidth = outputSizes[0][0]; 2103 minOutputHeight = outputSizes[0][1]; 2104 minOutputRatio = minOutputWidth / minOutputHeight; 2105 for (unsigned int i = 0; 2106 i < sizeof(outputSizes) / sizeof(outputSizes[0]); 2107 ++i) { 2108 2109 float outputWidth = outputSizes[i][0]; 2110 float outputHeight = outputSizes[i][1]; 2111 float outputRatio = outputWidth / outputHeight; 2112 2113 if (minOutputRatio > outputRatio) { 2114 minOutputRatio = outputRatio; 2115 minOutputWidth = outputWidth; 2116 minOutputHeight = outputHeight; 2117 } 2118 2119 // and then use this output ratio instead of preview output ratio 2120 ALOGV("Enumerating output ratio %f = %f / %f, min is %f", 2121 outputRatio, outputWidth, outputHeight, minOutputRatio); 2122 } 2123 } 2124 2125 /* Ensure that the width/height never go out of bounds 2126 * by scaling across a diffent dimension if an out-of-bounds 2127 * possibility exists. 2128 * 2129 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by 2130 * calculating the zoomWidth from zoomHeight we'll actually get a 2131 * zoomheight > arrayheight 2132 */ 2133 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight; 2134 if (minOutputRatio >= arrayRatio) { 2135 // Adjust the height based on the width 2136 zoomWidth = fastInfo.arrayWidth / zoomRatio; 2137 zoomHeight = zoomWidth * 2138 minOutputHeight / minOutputWidth; 2139 2140 } else { 2141 // Adjust the width based on the height 2142 zoomHeight = fastInfo.arrayHeight / zoomRatio; 2143 zoomWidth = zoomHeight * 2144 minOutputWidth / minOutputHeight; 2145 } 2146 // centering the zoom area within the active area 2147 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2; 2148 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2; 2149 2150 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d", 2151 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom); 2152 2153 2154 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight }; 2155 return crop; 2156} 2157 2158}; // namespace camera2 2159}; // namespace android 2160