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