Parameters.cpp revision af3d28870f7890370d6acb21d20cf1ccab4b9e08
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 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, 639 max3aRegions.data.i32[0]); 640 params.set(CameraParameters::KEY_FOCUS_AREAS, 641 "(0,0,0,0,0)"); 642 focusingAreas.clear(); 643 focusingAreas.add(Parameters::Area(0,0,0,0,0)); 644 645 camera_metadata_ro_entry_t availableFocalLengths = 646 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS); 647 if (!availableFocalLengths.count) return NO_INIT; 648 649 float minFocalLength = availableFocalLengths.data.f[0]; 650 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength); 651 652 camera_metadata_ro_entry_t sensorSize = 653 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2); 654 if (!sensorSize.count) return NO_INIT; 655 656 // The fields of view here assume infinity focus, maximum wide angle 657 float horizFov = 180 / M_PI * 658 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength)); 659 float vertFov = 180 / M_PI * 660 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength)); 661 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 662 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 663 664 exposureCompensation = 0; 665 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 666 exposureCompensation); 667 668 camera_metadata_ro_entry_t exposureCompensationRange = 669 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2); 670 if (!exposureCompensationRange.count) return NO_INIT; 671 672 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 673 exposureCompensationRange.data.i32[1]); 674 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 675 exposureCompensationRange.data.i32[0]); 676 677 camera_metadata_ro_entry_t exposureCompensationStep = 678 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1); 679 if (!exposureCompensationStep.count) return NO_INIT; 680 681 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 682 (float)exposureCompensationStep.data.r[0].numerator / 683 exposureCompensationStep.data.r[0].denominator); 684 685 autoExposureLock = false; 686 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 687 CameraParameters::FALSE); 688 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 689 CameraParameters::TRUE); 690 691 autoWhiteBalanceLock = false; 692 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 693 CameraParameters::FALSE); 694 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 695 CameraParameters::TRUE); 696 697 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 698 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 699 max3aRegions.data.i32[0]); 700 params.set(CameraParameters::KEY_METERING_AREAS, 701 "(0,0,0,0,0)"); 702 703 zoom = 0; 704 params.set(CameraParameters::KEY_ZOOM, zoom); 705 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 706 707 camera_metadata_ro_entry_t maxDigitalZoom = 708 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, /*minCount*/1, /*maxCount*/1); 709 if (!maxDigitalZoom.count) return NO_INIT; 710 711 { 712 String8 zoomRatios; 713 float zoom = 1.f; 714 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 715 (NUM_ZOOM_STEPS-1); 716 bool addComma = false; 717 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 718 if (addComma) zoomRatios += ","; 719 addComma = true; 720 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 721 zoom += zoomIncrement; 722 } 723 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 724 } 725 726 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 727 CameraParameters::TRUE); 728 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 729 CameraParameters::TRUE); 730 731 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 732 "Infinity,Infinity,Infinity"); 733 734 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 735 fastInfo.maxFaces); 736 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 737 0); 738 739 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 740 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE); 741 742 params.set(CameraParameters::KEY_RECORDING_HINT, 743 CameraParameters::FALSE); 744 745 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 746 CameraParameters::TRUE); 747 748 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 749 CameraParameters::FALSE); 750 751 camera_metadata_ro_entry_t availableVideoStabilizationModes = 752 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 753 if (!availableVideoStabilizationModes.count) return NO_INIT; 754 755 if (availableVideoStabilizationModes.count > 1) { 756 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 757 CameraParameters::TRUE); 758 } else { 759 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 760 CameraParameters::FALSE); 761 } 762 763 // Set up initial state for non-Camera.Parameters state variables 764 765 storeMetadataInBuffers = true; 766 playShutterSound = true; 767 enableFaceDetect = false; 768 769 enableFocusMoveMessages = false; 770 afTriggerCounter = 1; 771 currentAfTriggerId = -1; 772 773 precaptureTriggerCounter = 1; 774 775 previewCallbackFlags = 0; 776 777 char value[PROPERTY_VALUE_MAX]; 778 property_get("camera.disable_zsl_mode", value, "0"); 779 if (!strcmp(value,"1")) { 780 ALOGI("Camera %d: Disabling ZSL mode", cameraId); 781 zslMode = false; 782 } else { 783 zslMode = true; 784 } 785 786 lightFx = LIGHTFX_NONE; 787 788 state = STOPPED; 789 790 paramsFlattened = params.flatten(); 791 792 return OK; 793} 794 795String8 Parameters::get() const { 796 return paramsFlattened; 797} 798 799status_t Parameters::buildFastInfo() { 800 801 camera_metadata_ro_entry_t activeArraySize = 802 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2); 803 if (!activeArraySize.count) return NO_INIT; 804 int32_t arrayWidth = activeArraySize.data.i32[0]; 805 int32_t arrayHeight = activeArraySize.data.i32[1]; 806 807 camera_metadata_ro_entry_t availableFaceDetectModes = 808 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES); 809 if (!availableFaceDetectModes.count) return NO_INIT; 810 811 uint8_t bestFaceDetectMode = 812 ANDROID_STATS_FACE_DETECTION_OFF; 813 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) { 814 switch (availableFaceDetectModes.data.u8[i]) { 815 case ANDROID_STATS_FACE_DETECTION_OFF: 816 break; 817 case ANDROID_STATS_FACE_DETECTION_SIMPLE: 818 if (bestFaceDetectMode != 819 ANDROID_STATS_FACE_DETECTION_FULL) { 820 bestFaceDetectMode = 821 ANDROID_STATS_FACE_DETECTION_SIMPLE; 822 } 823 break; 824 case ANDROID_STATS_FACE_DETECTION_FULL: 825 bestFaceDetectMode = 826 ANDROID_STATS_FACE_DETECTION_FULL; 827 break; 828 default: 829 ALOGE("%s: Camera %d: Unknown face detect mode %d:", 830 __FUNCTION__, cameraId, 831 availableFaceDetectModes.data.u8[i]); 832 return NO_INIT; 833 } 834 } 835 836 camera_metadata_ro_entry_t maxFacesDetected = 837 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1); 838 if (!maxFacesDetected.count) return NO_INIT; 839 840 int32_t maxFaces = maxFacesDetected.data.i32[0]; 841 842 camera_metadata_ro_entry_t availableSceneModes = 843 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 844 camera_metadata_ro_entry_t sceneModeOverrides = 845 staticInfo(ANDROID_CONTROL_SCENE_MODE_OVERRIDES); 846 camera_metadata_ro_entry_t minFocusDistance = 847 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE); 848 bool fixedLens = (minFocusDistance.data.f[0] == 0); 849 850 if (sceneModeOverrides.count > 0) { 851 // sceneModeOverrides is defined to have 3 entries for each scene mode, 852 // which are AE, AWB, and AF override modes the HAL wants for that scene 853 // mode. 854 const size_t kModesPerSceneMode = 3; 855 if (sceneModeOverrides.count != 856 availableSceneModes.count * kModesPerSceneMode) { 857 ALOGE("%s: Camera %d: Scene mode override list is an " 858 "unexpected size: %d (expected %d)", __FUNCTION__, 859 cameraId, sceneModeOverrides.count, 860 availableSceneModes.count); 861 return NO_INIT; 862 } 863 for (size_t i = 0; i < availableSceneModes.count; i++) { 864 DeviceInfo::OverrideModes modes; 865 uint8_t aeMode = 866 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 0]; 867 switch(aeMode) { 868 case ANDROID_CONTROL_AE_ON: 869 modes.flashMode = FLASH_MODE_OFF; 870 break; 871 case ANDROID_CONTROL_AE_ON_AUTO_FLASH: 872 modes.flashMode = FLASH_MODE_AUTO; 873 break; 874 case ANDROID_CONTROL_AE_ON_ALWAYS_FLASH: 875 modes.flashMode = FLASH_MODE_ON; 876 break; 877 case ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE: 878 modes.flashMode = FLASH_MODE_RED_EYE; 879 break; 880 default: 881 ALOGE("%s: Unknown override AE mode: %d", __FUNCTION__, 882 aeMode); 883 modes.flashMode = FLASH_MODE_INVALID; 884 break; 885 } 886 modes.wbMode = 887 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 1]; 888 uint8_t afMode = 889 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 2]; 890 switch(afMode) { 891 case ANDROID_CONTROL_AF_OFF: 892 modes.focusMode = fixedLens ? 893 FOCUS_MODE_FIXED : FOCUS_MODE_INFINITY; 894 break; 895 case ANDROID_CONTROL_AF_AUTO: 896 case ANDROID_CONTROL_AF_MACRO: 897 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO: 898 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE: 899 case ANDROID_CONTROL_AF_EDOF: 900 modes.focusMode = static_cast<focusMode_t>(afMode); 901 break; 902 default: 903 ALOGE("%s: Unknown override AF mode: %d", __FUNCTION__, 904 afMode); 905 modes.focusMode = FOCUS_MODE_INVALID; 906 break; 907 } 908 fastInfo.sceneModeOverrides.add(availableSceneModes.data.u8[i], 909 modes); 910 } 911 } 912 913 fastInfo.arrayWidth = arrayWidth; 914 fastInfo.arrayHeight = arrayHeight; 915 fastInfo.bestFaceDetectMode = bestFaceDetectMode; 916 fastInfo.maxFaces = maxFaces; 917 return OK; 918} 919 920status_t Parameters::buildQuirks() { 921 camera_metadata_ro_entry_t entry; 922 entry = info->find(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO); 923 quirks.triggerAfWithAuto = (entry.count != 0 && entry.data.u8[0] == 1); 924 ALOGV_IF(quirks.triggerAfWithAuto, "Camera %d: Quirk triggerAfWithAuto enabled", 925 cameraId); 926 927 entry = info->find(ANDROID_QUIRKS_USE_ZSL_FORMAT); 928 quirks.useZslFormat = (entry.count != 0 && entry.data.u8[0] == 1); 929 ALOGV_IF(quirks.useZslFormat, "Camera %d: Quirk useZslFormat enabled", 930 cameraId); 931 932 return OK; 933} 934 935camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag, 936 size_t minCount, size_t maxCount) const { 937 status_t res; 938 camera_metadata_ro_entry_t entry = info->find(tag); 939 940 if (CC_UNLIKELY( entry.count == 0 )) { 941 const char* tagSection = get_camera_metadata_section_name(tag); 942 if (tagSection == NULL) tagSection = "<unknown>"; 943 const char* tagName = get_camera_metadata_tag_name(tag); 944 if (tagName == NULL) tagName = "<unknown>"; 945 946 ALOGE("Error finding static metadata entry '%s.%s' (%x)", 947 tagSection, tagName, tag); 948 } else if (CC_UNLIKELY( 949 (minCount != 0 && entry.count < minCount) || 950 (maxCount != 0 && entry.count > maxCount) ) ) { 951 const char* tagSection = get_camera_metadata_section_name(tag); 952 if (tagSection == NULL) tagSection = "<unknown>"; 953 const char* tagName = get_camera_metadata_tag_name(tag); 954 if (tagName == NULL) tagName = "<unknown>"; 955 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 956 "Expected between %d and %d values, but got %d values", 957 tagSection, tagName, tag, minCount, maxCount, entry.count); 958 } 959 960 return entry; 961} 962 963status_t Parameters::set(const String8& paramString) { 964 status_t res; 965 966 CameraParameters newParams(paramString); 967 968 // TODO: Currently ignoring any changes to supposedly read-only parameters 969 // such as supported preview sizes, etc. Should probably produce an error if 970 // they're changed. 971 972 /** Extract and verify new parameters */ 973 974 size_t i; 975 976 Parameters validatedParams(*this); 977 978 // PREVIEW_SIZE 979 newParams.getPreviewSize(&validatedParams.previewWidth, 980 &validatedParams.previewHeight); 981 982 if (validatedParams.previewWidth != previewWidth || 983 validatedParams.previewHeight != previewHeight) { 984 if (state >= PREVIEW) { 985 ALOGE("%s: Preview size cannot be updated when preview " 986 "is active! (Currently %d x %d, requested %d x %d", 987 __FUNCTION__, 988 previewWidth, previewHeight, 989 validatedParams.previewWidth, validatedParams.previewHeight); 990 return BAD_VALUE; 991 } 992 camera_metadata_ro_entry_t availablePreviewSizes = 993 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 994 for (i = 0; i < availablePreviewSizes.count; i += 2 ) { 995 if ((availablePreviewSizes.data.i32[i] == 996 validatedParams.previewWidth) && 997 (availablePreviewSizes.data.i32[i+1] == 998 validatedParams.previewHeight)) break; 999 } 1000 if (i == availablePreviewSizes.count) { 1001 ALOGE("%s: Requested preview size %d x %d is not supported", 1002 __FUNCTION__, validatedParams.previewWidth, 1003 validatedParams.previewHeight); 1004 return BAD_VALUE; 1005 } 1006 } 1007 1008 // RECORDING_HINT (always supported) 1009 validatedParams.recordingHint = boolFromString( 1010 newParams.get(CameraParameters::KEY_RECORDING_HINT) ); 1011 bool recordingHintChanged = validatedParams.recordingHint != recordingHint; 1012 ALOGV_IF(recordingHintChanged, "%s: Recording hint changed to %d", 1013 __FUNCTION__, recordingHintChanged); 1014 1015 // PREVIEW_FPS_RANGE 1016 bool fpsRangeChanged = false; 1017 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0], 1018 &validatedParams.previewFpsRange[1]); 1019 validatedParams.previewFpsRange[0] /= kFpsToApiScale; 1020 validatedParams.previewFpsRange[1] /= kFpsToApiScale; 1021 1022 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] || 1023 validatedParams.previewFpsRange[1] != previewFpsRange[1]) { 1024 fpsRangeChanged = true; 1025 camera_metadata_ro_entry_t availablePreviewFpsRanges = 1026 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 1027 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) { 1028 if ((availablePreviewFpsRanges.data.i32[i] == 1029 validatedParams.previewFpsRange[0]) && 1030 (availablePreviewFpsRanges.data.i32[i+1] == 1031 validatedParams.previewFpsRange[1]) ) { 1032 break; 1033 } 1034 } 1035 if (i == availablePreviewFpsRanges.count) { 1036 ALOGE("%s: Requested preview FPS range %d - %d is not supported", 1037 __FUNCTION__, validatedParams.previewFpsRange[0], 1038 validatedParams.previewFpsRange[1]); 1039 return BAD_VALUE; 1040 } 1041 validatedParams.previewFps = 1042 fpsFromRange(validatedParams.previewFpsRange[0], 1043 validatedParams.previewFpsRange[1]); 1044 newParams.setPreviewFrameRate(validatedParams.previewFps); 1045 } 1046 1047 // PREVIEW_FORMAT 1048 validatedParams.previewFormat = 1049 formatStringToEnum(newParams.getPreviewFormat()); 1050 if (validatedParams.previewFormat != previewFormat) { 1051 if (state >= PREVIEW) { 1052 ALOGE("%s: Preview format cannot be updated when preview " 1053 "is active!", __FUNCTION__); 1054 return BAD_VALUE; 1055 } 1056 camera_metadata_ro_entry_t availableFormats = 1057 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 1058 for (i = 0; i < availableFormats.count; i++) { 1059 if (availableFormats.data.i32[i] == validatedParams.previewFormat) 1060 break; 1061 } 1062 if (i == availableFormats.count) { 1063 ALOGE("%s: Requested preview format %s (0x%x) is not supported", 1064 __FUNCTION__, newParams.getPreviewFormat(), 1065 validatedParams.previewFormat); 1066 return BAD_VALUE; 1067 } 1068 } 1069 1070 // PREVIEW_FRAME_RATE 1071 // Deprecated, only use if the preview fps range is unchanged this time. 1072 // The single-value FPS is the same as the minimum of the range. 1073 if (!fpsRangeChanged) { 1074 validatedParams.previewFps = newParams.getPreviewFrameRate(); 1075 if (validatedParams.previewFps != previewFps || recordingHintChanged) { 1076 camera_metadata_ro_entry_t availableFrameRates = 1077 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES); 1078 /** 1079 * If recording hint is set, find the range that encompasses 1080 * previewFps with the largest min index. 1081 * 1082 * If recording hint is not set, find the range with previewFps 1083 * with the smallest min index. 1084 * 1085 * Either way, in case of multiple ranges, break the tie by 1086 * selecting the smaller range. 1087 */ 1088 int targetFps = validatedParams.previewFps; 1089 // all ranges which have targetFps 1090 Vector<Range> candidateRanges; 1091 for (i = 0; i < availableFrameRates.count; i+=2) { 1092 Range r = { 1093 availableFrameRates.data.i32[i], 1094 availableFrameRates.data.i32[i+1] 1095 }; 1096 1097 if (r.min <= targetFps && targetFps <= r.max) { 1098 candidateRanges.push(r); 1099 } 1100 } 1101 if (candidateRanges.isEmpty()) { 1102 ALOGE("%s: Requested preview frame rate %d is not supported", 1103 __FUNCTION__, validatedParams.previewFps); 1104 return BAD_VALUE; 1105 } 1106 // most applicable range with targetFps 1107 Range bestRange = candidateRanges[0]; 1108 for (i = 1; i < candidateRanges.size(); ++i) { 1109 Range r = candidateRanges[i]; 1110 1111 // Find by largest minIndex in recording mode 1112 if (validatedParams.recordingHint) { 1113 if (r.min > bestRange.min) { 1114 bestRange = r; 1115 } 1116 else if (r.min == bestRange.min && r.max < bestRange.max) { 1117 bestRange = r; 1118 } 1119 } 1120 // Find by smallest minIndex in preview mode 1121 else { 1122 if (r.min < bestRange.min) { 1123 bestRange = r; 1124 } 1125 else if (r.min == bestRange.min && r.max < bestRange.max) { 1126 bestRange = r; 1127 } 1128 } 1129 } 1130 1131 validatedParams.previewFpsRange[0] = 1132 bestRange.min; 1133 validatedParams.previewFpsRange[1] = 1134 bestRange.max; 1135 1136 ALOGV("%s: New preview FPS range: %d, %d, recordingHint = %d", 1137 __FUNCTION__, 1138 validatedParams.previewFpsRange[0], 1139 validatedParams.previewFpsRange[1], 1140 validatedParams.recordingHint); 1141 } 1142 newParams.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 1143 String8::format("%d,%d", 1144 validatedParams.previewFpsRange[0] * kFpsToApiScale, 1145 validatedParams.previewFpsRange[1] * kFpsToApiScale)); 1146 1147 } 1148 1149 // PICTURE_SIZE 1150 newParams.getPictureSize(&validatedParams.pictureWidth, 1151 &validatedParams.pictureHeight); 1152 if (validatedParams.pictureWidth == pictureWidth || 1153 validatedParams.pictureHeight == pictureHeight) { 1154 camera_metadata_ro_entry_t availablePictureSizes = 1155 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES); 1156 for (i = 0; i < availablePictureSizes.count; i+=2) { 1157 if ((availablePictureSizes.data.i32[i] == 1158 validatedParams.pictureWidth) && 1159 (availablePictureSizes.data.i32[i+1] == 1160 validatedParams.pictureHeight)) break; 1161 } 1162 if (i == availablePictureSizes.count) { 1163 ALOGE("%s: Requested picture size %d x %d is not supported", 1164 __FUNCTION__, validatedParams.pictureWidth, 1165 validatedParams.pictureHeight); 1166 return BAD_VALUE; 1167 } 1168 } 1169 1170 // JPEG_THUMBNAIL_WIDTH/HEIGHT 1171 validatedParams.jpegThumbSize[0] = 1172 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 1173 validatedParams.jpegThumbSize[1] = 1174 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 1175 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] || 1176 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) { 1177 camera_metadata_ro_entry_t availableJpegThumbSizes = 1178 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES); 1179 for (i = 0; i < availableJpegThumbSizes.count; i+=2) { 1180 if ((availableJpegThumbSizes.data.i32[i] == 1181 validatedParams.jpegThumbSize[0]) && 1182 (availableJpegThumbSizes.data.i32[i+1] == 1183 validatedParams.jpegThumbSize[1])) break; 1184 } 1185 if (i == availableJpegThumbSizes.count) { 1186 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported", 1187 __FUNCTION__, validatedParams.jpegThumbSize[0], 1188 validatedParams.jpegThumbSize[1]); 1189 return BAD_VALUE; 1190 } 1191 } 1192 1193 // JPEG_THUMBNAIL_QUALITY 1194 validatedParams.jpegThumbQuality = 1195 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 1196 if (validatedParams.jpegThumbQuality < 0 || 1197 validatedParams.jpegThumbQuality > 100) { 1198 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported", 1199 __FUNCTION__, validatedParams.jpegThumbQuality); 1200 return BAD_VALUE; 1201 } 1202 1203 // JPEG_QUALITY 1204 validatedParams.jpegQuality = 1205 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY); 1206 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) { 1207 ALOGE("%s: Requested JPEG quality %d is not supported", 1208 __FUNCTION__, validatedParams.jpegQuality); 1209 return BAD_VALUE; 1210 } 1211 1212 // ROTATION 1213 validatedParams.jpegRotation = 1214 newParams.getInt(CameraParameters::KEY_ROTATION); 1215 if (validatedParams.jpegRotation != 0 && 1216 validatedParams.jpegRotation != 90 && 1217 validatedParams.jpegRotation != 180 && 1218 validatedParams.jpegRotation != 270) { 1219 ALOGE("%s: Requested picture rotation angle %d is not supported", 1220 __FUNCTION__, validatedParams.jpegRotation); 1221 return BAD_VALUE; 1222 } 1223 1224 // GPS 1225 1226 const char *gpsLatStr = 1227 newParams.get(CameraParameters::KEY_GPS_LATITUDE); 1228 if (gpsLatStr != NULL) { 1229 const char *gpsLongStr = 1230 newParams.get(CameraParameters::KEY_GPS_LONGITUDE); 1231 const char *gpsAltitudeStr = 1232 newParams.get(CameraParameters::KEY_GPS_ALTITUDE); 1233 const char *gpsTimeStr = 1234 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP); 1235 const char *gpsProcMethodStr = 1236 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 1237 if (gpsLongStr == NULL || 1238 gpsAltitudeStr == NULL || 1239 gpsTimeStr == NULL || 1240 gpsProcMethodStr == NULL) { 1241 ALOGE("%s: Incomplete set of GPS parameters provided", 1242 __FUNCTION__); 1243 return BAD_VALUE; 1244 } 1245 char *endPtr; 1246 errno = 0; 1247 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr); 1248 if (errno || endPtr == gpsLatStr) { 1249 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr); 1250 return BAD_VALUE; 1251 } 1252 errno = 0; 1253 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr); 1254 if (errno || endPtr == gpsLongStr) { 1255 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr); 1256 return BAD_VALUE; 1257 } 1258 errno = 0; 1259 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr); 1260 if (errno || endPtr == gpsAltitudeStr) { 1261 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__, 1262 gpsAltitudeStr); 1263 return BAD_VALUE; 1264 } 1265 errno = 0; 1266 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10); 1267 if (errno || endPtr == gpsTimeStr) { 1268 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr); 1269 return BAD_VALUE; 1270 } 1271 validatedParams.gpsProcessingMethod = gpsProcMethodStr; 1272 1273 validatedParams.gpsEnabled = true; 1274 } else { 1275 validatedParams.gpsEnabled = false; 1276 } 1277 1278 // EFFECT 1279 validatedParams.effectMode = effectModeStringToEnum( 1280 newParams.get(CameraParameters::KEY_EFFECT) ); 1281 if (validatedParams.effectMode != effectMode) { 1282 camera_metadata_ro_entry_t availableEffectModes = 1283 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 1284 for (i = 0; i < availableEffectModes.count; i++) { 1285 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break; 1286 } 1287 if (i == availableEffectModes.count) { 1288 ALOGE("%s: Requested effect mode \"%s\" is not supported", 1289 __FUNCTION__, 1290 newParams.get(CameraParameters::KEY_EFFECT) ); 1291 return BAD_VALUE; 1292 } 1293 } 1294 1295 // ANTIBANDING 1296 validatedParams.antibandingMode = abModeStringToEnum( 1297 newParams.get(CameraParameters::KEY_ANTIBANDING) ); 1298 if (validatedParams.antibandingMode != antibandingMode) { 1299 camera_metadata_ro_entry_t availableAbModes = 1300 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 1301 for (i = 0; i < availableAbModes.count; i++) { 1302 if (validatedParams.antibandingMode == availableAbModes.data.u8[i]) 1303 break; 1304 } 1305 if (i == availableAbModes.count) { 1306 ALOGE("%s: Requested antibanding mode \"%s\" is not supported", 1307 __FUNCTION__, 1308 newParams.get(CameraParameters::KEY_ANTIBANDING)); 1309 return BAD_VALUE; 1310 } 1311 } 1312 1313 // SCENE_MODE 1314 validatedParams.sceneMode = sceneModeStringToEnum( 1315 newParams.get(CameraParameters::KEY_SCENE_MODE) ); 1316 if (validatedParams.sceneMode != sceneMode && 1317 validatedParams.sceneMode != 1318 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) { 1319 camera_metadata_ro_entry_t availableSceneModes = 1320 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 1321 for (i = 0; i < availableSceneModes.count; i++) { 1322 if (validatedParams.sceneMode == availableSceneModes.data.u8[i]) 1323 break; 1324 } 1325 if (i == availableSceneModes.count) { 1326 ALOGE("%s: Requested scene mode \"%s\" is not supported", 1327 __FUNCTION__, 1328 newParams.get(CameraParameters::KEY_SCENE_MODE)); 1329 return BAD_VALUE; 1330 } 1331 } 1332 bool sceneModeSet = 1333 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 1334 1335 // FLASH_MODE 1336 if (sceneModeSet) { 1337 validatedParams.flashMode = 1338 fastInfo.sceneModeOverrides. 1339 valueFor(validatedParams.sceneMode).flashMode; 1340 } else { 1341 validatedParams.flashMode = FLASH_MODE_INVALID; 1342 } 1343 if (validatedParams.flashMode == FLASH_MODE_INVALID) { 1344 validatedParams.flashMode = flashModeStringToEnum( 1345 newParams.get(CameraParameters::KEY_FLASH_MODE) ); 1346 } 1347 1348 if (validatedParams.flashMode != flashMode) { 1349 camera_metadata_ro_entry_t flashAvailable = 1350 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 1351 if (!flashAvailable.data.u8[0] && 1352 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) { 1353 ALOGE("%s: Requested flash mode \"%s\" is not supported: " 1354 "No flash on device", __FUNCTION__, 1355 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1356 return BAD_VALUE; 1357 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) { 1358 camera_metadata_ro_entry_t availableAeModes = 1359 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 1360 for (i = 0; i < availableAeModes.count; i++) { 1361 if (validatedParams.flashMode == availableAeModes.data.u8[i]) 1362 break; 1363 } 1364 if (i == availableAeModes.count) { 1365 ALOGE("%s: Requested flash mode \"%s\" is not supported", 1366 __FUNCTION__, 1367 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1368 return BAD_VALUE; 1369 } 1370 } else if (validatedParams.flashMode == -1) { 1371 ALOGE("%s: Requested flash mode \"%s\" is unknown", 1372 __FUNCTION__, 1373 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1374 return BAD_VALUE; 1375 } 1376 // Update in case of override 1377 newParams.set(CameraParameters::KEY_FLASH_MODE, 1378 flashModeEnumToString(validatedParams.flashMode)); 1379 } 1380 1381 // WHITE_BALANCE 1382 if (sceneModeSet) { 1383 validatedParams.wbMode = 1384 fastInfo.sceneModeOverrides. 1385 valueFor(validatedParams.sceneMode).wbMode; 1386 } else { 1387 validatedParams.wbMode = ANDROID_CONTROL_AWB_OFF; 1388 } 1389 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_OFF) { 1390 validatedParams.wbMode = wbModeStringToEnum( 1391 newParams.get(CameraParameters::KEY_WHITE_BALANCE) ); 1392 } 1393 if (validatedParams.wbMode != wbMode) { 1394 camera_metadata_ro_entry_t availableWbModes = 1395 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 1396 for (i = 0; i < availableWbModes.count; i++) { 1397 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break; 1398 } 1399 if (i == availableWbModes.count) { 1400 ALOGE("%s: Requested white balance mode %s is not supported", 1401 __FUNCTION__, 1402 newParams.get(CameraParameters::KEY_WHITE_BALANCE)); 1403 return BAD_VALUE; 1404 } 1405 // Update in case of override 1406 newParams.set(CameraParameters::KEY_WHITE_BALANCE, 1407 wbModeEnumToString(validatedParams.wbMode)); 1408 } 1409 1410 // FOCUS_MODE 1411 if (sceneModeSet) { 1412 validatedParams.focusMode = 1413 fastInfo.sceneModeOverrides. 1414 valueFor(validatedParams.sceneMode).focusMode; 1415 } else { 1416 validatedParams.focusMode = FOCUS_MODE_INVALID; 1417 } 1418 if (validatedParams.focusMode == FOCUS_MODE_INVALID) { 1419 validatedParams.focusMode = focusModeStringToEnum( 1420 newParams.get(CameraParameters::KEY_FOCUS_MODE) ); 1421 } 1422 if (validatedParams.focusMode != focusMode) { 1423 validatedParams.currentAfTriggerId = -1; 1424 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) { 1425 camera_metadata_ro_entry_t minFocusDistance = 1426 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE); 1427 if (minFocusDistance.data.f[0] == 0) { 1428 ALOGE("%s: Requested focus mode \"%s\" is not available: " 1429 "fixed focus lens", 1430 __FUNCTION__, 1431 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1432 return BAD_VALUE; 1433 } else if (validatedParams.focusMode != 1434 Parameters::FOCUS_MODE_INFINITY) { 1435 camera_metadata_ro_entry_t availableFocusModes = 1436 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1437 for (i = 0; i < availableFocusModes.count; i++) { 1438 if (validatedParams.focusMode == 1439 availableFocusModes.data.u8[i]) break; 1440 } 1441 if (i == availableFocusModes.count) { 1442 ALOGE("%s: Requested focus mode \"%s\" is not supported", 1443 __FUNCTION__, 1444 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1445 return BAD_VALUE; 1446 } 1447 } 1448 } 1449 // Always reset shadow focus mode to avoid reverting settings 1450 shadowFocusMode = FOCUS_MODE_INVALID; 1451 // Update in case of override 1452 newParams.set(CameraParameters::KEY_FOCUS_MODE, 1453 focusModeEnumToString(validatedParams.focusMode)); 1454 } else { 1455 validatedParams.currentAfTriggerId = currentAfTriggerId; 1456 } 1457 1458 // FOCUS_AREAS 1459 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS), 1460 &validatedParams.focusingAreas); 1461 size_t max3aRegions = 1462 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0]; 1463 if (res == OK) res = validateAreas(validatedParams.focusingAreas, 1464 max3aRegions); 1465 if (res != OK) { 1466 ALOGE("%s: Requested focus areas are malformed: %s", 1467 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS)); 1468 return BAD_VALUE; 1469 } 1470 1471 // EXPOSURE_COMPENSATION 1472 validatedParams.exposureCompensation = 1473 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1474 camera_metadata_ro_entry_t exposureCompensationRange = 1475 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE); 1476 if ((validatedParams.exposureCompensation < 1477 exposureCompensationRange.data.i32[0]) || 1478 (validatedParams.exposureCompensation > 1479 exposureCompensationRange.data.i32[1])) { 1480 ALOGE("%s: Requested exposure compensation index is out of bounds: %d", 1481 __FUNCTION__, validatedParams.exposureCompensation); 1482 return BAD_VALUE; 1483 } 1484 1485 // AUTO_EXPOSURE_LOCK (always supported) 1486 validatedParams.autoExposureLock = boolFromString( 1487 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 1488 1489 // AUTO_WHITEBALANCE_LOCK (always supported) 1490 validatedParams.autoWhiteBalanceLock = boolFromString( 1491 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 1492 1493 // METERING_AREAS 1494 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS), 1495 &validatedParams.meteringAreas); 1496 if (res == OK) { 1497 res = validateAreas(validatedParams.meteringAreas, max3aRegions); 1498 } 1499 if (res != OK) { 1500 ALOGE("%s: Requested metering areas are malformed: %s", 1501 __FUNCTION__, 1502 newParams.get(CameraParameters::KEY_METERING_AREAS)); 1503 return BAD_VALUE; 1504 } 1505 1506 // ZOOM 1507 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM); 1508 if (validatedParams.zoom < 0 || validatedParams.zoom > (int)NUM_ZOOM_STEPS) { 1509 ALOGE("%s: Requested zoom level %d is not supported", 1510 __FUNCTION__, validatedParams.zoom); 1511 return BAD_VALUE; 1512 } 1513 1514 // VIDEO_SIZE 1515 newParams.getVideoSize(&validatedParams.videoWidth, 1516 &validatedParams.videoHeight); 1517 if (validatedParams.videoWidth != videoWidth || 1518 validatedParams.videoHeight != videoHeight) { 1519 if (state == RECORD) { 1520 ALOGE("%s: Video size cannot be updated when recording is active!", 1521 __FUNCTION__); 1522 return BAD_VALUE; 1523 } 1524 camera_metadata_ro_entry_t availableVideoSizes = 1525 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 1526 for (i = 0; i < availableVideoSizes.count; i += 2 ) { 1527 if ((availableVideoSizes.data.i32[i] == 1528 validatedParams.videoWidth) && 1529 (availableVideoSizes.data.i32[i+1] == 1530 validatedParams.videoHeight)) break; 1531 } 1532 if (i == availableVideoSizes.count) { 1533 ALOGE("%s: Requested video size %d x %d is not supported", 1534 __FUNCTION__, validatedParams.videoWidth, 1535 validatedParams.videoHeight); 1536 return BAD_VALUE; 1537 } 1538 } 1539 1540 // VIDEO_STABILIZATION 1541 validatedParams.videoStabilization = boolFromString( 1542 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) ); 1543 camera_metadata_ro_entry_t availableVideoStabilizationModes = 1544 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 1545 if (validatedParams.videoStabilization && 1546 availableVideoStabilizationModes.count == 1) { 1547 ALOGE("%s: Video stabilization not supported", __FUNCTION__); 1548 } 1549 1550 /** Update internal parameters */ 1551 1552 *this = validatedParams; 1553 1554 // Need to flatten again in case of overrides 1555 paramsFlattened = newParams.flatten(); 1556 params = newParams; 1557 1558 return OK; 1559} 1560 1561status_t Parameters::updateRequest(CameraMetadata *request) const { 1562 ATRACE_CALL(); 1563 status_t res; 1564 1565 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL; 1566 res = request->update(ANDROID_REQUEST_METADATA_MODE, 1567 &metadataMode, 1); 1568 if (res != OK) return res; 1569 1570 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 1571 previewFpsRange, 2); 1572 if (res != OK) return res; 1573 1574 uint8_t reqWbLock = autoWhiteBalanceLock ? 1575 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF; 1576 res = request->update(ANDROID_CONTROL_AWB_LOCK, 1577 &reqWbLock, 1); 1578 1579 res = request->update(ANDROID_CONTROL_EFFECT_MODE, 1580 &effectMode, 1); 1581 if (res != OK) return res; 1582 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, 1583 &antibandingMode, 1); 1584 if (res != OK) return res; 1585 1586 // android.hardware.Camera requires that when face detect is enabled, the 1587 // camera is in a face-priority mode. HAL2 splits this into separate parts 1588 // (face detection statistics and face priority scene mode). Map from other 1589 // to the other. 1590 bool sceneModeActive = 1591 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 1592 uint8_t reqControlMode = ANDROID_CONTROL_AUTO; 1593 if (enableFaceDetect || sceneModeActive) { 1594 reqControlMode = ANDROID_CONTROL_USE_SCENE_MODE; 1595 } 1596 res = request->update(ANDROID_CONTROL_MODE, 1597 &reqControlMode, 1); 1598 if (res != OK) return res; 1599 1600 uint8_t reqSceneMode = 1601 sceneModeActive ? sceneMode : 1602 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : 1603 (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 1604 res = request->update(ANDROID_CONTROL_SCENE_MODE, 1605 &reqSceneMode, 1); 1606 if (res != OK) return res; 1607 1608 uint8_t reqFlashMode = ANDROID_FLASH_OFF; 1609 uint8_t reqAeMode = ANDROID_CONTROL_AE_OFF; 1610 switch (flashMode) { 1611 case Parameters::FLASH_MODE_OFF: 1612 reqAeMode = ANDROID_CONTROL_AE_ON; break; 1613 case Parameters::FLASH_MODE_AUTO: 1614 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break; 1615 case Parameters::FLASH_MODE_ON: 1616 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break; 1617 case Parameters::FLASH_MODE_TORCH: 1618 reqAeMode = ANDROID_CONTROL_AE_ON; 1619 reqFlashMode = ANDROID_FLASH_TORCH; 1620 break; 1621 case Parameters::FLASH_MODE_RED_EYE: 1622 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break; 1623 default: 1624 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__, 1625 cameraId, flashMode); 1626 return BAD_VALUE; 1627 } 1628 res = request->update(ANDROID_FLASH_MODE, 1629 &reqFlashMode, 1); 1630 if (res != OK) return res; 1631 res = request->update(ANDROID_CONTROL_AE_MODE, 1632 &reqAeMode, 1); 1633 if (res != OK) return res; 1634 1635 uint8_t reqAeLock = autoExposureLock ? 1636 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF; 1637 res = request->update(ANDROID_CONTROL_AE_LOCK, 1638 &reqAeLock, 1); 1639 if (res != OK) return res; 1640 1641 res = request->update(ANDROID_CONTROL_AWB_MODE, 1642 &wbMode, 1); 1643 if (res != OK) return res; 1644 1645 float reqFocusDistance = 0; // infinity focus in diopters 1646 uint8_t reqFocusMode = ANDROID_CONTROL_AF_OFF; 1647 switch (focusMode) { 1648 case Parameters::FOCUS_MODE_AUTO: 1649 case Parameters::FOCUS_MODE_MACRO: 1650 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1651 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1652 case Parameters::FOCUS_MODE_EDOF: 1653 reqFocusMode = focusMode; 1654 break; 1655 case Parameters::FOCUS_MODE_INFINITY: 1656 case Parameters::FOCUS_MODE_FIXED: 1657 reqFocusMode = ANDROID_CONTROL_AF_OFF; 1658 break; 1659 default: 1660 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__, 1661 cameraId, focusMode); 1662 return BAD_VALUE; 1663 } 1664 res = request->update(ANDROID_LENS_FOCUS_DISTANCE, 1665 &reqFocusDistance, 1); 1666 if (res != OK) return res; 1667 res = request->update(ANDROID_CONTROL_AF_MODE, 1668 &reqFocusMode, 1); 1669 if (res != OK) return res; 1670 1671 size_t reqFocusingAreasSize = focusingAreas.size() * 5; 1672 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize]; 1673 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) { 1674 if (focusingAreas[i].weight != 0) { 1675 reqFocusingAreas[i + 0] = 1676 normalizedXToArray(focusingAreas[i].left); 1677 reqFocusingAreas[i + 1] = 1678 normalizedYToArray(focusingAreas[i].top); 1679 reqFocusingAreas[i + 2] = 1680 normalizedXToArray(focusingAreas[i].right); 1681 reqFocusingAreas[i + 3] = 1682 normalizedYToArray(focusingAreas[i].bottom); 1683 } else { 1684 reqFocusingAreas[i + 0] = 0; 1685 reqFocusingAreas[i + 1] = 0; 1686 reqFocusingAreas[i + 2] = 0; 1687 reqFocusingAreas[i + 3] = 0; 1688 } 1689 reqFocusingAreas[i + 4] = focusingAreas[i].weight; 1690 } 1691 res = request->update(ANDROID_CONTROL_AF_REGIONS, 1692 reqFocusingAreas, reqFocusingAreasSize); 1693 if (res != OK) return res; 1694 delete[] reqFocusingAreas; 1695 1696 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION, 1697 &exposureCompensation, 1); 1698 if (res != OK) return res; 1699 1700 size_t reqMeteringAreasSize = meteringAreas.size() * 5; 1701 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize]; 1702 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) { 1703 if (meteringAreas[i].weight != 0) { 1704 reqMeteringAreas[i + 0] = 1705 normalizedXToArray(meteringAreas[i].left); 1706 reqMeteringAreas[i + 1] = 1707 normalizedYToArray(meteringAreas[i].top); 1708 reqMeteringAreas[i + 2] = 1709 normalizedXToArray(meteringAreas[i].right); 1710 reqMeteringAreas[i + 3] = 1711 normalizedYToArray(meteringAreas[i].bottom); 1712 } else { 1713 reqMeteringAreas[i + 0] = 0; 1714 reqMeteringAreas[i + 1] = 0; 1715 reqMeteringAreas[i + 2] = 0; 1716 reqMeteringAreas[i + 3] = 0; 1717 } 1718 reqMeteringAreas[i + 4] = meteringAreas[i].weight; 1719 } 1720 res = request->update(ANDROID_CONTROL_AE_REGIONS, 1721 reqMeteringAreas, reqMeteringAreasSize); 1722 if (res != OK) return res; 1723 1724 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 1725 reqMeteringAreas, reqMeteringAreasSize); 1726 if (res != OK) return res; 1727 delete[] reqMeteringAreas; 1728 1729 CropRegion crop = calculateCropRegion(); 1730 int32_t reqCropRegion[3] = { crop.left, crop.top, crop.width }; 1731 res = request->update(ANDROID_SCALER_CROP_REGION, 1732 reqCropRegion, 3); 1733 if (res != OK) return res; 1734 1735 uint8_t reqVstabMode = videoStabilization ? 1736 ANDROID_CONTROL_VIDEO_STABILIZATION_ON : 1737 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF; 1738 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 1739 &reqVstabMode, 1); 1740 if (res != OK) return res; 1741 1742 uint8_t reqFaceDetectMode = enableFaceDetect ? 1743 fastInfo.bestFaceDetectMode : 1744 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF; 1745 res = request->update(ANDROID_STATS_FACE_DETECT_MODE, 1746 &reqFaceDetectMode, 1); 1747 if (res != OK) return res; 1748 1749 return OK; 1750} 1751 1752status_t Parameters::updateRequestJpeg(CameraMetadata *request) const { 1753 status_t res; 1754 1755 res = request->update(ANDROID_JPEG_THUMBNAIL_SIZE, 1756 jpegThumbSize, 2); 1757 if (res != OK) return res; 1758 res = request->update(ANDROID_JPEG_THUMBNAIL_QUALITY, 1759 &jpegThumbQuality, 1); 1760 if (res != OK) return res; 1761 res = request->update(ANDROID_JPEG_QUALITY, 1762 &jpegQuality, 1); 1763 if (res != OK) return res; 1764 res = request->update( 1765 ANDROID_JPEG_ORIENTATION, 1766 &jpegRotation, 1); 1767 if (res != OK) return res; 1768 1769 if (gpsEnabled) { 1770 res = request->update( 1771 ANDROID_JPEG_GPS_COORDINATES, 1772 gpsCoordinates, 3); 1773 if (res != OK) return res; 1774 res = request->update( 1775 ANDROID_JPEG_GPS_TIMESTAMP, 1776 &gpsTimestamp, 1); 1777 if (res != OK) return res; 1778 res = request->update( 1779 ANDROID_JPEG_GPS_PROCESSING_METHOD, 1780 gpsProcessingMethod); 1781 if (res != OK) return res; 1782 } else { 1783 res = request->erase(ANDROID_JPEG_GPS_COORDINATES); 1784 if (res != OK) return res; 1785 res = request->erase(ANDROID_JPEG_GPS_TIMESTAMP); 1786 if (res != OK) return res; 1787 res = request->erase(ANDROID_JPEG_GPS_PROCESSING_METHOD); 1788 if (res != OK) return res; 1789 } 1790 return OK; 1791} 1792 1793 1794const char* Parameters::getStateName(State state) { 1795#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break; 1796 switch(state) { 1797 CASE_ENUM_TO_CHAR(DISCONNECTED) 1798 CASE_ENUM_TO_CHAR(STOPPED) 1799 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW) 1800 CASE_ENUM_TO_CHAR(PREVIEW) 1801 CASE_ENUM_TO_CHAR(RECORD) 1802 CASE_ENUM_TO_CHAR(STILL_CAPTURE) 1803 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT) 1804 default: 1805 return "Unknown state!"; 1806 break; 1807 } 1808#undef CASE_ENUM_TO_CHAR 1809} 1810 1811int Parameters::formatStringToEnum(const char *format) { 1812 return 1813 !format ? 1814 HAL_PIXEL_FORMAT_YCrCb_420_SP : 1815 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ? 1816 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16 1817 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ? 1818 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21 1819 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ? 1820 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2 1821 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ? 1822 HAL_PIXEL_FORMAT_YV12 : // YV12 1823 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ? 1824 HAL_PIXEL_FORMAT_RGB_565 : // RGB565 1825 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ? 1826 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888 1827 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ? 1828 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data 1829 -1; 1830} 1831 1832const char* Parameters::formatEnumToString(int format) { 1833 const char *fmt; 1834 switch(format) { 1835 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1836 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 1837 break; 1838 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1839 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 1840 break; 1841 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1842 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 1843 break; 1844 case HAL_PIXEL_FORMAT_YV12: // YV12 1845 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 1846 break; 1847 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 1848 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 1849 break; 1850 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 1851 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 1852 break; 1853 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1854 ALOGW("Raw sensor preview format requested."); 1855 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 1856 break; 1857 default: 1858 ALOGE("%s: Unknown preview format: %x", 1859 __FUNCTION__, format); 1860 fmt = NULL; 1861 break; 1862 } 1863 return fmt; 1864} 1865 1866int Parameters::wbModeStringToEnum(const char *wbMode) { 1867 return 1868 !wbMode ? 1869 ANDROID_CONTROL_AWB_AUTO : 1870 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ? 1871 ANDROID_CONTROL_AWB_AUTO : 1872 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ? 1873 ANDROID_CONTROL_AWB_INCANDESCENT : 1874 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ? 1875 ANDROID_CONTROL_AWB_FLUORESCENT : 1876 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ? 1877 ANDROID_CONTROL_AWB_WARM_FLUORESCENT : 1878 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ? 1879 ANDROID_CONTROL_AWB_DAYLIGHT : 1880 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ? 1881 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT : 1882 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ? 1883 ANDROID_CONTROL_AWB_TWILIGHT : 1884 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ? 1885 ANDROID_CONTROL_AWB_SHADE : 1886 -1; 1887} 1888 1889const char* Parameters::wbModeEnumToString(uint8_t wbMode) { 1890 switch (wbMode) { 1891 case ANDROID_CONTROL_AWB_AUTO: 1892 return CameraParameters::WHITE_BALANCE_AUTO; 1893 case ANDROID_CONTROL_AWB_INCANDESCENT: 1894 return CameraParameters::WHITE_BALANCE_INCANDESCENT; 1895 case ANDROID_CONTROL_AWB_FLUORESCENT: 1896 return CameraParameters::WHITE_BALANCE_FLUORESCENT; 1897 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT: 1898 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 1899 case ANDROID_CONTROL_AWB_DAYLIGHT: 1900 return CameraParameters::WHITE_BALANCE_DAYLIGHT; 1901 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT: 1902 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 1903 case ANDROID_CONTROL_AWB_TWILIGHT: 1904 return CameraParameters::WHITE_BALANCE_TWILIGHT; 1905 case ANDROID_CONTROL_AWB_SHADE: 1906 return CameraParameters::WHITE_BALANCE_SHADE; 1907 default: 1908 ALOGE("%s: Unknown AWB mode enum: %d", 1909 __FUNCTION__, wbMode); 1910 return "unknown"; 1911 } 1912} 1913 1914int Parameters::effectModeStringToEnum(const char *effectMode) { 1915 return 1916 !effectMode ? 1917 ANDROID_CONTROL_EFFECT_OFF : 1918 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ? 1919 ANDROID_CONTROL_EFFECT_OFF : 1920 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ? 1921 ANDROID_CONTROL_EFFECT_MONO : 1922 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ? 1923 ANDROID_CONTROL_EFFECT_NEGATIVE : 1924 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ? 1925 ANDROID_CONTROL_EFFECT_SOLARIZE : 1926 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ? 1927 ANDROID_CONTROL_EFFECT_SEPIA : 1928 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ? 1929 ANDROID_CONTROL_EFFECT_POSTERIZE : 1930 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ? 1931 ANDROID_CONTROL_EFFECT_WHITEBOARD : 1932 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ? 1933 ANDROID_CONTROL_EFFECT_BLACKBOARD : 1934 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ? 1935 ANDROID_CONTROL_EFFECT_AQUA : 1936 -1; 1937} 1938 1939int Parameters::abModeStringToEnum(const char *abMode) { 1940 return 1941 !abMode ? 1942 ANDROID_CONTROL_AE_ANTIBANDING_AUTO : 1943 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ? 1944 ANDROID_CONTROL_AE_ANTIBANDING_AUTO : 1945 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ? 1946 ANDROID_CONTROL_AE_ANTIBANDING_OFF : 1947 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ? 1948 ANDROID_CONTROL_AE_ANTIBANDING_50HZ : 1949 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ? 1950 ANDROID_CONTROL_AE_ANTIBANDING_60HZ : 1951 -1; 1952} 1953 1954int Parameters::sceneModeStringToEnum(const char *sceneMode) { 1955 return 1956 !sceneMode ? 1957 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED : 1958 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ? 1959 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED : 1960 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ? 1961 ANDROID_CONTROL_SCENE_MODE_ACTION : 1962 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ? 1963 ANDROID_CONTROL_SCENE_MODE_PORTRAIT : 1964 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ? 1965 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE : 1966 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ? 1967 ANDROID_CONTROL_SCENE_MODE_NIGHT : 1968 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ? 1969 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT : 1970 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ? 1971 ANDROID_CONTROL_SCENE_MODE_THEATRE : 1972 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ? 1973 ANDROID_CONTROL_SCENE_MODE_BEACH : 1974 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ? 1975 ANDROID_CONTROL_SCENE_MODE_SNOW : 1976 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ? 1977 ANDROID_CONTROL_SCENE_MODE_SUNSET : 1978 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ? 1979 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO : 1980 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ? 1981 ANDROID_CONTROL_SCENE_MODE_FIREWORKS : 1982 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ? 1983 ANDROID_CONTROL_SCENE_MODE_SPORTS : 1984 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ? 1985 ANDROID_CONTROL_SCENE_MODE_PARTY : 1986 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ? 1987 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT : 1988 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ? 1989 ANDROID_CONTROL_SCENE_MODE_BARCODE: 1990 -1; 1991} 1992 1993Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum( 1994 const char *flashMode) { 1995 return 1996 !flashMode ? 1997 Parameters::FLASH_MODE_INVALID : 1998 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ? 1999 Parameters::FLASH_MODE_OFF : 2000 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ? 2001 Parameters::FLASH_MODE_AUTO : 2002 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ? 2003 Parameters::FLASH_MODE_ON : 2004 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ? 2005 Parameters::FLASH_MODE_RED_EYE : 2006 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ? 2007 Parameters::FLASH_MODE_TORCH : 2008 Parameters::FLASH_MODE_INVALID; 2009} 2010 2011const char *Parameters::flashModeEnumToString(flashMode_t flashMode) { 2012 switch (flashMode) { 2013 case FLASH_MODE_OFF: 2014 return CameraParameters::FLASH_MODE_OFF; 2015 case FLASH_MODE_AUTO: 2016 return CameraParameters::FLASH_MODE_AUTO; 2017 case FLASH_MODE_ON: 2018 return CameraParameters::FLASH_MODE_ON; 2019 case FLASH_MODE_RED_EYE: 2020 return CameraParameters::FLASH_MODE_RED_EYE; 2021 case FLASH_MODE_TORCH: 2022 return CameraParameters::FLASH_MODE_TORCH; 2023 default: 2024 ALOGE("%s: Unknown flash mode enum %d", 2025 __FUNCTION__, flashMode); 2026 return "unknown"; 2027 } 2028} 2029 2030Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum( 2031 const char *focusMode) { 2032 return 2033 !focusMode ? 2034 Parameters::FOCUS_MODE_INVALID : 2035 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ? 2036 Parameters::FOCUS_MODE_AUTO : 2037 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ? 2038 Parameters::FOCUS_MODE_INFINITY : 2039 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ? 2040 Parameters::FOCUS_MODE_MACRO : 2041 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ? 2042 Parameters::FOCUS_MODE_FIXED : 2043 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ? 2044 Parameters::FOCUS_MODE_EDOF : 2045 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ? 2046 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO : 2047 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ? 2048 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE : 2049 Parameters::FOCUS_MODE_INVALID; 2050} 2051 2052const char *Parameters::focusModeEnumToString(focusMode_t focusMode) { 2053 switch (focusMode) { 2054 case FOCUS_MODE_AUTO: 2055 return CameraParameters::FOCUS_MODE_AUTO; 2056 case FOCUS_MODE_MACRO: 2057 return CameraParameters::FOCUS_MODE_MACRO; 2058 case FOCUS_MODE_CONTINUOUS_VIDEO: 2059 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 2060 case FOCUS_MODE_CONTINUOUS_PICTURE: 2061 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 2062 case FOCUS_MODE_EDOF: 2063 return CameraParameters::FOCUS_MODE_EDOF; 2064 case FOCUS_MODE_INFINITY: 2065 return CameraParameters::FOCUS_MODE_INFINITY; 2066 case FOCUS_MODE_FIXED: 2067 return CameraParameters::FOCUS_MODE_FIXED; 2068 default: 2069 ALOGE("%s: Unknown focus mode enum: %d", 2070 __FUNCTION__, focusMode); 2071 return "unknown"; 2072 } 2073} 2074 2075status_t Parameters::parseAreas(const char *areasCStr, 2076 Vector<Parameters::Area> *areas) { 2077 static const size_t NUM_FIELDS = 5; 2078 areas->clear(); 2079 if (areasCStr == NULL) { 2080 // If no key exists, use default (0,0,0,0,0) 2081 areas->push(); 2082 return OK; 2083 } 2084 String8 areasStr(areasCStr); 2085 ssize_t areaStart = areasStr.find("(", 0) + 1; 2086 while (areaStart != 0) { 2087 const char* area = areasStr.string() + areaStart; 2088 char *numEnd; 2089 int vals[NUM_FIELDS]; 2090 for (size_t i = 0; i < NUM_FIELDS; i++) { 2091 errno = 0; 2092 vals[i] = strtol(area, &numEnd, 10); 2093 if (errno || numEnd == area) return BAD_VALUE; 2094 area = numEnd + 1; 2095 } 2096 areas->push(Parameters::Area( 2097 vals[0], vals[1], vals[2], vals[3], vals[4]) ); 2098 areaStart = areasStr.find("(", areaStart) + 1; 2099 } 2100 return OK; 2101} 2102 2103status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas, 2104 size_t maxRegions) { 2105 // Definition of valid area can be found in 2106 // include/camera/CameraParameters.h 2107 if (areas.size() == 0) return BAD_VALUE; 2108 if (areas.size() == 1) { 2109 if (areas[0].left == 0 && 2110 areas[0].top == 0 && 2111 areas[0].right == 0 && 2112 areas[0].bottom == 0 && 2113 areas[0].weight == 0) { 2114 // Single (0,0,0,0,0) entry is always valid (== driver decides) 2115 return OK; 2116 } 2117 } 2118 if (areas.size() > maxRegions) { 2119 ALOGE("%s: Too many areas requested: %d", 2120 __FUNCTION__, areas.size()); 2121 return BAD_VALUE; 2122 } 2123 2124 for (Vector<Parameters::Area>::const_iterator a = areas.begin(); 2125 a != areas.end(); a++) { 2126 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE; 2127 if (a->left < -1000 || a->left > 1000) return BAD_VALUE; 2128 if (a->top < -1000 || a->top > 1000) return BAD_VALUE; 2129 if (a->right < -1000 || a->right > 1000) return BAD_VALUE; 2130 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE; 2131 if (a->left >= a->right) return BAD_VALUE; 2132 if (a->top >= a->bottom) return BAD_VALUE; 2133 } 2134 return OK; 2135} 2136 2137bool Parameters::boolFromString(const char *boolStr) { 2138 return !boolStr ? false : 2139 !strcmp(boolStr, CameraParameters::TRUE) ? true : 2140 false; 2141} 2142 2143int Parameters::degToTransform(int degrees, bool mirror) { 2144 if (!mirror) { 2145 if (degrees == 0) return 0; 2146 else if (degrees == 90) return HAL_TRANSFORM_ROT_90; 2147 else if (degrees == 180) return HAL_TRANSFORM_ROT_180; 2148 else if (degrees == 270) return HAL_TRANSFORM_ROT_270; 2149 } else { // Do mirror (horizontal flip) 2150 if (degrees == 0) { // FLIP_H and ROT_0 2151 return HAL_TRANSFORM_FLIP_H; 2152 } else if (degrees == 90) { // FLIP_H and ROT_90 2153 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90; 2154 } else if (degrees == 180) { // FLIP_H and ROT_180 2155 return HAL_TRANSFORM_FLIP_V; 2156 } else if (degrees == 270) { // FLIP_H and ROT_270 2157 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90; 2158 } 2159 } 2160 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees); 2161 return -1; 2162} 2163 2164int Parameters::arrayXToNormalized(int width) const { 2165 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000; 2166} 2167 2168int Parameters::arrayYToNormalized(int height) const { 2169 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000; 2170} 2171 2172int Parameters::normalizedXToArray(int x) const { 2173 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000; 2174} 2175 2176int Parameters::normalizedYToArray(int y) const { 2177 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000; 2178} 2179 2180Parameters::CropRegion Parameters::calculateCropRegion(void) const { 2181 2182 float zoomLeft, zoomTop, zoomWidth, zoomHeight; 2183 2184 // Need to convert zoom index into a crop rectangle. The rectangle is 2185 // chosen to maximize its area on the sensor 2186 2187 camera_metadata_ro_entry_t maxDigitalZoom = 2188 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM); 2189 // For each zoom step by how many pixels more do we change the zoom 2190 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) / 2191 (NUM_ZOOM_STEPS-1); 2192 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w) 2193 // via interpolating zoom step into a zoom ratio 2194 float zoomRatio = 1 + zoomIncrement * zoom; 2195 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]), 2196 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f", 2197 maxDigitalZoom.data.f[0], zoomRatio); 2198 2199 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, " 2200 "previewHeight=%d, activeWidth=%d, activeHeight=%d", 2201 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth, 2202 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight); 2203 2204 /* 2205 * Assumption: On the HAL side each stream buffer calculates its crop 2206 * rectangle as follows: 2207 * cropRect = (zoomLeft, zoomRight, 2208 * zoomWidth, zoomHeight * zoomWidth / outputWidth); 2209 * 2210 * Note that if zoomWidth > bufferWidth, the new cropHeight > zoomHeight 2211 * (we can then get into trouble if the cropHeight > arrayHeight). 2212 * By selecting the zoomRatio based on the smallest outputRatio, we 2213 * guarantee this will never happen. 2214 */ 2215 2216 // Enumerate all possible output sizes, select the one with the smallest 2217 // aspect ratio 2218 float minOutputWidth, minOutputHeight, minOutputRatio; 2219 { 2220 float outputSizes[][2] = { 2221 { previewWidth, previewHeight }, 2222 { videoWidth, videoHeight }, 2223 /* don't include jpeg thumbnail size - it's valid for 2224 it to be set to (0,0), meaning 'no thumbnail' */ 2225 // { jpegThumbSize[0], jpegThumbSize[1] }, 2226 { pictureWidth, pictureHeight }, 2227 }; 2228 2229 minOutputWidth = outputSizes[0][0]; 2230 minOutputHeight = outputSizes[0][1]; 2231 minOutputRatio = minOutputWidth / minOutputHeight; 2232 for (unsigned int i = 0; 2233 i < sizeof(outputSizes) / sizeof(outputSizes[0]); 2234 ++i) { 2235 2236 float outputWidth = outputSizes[i][0]; 2237 float outputHeight = outputSizes[i][1]; 2238 float outputRatio = outputWidth / outputHeight; 2239 2240 if (minOutputRatio > outputRatio) { 2241 minOutputRatio = outputRatio; 2242 minOutputWidth = outputWidth; 2243 minOutputHeight = outputHeight; 2244 } 2245 2246 // and then use this output ratio instead of preview output ratio 2247 ALOGV("Enumerating output ratio %f = %f / %f, min is %f", 2248 outputRatio, outputWidth, outputHeight, minOutputRatio); 2249 } 2250 } 2251 2252 /* Ensure that the width/height never go out of bounds 2253 * by scaling across a diffent dimension if an out-of-bounds 2254 * possibility exists. 2255 * 2256 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by 2257 * calculating the zoomWidth from zoomHeight we'll actually get a 2258 * zoomheight > arrayheight 2259 */ 2260 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight; 2261 if (minOutputRatio >= arrayRatio) { 2262 // Adjust the height based on the width 2263 zoomWidth = fastInfo.arrayWidth / zoomRatio; 2264 zoomHeight = zoomWidth * 2265 minOutputHeight / minOutputWidth; 2266 2267 } else { 2268 // Adjust the width based on the height 2269 zoomHeight = fastInfo.arrayHeight / zoomRatio; 2270 zoomWidth = zoomHeight * 2271 minOutputWidth / minOutputHeight; 2272 } 2273 // centering the zoom area within the active area 2274 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2; 2275 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2; 2276 2277 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d", 2278 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom); 2279 2280 2281 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight }; 2282 return crop; 2283} 2284 2285int32_t Parameters::fpsFromRange(int32_t min, int32_t max) const { 2286 return max; 2287} 2288 2289}; // namespace camera2 2290}; // namespace android 2291