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