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