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 #include "hardware/camera_common.h" 33 #include <android/hardware/ICamera.h> 34 #include <media/MediaProfiles.h> 35 #include <media/mediarecorder.h> 36 37 namespace android { 38 namespace camera2 { 39 40 Parameters::Parameters(int cameraId, 41 int cameraFacing) : 42 cameraId(cameraId), 43 cameraFacing(cameraFacing), 44 info(NULL), 45 mDefaultSceneMode(ANDROID_CONTROL_SCENE_MODE_DISABLED) { 46 } 47 48 Parameters::~Parameters() { 49 } 50 51 status_t Parameters::initialize(CameraDeviceBase *device, int deviceVersion) { 52 status_t res; 53 if (device == nullptr) { 54 ALOGE("%s: device is null!", __FUNCTION__); 55 return BAD_VALUE; 56 } 57 58 const CameraMetadata& info = device->info(); 59 if (info.entryCount() == 0) { 60 ALOGE("%s: No static information provided!", __FUNCTION__); 61 return BAD_VALUE; 62 } 63 Parameters::info = &info; 64 mDeviceVersion = deviceVersion; 65 66 res = buildFastInfo(device); 67 if (res != OK) return res; 68 69 res = buildQuirks(); 70 if (res != OK) return res; 71 72 Size maxPreviewSize = { MAX_PREVIEW_WIDTH, MAX_PREVIEW_HEIGHT }; 73 // Treat the H.264 max size as the max supported video size. 74 MediaProfiles *videoEncoderProfiles = MediaProfiles::getInstance(); 75 Vector<video_encoder> encoders = videoEncoderProfiles->getVideoEncoders(); 76 int32_t maxVideoWidth = 0; 77 int32_t maxVideoHeight = 0; 78 for (size_t i = 0; i < encoders.size(); i++) { 79 int width = videoEncoderProfiles->getVideoEncoderParamByName( 80 "enc.vid.width.max", encoders[i]); 81 int height = videoEncoderProfiles->getVideoEncoderParamByName( 82 "enc.vid.height.max", encoders[i]); 83 // Treat width/height separately here to handle the case where different 84 // profile might report max size of different aspect ratio 85 if (width > maxVideoWidth) { 86 maxVideoWidth = width; 87 } 88 if (height > maxVideoHeight) { 89 maxVideoHeight = height; 90 } 91 } 92 // This is just an upper bound and may not be an actually valid video size 93 Size videoSizeUpperBound = {maxVideoWidth, maxVideoHeight}; 94 95 if (fastInfo.supportsPreferredConfigs) { 96 maxPreviewSize = getMaxSize(getPreferredPreviewSizes()); 97 videoSizeUpperBound = getMaxSize(getPreferredVideoSizes()); 98 } 99 100 res = getFilteredSizes(maxPreviewSize, &availablePreviewSizes); 101 if (res != OK) return res; 102 res = getFilteredSizes(videoSizeUpperBound, &availableVideoSizes); 103 if (res != OK) return res; 104 105 // Select initial preview and video size that's under the initial bound and 106 // on the list of both preview and recording sizes 107 previewWidth = 0; 108 previewHeight = 0; 109 for (size_t i = 0 ; i < availablePreviewSizes.size(); i++) { 110 int newWidth = availablePreviewSizes[i].width; 111 int newHeight = availablePreviewSizes[i].height; 112 if (newWidth >= previewWidth && newHeight >= previewHeight && 113 newWidth <= MAX_INITIAL_PREVIEW_WIDTH && 114 newHeight <= MAX_INITIAL_PREVIEW_HEIGHT) { 115 for (size_t j = 0; j < availableVideoSizes.size(); j++) { 116 if (availableVideoSizes[j].width == newWidth && 117 availableVideoSizes[j].height == newHeight) { 118 previewWidth = newWidth; 119 previewHeight = newHeight; 120 } 121 } 122 } 123 } 124 if (previewWidth == 0) { 125 ALOGE("%s: No initial preview size can be found!", __FUNCTION__); 126 return BAD_VALUE; 127 } 128 videoWidth = previewWidth; 129 videoHeight = previewHeight; 130 131 params.setPreviewSize(previewWidth, previewHeight); 132 params.setVideoSize(videoWidth, videoHeight); 133 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, 134 String8::format("%dx%d", 135 previewWidth, previewHeight)); 136 { 137 String8 supportedPreviewSizes; 138 for (size_t i = 0; i < availablePreviewSizes.size(); i++) { 139 if (i != 0) supportedPreviewSizes += ","; 140 supportedPreviewSizes += String8::format("%dx%d", 141 availablePreviewSizes[i].width, 142 availablePreviewSizes[i].height); 143 } 144 ALOGV("Supported preview sizes are: %s", supportedPreviewSizes.string()); 145 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 146 supportedPreviewSizes); 147 148 String8 supportedVideoSizes; 149 for (size_t i = 0; i < availableVideoSizes.size(); i++) { 150 if (i != 0) supportedVideoSizes += ","; 151 supportedVideoSizes += String8::format("%dx%d", 152 availableVideoSizes[i].width, 153 availableVideoSizes[i].height); 154 } 155 ALOGV("Supported video sizes are: %s", supportedVideoSizes.string()); 156 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, 157 supportedVideoSizes); 158 } 159 160 camera_metadata_ro_entry_t availableFpsRanges = 161 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 162 if (!availableFpsRanges.count) return NO_INIT; 163 164 previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 165 params.set(CameraParameters::KEY_PREVIEW_FORMAT, 166 formatEnumToString(previewFormat)); // NV21 167 168 previewTransform = degToTransform(0, 169 cameraFacing == CAMERA_FACING_FRONT); 170 171 { 172 String8 supportedPreviewFormats; 173 SortedVector<int32_t> outputFormats = getAvailableOutputFormats(); 174 bool addComma = false; 175 for (size_t i=0; i < outputFormats.size(); i++) { 176 if (addComma) supportedPreviewFormats += ","; 177 addComma = true; 178 switch (outputFormats[i]) { 179 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 180 supportedPreviewFormats += 181 CameraParameters::PIXEL_FORMAT_YUV422SP; 182 break; 183 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 184 supportedPreviewFormats += 185 CameraParameters::PIXEL_FORMAT_YUV420SP; 186 break; 187 case HAL_PIXEL_FORMAT_YCbCr_422_I: 188 supportedPreviewFormats += 189 CameraParameters::PIXEL_FORMAT_YUV422I; 190 break; 191 case HAL_PIXEL_FORMAT_YV12: 192 supportedPreviewFormats += 193 CameraParameters::PIXEL_FORMAT_YUV420P; 194 break; 195 case HAL_PIXEL_FORMAT_RGB_565: 196 supportedPreviewFormats += 197 CameraParameters::PIXEL_FORMAT_RGB565; 198 break; 199 case HAL_PIXEL_FORMAT_RGBA_8888: 200 supportedPreviewFormats += 201 CameraParameters::PIXEL_FORMAT_RGBA8888; 202 break; 203 case HAL_PIXEL_FORMAT_YCbCr_420_888: 204 // Flexible YUV allows both YV12 and NV21 205 supportedPreviewFormats += 206 CameraParameters::PIXEL_FORMAT_YUV420P; 207 supportedPreviewFormats += ","; 208 supportedPreviewFormats += 209 CameraParameters::PIXEL_FORMAT_YUV420SP; 210 break; 211 // Not advertizing JPEG, RAW16, etc, for preview formats 212 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 213 case HAL_PIXEL_FORMAT_RAW16: 214 case HAL_PIXEL_FORMAT_BLOB: 215 addComma = false; 216 break; 217 218 default: 219 ALOGW("%s: Camera %d: Unknown preview format: %x", 220 __FUNCTION__, cameraId, outputFormats[i]); 221 addComma = false; 222 break; 223 } 224 } 225 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 226 supportedPreviewFormats); 227 } 228 229 previewFpsRange[0] = fastInfo.bestStillCaptureFpsRange[0]; 230 previewFpsRange[1] = fastInfo.bestStillCaptureFpsRange[1]; 231 232 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but 233 // still have to do something sane for them 234 235 // NOTE: Not scaled like FPS range values are. 236 int previewFps = fpsFromRange(previewFpsRange[0], previewFpsRange[1]); 237 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE, 238 previewFps); 239 240 // PREVIEW_FPS_RANGE 241 // -- Order matters. Set range after single value to so that a roundtrip 242 // of setParameters(getParameters()) would keep the FPS range in higher 243 // order. 244 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 245 String8::format("%d,%d", 246 previewFpsRange[0] * kFpsToApiScale, 247 previewFpsRange[1] * kFpsToApiScale)); 248 249 { 250 String8 supportedPreviewFpsRange; 251 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 252 if (!isFpsSupported(availablePreviewSizes, 253 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, availableFpsRanges.data.i32[i+1])) { 254 continue; 255 } 256 if (supportedPreviewFpsRange.length() > 0) { 257 supportedPreviewFpsRange += ","; 258 } 259 supportedPreviewFpsRange += String8::format("(%d,%d)", 260 availableFpsRanges.data.i32[i] * kFpsToApiScale, 261 availableFpsRanges.data.i32[i+1] * kFpsToApiScale); 262 } 263 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 264 supportedPreviewFpsRange); 265 } 266 267 { 268 SortedVector<int32_t> sortedPreviewFrameRates; 269 270 String8 supportedPreviewFrameRates; 271 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 272 // from the [min, max] fps range use the max value 273 int fps = fpsFromRange(availableFpsRanges.data.i32[i], 274 availableFpsRanges.data.i32[i+1]); 275 if (!isFpsSupported(availablePreviewSizes, 276 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, fps)) { 277 continue; 278 } 279 // de-dupe frame rates 280 if (sortedPreviewFrameRates.indexOf(fps) == NAME_NOT_FOUND) { 281 sortedPreviewFrameRates.add(fps); 282 } 283 else { 284 continue; 285 } 286 287 if (sortedPreviewFrameRates.size() > 1) { 288 supportedPreviewFrameRates += ","; 289 } 290 291 supportedPreviewFrameRates += String8::format("%d", 292 fps); 293 294 ALOGV("%s: Supported preview frame rates: %s", 295 __FUNCTION__, supportedPreviewFrameRates.string()); 296 } 297 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 298 supportedPreviewFrameRates); 299 } 300 301 Vector<Size> availableJpegSizes = getAvailableJpegSizes(); 302 if (!availableJpegSizes.size()) return NO_INIT; 303 304 pictureWidth = availableJpegSizes[0].width; 305 pictureHeight = availableJpegSizes[0].height; 306 if (fastInfo.supportsPreferredConfigs) { 307 Size suggestedJpegSize = getMaxSize(getPreferredJpegSizes()); 308 pictureWidth = suggestedJpegSize.width; 309 pictureHeight = suggestedJpegSize.height; 310 } 311 pictureWidthLastSet = pictureWidth; 312 pictureHeightLastSet = pictureHeight; 313 pictureSizeOverriden = false; 314 315 params.setPictureSize(pictureWidth, 316 pictureHeight); 317 318 { 319 String8 supportedPictureSizes; 320 for (size_t i=0; i < availableJpegSizes.size(); i++) { 321 if (i != 0) supportedPictureSizes += ","; 322 supportedPictureSizes += String8::format("%dx%d", 323 availableJpegSizes[i].width, 324 availableJpegSizes[i].height); 325 } 326 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 327 supportedPictureSizes); 328 } 329 330 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 331 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 332 CameraParameters::PIXEL_FORMAT_JPEG); 333 334 camera_metadata_ro_entry_t availableJpegThumbnailSizes = 335 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 4); 336 if (!availableJpegThumbnailSizes.count) return NO_INIT; 337 338 // Pick the largest thumbnail size that matches still image aspect ratio. 339 ALOG_ASSERT(pictureWidth > 0 && pictureHeight > 0, 340 "Invalid picture size, %d x %d", pictureWidth, pictureHeight); 341 float picAspectRatio = static_cast<float>(pictureWidth) / pictureHeight; 342 Size thumbnailSize = 343 getMaxSizeForRatio( 344 picAspectRatio, 345 &availableJpegThumbnailSizes.data.i32[0], 346 availableJpegThumbnailSizes.count); 347 jpegThumbSize[0] = thumbnailSize.width; 348 jpegThumbSize[1] = thumbnailSize.height; 349 350 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 351 jpegThumbSize[0]); 352 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 353 jpegThumbSize[1]); 354 355 { 356 String8 supportedJpegThumbSizes; 357 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) { 358 if (i != 0) supportedJpegThumbSizes += ","; 359 supportedJpegThumbSizes += String8::format("%dx%d", 360 availableJpegThumbnailSizes.data.i32[i], 361 availableJpegThumbnailSizes.data.i32[i+1]); 362 } 363 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 364 supportedJpegThumbSizes); 365 } 366 367 jpegThumbQuality = 90; 368 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 369 jpegThumbQuality); 370 jpegQuality = 90; 371 params.set(CameraParameters::KEY_JPEG_QUALITY, 372 jpegQuality); 373 jpegRotation = 0; 374 params.set(CameraParameters::KEY_ROTATION, 375 jpegRotation); 376 377 gpsEnabled = false; 378 gpsCoordinates[0] = 0.0; 379 gpsCoordinates[1] = 0.0; 380 gpsCoordinates[2] = 0.0; 381 gpsTimestamp = 0; 382 gpsProcessingMethod = "unknown"; 383 // GPS fields in CameraParameters are not set by implementation 384 385 wbMode = ANDROID_CONTROL_AWB_MODE_AUTO; 386 params.set(CameraParameters::KEY_WHITE_BALANCE, 387 CameraParameters::WHITE_BALANCE_AUTO); 388 389 camera_metadata_ro_entry_t availableWhiteBalanceModes = 390 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 0, 0, false); 391 if (!availableWhiteBalanceModes.count) { 392 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 393 CameraParameters::WHITE_BALANCE_AUTO); 394 } else { 395 String8 supportedWhiteBalance; 396 bool addComma = false; 397 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) { 398 if (addComma) supportedWhiteBalance += ","; 399 addComma = true; 400 switch (availableWhiteBalanceModes.data.u8[i]) { 401 case ANDROID_CONTROL_AWB_MODE_AUTO: 402 supportedWhiteBalance += 403 CameraParameters::WHITE_BALANCE_AUTO; 404 break; 405 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT: 406 supportedWhiteBalance += 407 CameraParameters::WHITE_BALANCE_INCANDESCENT; 408 break; 409 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT: 410 supportedWhiteBalance += 411 CameraParameters::WHITE_BALANCE_FLUORESCENT; 412 break; 413 case ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT: 414 supportedWhiteBalance += 415 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 416 break; 417 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT: 418 supportedWhiteBalance += 419 CameraParameters::WHITE_BALANCE_DAYLIGHT; 420 break; 421 case ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT: 422 supportedWhiteBalance += 423 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 424 break; 425 case ANDROID_CONTROL_AWB_MODE_TWILIGHT: 426 supportedWhiteBalance += 427 CameraParameters::WHITE_BALANCE_TWILIGHT; 428 break; 429 case ANDROID_CONTROL_AWB_MODE_SHADE: 430 supportedWhiteBalance += 431 CameraParameters::WHITE_BALANCE_SHADE; 432 break; 433 // Skipping values not mappable to v1 API 434 case ANDROID_CONTROL_AWB_MODE_OFF: 435 addComma = false; 436 break; 437 default: 438 ALOGW("%s: Camera %d: Unknown white balance value: %d", 439 __FUNCTION__, cameraId, 440 availableWhiteBalanceModes.data.u8[i]); 441 addComma = false; 442 break; 443 } 444 } 445 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 446 supportedWhiteBalance); 447 } 448 449 effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 450 params.set(CameraParameters::KEY_EFFECT, 451 CameraParameters::EFFECT_NONE); 452 453 camera_metadata_ro_entry_t availableEffects = 454 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS, 0, 0, false); 455 if (!availableEffects.count) { 456 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, 457 CameraParameters::EFFECT_NONE); 458 } else { 459 String8 supportedEffects; 460 bool addComma = false; 461 for (size_t i=0; i < availableEffects.count; i++) { 462 if (addComma) supportedEffects += ","; 463 addComma = true; 464 switch (availableEffects.data.u8[i]) { 465 case ANDROID_CONTROL_EFFECT_MODE_OFF: 466 supportedEffects += 467 CameraParameters::EFFECT_NONE; 468 break; 469 case ANDROID_CONTROL_EFFECT_MODE_MONO: 470 supportedEffects += 471 CameraParameters::EFFECT_MONO; 472 break; 473 case ANDROID_CONTROL_EFFECT_MODE_NEGATIVE: 474 supportedEffects += 475 CameraParameters::EFFECT_NEGATIVE; 476 break; 477 case ANDROID_CONTROL_EFFECT_MODE_SOLARIZE: 478 supportedEffects += 479 CameraParameters::EFFECT_SOLARIZE; 480 break; 481 case ANDROID_CONTROL_EFFECT_MODE_SEPIA: 482 supportedEffects += 483 CameraParameters::EFFECT_SEPIA; 484 break; 485 case ANDROID_CONTROL_EFFECT_MODE_POSTERIZE: 486 supportedEffects += 487 CameraParameters::EFFECT_POSTERIZE; 488 break; 489 case ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD: 490 supportedEffects += 491 CameraParameters::EFFECT_WHITEBOARD; 492 break; 493 case ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD: 494 supportedEffects += 495 CameraParameters::EFFECT_BLACKBOARD; 496 break; 497 case ANDROID_CONTROL_EFFECT_MODE_AQUA: 498 supportedEffects += 499 CameraParameters::EFFECT_AQUA; 500 break; 501 default: 502 ALOGW("%s: Camera %d: Unknown effect value: %d", 503 __FUNCTION__, cameraId, availableEffects.data.u8[i]); 504 addComma = false; 505 break; 506 } 507 } 508 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects); 509 } 510 511 antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; 512 params.set(CameraParameters::KEY_ANTIBANDING, 513 CameraParameters::ANTIBANDING_AUTO); 514 515 camera_metadata_ro_entry_t availableAntibandingModes = 516 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 0, 0, false); 517 if (!availableAntibandingModes.count) { 518 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 519 CameraParameters::ANTIBANDING_OFF); 520 } else { 521 String8 supportedAntibanding; 522 bool addComma = false; 523 for (size_t i=0; i < availableAntibandingModes.count; i++) { 524 if (addComma) supportedAntibanding += ","; 525 addComma = true; 526 switch (availableAntibandingModes.data.u8[i]) { 527 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF: 528 supportedAntibanding += 529 CameraParameters::ANTIBANDING_OFF; 530 break; 531 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ: 532 supportedAntibanding += 533 CameraParameters::ANTIBANDING_50HZ; 534 break; 535 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ: 536 supportedAntibanding += 537 CameraParameters::ANTIBANDING_60HZ; 538 break; 539 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO: 540 supportedAntibanding += 541 CameraParameters::ANTIBANDING_AUTO; 542 break; 543 default: 544 ALOGW("%s: Camera %d: Unknown antibanding value: %d", 545 __FUNCTION__, cameraId, 546 availableAntibandingModes.data.u8[i]); 547 addComma = false; 548 break; 549 } 550 } 551 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 552 supportedAntibanding); 553 } 554 555 sceneMode = ANDROID_CONTROL_SCENE_MODE_DISABLED; 556 params.set(CameraParameters::KEY_SCENE_MODE, 557 CameraParameters::SCENE_MODE_AUTO); 558 559 camera_metadata_ro_entry_t availableSceneModes = 560 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 0, 0, false); 561 if (!availableSceneModes.count) { 562 params.remove(CameraParameters::KEY_SCENE_MODE); 563 } else { 564 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO); 565 bool addComma = true; 566 bool noSceneModes = false; 567 for (size_t i=0; i < availableSceneModes.count; i++) { 568 if (addComma) supportedSceneModes += ","; 569 addComma = true; 570 switch (availableSceneModes.data.u8[i]) { 571 case ANDROID_CONTROL_SCENE_MODE_DISABLED: 572 noSceneModes = true; 573 break; 574 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 575 // Face priority can be used as alternate default if supported. 576 // Per API contract it shouldn't override the user set flash, 577 // white balance and focus modes. 578 mDefaultSceneMode = availableSceneModes.data.u8[i]; 579 // Not in old API 580 addComma = false; 581 break; 582 case ANDROID_CONTROL_SCENE_MODE_ACTION: 583 supportedSceneModes += 584 CameraParameters::SCENE_MODE_ACTION; 585 break; 586 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT: 587 supportedSceneModes += 588 CameraParameters::SCENE_MODE_PORTRAIT; 589 break; 590 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE: 591 supportedSceneModes += 592 CameraParameters::SCENE_MODE_LANDSCAPE; 593 break; 594 case ANDROID_CONTROL_SCENE_MODE_NIGHT: 595 supportedSceneModes += 596 CameraParameters::SCENE_MODE_NIGHT; 597 break; 598 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT: 599 supportedSceneModes += 600 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT; 601 break; 602 case ANDROID_CONTROL_SCENE_MODE_THEATRE: 603 supportedSceneModes += 604 CameraParameters::SCENE_MODE_THEATRE; 605 break; 606 case ANDROID_CONTROL_SCENE_MODE_BEACH: 607 supportedSceneModes += 608 CameraParameters::SCENE_MODE_BEACH; 609 break; 610 case ANDROID_CONTROL_SCENE_MODE_SNOW: 611 supportedSceneModes += 612 CameraParameters::SCENE_MODE_SNOW; 613 break; 614 case ANDROID_CONTROL_SCENE_MODE_SUNSET: 615 supportedSceneModes += 616 CameraParameters::SCENE_MODE_SUNSET; 617 break; 618 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO: 619 supportedSceneModes += 620 CameraParameters::SCENE_MODE_STEADYPHOTO; 621 break; 622 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS: 623 supportedSceneModes += 624 CameraParameters::SCENE_MODE_FIREWORKS; 625 break; 626 case ANDROID_CONTROL_SCENE_MODE_SPORTS: 627 supportedSceneModes += 628 CameraParameters::SCENE_MODE_SPORTS; 629 break; 630 case ANDROID_CONTROL_SCENE_MODE_PARTY: 631 supportedSceneModes += 632 CameraParameters::SCENE_MODE_PARTY; 633 break; 634 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT: 635 supportedSceneModes += 636 CameraParameters::SCENE_MODE_CANDLELIGHT; 637 break; 638 case ANDROID_CONTROL_SCENE_MODE_BARCODE: 639 supportedSceneModes += 640 CameraParameters::SCENE_MODE_BARCODE; 641 break; 642 case ANDROID_CONTROL_SCENE_MODE_HDR: 643 supportedSceneModes += 644 CameraParameters::SCENE_MODE_HDR; 645 break; 646 default: 647 ALOGW("%s: Camera %d: Unknown scene mode value: %d", 648 __FUNCTION__, cameraId, 649 availableSceneModes.data.u8[i]); 650 addComma = false; 651 break; 652 } 653 } 654 if (!noSceneModes) { 655 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 656 supportedSceneModes); 657 } else { 658 params.remove(CameraParameters::KEY_SCENE_MODE); 659 } 660 } 661 662 bool isFlashAvailable = false; 663 camera_metadata_ro_entry_t flashAvailable = 664 staticInfo(ANDROID_FLASH_INFO_AVAILABLE, 0, 1, false); 665 if (flashAvailable.count) { 666 isFlashAvailable = flashAvailable.data.u8[0]; 667 } 668 669 camera_metadata_ro_entry_t availableAeModes = 670 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES, 0, 0, false); 671 672 flashMode = Parameters::FLASH_MODE_OFF; 673 if (isFlashAvailable) { 674 params.set(CameraParameters::KEY_FLASH_MODE, 675 CameraParameters::FLASH_MODE_OFF); 676 677 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF); 678 supportedFlashModes = supportedFlashModes + 679 "," + CameraParameters::FLASH_MODE_AUTO + 680 "," + CameraParameters::FLASH_MODE_ON + 681 "," + CameraParameters::FLASH_MODE_TORCH; 682 for (size_t i=0; i < availableAeModes.count; i++) { 683 if (availableAeModes.data.u8[i] == 684 ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE) { 685 supportedFlashModes = supportedFlashModes + "," + 686 CameraParameters::FLASH_MODE_RED_EYE; 687 break; 688 } 689 } 690 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 691 supportedFlashModes); 692 } else { 693 // No flash means null flash mode and supported flash modes keys, so 694 // remove them just to be safe 695 params.remove(CameraParameters::KEY_FLASH_MODE); 696 params.remove(CameraParameters::KEY_SUPPORTED_FLASH_MODES); 697 } 698 699 camera_metadata_ro_entry_t minFocusDistance = 700 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 1, false); 701 702 camera_metadata_ro_entry_t availableAfModes = 703 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES, 0, 0, false); 704 705 if (!minFocusDistance.count || minFocusDistance.data.f[0] == 0) { 706 // Fixed-focus lens 707 focusMode = Parameters::FOCUS_MODE_FIXED; 708 params.set(CameraParameters::KEY_FOCUS_MODE, 709 CameraParameters::FOCUS_MODE_FIXED); 710 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 711 CameraParameters::FOCUS_MODE_FIXED); 712 } else { 713 focusMode = Parameters::FOCUS_MODE_AUTO; 714 params.set(CameraParameters::KEY_FOCUS_MODE, 715 CameraParameters::FOCUS_MODE_AUTO); 716 String8 supportedFocusModes; 717 bool addComma = false; 718 camera_metadata_ro_entry_t focusDistanceCalibration = 719 staticInfo(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, 0, 0, false); 720 721 if (focusDistanceCalibration.count && 722 focusDistanceCalibration.data.u8[0] != 723 ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED) { 724 supportedFocusModes += CameraParameters::FOCUS_MODE_INFINITY; 725 addComma = true; 726 } 727 728 for (size_t i=0; i < availableAfModes.count; i++) { 729 if (addComma) supportedFocusModes += ","; 730 addComma = true; 731 switch (availableAfModes.data.u8[i]) { 732 case ANDROID_CONTROL_AF_MODE_AUTO: 733 supportedFocusModes += 734 CameraParameters::FOCUS_MODE_AUTO; 735 break; 736 case ANDROID_CONTROL_AF_MODE_MACRO: 737 supportedFocusModes += 738 CameraParameters::FOCUS_MODE_MACRO; 739 break; 740 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 741 supportedFocusModes += 742 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 743 break; 744 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 745 supportedFocusModes += 746 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 747 break; 748 case ANDROID_CONTROL_AF_MODE_EDOF: 749 supportedFocusModes += 750 CameraParameters::FOCUS_MODE_EDOF; 751 break; 752 // Not supported in old API 753 case ANDROID_CONTROL_AF_MODE_OFF: 754 addComma = false; 755 break; 756 default: 757 ALOGW("%s: Camera %d: Unknown AF mode value: %d", 758 __FUNCTION__, cameraId, availableAfModes.data.u8[i]); 759 addComma = false; 760 break; 761 } 762 } 763 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 764 supportedFocusModes); 765 } 766 focusState = ANDROID_CONTROL_AF_STATE_INACTIVE; 767 shadowFocusMode = FOCUS_MODE_INVALID; 768 769 aeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 770 camera_metadata_ro_entry_t max3aRegions = staticInfo(ANDROID_CONTROL_MAX_REGIONS, 771 Parameters::NUM_REGION, Parameters::NUM_REGION); 772 if (max3aRegions.count != Parameters::NUM_REGION) return NO_INIT; 773 774 int32_t maxNumFocusAreas = 0; 775 if (focusMode != Parameters::FOCUS_MODE_FIXED) { 776 maxNumFocusAreas = max3aRegions.data.i32[Parameters::REGION_AF]; 777 } 778 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, maxNumFocusAreas); 779 params.set(CameraParameters::KEY_FOCUS_AREAS, 780 "(0,0,0,0,0)"); 781 focusingAreas.clear(); 782 focusingAreas.add(Parameters::Area(0,0,0,0,0)); 783 784 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, fastInfo.defaultFocalLength); 785 786 float horizFov, vertFov; 787 res = calculatePictureFovs(&horizFov, &vertFov); 788 if (res != OK) { 789 ALOGE("%s: Can't calculate field of views!", __FUNCTION__); 790 return res; 791 } 792 793 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 794 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 795 796 exposureCompensation = 0; 797 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 798 exposureCompensation); 799 800 camera_metadata_ro_entry_t exposureCompensationRange = 801 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 2, 2); 802 if (!exposureCompensationRange.count) return NO_INIT; 803 804 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 805 exposureCompensationRange.data.i32[1]); 806 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 807 exposureCompensationRange.data.i32[0]); 808 809 camera_metadata_ro_entry_t exposureCompensationStep = 810 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_STEP, 1, 1); 811 if (!exposureCompensationStep.count) return NO_INIT; 812 813 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 814 (float)exposureCompensationStep.data.r[0].numerator / 815 exposureCompensationStep.data.r[0].denominator); 816 817 autoExposureLock = false; 818 autoExposureLockAvailable = false; 819 camera_metadata_ro_entry_t exposureLockAvailable = 820 staticInfo(ANDROID_CONTROL_AE_LOCK_AVAILABLE, 1, 1); 821 if ((0 < exposureLockAvailable.count) && 822 (ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE == 823 exposureLockAvailable.data.u8[0])) { 824 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 825 CameraParameters::FALSE); 826 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 827 CameraParameters::TRUE); 828 autoExposureLockAvailable = true; 829 } else { 830 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 831 CameraParameters::FALSE); 832 } 833 834 autoWhiteBalanceLock = false; 835 autoWhiteBalanceLockAvailable = false; 836 camera_metadata_ro_entry_t whitebalanceLockAvailable = 837 staticInfo(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, 1, 1); 838 if ((0 < whitebalanceLockAvailable.count) && 839 (ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE == 840 whitebalanceLockAvailable.data.u8[0])) { 841 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 842 CameraParameters::FALSE); 843 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 844 CameraParameters::TRUE); 845 autoWhiteBalanceLockAvailable = true; 846 } else { 847 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 848 CameraParameters::FALSE); 849 } 850 851 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 852 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 853 max3aRegions.data.i32[Parameters::REGION_AE]); 854 params.set(CameraParameters::KEY_METERING_AREAS, 855 "(0,0,0,0,0)"); 856 857 zoom = 0; 858 zoomAvailable = false; 859 camera_metadata_ro_entry_t maxDigitalZoom = 860 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, /*minCount*/1, /*maxCount*/1); 861 if (!maxDigitalZoom.count) return NO_INIT; 862 863 if (fabs(maxDigitalZoom.data.f[0] - 1.f) > 0.00001f) { 864 params.set(CameraParameters::KEY_ZOOM, zoom); 865 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 866 867 { 868 String8 zoomRatios; 869 float zoom = 1.f; 870 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 871 (NUM_ZOOM_STEPS-1); 872 bool addComma = false; 873 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 874 if (addComma) zoomRatios += ","; 875 addComma = true; 876 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 877 zoom += zoomIncrement; 878 } 879 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 880 } 881 882 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 883 CameraParameters::TRUE); 884 zoomAvailable = true; 885 } else { 886 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 887 CameraParameters::FALSE); 888 } 889 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 890 CameraParameters::FALSE); 891 892 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 893 "Infinity,Infinity,Infinity"); 894 895 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 896 fastInfo.maxFaces); 897 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 898 0); 899 900 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 901 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE); 902 903 recordingHint = false; 904 params.set(CameraParameters::KEY_RECORDING_HINT, 905 CameraParameters::FALSE); 906 907 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 908 CameraParameters::TRUE); 909 910 videoStabilization = false; 911 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 912 CameraParameters::FALSE); 913 914 camera_metadata_ro_entry_t availableVideoStabilizationModes = 915 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 0, 0, 916 false); 917 918 if (availableVideoStabilizationModes.count > 1) { 919 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 920 CameraParameters::TRUE); 921 } else { 922 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 923 CameraParameters::FALSE); 924 } 925 926 // Set up initial state for non-Camera.Parameters state variables 927 videoFormat = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; 928 videoDataSpace = HAL_DATASPACE_V0_BT709; 929 videoBufferMode = hardware::ICamera::VIDEO_BUFFER_MODE_DATA_CALLBACK_YUV; 930 playShutterSound = true; 931 enableFaceDetect = false; 932 933 enableFocusMoveMessages = false; 934 afTriggerCounter = 1; 935 afStateCounter = 0; 936 currentAfTriggerId = -1; 937 afInMotion = false; 938 939 precaptureTriggerCounter = 1; 940 941 takePictureCounter = 0; 942 943 previewCallbackFlags = 0; 944 previewCallbackOneShot = false; 945 previewCallbackSurface = false; 946 947 Size maxJpegSize = getMaxSize(getAvailableJpegSizes()); 948 int64_t minFrameDurationNs = getJpegStreamMinFrameDurationNs(maxJpegSize); 949 950 slowJpegMode = false; 951 if (minFrameDurationNs > kSlowJpegModeThreshold) { 952 slowJpegMode = true; 953 // Slow jpeg devices does not support video snapshot without 954 // slowing down preview. 955 // TODO: support video size video snapshot only? 956 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 957 CameraParameters::FALSE); 958 } 959 960 isZslReprocessPresent = false; 961 camera_metadata_ro_entry_t availableCapabilities = 962 staticInfo(ANDROID_REQUEST_AVAILABLE_CAPABILITIES); 963 if (0 < availableCapabilities.count) { 964 const uint8_t *caps = availableCapabilities.data.u8; 965 for (size_t i = 0; i < availableCapabilities.count; i++) { 966 if (ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING == 967 caps[i]) { 968 isZslReprocessPresent = true; 969 break; 970 } 971 } 972 } 973 974 isDistortionCorrectionSupported = false; 975 camera_metadata_ro_entry_t distortionCorrectionModes = 976 staticInfo(ANDROID_DISTORTION_CORRECTION_AVAILABLE_MODES); 977 for (size_t i = 0; i < distortionCorrectionModes.count; i++) { 978 if (distortionCorrectionModes.data.u8[i] != 979 ANDROID_DISTORTION_CORRECTION_MODE_OFF) { 980 isDistortionCorrectionSupported = true; 981 break; 982 } 983 } 984 985 if (isDeviceZslSupported || slowJpegMode || 986 property_get_bool("camera.disable_zsl_mode", false)) { 987 ALOGI("Camera %d: Disabling ZSL mode", cameraId); 988 allowZslMode = false; 989 } else { 990 allowZslMode = isZslReprocessPresent; 991 } 992 993 ALOGI("%s: allowZslMode: %d slowJpegMode %d", __FUNCTION__, allowZslMode, slowJpegMode); 994 995 state = STOPPED; 996 997 paramsFlattened = params.flatten(); 998 999 return OK; 1000 } 1001 1002 String8 Parameters::get() const { 1003 return paramsFlattened; 1004 } 1005 1006 status_t Parameters::buildFastInfo(CameraDeviceBase *device) { 1007 1008 camera_metadata_ro_entry_t activeArraySize = 1009 staticInfo(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 2, 4); 1010 if (!activeArraySize.count) return NO_INIT; 1011 int32_t arrayWidth; 1012 int32_t arrayHeight; 1013 if (activeArraySize.count == 2) { 1014 ALOGW("%s: Camera %d: activeArraySize is missing xmin/ymin!", 1015 __FUNCTION__, cameraId); 1016 arrayWidth = activeArraySize.data.i32[0]; 1017 arrayHeight = activeArraySize.data.i32[1]; 1018 } else if (activeArraySize.count == 4) { 1019 arrayWidth = activeArraySize.data.i32[2]; 1020 arrayHeight = activeArraySize.data.i32[3]; 1021 } else return NO_INIT; 1022 1023 fastInfo.supportsPreferredConfigs = 1024 info->exists(ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS); 1025 1026 // We'll set the target FPS range for still captures to be as wide 1027 // as possible to give the HAL maximum latitude for exposure selection 1028 camera_metadata_ro_entry_t availableFpsRanges = 1029 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 1030 if (availableFpsRanges.count < 2 || availableFpsRanges.count % 2 != 0) { 1031 return NO_INIT; 1032 } 1033 1034 // Get supported preview fps ranges, up to default maximum. 1035 Vector<Size> supportedPreviewSizes; 1036 Vector<FpsRange> supportedPreviewFpsRanges; 1037 Size previewSizeBound = { MAX_PREVIEW_WIDTH, MAX_PREVIEW_HEIGHT }; 1038 if (fastInfo.supportsPreferredConfigs) { 1039 previewSizeBound = getMaxSize(getPreferredPreviewSizes()); 1040 } 1041 status_t res = getFilteredSizes(previewSizeBound, &supportedPreviewSizes); 1042 if (res != OK) return res; 1043 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 1044 if (!isFpsSupported(supportedPreviewSizes, 1045 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, availableFpsRanges.data.i32[i+1]) || 1046 availableFpsRanges.data.i32[i+1] > MAX_DEFAULT_FPS) { 1047 continue; 1048 } 1049 FpsRange fpsRange = {availableFpsRanges.data.i32[i], availableFpsRanges.data.i32[i+1]}; 1050 supportedPreviewFpsRanges.add(fpsRange); 1051 } 1052 if (supportedPreviewFpsRanges.size() == 0) { 1053 ALOGE("Supported preview fps range is empty"); 1054 return NO_INIT; 1055 } 1056 1057 int32_t bestStillCaptureFpsRange[2] = { 1058 supportedPreviewFpsRanges[0].low, supportedPreviewFpsRanges[0].high 1059 }; 1060 int32_t curRange = 1061 bestStillCaptureFpsRange[1] - bestStillCaptureFpsRange[0]; 1062 for (size_t i = 1; i < supportedPreviewFpsRanges.size(); i ++) { 1063 int32_t nextRange = 1064 supportedPreviewFpsRanges[i].high - 1065 supportedPreviewFpsRanges[i].low; 1066 if ( (nextRange > curRange) || // Maximize size of FPS range first 1067 (nextRange == curRange && // Then minimize low-end FPS 1068 bestStillCaptureFpsRange[0] > supportedPreviewFpsRanges[i].low)) { 1069 1070 bestStillCaptureFpsRange[0] = supportedPreviewFpsRanges[i].low; 1071 bestStillCaptureFpsRange[1] = supportedPreviewFpsRanges[i].high; 1072 curRange = nextRange; 1073 } 1074 } 1075 1076 camera_metadata_ro_entry_t availableFaceDetectModes = 1077 staticInfo(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, 0, 0, 1078 false); 1079 1080 uint8_t bestFaceDetectMode = 1081 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; 1082 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) { 1083 switch (availableFaceDetectModes.data.u8[i]) { 1084 case ANDROID_STATISTICS_FACE_DETECT_MODE_OFF: 1085 break; 1086 case ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE: 1087 if (bestFaceDetectMode != 1088 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL) { 1089 bestFaceDetectMode = 1090 ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE; 1091 } 1092 break; 1093 case ANDROID_STATISTICS_FACE_DETECT_MODE_FULL: 1094 bestFaceDetectMode = 1095 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL; 1096 break; 1097 default: 1098 ALOGE("%s: Camera %d: Unknown face detect mode %d:", 1099 __FUNCTION__, cameraId, 1100 availableFaceDetectModes.data.u8[i]); 1101 return NO_INIT; 1102 } 1103 } 1104 1105 int32_t maxFaces = 0; 1106 camera_metadata_ro_entry_t maxFacesDetected = 1107 staticInfo(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 0, 1, false); 1108 if (maxFacesDetected.count) { 1109 maxFaces = maxFacesDetected.data.i32[0]; 1110 } 1111 1112 camera_metadata_ro_entry_t availableSceneModes = 1113 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 0, 0, false); 1114 camera_metadata_ro_entry_t sceneModeOverrides = 1115 staticInfo(ANDROID_CONTROL_SCENE_MODE_OVERRIDES, 0, 0, false); 1116 camera_metadata_ro_entry_t minFocusDistance = 1117 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 0, false); 1118 bool fixedLens = minFocusDistance.count == 0 || 1119 minFocusDistance.data.f[0] == 0; 1120 1121 camera_metadata_ro_entry_t focusDistanceCalibration = 1122 staticInfo(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, 0, 0, 1123 false); 1124 bool canFocusInfinity = (focusDistanceCalibration.count && 1125 focusDistanceCalibration.data.u8[0] != 1126 ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED); 1127 1128 res = getDefaultFocalLength(device); 1129 if (res != OK) return res; 1130 1131 SortedVector<int32_t> availableFormats = getAvailableOutputFormats(); 1132 if (!availableFormats.size()) return NO_INIT; 1133 1134 if (sceneModeOverrides.count > 0) { 1135 // sceneModeOverrides is defined to have 3 entries for each scene mode, 1136 // which are AE, AWB, and AF override modes the HAL wants for that scene 1137 // mode. 1138 const size_t kModesPerSceneMode = 3; 1139 if (sceneModeOverrides.count != 1140 availableSceneModes.count * kModesPerSceneMode) { 1141 ALOGE("%s: Camera %d: Scene mode override list is an " 1142 "unexpected size: %zu (expected %zu)", __FUNCTION__, 1143 cameraId, sceneModeOverrides.count, 1144 availableSceneModes.count * kModesPerSceneMode); 1145 return NO_INIT; 1146 } 1147 for (size_t i = 0; i < availableSceneModes.count; i++) { 1148 DeviceInfo::OverrideModes modes; 1149 uint8_t aeMode = 1150 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 0]; 1151 switch(aeMode) { 1152 case ANDROID_CONTROL_AE_MODE_ON: 1153 modes.flashMode = FLASH_MODE_OFF; 1154 break; 1155 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH: 1156 modes.flashMode = FLASH_MODE_AUTO; 1157 break; 1158 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH: 1159 modes.flashMode = FLASH_MODE_ON; 1160 break; 1161 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: 1162 modes.flashMode = FLASH_MODE_RED_EYE; 1163 break; 1164 default: 1165 ALOGE("%s: Unknown override AE mode: %d", __FUNCTION__, 1166 aeMode); 1167 modes.flashMode = FLASH_MODE_INVALID; 1168 break; 1169 } 1170 modes.wbMode = 1171 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 1]; 1172 uint8_t afMode = 1173 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 2]; 1174 switch(afMode) { 1175 case ANDROID_CONTROL_AF_MODE_OFF: 1176 if (!fixedLens && !canFocusInfinity) { 1177 ALOGE("%s: Camera %d: Scene mode override lists asks for" 1178 " fixed focus on a device with focuser but not" 1179 " calibrated for infinity focus", __FUNCTION__, 1180 cameraId); 1181 return NO_INIT; 1182 } 1183 modes.focusMode = fixedLens ? 1184 FOCUS_MODE_FIXED : FOCUS_MODE_INFINITY; 1185 break; 1186 case ANDROID_CONTROL_AF_MODE_AUTO: 1187 case ANDROID_CONTROL_AF_MODE_MACRO: 1188 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1189 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1190 case ANDROID_CONTROL_AF_MODE_EDOF: 1191 modes.focusMode = static_cast<focusMode_t>(afMode); 1192 break; 1193 default: 1194 ALOGE("%s: Unknown override AF mode: %d", __FUNCTION__, 1195 afMode); 1196 modes.focusMode = FOCUS_MODE_INVALID; 1197 break; 1198 } 1199 fastInfo.sceneModeOverrides.add(availableSceneModes.data.u8[i], 1200 modes); 1201 } 1202 } 1203 1204 fastInfo.arrayWidth = arrayWidth; 1205 fastInfo.arrayHeight = arrayHeight; 1206 fastInfo.bestStillCaptureFpsRange[0] = bestStillCaptureFpsRange[0]; 1207 fastInfo.bestStillCaptureFpsRange[1] = bestStillCaptureFpsRange[1]; 1208 fastInfo.bestFaceDetectMode = bestFaceDetectMode; 1209 fastInfo.maxFaces = maxFaces; 1210 1211 // Check if the HAL supports HAL_PIXEL_FORMAT_YCbCr_420_888 1212 fastInfo.useFlexibleYuv = false; 1213 for (size_t i = 0; i < availableFormats.size(); i++) { 1214 if (availableFormats[i] == HAL_PIXEL_FORMAT_YCbCr_420_888) { 1215 fastInfo.useFlexibleYuv = true; 1216 break; 1217 } 1218 } 1219 ALOGV("Camera %d: Flexible YUV %s supported", 1220 cameraId, fastInfo.useFlexibleYuv ? "is" : "is not"); 1221 1222 fastInfo.maxJpegSize = getMaxSize(getAvailableJpegSizes()); 1223 1224 isZslReprocessPresent = false; 1225 camera_metadata_ro_entry_t availableCapabilities = 1226 staticInfo(ANDROID_REQUEST_AVAILABLE_CAPABILITIES); 1227 if (0 < availableCapabilities.count) { 1228 const uint8_t *caps = availableCapabilities.data.u8; 1229 for (size_t i = 0; i < availableCapabilities.count; i++) { 1230 if (ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING == 1231 caps[i]) { 1232 isZslReprocessPresent = true; 1233 break; 1234 } 1235 } 1236 } 1237 if (isZslReprocessPresent) { 1238 Vector<StreamConfiguration> scs = getStreamConfigurations(); 1239 Size maxPrivInputSize = {0, 0}; 1240 for (const auto& sc : scs) { 1241 if (sc.isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT && 1242 sc.format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 1243 if (sc.width * sc.height > maxPrivInputSize.width * maxPrivInputSize.height) { 1244 maxPrivInputSize = {sc.width, sc.height}; 1245 } 1246 } 1247 } 1248 fastInfo.maxZslSize = maxPrivInputSize; 1249 } else { 1250 fastInfo.maxZslSize = {0, 0}; 1251 } 1252 1253 return OK; 1254 } 1255 1256 status_t Parameters::buildQuirks() { 1257 camera_metadata_ro_entry_t entry; 1258 entry = info->find(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO); 1259 quirks.triggerAfWithAuto = (entry.count != 0 && entry.data.u8[0] == 1); 1260 ALOGV_IF(quirks.triggerAfWithAuto, "Camera %d: Quirk triggerAfWithAuto enabled", 1261 cameraId); 1262 1263 entry = info->find(ANDROID_QUIRKS_USE_ZSL_FORMAT); 1264 quirks.useZslFormat = (entry.count != 0 && entry.data.u8[0] == 1); 1265 ALOGV_IF(quirks.useZslFormat, "Camera %d: Quirk useZslFormat enabled", 1266 cameraId); 1267 1268 entry = info->find(ANDROID_QUIRKS_METERING_CROP_REGION); 1269 quirks.meteringCropRegion = (entry.count != 0 && entry.data.u8[0] == 1); 1270 ALOGV_IF(quirks.meteringCropRegion, "Camera %d: Quirk meteringCropRegion" 1271 " enabled", cameraId); 1272 1273 entry = info->find(ANDROID_QUIRKS_USE_PARTIAL_RESULT); 1274 quirks.partialResults = (entry.count != 0 && entry.data.u8[0] == 1); 1275 ALOGV_IF(quirks.partialResults, "Camera %d: Quirk usePartialResult" 1276 " enabled", cameraId); 1277 1278 return OK; 1279 } 1280 1281 camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag, 1282 size_t minCount, size_t maxCount, bool required) const { 1283 camera_metadata_ro_entry_t entry = info->find(tag); 1284 const camera_metadata_t *metaBuffer = info->getAndLock(); 1285 1286 if (CC_UNLIKELY( entry.count == 0 ) && required) { 1287 const char* tagSection = get_local_camera_metadata_section_name(tag, 1288 metaBuffer); 1289 if (tagSection == NULL) tagSection = "<unknown>"; 1290 const char* tagName = get_local_camera_metadata_tag_name(tag, 1291 metaBuffer); 1292 if (tagName == NULL) tagName = "<unknown>"; 1293 1294 ALOGE("Error finding static metadata entry '%s.%s' (%x)", 1295 tagSection, tagName, tag); 1296 } else if (CC_UNLIKELY( 1297 (minCount != 0 && entry.count < minCount) || 1298 (maxCount != 0 && entry.count > maxCount) ) ) { 1299 const char* tagSection = get_local_camera_metadata_section_name(tag, 1300 metaBuffer); 1301 if (tagSection == NULL) tagSection = "<unknown>"; 1302 const char* tagName = get_local_camera_metadata_tag_name(tag, 1303 metaBuffer); 1304 if (tagName == NULL) tagName = "<unknown>"; 1305 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 1306 "Expected between %zu and %zu values, but got %zu values", 1307 tagSection, tagName, tag, minCount, maxCount, entry.count); 1308 } 1309 info->unlock(metaBuffer); 1310 1311 return entry; 1312 } 1313 1314 status_t Parameters::set(const String8& paramString) { 1315 status_t res; 1316 1317 CameraParameters2 newParams(paramString); 1318 1319 // TODO: Currently ignoring any changes to supposedly read-only parameters 1320 // such as supported preview sizes, etc. Should probably produce an error if 1321 // they're changed. 1322 1323 /** Extract and verify new parameters */ 1324 1325 size_t i; 1326 1327 Parameters validatedParams(*this); 1328 1329 // PREVIEW_SIZE 1330 newParams.getPreviewSize(&validatedParams.previewWidth, 1331 &validatedParams.previewHeight); 1332 1333 if (validatedParams.previewWidth != previewWidth || 1334 validatedParams.previewHeight != previewHeight) { 1335 if (state >= PREVIEW) { 1336 ALOGE("%s: Preview size cannot be updated when preview " 1337 "is active! (Currently %d x %d, requested %d x %d", 1338 __FUNCTION__, 1339 previewWidth, previewHeight, 1340 validatedParams.previewWidth, validatedParams.previewHeight); 1341 return BAD_VALUE; 1342 } 1343 for (i = 0; i < availablePreviewSizes.size(); i++) { 1344 if ((availablePreviewSizes[i].width == 1345 validatedParams.previewWidth) && 1346 (availablePreviewSizes[i].height == 1347 validatedParams.previewHeight)) break; 1348 } 1349 if (i == availablePreviewSizes.size()) { 1350 ALOGE("%s: Requested preview size %d x %d is not supported", 1351 __FUNCTION__, validatedParams.previewWidth, 1352 validatedParams.previewHeight); 1353 return BAD_VALUE; 1354 } 1355 } 1356 1357 // RECORDING_HINT (always supported) 1358 validatedParams.recordingHint = boolFromString( 1359 newParams.get(CameraParameters::KEY_RECORDING_HINT) ); 1360 IF_ALOGV() { // Avoid unused variable warning 1361 bool recordingHintChanged = 1362 validatedParams.recordingHint != recordingHint; 1363 if (recordingHintChanged) { 1364 ALOGV("%s: Recording hint changed to %d", 1365 __FUNCTION__, validatedParams.recordingHint); 1366 } 1367 } 1368 1369 // PREVIEW_FPS_RANGE 1370 1371 /** 1372 * Use the single FPS value if it was set later than the range. 1373 * Otherwise, use the range value. 1374 */ 1375 bool fpsUseSingleValue; 1376 { 1377 const char *fpsRange, *fpsSingle; 1378 1379 fpsSingle = newParams.get(CameraParameters::KEY_PREVIEW_FRAME_RATE); 1380 fpsRange = newParams.get(CameraParameters::KEY_PREVIEW_FPS_RANGE); 1381 1382 /** 1383 * Pick either the range or the single key if only one was set. 1384 * 1385 * If both are set, pick the one that has greater set order. 1386 */ 1387 if (fpsRange == NULL && fpsSingle == NULL) { 1388 ALOGE("%s: FPS was not set. One of %s or %s must be set.", 1389 __FUNCTION__, CameraParameters::KEY_PREVIEW_FRAME_RATE, 1390 CameraParameters::KEY_PREVIEW_FPS_RANGE); 1391 return BAD_VALUE; 1392 } else if (fpsRange == NULL) { 1393 fpsUseSingleValue = true; 1394 ALOGV("%s: FPS range not set, using FPS single value", 1395 __FUNCTION__); 1396 } else if (fpsSingle == NULL) { 1397 fpsUseSingleValue = false; 1398 ALOGV("%s: FPS single not set, using FPS range value", 1399 __FUNCTION__); 1400 } else { 1401 int fpsKeyOrder; 1402 res = newParams.compareSetOrder( 1403 CameraParameters::KEY_PREVIEW_FRAME_RATE, 1404 CameraParameters::KEY_PREVIEW_FPS_RANGE, 1405 &fpsKeyOrder); 1406 LOG_ALWAYS_FATAL_IF(res != OK, "Impossibly bad FPS keys"); 1407 1408 fpsUseSingleValue = (fpsKeyOrder > 0); 1409 1410 } 1411 1412 ALOGV("%s: Preview FPS value is used from '%s'", 1413 __FUNCTION__, fpsUseSingleValue ? "single" : "range"); 1414 } 1415 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0], 1416 &validatedParams.previewFpsRange[1]); 1417 1418 validatedParams.previewFpsRange[0] /= kFpsToApiScale; 1419 validatedParams.previewFpsRange[1] /= kFpsToApiScale; 1420 1421 // Ignore the FPS range if the FPS single has higher precedence 1422 if (!fpsUseSingleValue) { 1423 ALOGV("%s: Preview FPS range (%d, %d)", __FUNCTION__, 1424 validatedParams.previewFpsRange[0], 1425 validatedParams.previewFpsRange[1]); 1426 1427 camera_metadata_ro_entry_t availablePreviewFpsRanges = 1428 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 1429 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) { 1430 if ((availablePreviewFpsRanges.data.i32[i] == 1431 validatedParams.previewFpsRange[0]) && 1432 (availablePreviewFpsRanges.data.i32[i+1] == 1433 validatedParams.previewFpsRange[1]) ) { 1434 break; 1435 } 1436 } 1437 if (i == availablePreviewFpsRanges.count) { 1438 ALOGE("%s: Requested preview FPS range %d - %d is not supported", 1439 __FUNCTION__, validatedParams.previewFpsRange[0], 1440 validatedParams.previewFpsRange[1]); 1441 return BAD_VALUE; 1442 } 1443 } 1444 1445 // PREVIEW_FORMAT 1446 validatedParams.previewFormat = 1447 formatStringToEnum(newParams.getPreviewFormat()); 1448 if (validatedParams.previewFormat != previewFormat) { 1449 if (state >= PREVIEW) { 1450 ALOGE("%s: Preview format cannot be updated when preview " 1451 "is active!", __FUNCTION__); 1452 return BAD_VALUE; 1453 } 1454 SortedVector<int32_t> availableFormats = getAvailableOutputFormats(); 1455 // If using flexible YUV, always support NV21/YV12. Otherwise, check 1456 // HAL's list. 1457 if (! (fastInfo.useFlexibleYuv && 1458 (validatedParams.previewFormat == 1459 HAL_PIXEL_FORMAT_YCrCb_420_SP || 1460 validatedParams.previewFormat == 1461 HAL_PIXEL_FORMAT_YV12) ) ) { 1462 // Not using flexible YUV format, so check explicitly 1463 for (i = 0; i < availableFormats.size(); i++) { 1464 if (availableFormats[i] == validatedParams.previewFormat) break; 1465 } 1466 if (i == availableFormats.size()) { 1467 ALOGE("%s: Requested preview format %s (0x%x) is not supported", 1468 __FUNCTION__, newParams.getPreviewFormat(), 1469 validatedParams.previewFormat); 1470 return BAD_VALUE; 1471 } 1472 } 1473 } 1474 1475 // PREVIEW_FRAME_RATE Deprecated 1476 // - Use only if the single FPS value was set later than the FPS range 1477 if (fpsUseSingleValue) { 1478 int previewFps = newParams.getPreviewFrameRate(); 1479 ALOGV("%s: Preview FPS single value requested: %d", 1480 __FUNCTION__, previewFps); 1481 { 1482 camera_metadata_ro_entry_t availableFrameRates = 1483 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES); 1484 /** 1485 * If recording hint is set, find the range that encompasses 1486 * previewFps with the largest min index. 1487 * 1488 * If recording hint is not set, find the range with previewFps 1489 * with the smallest min index. 1490 * 1491 * Either way, in case of multiple ranges, break the tie by 1492 * selecting the smaller range. 1493 * 1494 * Always select range within 30fps if one exists. 1495 */ 1496 1497 // all ranges which have previewFps 1498 Vector<Range> candidateRanges; 1499 Vector<Range> candidateFastRanges; 1500 for (i = 0; i < availableFrameRates.count; i+=2) { 1501 Range r = { 1502 availableFrameRates.data.i32[i], 1503 availableFrameRates.data.i32[i+1] 1504 }; 1505 if (!isFpsSupported(availablePreviewSizes, 1506 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, r.max)) { 1507 continue; 1508 } 1509 1510 if (r.min <= previewFps && previewFps <= r.max) { 1511 if (r.max <= MAX_DEFAULT_FPS) { 1512 candidateRanges.push(r); 1513 } else { 1514 candidateFastRanges.push(r); 1515 } 1516 } 1517 } 1518 if (candidateRanges.isEmpty() && candidateFastRanges.isEmpty()) { 1519 ALOGE("%s: Requested preview frame rate %d is not supported", 1520 __FUNCTION__, previewFps); 1521 return BAD_VALUE; 1522 } 1523 1524 // most applicable range with targetFps 1525 Vector<Range>& ranges = 1526 candidateRanges.size() > 0 ? candidateRanges : candidateFastRanges; 1527 Range bestRange = ranges[0]; 1528 for (i = 1; i < ranges.size(); ++i) { 1529 Range r = ranges[i]; 1530 // Find by largest minIndex in recording mode 1531 if (validatedParams.recordingHint) { 1532 if (r.min > bestRange.min) { 1533 bestRange = r; 1534 } 1535 else if (r.min == bestRange.min && r.max < bestRange.max) { 1536 bestRange = r; 1537 } 1538 } 1539 // Find by smallest minIndex in preview mode 1540 else { 1541 if (r.min < bestRange.min) { 1542 bestRange = r; 1543 } 1544 else if (r.min == bestRange.min && r.max < bestRange.max) { 1545 bestRange = r; 1546 } 1547 } 1548 } 1549 1550 validatedParams.previewFpsRange[0] = 1551 bestRange.min; 1552 validatedParams.previewFpsRange[1] = 1553 bestRange.max; 1554 1555 ALOGV("%s: New preview FPS range: %d, %d, recordingHint = %d", 1556 __FUNCTION__, 1557 validatedParams.previewFpsRange[0], 1558 validatedParams.previewFpsRange[1], 1559 validatedParams.recordingHint); 1560 } 1561 } 1562 1563 /** 1564 * Update Preview FPS and Preview FPS ranges based on 1565 * what we actually set. 1566 * 1567 * This updates the API-visible (Camera.Parameters#getParameters) values of 1568 * the FPS fields, not only the internal versions. 1569 * 1570 * Order matters: The value that was set last takes precedence. 1571 * - If the client does a setParameters(getParameters()) we retain 1572 * the same order for preview FPS. 1573 */ 1574 if (!fpsUseSingleValue) { 1575 // Set fps single, then fps range (range wins) 1576 newParams.setPreviewFrameRate( 1577 fpsFromRange(/*min*/validatedParams.previewFpsRange[0], 1578 /*max*/validatedParams.previewFpsRange[1])); 1579 newParams.setPreviewFpsRange( 1580 validatedParams.previewFpsRange[0] * kFpsToApiScale, 1581 validatedParams.previewFpsRange[1] * kFpsToApiScale); 1582 } else { 1583 // Set fps range, then fps single (single wins) 1584 newParams.setPreviewFpsRange( 1585 validatedParams.previewFpsRange[0] * kFpsToApiScale, 1586 validatedParams.previewFpsRange[1] * kFpsToApiScale); 1587 // Set this to the same value, but with higher priority 1588 newParams.setPreviewFrameRate( 1589 newParams.getPreviewFrameRate()); 1590 } 1591 1592 // PICTURE_SIZE 1593 newParams.getPictureSize(&validatedParams.pictureWidth, 1594 &validatedParams.pictureHeight); 1595 if (validatedParams.pictureWidth != pictureWidth || 1596 validatedParams.pictureHeight != pictureHeight) { 1597 Vector<Size> availablePictureSizes = getAvailableJpegSizes(); 1598 for (i = 0; i < availablePictureSizes.size(); i++) { 1599 if ((availablePictureSizes[i].width == 1600 validatedParams.pictureWidth) && 1601 (availablePictureSizes[i].height == 1602 validatedParams.pictureHeight)) break; 1603 } 1604 if (i == availablePictureSizes.size()) { 1605 ALOGE("%s: Requested picture size %d x %d is not supported", 1606 __FUNCTION__, validatedParams.pictureWidth, 1607 validatedParams.pictureHeight); 1608 return BAD_VALUE; 1609 } 1610 } 1611 1612 // JPEG_THUMBNAIL_WIDTH/HEIGHT 1613 validatedParams.jpegThumbSize[0] = 1614 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 1615 validatedParams.jpegThumbSize[1] = 1616 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 1617 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] || 1618 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) { 1619 camera_metadata_ro_entry_t availableJpegThumbSizes = 1620 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES); 1621 for (i = 0; i < availableJpegThumbSizes.count; i+=2) { 1622 if ((availableJpegThumbSizes.data.i32[i] == 1623 validatedParams.jpegThumbSize[0]) && 1624 (availableJpegThumbSizes.data.i32[i+1] == 1625 validatedParams.jpegThumbSize[1])) break; 1626 } 1627 if (i == availableJpegThumbSizes.count) { 1628 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported", 1629 __FUNCTION__, validatedParams.jpegThumbSize[0], 1630 validatedParams.jpegThumbSize[1]); 1631 return BAD_VALUE; 1632 } 1633 } 1634 1635 // JPEG_THUMBNAIL_QUALITY 1636 int quality = newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 1637 // also makes sure quality fits in uint8_t 1638 if (quality < 0 || quality > 100) { 1639 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported", 1640 __FUNCTION__, quality); 1641 return BAD_VALUE; 1642 } 1643 validatedParams.jpegThumbQuality = quality; 1644 1645 // JPEG_QUALITY 1646 quality = newParams.getInt(CameraParameters::KEY_JPEG_QUALITY); 1647 // also makes sure quality fits in uint8_t 1648 if (quality < 0 || quality > 100) { 1649 ALOGE("%s: Requested JPEG quality %d is not supported", 1650 __FUNCTION__, quality); 1651 return BAD_VALUE; 1652 } 1653 validatedParams.jpegQuality = quality; 1654 1655 // ROTATION 1656 validatedParams.jpegRotation = 1657 newParams.getInt(CameraParameters::KEY_ROTATION); 1658 if (validatedParams.jpegRotation != 0 && 1659 validatedParams.jpegRotation != 90 && 1660 validatedParams.jpegRotation != 180 && 1661 validatedParams.jpegRotation != 270) { 1662 ALOGE("%s: Requested picture rotation angle %d is not supported", 1663 __FUNCTION__, validatedParams.jpegRotation); 1664 return BAD_VALUE; 1665 } 1666 1667 // GPS 1668 1669 const char *gpsLatStr = 1670 newParams.get(CameraParameters::KEY_GPS_LATITUDE); 1671 if (gpsLatStr != NULL) { 1672 const char *gpsLongStr = 1673 newParams.get(CameraParameters::KEY_GPS_LONGITUDE); 1674 const char *gpsAltitudeStr = 1675 newParams.get(CameraParameters::KEY_GPS_ALTITUDE); 1676 const char *gpsTimeStr = 1677 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP); 1678 const char *gpsProcMethodStr = 1679 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 1680 if (gpsLongStr == NULL || 1681 gpsAltitudeStr == NULL || 1682 gpsTimeStr == NULL || 1683 gpsProcMethodStr == NULL) { 1684 ALOGE("%s: Incomplete set of GPS parameters provided", 1685 __FUNCTION__); 1686 return BAD_VALUE; 1687 } 1688 char *endPtr; 1689 errno = 0; 1690 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr); 1691 if (errno || endPtr == gpsLatStr) { 1692 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr); 1693 return BAD_VALUE; 1694 } 1695 errno = 0; 1696 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr); 1697 if (errno || endPtr == gpsLongStr) { 1698 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr); 1699 return BAD_VALUE; 1700 } 1701 errno = 0; 1702 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr); 1703 if (errno || endPtr == gpsAltitudeStr) { 1704 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__, 1705 gpsAltitudeStr); 1706 return BAD_VALUE; 1707 } 1708 errno = 0; 1709 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10); 1710 if (errno || endPtr == gpsTimeStr) { 1711 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr); 1712 return BAD_VALUE; 1713 } 1714 validatedParams.gpsProcessingMethod = gpsProcMethodStr; 1715 1716 validatedParams.gpsEnabled = true; 1717 } else { 1718 validatedParams.gpsEnabled = false; 1719 } 1720 1721 // EFFECT 1722 validatedParams.effectMode = effectModeStringToEnum( 1723 newParams.get(CameraParameters::KEY_EFFECT) ); 1724 if (validatedParams.effectMode != effectMode) { 1725 camera_metadata_ro_entry_t availableEffectModes = 1726 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 1727 for (i = 0; i < availableEffectModes.count; i++) { 1728 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break; 1729 } 1730 if (i == availableEffectModes.count) { 1731 ALOGE("%s: Requested effect mode \"%s\" is not supported", 1732 __FUNCTION__, 1733 newParams.get(CameraParameters::KEY_EFFECT) ); 1734 return BAD_VALUE; 1735 } 1736 } 1737 1738 // ANTIBANDING 1739 validatedParams.antibandingMode = abModeStringToEnum( 1740 newParams.get(CameraParameters::KEY_ANTIBANDING) ); 1741 if (validatedParams.antibandingMode != antibandingMode) { 1742 camera_metadata_ro_entry_t availableAbModes = 1743 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 1744 for (i = 0; i < availableAbModes.count; i++) { 1745 if (validatedParams.antibandingMode == availableAbModes.data.u8[i]) 1746 break; 1747 } 1748 if (i == availableAbModes.count) { 1749 ALOGE("%s: Requested antibanding mode \"%s\" is not supported", 1750 __FUNCTION__, 1751 newParams.get(CameraParameters::KEY_ANTIBANDING)); 1752 return BAD_VALUE; 1753 } 1754 } 1755 1756 // SCENE_MODE 1757 validatedParams.sceneMode = sceneModeStringToEnum( 1758 newParams.get(CameraParameters::KEY_SCENE_MODE), mDefaultSceneMode); 1759 if (validatedParams.sceneMode != sceneMode && 1760 validatedParams.sceneMode != 1761 ANDROID_CONTROL_SCENE_MODE_DISABLED) { 1762 camera_metadata_ro_entry_t availableSceneModes = 1763 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 1764 for (i = 0; i < availableSceneModes.count; i++) { 1765 if (validatedParams.sceneMode == availableSceneModes.data.u8[i]) 1766 break; 1767 } 1768 if (i == availableSceneModes.count) { 1769 ALOGE("%s: Requested scene mode \"%s\" is not supported", 1770 __FUNCTION__, 1771 newParams.get(CameraParameters::KEY_SCENE_MODE)); 1772 return BAD_VALUE; 1773 } 1774 } 1775 bool sceneModeSet = 1776 validatedParams.sceneMode != mDefaultSceneMode; 1777 1778 // FLASH_MODE 1779 if (sceneModeSet) { 1780 validatedParams.flashMode = 1781 fastInfo.sceneModeOverrides. 1782 valueFor(validatedParams.sceneMode).flashMode; 1783 } else { 1784 validatedParams.flashMode = FLASH_MODE_INVALID; 1785 } 1786 if (validatedParams.flashMode == FLASH_MODE_INVALID) { 1787 validatedParams.flashMode = flashModeStringToEnum( 1788 newParams.get(CameraParameters::KEY_FLASH_MODE) ); 1789 } 1790 1791 if (validatedParams.flashMode != flashMode) { 1792 camera_metadata_ro_entry_t flashAvailable = 1793 staticInfo(ANDROID_FLASH_INFO_AVAILABLE, 1, 1); 1794 bool isFlashAvailable = 1795 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE; 1796 if (!isFlashAvailable && 1797 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) { 1798 ALOGE("%s: Requested flash mode \"%s\" is not supported: " 1799 "No flash on device", __FUNCTION__, 1800 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1801 return BAD_VALUE; 1802 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) { 1803 camera_metadata_ro_entry_t availableAeModes = 1804 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 1805 for (i = 0; i < availableAeModes.count; i++) { 1806 if (validatedParams.flashMode == availableAeModes.data.u8[i]) 1807 break; 1808 } 1809 if (i == availableAeModes.count) { 1810 ALOGE("%s: Requested flash mode \"%s\" is not supported", 1811 __FUNCTION__, 1812 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1813 return BAD_VALUE; 1814 } 1815 } else if (validatedParams.flashMode == -1) { 1816 ALOGE("%s: Requested flash mode \"%s\" is unknown", 1817 __FUNCTION__, 1818 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1819 return BAD_VALUE; 1820 } 1821 // Update in case of override, but only if flash is supported 1822 if (isFlashAvailable) { 1823 newParams.set(CameraParameters::KEY_FLASH_MODE, 1824 flashModeEnumToString(validatedParams.flashMode)); 1825 } 1826 } 1827 1828 // WHITE_BALANCE 1829 if (sceneModeSet) { 1830 validatedParams.wbMode = 1831 fastInfo.sceneModeOverrides. 1832 valueFor(validatedParams.sceneMode).wbMode; 1833 } else { 1834 validatedParams.wbMode = ANDROID_CONTROL_AWB_MODE_OFF; 1835 } 1836 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_MODE_OFF) { 1837 validatedParams.wbMode = wbModeStringToEnum( 1838 newParams.get(CameraParameters::KEY_WHITE_BALANCE) ); 1839 } 1840 if (validatedParams.wbMode != wbMode) { 1841 camera_metadata_ro_entry_t availableWbModes = 1842 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 0, 0, false); 1843 for (i = 0; i < availableWbModes.count; i++) { 1844 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break; 1845 } 1846 if (i == availableWbModes.count) { 1847 ALOGE("%s: Requested white balance mode %s is not supported", 1848 __FUNCTION__, 1849 newParams.get(CameraParameters::KEY_WHITE_BALANCE)); 1850 return BAD_VALUE; 1851 } 1852 // Update in case of override 1853 newParams.set(CameraParameters::KEY_WHITE_BALANCE, 1854 wbModeEnumToString(validatedParams.wbMode)); 1855 } 1856 1857 // FOCUS_MODE 1858 if (sceneModeSet) { 1859 validatedParams.focusMode = 1860 fastInfo.sceneModeOverrides. 1861 valueFor(validatedParams.sceneMode).focusMode; 1862 } else { 1863 validatedParams.focusMode = FOCUS_MODE_INVALID; 1864 } 1865 if (validatedParams.focusMode == FOCUS_MODE_INVALID) { 1866 validatedParams.focusMode = focusModeStringToEnum( 1867 newParams.get(CameraParameters::KEY_FOCUS_MODE) ); 1868 } 1869 if (validatedParams.focusMode != focusMode) { 1870 validatedParams.currentAfTriggerId = -1; 1871 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) { 1872 camera_metadata_ro_entry_t minFocusDistance = 1873 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 0, 1874 false); 1875 if (minFocusDistance.count && minFocusDistance.data.f[0] == 0) { 1876 ALOGE("%s: Requested focus mode \"%s\" is not available: " 1877 "fixed focus lens", 1878 __FUNCTION__, 1879 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1880 return BAD_VALUE; 1881 } else if (validatedParams.focusMode != 1882 Parameters::FOCUS_MODE_INFINITY) { 1883 camera_metadata_ro_entry_t availableFocusModes = 1884 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1885 for (i = 0; i < availableFocusModes.count; i++) { 1886 if (validatedParams.focusMode == 1887 availableFocusModes.data.u8[i]) break; 1888 } 1889 if (i == availableFocusModes.count) { 1890 ALOGE("%s: Requested focus mode \"%s\" is not supported", 1891 __FUNCTION__, 1892 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1893 return BAD_VALUE; 1894 } 1895 } 1896 } 1897 validatedParams.focusState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1898 // Always reset shadow focus mode to avoid reverting settings 1899 validatedParams.shadowFocusMode = FOCUS_MODE_INVALID; 1900 // Update in case of override 1901 newParams.set(CameraParameters::KEY_FOCUS_MODE, 1902 focusModeEnumToString(validatedParams.focusMode)); 1903 } else { 1904 validatedParams.currentAfTriggerId = currentAfTriggerId; 1905 } 1906 1907 // FOCUS_AREAS 1908 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS), 1909 &validatedParams.focusingAreas); 1910 size_t maxAfRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1911 Parameters::NUM_REGION, Parameters::NUM_REGION). 1912 data.i32[Parameters::REGION_AF]; 1913 if (res == OK) res = validateAreas(validatedParams.focusingAreas, 1914 maxAfRegions, AREA_KIND_FOCUS); 1915 if (res != OK) { 1916 ALOGE("%s: Requested focus areas are malformed: %s", 1917 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS)); 1918 return BAD_VALUE; 1919 } 1920 1921 // EXPOSURE_COMPENSATION 1922 validatedParams.exposureCompensation = 1923 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1924 camera_metadata_ro_entry_t exposureCompensationRange = 1925 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_RANGE); 1926 if ((validatedParams.exposureCompensation < 1927 exposureCompensationRange.data.i32[0]) || 1928 (validatedParams.exposureCompensation > 1929 exposureCompensationRange.data.i32[1])) { 1930 ALOGE("%s: Requested exposure compensation index is out of bounds: %d", 1931 __FUNCTION__, validatedParams.exposureCompensation); 1932 return BAD_VALUE; 1933 } 1934 1935 if (autoExposureLockAvailable) { 1936 validatedParams.autoExposureLock = boolFromString( 1937 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 1938 } else if (nullptr != 1939 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)){ 1940 ALOGE("%s: Requested auto exposure lock is not supported", 1941 __FUNCTION__); 1942 return BAD_VALUE; 1943 } 1944 1945 if (autoWhiteBalanceLockAvailable) { 1946 validatedParams.autoWhiteBalanceLock = boolFromString( 1947 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 1948 } else if (nullptr != 1949 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) { 1950 ALOGE("%s: Requested auto whitebalance lock is not supported", 1951 __FUNCTION__); 1952 return BAD_VALUE; 1953 } 1954 1955 // METERING_AREAS 1956 size_t maxAeRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1957 Parameters::NUM_REGION, Parameters::NUM_REGION). 1958 data.i32[Parameters::REGION_AE]; 1959 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS), 1960 &validatedParams.meteringAreas); 1961 if (res == OK) { 1962 res = validateAreas(validatedParams.meteringAreas, maxAeRegions, 1963 AREA_KIND_METERING); 1964 } 1965 if (res != OK) { 1966 ALOGE("%s: Requested metering areas are malformed: %s", 1967 __FUNCTION__, 1968 newParams.get(CameraParameters::KEY_METERING_AREAS)); 1969 return BAD_VALUE; 1970 } 1971 1972 // ZOOM 1973 if (zoomAvailable) { 1974 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM); 1975 if (validatedParams.zoom < 0 1976 || validatedParams.zoom >= (int)NUM_ZOOM_STEPS) { 1977 ALOGE("%s: Requested zoom level %d is not supported", 1978 __FUNCTION__, validatedParams.zoom); 1979 return BAD_VALUE; 1980 } 1981 } 1982 1983 // VIDEO_SIZE 1984 newParams.getVideoSize(&validatedParams.videoWidth, 1985 &validatedParams.videoHeight); 1986 if (validatedParams.videoWidth != videoWidth || 1987 validatedParams.videoHeight != videoHeight) { 1988 if (state == RECORD) { 1989 ALOGW("%s: Video size cannot be updated (from %d x %d to %d x %d)" 1990 " when recording is active! Ignore the size update!", 1991 __FUNCTION__, videoWidth, videoHeight, validatedParams.videoWidth, 1992 validatedParams.videoHeight); 1993 validatedParams.videoWidth = videoWidth; 1994 validatedParams.videoHeight = videoHeight; 1995 newParams.setVideoSize(videoWidth, videoHeight); 1996 } else { 1997 for (i = 0; i < availableVideoSizes.size(); i++) { 1998 if ((availableVideoSizes[i].width == 1999 validatedParams.videoWidth) && 2000 (availableVideoSizes[i].height == 2001 validatedParams.videoHeight)) break; 2002 } 2003 if (i == availableVideoSizes.size()) { 2004 ALOGE("%s: Requested video size %d x %d is not supported", 2005 __FUNCTION__, validatedParams.videoWidth, 2006 validatedParams.videoHeight); 2007 return BAD_VALUE; 2008 } 2009 } 2010 } 2011 2012 // VIDEO_STABILIZATION 2013 validatedParams.videoStabilization = boolFromString( 2014 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) ); 2015 camera_metadata_ro_entry_t availableVideoStabilizationModes = 2016 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 0, 0, 2017 false); 2018 if (validatedParams.videoStabilization && 2019 availableVideoStabilizationModes.count == 1) { 2020 ALOGE("%s: Video stabilization not supported", __FUNCTION__); 2021 } 2022 2023 /** Update internal parameters */ 2024 2025 *this = validatedParams; 2026 updateOverriddenJpegSize(); 2027 2028 /** Update external parameters calculated from the internal ones */ 2029 2030 // HORIZONTAL/VERTICAL FIELD OF VIEW 2031 float horizFov, vertFov; 2032 res = calculatePictureFovs(&horizFov, &vertFov); 2033 if (res != OK) { 2034 ALOGE("%s: Can't calculate FOVs", __FUNCTION__); 2035 // continue so parameters are at least consistent 2036 } 2037 newParams.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, 2038 horizFov); 2039 newParams.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, 2040 vertFov); 2041 ALOGV("Current still picture FOV: %f x %f deg", horizFov, vertFov); 2042 2043 // Need to flatten again in case of overrides 2044 paramsFlattened = newParams.flatten(); 2045 params = newParams; 2046 2047 slowJpegMode = false; 2048 Size pictureSize = { pictureWidth, pictureHeight }; 2049 int64_t minFrameDurationNs = getJpegStreamMinFrameDurationNs(pictureSize); 2050 if (previewFpsRange[1] > 1e9/minFrameDurationNs + FPS_MARGIN) { 2051 slowJpegMode = true; 2052 } 2053 if (isDeviceZslSupported || slowJpegMode || 2054 property_get_bool("camera.disable_zsl_mode", false)) { 2055 allowZslMode = false; 2056 } else { 2057 allowZslMode = isZslReprocessPresent; 2058 } 2059 ALOGV("%s: allowZslMode: %d slowJpegMode %d", __FUNCTION__, allowZslMode, slowJpegMode); 2060 2061 return OK; 2062 } 2063 2064 status_t Parameters::updateRequest(CameraMetadata *request) const { 2065 ATRACE_CALL(); 2066 status_t res; 2067 2068 /** 2069 * Mixin default important security values 2070 * - android.led.transmit = defaulted ON 2071 */ 2072 camera_metadata_ro_entry_t entry = staticInfo(ANDROID_LED_AVAILABLE_LEDS, 2073 /*minimumCount*/0, 2074 /*maximumCount*/0, 2075 /*required*/false); 2076 for(size_t i = 0; i < entry.count; ++i) { 2077 uint8_t led = entry.data.u8[i]; 2078 2079 switch(led) { 2080 // Transmit LED is unconditionally on when using 2081 // the android.hardware.Camera API 2082 case ANDROID_LED_AVAILABLE_LEDS_TRANSMIT: { 2083 uint8_t transmitDefault = ANDROID_LED_TRANSMIT_ON; 2084 res = request->update(ANDROID_LED_TRANSMIT, 2085 &transmitDefault, 1); 2086 if (res != OK) return res; 2087 break; 2088 } 2089 } 2090 } 2091 2092 /** 2093 * Construct metadata from parameters 2094 */ 2095 2096 uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; 2097 res = request->update(ANDROID_REQUEST_METADATA_MODE, 2098 &metadataMode, 1); 2099 if (res != OK) return res; 2100 2101 camera_metadata_entry_t intent = 2102 request->find(ANDROID_CONTROL_CAPTURE_INTENT); 2103 2104 if (intent.count == 0) return BAD_VALUE; 2105 2106 uint8_t distortionMode = ANDROID_DISTORTION_CORRECTION_MODE_OFF; 2107 if (intent.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE) { 2108 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 2109 fastInfo.bestStillCaptureFpsRange, 2); 2110 distortionMode = ANDROID_DISTORTION_CORRECTION_MODE_HIGH_QUALITY; 2111 } else { 2112 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 2113 previewFpsRange, 2); 2114 distortionMode = ANDROID_DISTORTION_CORRECTION_MODE_FAST; 2115 } 2116 if (res != OK) return res; 2117 2118 if (isDistortionCorrectionSupported) { 2119 res = request->update(ANDROID_DISTORTION_CORRECTION_MODE, 2120 &distortionMode, 1); 2121 if (res != OK) return res; 2122 } 2123 2124 if (autoWhiteBalanceLockAvailable) { 2125 uint8_t reqWbLock = autoWhiteBalanceLock ? 2126 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF; 2127 res = request->update(ANDROID_CONTROL_AWB_LOCK, 2128 &reqWbLock, 1); 2129 } 2130 2131 res = request->update(ANDROID_CONTROL_EFFECT_MODE, 2132 &effectMode, 1); 2133 if (res != OK) return res; 2134 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, 2135 &antibandingMode, 1); 2136 if (res != OK) return res; 2137 2138 // android.hardware.Camera requires that when face detect is enabled, the 2139 // camera is in a face-priority mode. HAL3.x splits this into separate parts 2140 // (face detection statistics and face priority scene mode). Map from other 2141 // to the other. 2142 bool sceneModeActive = 2143 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_DISABLED; 2144 uint8_t reqControlMode = ANDROID_CONTROL_MODE_AUTO; 2145 if (enableFaceDetect || sceneModeActive) { 2146 reqControlMode = ANDROID_CONTROL_MODE_USE_SCENE_MODE; 2147 } 2148 res = request->update(ANDROID_CONTROL_MODE, 2149 &reqControlMode, 1); 2150 if (res != OK) return res; 2151 2152 uint8_t reqSceneMode = 2153 sceneModeActive ? sceneMode : 2154 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : 2155 mDefaultSceneMode; 2156 res = request->update(ANDROID_CONTROL_SCENE_MODE, 2157 &reqSceneMode, 1); 2158 if (res != OK) return res; 2159 2160 uint8_t reqFlashMode = ANDROID_FLASH_MODE_OFF; 2161 uint8_t reqAeMode = ANDROID_CONTROL_AE_MODE_OFF; 2162 switch (flashMode) { 2163 case Parameters::FLASH_MODE_OFF: 2164 reqAeMode = ANDROID_CONTROL_AE_MODE_ON; break; 2165 case Parameters::FLASH_MODE_AUTO: 2166 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH; break; 2167 case Parameters::FLASH_MODE_ON: 2168 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH; break; 2169 case Parameters::FLASH_MODE_TORCH: 2170 reqAeMode = ANDROID_CONTROL_AE_MODE_ON; 2171 reqFlashMode = ANDROID_FLASH_MODE_TORCH; 2172 break; 2173 case Parameters::FLASH_MODE_RED_EYE: 2174 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE; break; 2175 default: 2176 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__, 2177 cameraId, flashMode); 2178 return BAD_VALUE; 2179 } 2180 res = request->update(ANDROID_FLASH_MODE, 2181 &reqFlashMode, 1); 2182 if (res != OK) return res; 2183 res = request->update(ANDROID_CONTROL_AE_MODE, 2184 &reqAeMode, 1); 2185 if (res != OK) return res; 2186 2187 if (autoExposureLockAvailable) { 2188 uint8_t reqAeLock = autoExposureLock ? 2189 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF; 2190 res = request->update(ANDROID_CONTROL_AE_LOCK, 2191 &reqAeLock, 1); 2192 if (res != OK) return res; 2193 } 2194 2195 res = request->update(ANDROID_CONTROL_AWB_MODE, 2196 &wbMode, 1); 2197 if (res != OK) return res; 2198 2199 float reqFocusDistance = 0; // infinity focus in diopters 2200 uint8_t reqFocusMode = ANDROID_CONTROL_AF_MODE_OFF; 2201 switch (focusMode) { 2202 case Parameters::FOCUS_MODE_AUTO: 2203 case Parameters::FOCUS_MODE_MACRO: 2204 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 2205 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 2206 case Parameters::FOCUS_MODE_EDOF: 2207 reqFocusMode = focusMode; 2208 break; 2209 case Parameters::FOCUS_MODE_INFINITY: 2210 case Parameters::FOCUS_MODE_FIXED: 2211 reqFocusMode = ANDROID_CONTROL_AF_MODE_OFF; 2212 break; 2213 default: 2214 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__, 2215 cameraId, focusMode); 2216 return BAD_VALUE; 2217 } 2218 res = request->update(ANDROID_LENS_FOCUS_DISTANCE, 2219 &reqFocusDistance, 1); 2220 if (res != OK) return res; 2221 res = request->update(ANDROID_CONTROL_AF_MODE, 2222 &reqFocusMode, 1); 2223 if (res != OK) return res; 2224 2225 size_t reqFocusingAreasSize = focusingAreas.size() * 5; 2226 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize]; 2227 for (size_t i = 0, j = 0; i < reqFocusingAreasSize; i += 5, j++) { 2228 if (focusingAreas[j].weight != 0) { 2229 reqFocusingAreas[i + 0] = 2230 normalizedXToArray(focusingAreas[j].left); 2231 reqFocusingAreas[i + 1] = 2232 normalizedYToArray(focusingAreas[j].top); 2233 reqFocusingAreas[i + 2] = 2234 normalizedXToArray(focusingAreas[j].right); 2235 reqFocusingAreas[i + 3] = 2236 normalizedYToArray(focusingAreas[j].bottom); 2237 } else { 2238 reqFocusingAreas[i + 0] = 0; 2239 reqFocusingAreas[i + 1] = 0; 2240 reqFocusingAreas[i + 2] = 0; 2241 reqFocusingAreas[i + 3] = 0; 2242 } 2243 reqFocusingAreas[i + 4] = focusingAreas[j].weight; 2244 } 2245 res = request->update(ANDROID_CONTROL_AF_REGIONS, 2246 reqFocusingAreas, reqFocusingAreasSize); 2247 if (res != OK) return res; 2248 delete[] reqFocusingAreas; 2249 2250 res = request->update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, 2251 &exposureCompensation, 1); 2252 if (res != OK) return res; 2253 2254 size_t reqMeteringAreasSize = meteringAreas.size() * 5; 2255 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize]; 2256 for (size_t i = 0, j = 0; i < reqMeteringAreasSize; i += 5, j++) { 2257 if (meteringAreas[j].weight != 0) { 2258 reqMeteringAreas[i + 0] = 2259 normalizedXToArray(meteringAreas[j].left); 2260 reqMeteringAreas[i + 1] = 2261 normalizedYToArray(meteringAreas[j].top); 2262 reqMeteringAreas[i + 2] = 2263 normalizedXToArray(meteringAreas[j].right); 2264 reqMeteringAreas[i + 3] = 2265 normalizedYToArray(meteringAreas[j].bottom); 2266 // Requested size may be zero by rounding error with/without zooming. 2267 // The ae regions should be at least 1 if metering width/height is not zero. 2268 if (reqMeteringAreas[i + 0] == reqMeteringAreas[i + 2]) { 2269 reqMeteringAreas[i + 2]++; 2270 } 2271 if (reqMeteringAreas[i + 1] == reqMeteringAreas[i + 3]) { 2272 reqMeteringAreas[i + 3]++; 2273 } 2274 } else { 2275 reqMeteringAreas[i + 0] = 0; 2276 reqMeteringAreas[i + 1] = 0; 2277 reqMeteringAreas[i + 2] = 0; 2278 reqMeteringAreas[i + 3] = 0; 2279 } 2280 reqMeteringAreas[i + 4] = meteringAreas[j].weight; 2281 } 2282 res = request->update(ANDROID_CONTROL_AE_REGIONS, 2283 reqMeteringAreas, reqMeteringAreasSize); 2284 if (res != OK) return res; 2285 2286 // Set awb regions to be the same as the metering regions if allowed 2287 size_t maxAwbRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 2288 Parameters::NUM_REGION, Parameters::NUM_REGION). 2289 data.i32[Parameters::REGION_AWB]; 2290 if (maxAwbRegions > 0) { 2291 if (maxAwbRegions >= meteringAreas.size()) { 2292 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 2293 reqMeteringAreas, reqMeteringAreasSize); 2294 } else { 2295 // Ensure the awb regions are zeroed if the region count is too high. 2296 int32_t zeroedAwbAreas[5] = {0, 0, 0, 0, 0}; 2297 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 2298 zeroedAwbAreas, sizeof(zeroedAwbAreas)/sizeof(int32_t)); 2299 } 2300 if (res != OK) return res; 2301 } 2302 2303 delete[] reqMeteringAreas; 2304 2305 CropRegion crop = calculateCropRegion(/*previewOnly*/ false); 2306 int32_t reqCropRegion[4] = { 2307 static_cast<int32_t>(crop.left), 2308 static_cast<int32_t>(crop.top), 2309 static_cast<int32_t>(crop.width), 2310 static_cast<int32_t>(crop.height) 2311 }; 2312 res = request->update(ANDROID_SCALER_CROP_REGION, 2313 reqCropRegion, 4); 2314 if (res != OK) return res; 2315 2316 uint8_t reqVstabMode = videoStabilization ? 2317 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON : 2318 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; 2319 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 2320 &reqVstabMode, 1); 2321 if (res != OK) return res; 2322 2323 uint8_t reqFaceDetectMode = enableFaceDetect ? 2324 fastInfo.bestFaceDetectMode : 2325 (uint8_t)ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; 2326 res = request->update(ANDROID_STATISTICS_FACE_DETECT_MODE, 2327 &reqFaceDetectMode, 1); 2328 if (res != OK) return res; 2329 2330 return OK; 2331 } 2332 2333 status_t Parameters::updateRequestJpeg(CameraMetadata *request) const { 2334 status_t res; 2335 2336 res = request->update(ANDROID_JPEG_THUMBNAIL_SIZE, 2337 jpegThumbSize, 2); 2338 if (res != OK) return res; 2339 res = request->update(ANDROID_JPEG_THUMBNAIL_QUALITY, 2340 &jpegThumbQuality, 1); 2341 if (res != OK) return res; 2342 res = request->update(ANDROID_JPEG_QUALITY, 2343 &jpegQuality, 1); 2344 if (res != OK) return res; 2345 res = request->update( 2346 ANDROID_JPEG_ORIENTATION, 2347 &jpegRotation, 1); 2348 if (res != OK) return res; 2349 2350 if (gpsEnabled) { 2351 res = request->update( 2352 ANDROID_JPEG_GPS_COORDINATES, 2353 gpsCoordinates, 3); 2354 if (res != OK) return res; 2355 res = request->update( 2356 ANDROID_JPEG_GPS_TIMESTAMP, 2357 &gpsTimestamp, 1); 2358 if (res != OK) return res; 2359 res = request->update( 2360 ANDROID_JPEG_GPS_PROCESSING_METHOD, 2361 gpsProcessingMethod); 2362 if (res != OK) return res; 2363 } else { 2364 res = request->erase(ANDROID_JPEG_GPS_COORDINATES); 2365 if (res != OK) return res; 2366 res = request->erase(ANDROID_JPEG_GPS_TIMESTAMP); 2367 if (res != OK) return res; 2368 res = request->erase(ANDROID_JPEG_GPS_PROCESSING_METHOD); 2369 if (res != OK) return res; 2370 } 2371 return OK; 2372 } 2373 2374 status_t Parameters::overrideJpegSizeByVideoSize() { 2375 if (pictureSizeOverriden) { 2376 ALOGV("Picture size has been overridden. Skip overriding"); 2377 return OK; 2378 } 2379 2380 pictureSizeOverriden = true; 2381 pictureWidthLastSet = pictureWidth; 2382 pictureHeightLastSet = pictureHeight; 2383 pictureWidth = videoWidth; 2384 pictureHeight = videoHeight; 2385 // This change of picture size is invisible to app layer. 2386 // Do not update app visible params 2387 return OK; 2388 } 2389 2390 status_t Parameters::updateOverriddenJpegSize() { 2391 if (!pictureSizeOverriden) { 2392 ALOGV("Picture size has not been overridden. Skip checking"); 2393 return OK; 2394 } 2395 2396 pictureWidthLastSet = pictureWidth; 2397 pictureHeightLastSet = pictureHeight; 2398 2399 if (pictureWidth <= videoWidth && pictureHeight <= videoHeight) { 2400 // Picture size is now smaller than video size. No need to override anymore 2401 return recoverOverriddenJpegSize(); 2402 } 2403 2404 pictureWidth = videoWidth; 2405 pictureHeight = videoHeight; 2406 2407 return OK; 2408 } 2409 2410 status_t Parameters::recoverOverriddenJpegSize() { 2411 if (!pictureSizeOverriden) { 2412 ALOGV("Picture size has not been overridden. Skip recovering"); 2413 return OK; 2414 } 2415 pictureSizeOverriden = false; 2416 pictureWidth = pictureWidthLastSet; 2417 pictureHeight = pictureHeightLastSet; 2418 return OK; 2419 } 2420 2421 bool Parameters::isJpegSizeOverridden() { 2422 return pictureSizeOverriden; 2423 } 2424 2425 bool Parameters::useZeroShutterLag() const { 2426 // If ZSL mode is disabled, don't use it 2427 if (!allowZslMode) return false; 2428 // If recording hint is enabled, don't do ZSL 2429 if (recordingHint) return false; 2430 // If still capture size is no bigger than preview or video size, 2431 // don't do ZSL 2432 if (pictureWidth <= previewWidth || pictureHeight <= previewHeight || 2433 pictureWidth <= videoWidth || pictureHeight <= videoHeight) { 2434 return false; 2435 } 2436 // If still capture size is less than quarter of max, don't do ZSL 2437 if ((pictureWidth * pictureHeight) < 2438 (fastInfo.maxJpegSize.width * fastInfo.maxJpegSize.height / 4) ) { 2439 return false; 2440 } 2441 return true; 2442 } 2443 2444 status_t Parameters::getDefaultFocalLength(CameraDeviceBase *device) { 2445 if (device == nullptr) { 2446 ALOGE("%s: Camera device is nullptr", __FUNCTION__); 2447 return BAD_VALUE; 2448 } 2449 2450 camera_metadata_ro_entry_t hwLevel = staticInfo(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL); 2451 if (!hwLevel.count) return NO_INIT; 2452 fastInfo.isExternalCamera = 2453 hwLevel.data.u8[0] == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL; 2454 2455 camera_metadata_ro_entry_t availableFocalLengths = 2456 staticInfo(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 0, 0, /*required*/false); 2457 if (!availableFocalLengths.count && !fastInfo.isExternalCamera) return NO_INIT; 2458 2459 // Find focal length in PREVIEW template to use as default focal length. 2460 if (fastInfo.isExternalCamera) { 2461 fastInfo.defaultFocalLength = -1.0; 2462 } else { 2463 // Find smallest (widest-angle) focal length to use as basis of still 2464 // picture FOV reporting. 2465 fastInfo.defaultFocalLength = availableFocalLengths.data.f[0]; 2466 for (size_t i = 1; i < availableFocalLengths.count; i++) { 2467 if (fastInfo.defaultFocalLength > availableFocalLengths.data.f[i]) { 2468 fastInfo.defaultFocalLength = availableFocalLengths.data.f[i]; 2469 } 2470 } 2471 2472 // Use focal length in preview template if it exists 2473 CameraMetadata previewTemplate; 2474 status_t res = device->createDefaultRequest(CAMERA3_TEMPLATE_PREVIEW, &previewTemplate); 2475 if (res != OK) { 2476 ALOGE("%s: Failed to create default PREVIEW request: %s (%d)", 2477 __FUNCTION__, strerror(-res), res); 2478 return res; 2479 } 2480 camera_metadata_entry entry = previewTemplate.find(ANDROID_LENS_FOCAL_LENGTH); 2481 if (entry.count != 0) { 2482 fastInfo.defaultFocalLength = entry.data.f[0]; 2483 } 2484 } 2485 return OK; 2486 } 2487 2488 const char* Parameters::getStateName(State state) { 2489 #define CASE_ENUM_TO_CHAR(x) case x: return(#x); break; 2490 switch(state) { 2491 CASE_ENUM_TO_CHAR(DISCONNECTED) 2492 CASE_ENUM_TO_CHAR(STOPPED) 2493 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW) 2494 CASE_ENUM_TO_CHAR(PREVIEW) 2495 CASE_ENUM_TO_CHAR(RECORD) 2496 CASE_ENUM_TO_CHAR(STILL_CAPTURE) 2497 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT) 2498 default: 2499 return "Unknown state!"; 2500 break; 2501 } 2502 #undef CASE_ENUM_TO_CHAR 2503 } 2504 2505 int Parameters::formatStringToEnum(const char *format) { 2506 return CameraParameters::previewFormatToEnum(format); 2507 } 2508 2509 const char* Parameters::formatEnumToString(int format) { 2510 const char *fmt; 2511 switch(format) { 2512 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 2513 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 2514 break; 2515 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 2516 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 2517 break; 2518 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 2519 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 2520 break; 2521 case HAL_PIXEL_FORMAT_YV12: // YV12 2522 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 2523 break; 2524 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 2525 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 2526 break; 2527 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 2528 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 2529 break; 2530 case HAL_PIXEL_FORMAT_RAW16: 2531 ALOGW("Raw sensor preview format requested."); 2532 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 2533 break; 2534 default: 2535 ALOGE("%s: Unknown preview format: %x", 2536 __FUNCTION__, format); 2537 fmt = NULL; 2538 break; 2539 } 2540 return fmt; 2541 } 2542 2543 int Parameters::wbModeStringToEnum(const char *wbMode) { 2544 return 2545 !wbMode ? 2546 ANDROID_CONTROL_AWB_MODE_AUTO : 2547 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ? 2548 ANDROID_CONTROL_AWB_MODE_AUTO : 2549 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ? 2550 ANDROID_CONTROL_AWB_MODE_INCANDESCENT : 2551 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ? 2552 ANDROID_CONTROL_AWB_MODE_FLUORESCENT : 2553 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ? 2554 ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT : 2555 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ? 2556 ANDROID_CONTROL_AWB_MODE_DAYLIGHT : 2557 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ? 2558 ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT : 2559 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ? 2560 ANDROID_CONTROL_AWB_MODE_TWILIGHT : 2561 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ? 2562 ANDROID_CONTROL_AWB_MODE_SHADE : 2563 -1; 2564 } 2565 2566 const char* Parameters::wbModeEnumToString(uint8_t wbMode) { 2567 switch (wbMode) { 2568 case ANDROID_CONTROL_AWB_MODE_AUTO: 2569 return CameraParameters::WHITE_BALANCE_AUTO; 2570 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT: 2571 return CameraParameters::WHITE_BALANCE_INCANDESCENT; 2572 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT: 2573 return CameraParameters::WHITE_BALANCE_FLUORESCENT; 2574 case ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT: 2575 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 2576 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT: 2577 return CameraParameters::WHITE_BALANCE_DAYLIGHT; 2578 case ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT: 2579 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 2580 case ANDROID_CONTROL_AWB_MODE_TWILIGHT: 2581 return CameraParameters::WHITE_BALANCE_TWILIGHT; 2582 case ANDROID_CONTROL_AWB_MODE_SHADE: 2583 return CameraParameters::WHITE_BALANCE_SHADE; 2584 default: 2585 ALOGE("%s: Unknown AWB mode enum: %d", 2586 __FUNCTION__, wbMode); 2587 return "unknown"; 2588 } 2589 } 2590 2591 int Parameters::effectModeStringToEnum(const char *effectMode) { 2592 return 2593 !effectMode ? 2594 ANDROID_CONTROL_EFFECT_MODE_OFF : 2595 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ? 2596 ANDROID_CONTROL_EFFECT_MODE_OFF : 2597 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ? 2598 ANDROID_CONTROL_EFFECT_MODE_MONO : 2599 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ? 2600 ANDROID_CONTROL_EFFECT_MODE_NEGATIVE : 2601 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ? 2602 ANDROID_CONTROL_EFFECT_MODE_SOLARIZE : 2603 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ? 2604 ANDROID_CONTROL_EFFECT_MODE_SEPIA : 2605 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ? 2606 ANDROID_CONTROL_EFFECT_MODE_POSTERIZE : 2607 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ? 2608 ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD : 2609 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ? 2610 ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD : 2611 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ? 2612 ANDROID_CONTROL_EFFECT_MODE_AQUA : 2613 -1; 2614 } 2615 2616 int Parameters::abModeStringToEnum(const char *abMode) { 2617 return 2618 !abMode ? 2619 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO : 2620 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ? 2621 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO : 2622 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ? 2623 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF : 2624 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ? 2625 ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ : 2626 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ? 2627 ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ : 2628 -1; 2629 } 2630 2631 int Parameters::sceneModeStringToEnum(const char *sceneMode, uint8_t defaultSceneMode) { 2632 return 2633 !sceneMode ? 2634 defaultSceneMode : 2635 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ? 2636 defaultSceneMode : 2637 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ? 2638 ANDROID_CONTROL_SCENE_MODE_ACTION : 2639 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ? 2640 ANDROID_CONTROL_SCENE_MODE_PORTRAIT : 2641 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ? 2642 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE : 2643 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ? 2644 ANDROID_CONTROL_SCENE_MODE_NIGHT : 2645 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ? 2646 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT : 2647 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ? 2648 ANDROID_CONTROL_SCENE_MODE_THEATRE : 2649 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ? 2650 ANDROID_CONTROL_SCENE_MODE_BEACH : 2651 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ? 2652 ANDROID_CONTROL_SCENE_MODE_SNOW : 2653 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ? 2654 ANDROID_CONTROL_SCENE_MODE_SUNSET : 2655 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ? 2656 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO : 2657 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ? 2658 ANDROID_CONTROL_SCENE_MODE_FIREWORKS : 2659 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ? 2660 ANDROID_CONTROL_SCENE_MODE_SPORTS : 2661 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ? 2662 ANDROID_CONTROL_SCENE_MODE_PARTY : 2663 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ? 2664 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT : 2665 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ? 2666 ANDROID_CONTROL_SCENE_MODE_BARCODE: 2667 !strcmp(sceneMode, CameraParameters::SCENE_MODE_HDR) ? 2668 ANDROID_CONTROL_SCENE_MODE_HDR: 2669 -1; 2670 } 2671 2672 Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum( 2673 const char *flashMode) { 2674 return 2675 !flashMode ? 2676 Parameters::FLASH_MODE_OFF : 2677 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ? 2678 Parameters::FLASH_MODE_OFF : 2679 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ? 2680 Parameters::FLASH_MODE_AUTO : 2681 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ? 2682 Parameters::FLASH_MODE_ON : 2683 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ? 2684 Parameters::FLASH_MODE_RED_EYE : 2685 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ? 2686 Parameters::FLASH_MODE_TORCH : 2687 Parameters::FLASH_MODE_INVALID; 2688 } 2689 2690 const char *Parameters::flashModeEnumToString(flashMode_t flashMode) { 2691 switch (flashMode) { 2692 case FLASH_MODE_OFF: 2693 return CameraParameters::FLASH_MODE_OFF; 2694 case FLASH_MODE_AUTO: 2695 return CameraParameters::FLASH_MODE_AUTO; 2696 case FLASH_MODE_ON: 2697 return CameraParameters::FLASH_MODE_ON; 2698 case FLASH_MODE_RED_EYE: 2699 return CameraParameters::FLASH_MODE_RED_EYE; 2700 case FLASH_MODE_TORCH: 2701 return CameraParameters::FLASH_MODE_TORCH; 2702 default: 2703 ALOGE("%s: Unknown flash mode enum %d", 2704 __FUNCTION__, flashMode); 2705 return "unknown"; 2706 } 2707 } 2708 2709 Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum( 2710 const char *focusMode) { 2711 return 2712 !focusMode ? 2713 Parameters::FOCUS_MODE_INVALID : 2714 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ? 2715 Parameters::FOCUS_MODE_AUTO : 2716 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ? 2717 Parameters::FOCUS_MODE_INFINITY : 2718 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ? 2719 Parameters::FOCUS_MODE_MACRO : 2720 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ? 2721 Parameters::FOCUS_MODE_FIXED : 2722 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ? 2723 Parameters::FOCUS_MODE_EDOF : 2724 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ? 2725 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO : 2726 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ? 2727 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE : 2728 Parameters::FOCUS_MODE_INVALID; 2729 } 2730 2731 const char *Parameters::focusModeEnumToString(focusMode_t focusMode) { 2732 switch (focusMode) { 2733 case FOCUS_MODE_AUTO: 2734 return CameraParameters::FOCUS_MODE_AUTO; 2735 case FOCUS_MODE_MACRO: 2736 return CameraParameters::FOCUS_MODE_MACRO; 2737 case FOCUS_MODE_CONTINUOUS_VIDEO: 2738 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 2739 case FOCUS_MODE_CONTINUOUS_PICTURE: 2740 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 2741 case FOCUS_MODE_EDOF: 2742 return CameraParameters::FOCUS_MODE_EDOF; 2743 case FOCUS_MODE_INFINITY: 2744 return CameraParameters::FOCUS_MODE_INFINITY; 2745 case FOCUS_MODE_FIXED: 2746 return CameraParameters::FOCUS_MODE_FIXED; 2747 default: 2748 ALOGE("%s: Unknown focus mode enum: %d", 2749 __FUNCTION__, focusMode); 2750 return "unknown"; 2751 } 2752 } 2753 2754 status_t Parameters::parseAreas(const char *areasCStr, 2755 Vector<Parameters::Area> *areas) { 2756 static const size_t NUM_FIELDS = 5; 2757 areas->clear(); 2758 if (areasCStr == NULL) { 2759 // If no key exists, use default (0,0,0,0,0) 2760 areas->push(); 2761 return OK; 2762 } 2763 String8 areasStr(areasCStr); 2764 ssize_t areaStart = areasStr.find("(", 0) + 1; 2765 while (areaStart != 0) { 2766 const char* area = areasStr.string() + areaStart; 2767 char *numEnd; 2768 int vals[NUM_FIELDS]; 2769 for (size_t i = 0; i < NUM_FIELDS; i++) { 2770 errno = 0; 2771 vals[i] = strtol(area, &numEnd, 10); 2772 if (errno || numEnd == area) return BAD_VALUE; 2773 area = numEnd + 1; 2774 } 2775 areas->push(Parameters::Area( 2776 vals[0], vals[1], vals[2], vals[3], vals[4]) ); 2777 areaStart = areasStr.find("(", areaStart) + 1; 2778 } 2779 return OK; 2780 } 2781 2782 status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas, 2783 size_t maxRegions, 2784 AreaKind areaKind) const { 2785 // Definition of valid area can be found in 2786 // include/camera/CameraParameters.h 2787 if (areas.size() == 0) return BAD_VALUE; 2788 if (areas.size() == 1) { 2789 if (areas[0].left == 0 && 2790 areas[0].top == 0 && 2791 areas[0].right == 0 && 2792 areas[0].bottom == 0 && 2793 areas[0].weight == 0) { 2794 // Single (0,0,0,0,0) entry is always valid (== driver decides) 2795 return OK; 2796 } 2797 } 2798 2799 // fixed focus can only set (0,0,0,0,0) focus area 2800 if (areaKind == AREA_KIND_FOCUS && focusMode == FOCUS_MODE_FIXED) { 2801 return BAD_VALUE; 2802 } 2803 2804 if (areas.size() > maxRegions) { 2805 ALOGE("%s: Too many areas requested: %zu", 2806 __FUNCTION__, areas.size()); 2807 return BAD_VALUE; 2808 } 2809 2810 for (Vector<Parameters::Area>::const_iterator a = areas.begin(); 2811 a != areas.end(); a++) { 2812 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE; 2813 if (a->left < -1000 || a->left > 1000) return BAD_VALUE; 2814 if (a->top < -1000 || a->top > 1000) return BAD_VALUE; 2815 if (a->right < -1000 || a->right > 1000) return BAD_VALUE; 2816 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE; 2817 if (a->left >= a->right) return BAD_VALUE; 2818 if (a->top >= a->bottom) return BAD_VALUE; 2819 } 2820 return OK; 2821 } 2822 2823 bool Parameters::boolFromString(const char *boolStr) { 2824 return !boolStr ? false : 2825 !strcmp(boolStr, CameraParameters::TRUE) ? true : 2826 false; 2827 } 2828 2829 int Parameters::degToTransform(int degrees, bool mirror) { 2830 if (!mirror) { 2831 if (degrees == 0) return 0; 2832 else if (degrees == 90) return HAL_TRANSFORM_ROT_90; 2833 else if (degrees == 180) return HAL_TRANSFORM_ROT_180; 2834 else if (degrees == 270) return HAL_TRANSFORM_ROT_270; 2835 } else { // Do mirror (horizontal flip) 2836 if (degrees == 0) { // FLIP_H and ROT_0 2837 return HAL_TRANSFORM_FLIP_H; 2838 } else if (degrees == 90) { // FLIP_H and ROT_90 2839 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90; 2840 } else if (degrees == 180) { // FLIP_H and ROT_180 2841 return HAL_TRANSFORM_FLIP_V; 2842 } else if (degrees == 270) { // FLIP_H and ROT_270 2843 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90; 2844 } 2845 } 2846 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees); 2847 return -1; 2848 } 2849 2850 int Parameters::cropXToArray(int x) const { 2851 ALOG_ASSERT(x >= 0, "Crop-relative X coordinate = '%d' is out of bounds" 2852 "(lower = 0)", x); 2853 2854 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true); 2855 ALOG_ASSERT(x < previewCrop.width, "Crop-relative X coordinate = '%d' " 2856 "is out of bounds (upper = %f)", x, previewCrop.width); 2857 2858 int ret = x + previewCrop.left; 2859 2860 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayWidth), 2861 "Calculated pixel array value X = '%d' is out of bounds (upper = %d)", 2862 ret, fastInfo.arrayWidth); 2863 return ret; 2864 } 2865 2866 int Parameters::cropYToArray(int y) const { 2867 ALOG_ASSERT(y >= 0, "Crop-relative Y coordinate = '%d' is out of bounds " 2868 "(lower = 0)", y); 2869 2870 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true); 2871 ALOG_ASSERT(y < previewCrop.height, "Crop-relative Y coordinate = '%d' is " 2872 "out of bounds (upper = %f)", y, previewCrop.height); 2873 2874 int ret = y + previewCrop.top; 2875 2876 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayHeight), 2877 "Calculated pixel array value Y = '%d' is out of bounds (upper = %d)", 2878 ret, fastInfo.arrayHeight); 2879 2880 return ret; 2881 2882 } 2883 2884 int Parameters::normalizedXToCrop(int x) const { 2885 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true); 2886 return (x + 1000) * (previewCrop.width - 1) / 2000; 2887 } 2888 2889 int Parameters::normalizedYToCrop(int y) const { 2890 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true); 2891 return (y + 1000) * (previewCrop.height - 1) / 2000; 2892 } 2893 2894 int Parameters::normalizedXToArray(int x) const { 2895 2896 // Work-around for HAL pre-scaling the coordinates themselves 2897 if (quirks.meteringCropRegion) { 2898 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000; 2899 } 2900 2901 return cropXToArray(normalizedXToCrop(x)); 2902 } 2903 2904 int Parameters::normalizedYToArray(int y) const { 2905 // Work-around for HAL pre-scaling the coordinates themselves 2906 if (quirks.meteringCropRegion) { 2907 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000; 2908 } 2909 2910 return cropYToArray(normalizedYToCrop(y)); 2911 } 2912 2913 2914 Parameters::CropRegion Parameters::calculatePreviewCrop( 2915 const CropRegion &scalerCrop) const { 2916 float left, top, width, height; 2917 float previewAspect = static_cast<float>(previewWidth) / previewHeight; 2918 float cropAspect = scalerCrop.width / scalerCrop.height; 2919 2920 if (previewAspect > cropAspect) { 2921 width = scalerCrop.width; 2922 height = cropAspect * scalerCrop.height / previewAspect; 2923 2924 left = scalerCrop.left; 2925 top = scalerCrop.top + (scalerCrop.height - height) / 2; 2926 } else { 2927 width = previewAspect * scalerCrop.width / cropAspect; 2928 height = scalerCrop.height; 2929 2930 left = scalerCrop.left + (scalerCrop.width - width) / 2; 2931 top = scalerCrop.top; 2932 } 2933 2934 CropRegion previewCrop = {left, top, width, height}; 2935 2936 return previewCrop; 2937 } 2938 2939 int Parameters::arrayXToNormalizedWithCrop(int x, 2940 const CropRegion &scalerCrop) const { 2941 // Work-around for HAL pre-scaling the coordinates themselves 2942 if (quirks.meteringCropRegion) { 2943 return x * 2000 / (fastInfo.arrayWidth - 1) - 1000; 2944 } else { 2945 CropRegion previewCrop = calculatePreviewCrop(scalerCrop); 2946 return (x - previewCrop.left) * 2000 / (previewCrop.width - 1) - 1000; 2947 } 2948 } 2949 2950 int Parameters::arrayYToNormalizedWithCrop(int y, 2951 const CropRegion &scalerCrop) const { 2952 // Work-around for HAL pre-scaling the coordinates themselves 2953 if (quirks.meteringCropRegion) { 2954 return y * 2000 / (fastInfo.arrayHeight - 1) - 1000; 2955 } else { 2956 CropRegion previewCrop = calculatePreviewCrop(scalerCrop); 2957 return (y - previewCrop.top) * 2000 / (previewCrop.height - 1) - 1000; 2958 } 2959 } 2960 2961 status_t Parameters::getFilteredSizes(Size limit, Vector<Size> *sizes) { 2962 if (info == NULL) { 2963 ALOGE("%s: Static metadata is not initialized", __FUNCTION__); 2964 return NO_INIT; 2965 } 2966 if (sizes == NULL) { 2967 ALOGE("%s: Input size is null", __FUNCTION__); 2968 return BAD_VALUE; 2969 } 2970 sizes->clear(); 2971 2972 Vector<StreamConfiguration> scs = getStreamConfigurations(); 2973 for (size_t i=0; i < scs.size(); i++) { 2974 const StreamConfiguration &sc = scs[i]; 2975 if (sc.isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT && 2976 sc.format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED && 2977 sc.width <= limit.width && sc.height <= limit.height) { 2978 int64_t minFrameDuration = getMinFrameDurationNs( 2979 {sc.width, sc.height}, HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED); 2980 if (minFrameDuration > MAX_PREVIEW_RECORD_DURATION_NS) { 2981 // Filter slow sizes from preview/record 2982 continue; 2983 } 2984 sizes->push({sc.width, sc.height}); 2985 } 2986 } 2987 2988 if (sizes->isEmpty()) { 2989 ALOGE("generated preview size list is empty!!"); 2990 return BAD_VALUE; 2991 } 2992 return OK; 2993 } 2994 2995 Parameters::Size Parameters::getMaxSizeForRatio( 2996 float ratio, const int32_t* sizeArray, size_t count) { 2997 ALOG_ASSERT(sizeArray != NULL, "size array shouldn't be NULL"); 2998 ALOG_ASSERT(count >= 2 && count % 2 == 0, "count must be a positive even number"); 2999 3000 Size maxSize = {0, 0}; 3001 for (size_t i = 0; i < count; i += 2) { 3002 if (sizeArray[i] > 0 && sizeArray[i+1] > 0) { 3003 float curRatio = static_cast<float>(sizeArray[i]) / sizeArray[i+1]; 3004 if (fabs(curRatio - ratio) < ASPECT_RATIO_TOLERANCE && maxSize.width < sizeArray[i]) { 3005 maxSize.width = sizeArray[i]; 3006 maxSize.height = sizeArray[i+1]; 3007 } 3008 } 3009 } 3010 3011 if (maxSize.width == 0 || maxSize.height == 0) { 3012 maxSize.width = sizeArray[0]; 3013 maxSize.height = sizeArray[1]; 3014 ALOGW("Unable to find the size to match the given aspect ratio %f." 3015 "Fall back to %d x %d", ratio, maxSize.width, maxSize.height); 3016 } 3017 3018 return maxSize; 3019 } 3020 3021 Parameters::Size Parameters::getMaxSize(const Vector<Parameters::Size> &sizes) { 3022 Size maxSize = {-1, -1}; 3023 for (size_t i = 0; i < sizes.size(); i++) { 3024 if (sizes[i].width > maxSize.width || 3025 (sizes[i].width == maxSize.width && sizes[i].height > maxSize.height )) { 3026 maxSize = sizes[i]; 3027 } 3028 } 3029 return maxSize; 3030 } 3031 3032 Vector<Parameters::StreamConfiguration> Parameters::getStreamConfigurations() { 3033 const int STREAM_CONFIGURATION_SIZE = 4; 3034 const int STREAM_FORMAT_OFFSET = 0; 3035 const int STREAM_WIDTH_OFFSET = 1; 3036 const int STREAM_HEIGHT_OFFSET = 2; 3037 const int STREAM_IS_INPUT_OFFSET = 3; 3038 Vector<StreamConfiguration> scs; 3039 3040 camera_metadata_ro_entry_t availableStreamConfigs = 3041 staticInfo(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS); 3042 for (size_t i = 0; i < availableStreamConfigs.count; i+= STREAM_CONFIGURATION_SIZE) { 3043 int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET]; 3044 int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET]; 3045 int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET]; 3046 int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET]; 3047 StreamConfiguration sc = {format, width, height, isInput}; 3048 scs.add(sc); 3049 } 3050 return scs; 3051 } 3052 3053 int64_t Parameters::getJpegStreamMinFrameDurationNs(Parameters::Size size) { 3054 return getMinFrameDurationNs(size, HAL_PIXEL_FORMAT_BLOB); 3055 } 3056 3057 int64_t Parameters::getMinFrameDurationNs(Parameters::Size size, int fmt) { 3058 const int STREAM_DURATION_SIZE = 4; 3059 const int STREAM_FORMAT_OFFSET = 0; 3060 const int STREAM_WIDTH_OFFSET = 1; 3061 const int STREAM_HEIGHT_OFFSET = 2; 3062 const int STREAM_DURATION_OFFSET = 3; 3063 camera_metadata_ro_entry_t availableStreamMinDurations = 3064 staticInfo(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS); 3065 for (size_t i = 0; i < availableStreamMinDurations.count; i+= STREAM_DURATION_SIZE) { 3066 int64_t format = availableStreamMinDurations.data.i64[i + STREAM_FORMAT_OFFSET]; 3067 int64_t width = availableStreamMinDurations.data.i64[i + STREAM_WIDTH_OFFSET]; 3068 int64_t height = availableStreamMinDurations.data.i64[i + STREAM_HEIGHT_OFFSET]; 3069 int64_t duration = availableStreamMinDurations.data.i64[i + STREAM_DURATION_OFFSET]; 3070 if (format == fmt && width == size.width && height == size.height) { 3071 return duration; 3072 } 3073 } 3074 3075 return -1; 3076 } 3077 3078 bool Parameters::isFpsSupported(const Vector<Size> &sizes, int format, int32_t fps) { 3079 // Get min frame duration for each size and check if the given fps range can be supported. 3080 for (size_t i = 0 ; i < sizes.size(); i++) { 3081 int64_t minFrameDuration = getMinFrameDurationNs(sizes[i], format); 3082 if (minFrameDuration <= 0) { 3083 ALOGE("Min frame duration (%" PRId64") for size (%dx%d) and format 0x%x is wrong!", 3084 minFrameDuration, sizes[i].width, sizes[i].height, format); 3085 return false; 3086 } 3087 int32_t maxSupportedFps = 1e9 / minFrameDuration; 3088 // Add some margin here for the case where the hal supports 29.xxxfps. 3089 maxSupportedFps += FPS_MARGIN; 3090 if (fps > maxSupportedFps) { 3091 return false; 3092 } 3093 } 3094 return true; 3095 } 3096 3097 SortedVector<int32_t> Parameters::getAvailableOutputFormats() { 3098 SortedVector<int32_t> outputFormats; // Non-duplicated output formats 3099 Vector<StreamConfiguration> scs = getStreamConfigurations(); 3100 for (size_t i = 0; i < scs.size(); i++) { 3101 const StreamConfiguration &sc = scs[i]; 3102 if (sc.isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT) { 3103 outputFormats.add(sc.format); 3104 } 3105 } 3106 3107 return outputFormats; 3108 } 3109 3110 Vector<Parameters::Size> Parameters::getAvailableJpegSizes() { 3111 Vector<Parameters::Size> jpegSizes; 3112 Vector<StreamConfiguration> scs = getStreamConfigurations(); 3113 for (size_t i = 0; i < scs.size(); i++) { 3114 const StreamConfiguration &sc = scs[i]; 3115 if (sc.isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT && 3116 sc.format == HAL_PIXEL_FORMAT_BLOB) { 3117 Size sz = {sc.width, sc.height}; 3118 jpegSizes.add(sz); 3119 } 3120 } 3121 3122 return jpegSizes; 3123 } 3124 3125 Vector<Parameters::StreamConfiguration> Parameters::getPreferredStreamConfigurations( 3126 int32_t usecaseId) const { 3127 const size_t STREAM_CONFIGURATION_SIZE = 5; 3128 const size_t STREAM_WIDTH_OFFSET = 0; 3129 const size_t STREAM_HEIGHT_OFFSET = 1; 3130 const size_t STREAM_FORMAT_OFFSET = 2; 3131 const size_t STREAM_IS_INPUT_OFFSET = 3; 3132 const size_t STREAM_USECASE_BITMAP_OFFSET = 4; 3133 Vector<StreamConfiguration> scs; 3134 3135 if (fastInfo.supportsPreferredConfigs) { 3136 camera_metadata_ro_entry_t availableStreamConfigs = staticInfo( 3137 ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS); 3138 for (size_t i = 0; i < availableStreamConfigs.count; i+= STREAM_CONFIGURATION_SIZE) { 3139 int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET]; 3140 int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET]; 3141 int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET]; 3142 int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET]; 3143 int32_t supportedUsecases = 3144 availableStreamConfigs.data.i32[i + STREAM_USECASE_BITMAP_OFFSET]; 3145 if (supportedUsecases & (1 << usecaseId)) { 3146 StreamConfiguration sc = {format, width, height, isInput}; 3147 scs.add(sc); 3148 } 3149 } 3150 } 3151 3152 return scs; 3153 } 3154 3155 Vector<Parameters::Size> Parameters::getPreferredFilteredSizes(int32_t usecaseId, 3156 int32_t format) const { 3157 Vector<Parameters::Size> sizes; 3158 Vector<StreamConfiguration> scs = getPreferredStreamConfigurations(usecaseId); 3159 for (const auto &it : scs) { 3160 if (it.format == format) { 3161 sizes.add({it.width, it.height}); 3162 } 3163 } 3164 3165 return sizes; 3166 } 3167 3168 Vector<Parameters::Size> Parameters::getPreferredJpegSizes() const { 3169 return getPreferredFilteredSizes( 3170 ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT, 3171 HAL_PIXEL_FORMAT_BLOB); 3172 } 3173 3174 Vector<Parameters::Size> Parameters::getPreferredPreviewSizes() const { 3175 return getPreferredFilteredSizes( 3176 ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW, 3177 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED); 3178 } 3179 3180 Vector<Parameters::Size> Parameters::getPreferredVideoSizes() const { 3181 return getPreferredFilteredSizes( 3182 ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD, 3183 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED); 3184 } 3185 3186 Parameters::CropRegion Parameters::calculateCropRegion(bool previewOnly) const { 3187 3188 float zoomLeft, zoomTop, zoomWidth, zoomHeight; 3189 3190 // Need to convert zoom index into a crop rectangle. The rectangle is 3191 // chosen to maximize its area on the sensor 3192 3193 camera_metadata_ro_entry_t maxDigitalZoom = 3194 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM); 3195 // For each zoom step by how many pixels more do we change the zoom 3196 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) / 3197 (NUM_ZOOM_STEPS-1); 3198 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w) 3199 // via interpolating zoom step into a zoom ratio 3200 float zoomRatio = 1 + zoomIncrement * zoom; 3201 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]), 3202 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f", 3203 maxDigitalZoom.data.f[0], zoomRatio); 3204 3205 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, " 3206 "previewHeight=%d, activeWidth=%d, activeHeight=%d", 3207 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth, 3208 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight); 3209 3210 if (previewOnly) { 3211 // Calculate a tight crop region for the preview stream only 3212 float previewRatio = static_cast<float>(previewWidth) / previewHeight; 3213 3214 /* Ensure that the width/height never go out of bounds 3215 * by scaling across a diffent dimension if an out-of-bounds 3216 * possibility exists. 3217 * 3218 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by 3219 * calculating the zoomWidth from zoomHeight we'll actually get a 3220 * zoomheight > arrayheight 3221 */ 3222 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight; 3223 if (previewRatio >= arrayRatio) { 3224 // Adjust the height based on the width 3225 zoomWidth = fastInfo.arrayWidth / zoomRatio; 3226 zoomHeight = zoomWidth * 3227 previewHeight / previewWidth; 3228 3229 } else { 3230 // Adjust the width based on the height 3231 zoomHeight = fastInfo.arrayHeight / zoomRatio; 3232 zoomWidth = zoomHeight * 3233 previewWidth / previewHeight; 3234 } 3235 } else { 3236 // Calculate the global crop region with a shape matching the active 3237 // array. 3238 zoomWidth = fastInfo.arrayWidth / zoomRatio; 3239 zoomHeight = fastInfo.arrayHeight / zoomRatio; 3240 } 3241 3242 // center the zoom area within the active area 3243 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2; 3244 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2; 3245 3246 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d", 3247 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom); 3248 3249 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight }; 3250 return crop; 3251 } 3252 3253 status_t Parameters::calculatePictureFovs(float *horizFov, float *vertFov) 3254 const { 3255 if (fastInfo.isExternalCamera) { 3256 if (horizFov != NULL) { 3257 *horizFov = -1.0; 3258 } 3259 if (vertFov != NULL) { 3260 *vertFov = -1.0; 3261 } 3262 return OK; 3263 } 3264 3265 camera_metadata_ro_entry_t sensorSize = 3266 staticInfo(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 2, 2); 3267 if (!sensorSize.count) return NO_INIT; 3268 3269 camera_metadata_ro_entry_t pixelArraySize = 3270 staticInfo(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 2, 2); 3271 if (!pixelArraySize.count) return NO_INIT; 3272 3273 float arrayAspect = static_cast<float>(fastInfo.arrayWidth) / 3274 fastInfo.arrayHeight; 3275 float stillAspect = static_cast<float>(pictureWidth) / pictureHeight; 3276 ALOGV("Array aspect: %f, still aspect: %f", arrayAspect, stillAspect); 3277 3278 // The crop factors from the full sensor array to the still picture crop 3279 // region 3280 float horizCropFactor = 1.f; 3281 float vertCropFactor = 1.f; 3282 3283 /** 3284 * Need to calculate the still image field of view based on the total pixel 3285 * array field of view, and the relative aspect ratios of the pixel array 3286 * and output streams. 3287 * 3288 * Special treatment for quirky definition of crop region and relative 3289 * stream cropping. 3290 */ 3291 if (quirks.meteringCropRegion) { 3292 // Use max of preview and video as first crop 3293 float previewAspect = static_cast<float>(previewWidth) / previewHeight; 3294 float videoAspect = static_cast<float>(videoWidth) / videoHeight; 3295 if (videoAspect > previewAspect) { 3296 previewAspect = videoAspect; 3297 } 3298 // First crop sensor to preview aspect ratio 3299 if (arrayAspect < previewAspect) { 3300 vertCropFactor = arrayAspect / previewAspect; 3301 } else { 3302 horizCropFactor = previewAspect / arrayAspect; 3303 } 3304 // Second crop to still aspect ratio 3305 if (stillAspect < previewAspect) { 3306 horizCropFactor *= stillAspect / previewAspect; 3307 } else { 3308 vertCropFactor *= previewAspect / stillAspect; 3309 } 3310 } else { 3311 /** 3312 * Crop are just a function of just the still/array relative aspect 3313 * ratios. Since each stream will maximize its area within the crop 3314 * region, and for FOV we assume a full-sensor crop region, we only ever 3315 * crop the FOV either vertically or horizontally, never both. 3316 */ 3317 horizCropFactor = (arrayAspect > stillAspect) ? 3318 (stillAspect / arrayAspect) : 1.f; 3319 vertCropFactor = (arrayAspect < stillAspect) ? 3320 (arrayAspect / stillAspect) : 1.f; 3321 } 3322 3323 /** 3324 * Convert the crop factors w.r.t the active array size to the crop factors 3325 * w.r.t the pixel array size. 3326 */ 3327 horizCropFactor *= (static_cast<float>(fastInfo.arrayWidth) / 3328 pixelArraySize.data.i32[0]); 3329 vertCropFactor *= (static_cast<float>(fastInfo.arrayHeight) / 3330 pixelArraySize.data.i32[1]); 3331 3332 ALOGV("Horiz crop factor: %f, vert crop fact: %f", 3333 horizCropFactor, vertCropFactor); 3334 /** 3335 * Basic field of view formula is: 3336 * angle of view = 2 * arctangent ( d / 2f ) 3337 * where d is the physical sensor dimension of interest, and f is 3338 * the focal length. This only applies to rectilinear sensors, for focusing 3339 * at distances >> f, etc. 3340 */ 3341 if (horizFov != NULL) { 3342 *horizFov = 180 / M_PI * 2 * 3343 atanf(horizCropFactor * sensorSize.data.f[0] / 3344 (2 * fastInfo.defaultFocalLength)); 3345 } 3346 if (vertFov != NULL) { 3347 *vertFov = 180 / M_PI * 2 * 3348 atanf(vertCropFactor * sensorSize.data.f[1] / 3349 (2 * fastInfo.defaultFocalLength)); 3350 } 3351 return OK; 3352 } 3353 3354 int32_t Parameters::fpsFromRange(int32_t /*min*/, int32_t max) const { 3355 return max; 3356 } 3357 3358 }; // namespace camera2 3359 }; // namespace android 3360
