Parameters.cpp revision 96150cfc6b9ae93b6c4b60b5c7889a7a90af5def
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 24#include <math.h> 25#include <stdlib.h> 26 27#include "Parameters.h" 28#include "system/camera.h" 29#include "camera/CameraParameters.h" 30 31namespace android { 32namespace camera2 { 33 34Parameters::Parameters(int cameraId, 35 int cameraFacing) : 36 cameraId(cameraId), 37 cameraFacing(cameraFacing), 38 info(NULL) { 39} 40 41Parameters::~Parameters() { 42} 43 44status_t Parameters::initialize(const CameraMetadata *info) { 45 status_t res; 46 47 if (info->entryCount() == 0) { 48 ALOGE("%s: No static information provided!", __FUNCTION__); 49 return BAD_VALUE; 50 } 51 Parameters::info = info; 52 53 res = buildFastInfo(); 54 if (res != OK) return res; 55 56 CameraParameters params; 57 58 camera_metadata_ro_entry_t availableProcessedSizes = 59 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2); 60 if (!availableProcessedSizes.count) return NO_INIT; 61 62 // TODO: Pick more intelligently 63 previewWidth = availableProcessedSizes.data.i32[0]; 64 previewHeight = availableProcessedSizes.data.i32[1]; 65 videoWidth = previewWidth; 66 videoHeight = previewHeight; 67 68 params.setPreviewSize(previewWidth, previewHeight); 69 params.setVideoSize(videoWidth, videoHeight); 70 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, 71 String8::format("%dx%d", 72 previewWidth, previewHeight)); 73 { 74 String8 supportedPreviewSizes; 75 for (size_t i=0; i < availableProcessedSizes.count; i += 2) { 76 if (i != 0) supportedPreviewSizes += ","; 77 supportedPreviewSizes += String8::format("%dx%d", 78 availableProcessedSizes.data.i32[i], 79 availableProcessedSizes.data.i32[i+1]); 80 } 81 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 82 supportedPreviewSizes); 83 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, 84 supportedPreviewSizes); 85 } 86 87 camera_metadata_ro_entry_t availableFpsRanges = 88 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 89 if (!availableFpsRanges.count) return NO_INIT; 90 91 previewFpsRange[0] = availableFpsRanges.data.i32[0]; 92 previewFpsRange[1] = availableFpsRanges.data.i32[1]; 93 94 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 95 String8::format("%d,%d", 96 previewFpsRange[0], 97 previewFpsRange[1])); 98 99 { 100 String8 supportedPreviewFpsRange; 101 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 102 if (i != 0) supportedPreviewFpsRange += ","; 103 supportedPreviewFpsRange += String8::format("(%d,%d)", 104 availableFpsRanges.data.i32[i], 105 availableFpsRanges.data.i32[i+1]); 106 } 107 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 108 supportedPreviewFpsRange); 109 } 110 111 previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 112 params.set(CameraParameters::KEY_PREVIEW_FORMAT, 113 formatEnumToString(previewFormat)); // NV21 114 115 previewTransform = degToTransform(0, 116 cameraFacing == CAMERA_FACING_FRONT); 117 118 camera_metadata_ro_entry_t availableFormats = 119 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 120 121 { 122 String8 supportedPreviewFormats; 123 bool addComma = false; 124 for (size_t i=0; i < availableFormats.count; i++) { 125 if (addComma) supportedPreviewFormats += ","; 126 addComma = true; 127 switch (availableFormats.data.i32[i]) { 128 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 129 supportedPreviewFormats += 130 CameraParameters::PIXEL_FORMAT_YUV422SP; 131 break; 132 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 133 supportedPreviewFormats += 134 CameraParameters::PIXEL_FORMAT_YUV420SP; 135 break; 136 case HAL_PIXEL_FORMAT_YCbCr_422_I: 137 supportedPreviewFormats += 138 CameraParameters::PIXEL_FORMAT_YUV422I; 139 break; 140 case HAL_PIXEL_FORMAT_YV12: 141 supportedPreviewFormats += 142 CameraParameters::PIXEL_FORMAT_YUV420P; 143 break; 144 case HAL_PIXEL_FORMAT_RGB_565: 145 supportedPreviewFormats += 146 CameraParameters::PIXEL_FORMAT_RGB565; 147 break; 148 case HAL_PIXEL_FORMAT_RGBA_8888: 149 supportedPreviewFormats += 150 CameraParameters::PIXEL_FORMAT_RGBA8888; 151 break; 152 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats 153 case HAL_PIXEL_FORMAT_RAW_SENSOR: 154 case HAL_PIXEL_FORMAT_BLOB: 155 addComma = false; 156 break; 157 158 default: 159 ALOGW("%s: Camera %d: Unknown preview format: %x", 160 __FUNCTION__, cameraId, availableFormats.data.i32[i]); 161 addComma = false; 162 break; 163 } 164 } 165 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 166 supportedPreviewFormats); 167 } 168 169 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but 170 // still have to do something sane for them 171 172 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE, 173 previewFpsRange[0]); 174 175 { 176 String8 supportedPreviewFrameRates; 177 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 178 if (i != 0) supportedPreviewFrameRates += ","; 179 supportedPreviewFrameRates += String8::format("%d", 180 availableFpsRanges.data.i32[i]); 181 } 182 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 183 supportedPreviewFrameRates); 184 } 185 186 camera_metadata_ro_entry_t availableJpegSizes = 187 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2); 188 if (!availableJpegSizes.count) return NO_INIT; 189 190 // TODO: Pick maximum 191 pictureWidth = availableJpegSizes.data.i32[0]; 192 pictureHeight = availableJpegSizes.data.i32[1]; 193 194 params.setPictureSize(pictureWidth, 195 pictureHeight); 196 197 { 198 String8 supportedPictureSizes; 199 for (size_t i=0; i < availableJpegSizes.count; i += 2) { 200 if (i != 0) supportedPictureSizes += ","; 201 supportedPictureSizes += String8::format("%dx%d", 202 availableJpegSizes.data.i32[i], 203 availableJpegSizes.data.i32[i+1]); 204 } 205 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 206 supportedPictureSizes); 207 } 208 209 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 210 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 211 CameraParameters::PIXEL_FORMAT_JPEG); 212 213 camera_metadata_ro_entry_t availableJpegThumbnailSizes = 214 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 4); 215 if (!availableJpegThumbnailSizes.count) return NO_INIT; 216 217 // TODO: Pick default thumbnail size sensibly 218 jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0]; 219 jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1]; 220 221 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 222 jpegThumbSize[0]); 223 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 224 jpegThumbSize[1]); 225 226 { 227 String8 supportedJpegThumbSizes; 228 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) { 229 if (i != 0) supportedJpegThumbSizes += ","; 230 supportedJpegThumbSizes += String8::format("%dx%d", 231 availableJpegThumbnailSizes.data.i32[i], 232 availableJpegThumbnailSizes.data.i32[i+1]); 233 } 234 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 235 supportedJpegThumbSizes); 236 } 237 238 jpegThumbQuality = 90; 239 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 240 jpegThumbQuality); 241 jpegQuality = 90; 242 params.set(CameraParameters::KEY_JPEG_QUALITY, 243 jpegQuality); 244 jpegRotation = 0; 245 params.set(CameraParameters::KEY_ROTATION, 246 jpegRotation); 247 248 gpsEnabled = false; 249 gpsProcessingMethod = "unknown"; 250 // GPS fields in CameraParameters are not set by implementation 251 252 wbMode = ANDROID_CONTROL_AWB_AUTO; 253 params.set(CameraParameters::KEY_WHITE_BALANCE, 254 CameraParameters::WHITE_BALANCE_AUTO); 255 256 camera_metadata_ro_entry_t availableWhiteBalanceModes = 257 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 258 { 259 String8 supportedWhiteBalance; 260 bool addComma = false; 261 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) { 262 if (addComma) supportedWhiteBalance += ","; 263 addComma = true; 264 switch (availableWhiteBalanceModes.data.u8[i]) { 265 case ANDROID_CONTROL_AWB_AUTO: 266 supportedWhiteBalance += 267 CameraParameters::WHITE_BALANCE_AUTO; 268 break; 269 case ANDROID_CONTROL_AWB_INCANDESCENT: 270 supportedWhiteBalance += 271 CameraParameters::WHITE_BALANCE_INCANDESCENT; 272 break; 273 case ANDROID_CONTROL_AWB_FLUORESCENT: 274 supportedWhiteBalance += 275 CameraParameters::WHITE_BALANCE_FLUORESCENT; 276 break; 277 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT: 278 supportedWhiteBalance += 279 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 280 break; 281 case ANDROID_CONTROL_AWB_DAYLIGHT: 282 supportedWhiteBalance += 283 CameraParameters::WHITE_BALANCE_DAYLIGHT; 284 break; 285 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT: 286 supportedWhiteBalance += 287 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 288 break; 289 case ANDROID_CONTROL_AWB_TWILIGHT: 290 supportedWhiteBalance += 291 CameraParameters::WHITE_BALANCE_TWILIGHT; 292 break; 293 case ANDROID_CONTROL_AWB_SHADE: 294 supportedWhiteBalance += 295 CameraParameters::WHITE_BALANCE_SHADE; 296 break; 297 // Skipping values not mappable to v1 API 298 case ANDROID_CONTROL_AWB_OFF: 299 addComma = false; 300 break; 301 default: 302 ALOGW("%s: Camera %d: Unknown white balance value: %d", 303 __FUNCTION__, cameraId, 304 availableWhiteBalanceModes.data.u8[i]); 305 addComma = false; 306 break; 307 } 308 } 309 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 310 supportedWhiteBalance); 311 } 312 313 effectMode = ANDROID_CONTROL_EFFECT_OFF; 314 params.set(CameraParameters::KEY_EFFECT, 315 CameraParameters::EFFECT_NONE); 316 317 camera_metadata_ro_entry_t availableEffects = 318 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 319 if (!availableEffects.count) return NO_INIT; 320 { 321 String8 supportedEffects; 322 bool addComma = false; 323 for (size_t i=0; i < availableEffects.count; i++) { 324 if (addComma) supportedEffects += ","; 325 addComma = true; 326 switch (availableEffects.data.u8[i]) { 327 case ANDROID_CONTROL_EFFECT_OFF: 328 supportedEffects += 329 CameraParameters::EFFECT_NONE; 330 break; 331 case ANDROID_CONTROL_EFFECT_MONO: 332 supportedEffects += 333 CameraParameters::EFFECT_MONO; 334 break; 335 case ANDROID_CONTROL_EFFECT_NEGATIVE: 336 supportedEffects += 337 CameraParameters::EFFECT_NEGATIVE; 338 break; 339 case ANDROID_CONTROL_EFFECT_SOLARIZE: 340 supportedEffects += 341 CameraParameters::EFFECT_SOLARIZE; 342 break; 343 case ANDROID_CONTROL_EFFECT_SEPIA: 344 supportedEffects += 345 CameraParameters::EFFECT_SEPIA; 346 break; 347 case ANDROID_CONTROL_EFFECT_POSTERIZE: 348 supportedEffects += 349 CameraParameters::EFFECT_POSTERIZE; 350 break; 351 case ANDROID_CONTROL_EFFECT_WHITEBOARD: 352 supportedEffects += 353 CameraParameters::EFFECT_WHITEBOARD; 354 break; 355 case ANDROID_CONTROL_EFFECT_BLACKBOARD: 356 supportedEffects += 357 CameraParameters::EFFECT_BLACKBOARD; 358 break; 359 case ANDROID_CONTROL_EFFECT_AQUA: 360 supportedEffects += 361 CameraParameters::EFFECT_AQUA; 362 break; 363 default: 364 ALOGW("%s: Camera %d: Unknown effect value: %d", 365 __FUNCTION__, cameraId, availableEffects.data.u8[i]); 366 addComma = false; 367 break; 368 } 369 } 370 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects); 371 } 372 373 antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO; 374 params.set(CameraParameters::KEY_ANTIBANDING, 375 CameraParameters::ANTIBANDING_AUTO); 376 377 camera_metadata_ro_entry_t availableAntibandingModes = 378 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 379 if (!availableAntibandingModes.count) return NO_INIT; 380 { 381 String8 supportedAntibanding; 382 bool addComma = false; 383 for (size_t i=0; i < availableAntibandingModes.count; i++) { 384 if (addComma) supportedAntibanding += ","; 385 addComma = true; 386 switch (availableAntibandingModes.data.u8[i]) { 387 case ANDROID_CONTROL_AE_ANTIBANDING_OFF: 388 supportedAntibanding += 389 CameraParameters::ANTIBANDING_OFF; 390 break; 391 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ: 392 supportedAntibanding += 393 CameraParameters::ANTIBANDING_50HZ; 394 break; 395 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ: 396 supportedAntibanding += 397 CameraParameters::ANTIBANDING_60HZ; 398 break; 399 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO: 400 supportedAntibanding += 401 CameraParameters::ANTIBANDING_AUTO; 402 break; 403 default: 404 ALOGW("%s: Camera %d: Unknown antibanding value: %d", 405 __FUNCTION__, cameraId, 406 availableAntibandingModes.data.u8[i]); 407 addComma = false; 408 break; 409 } 410 } 411 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 412 supportedAntibanding); 413 } 414 415 sceneMode = ANDROID_CONTROL_OFF; 416 params.set(CameraParameters::KEY_SCENE_MODE, 417 CameraParameters::SCENE_MODE_AUTO); 418 419 camera_metadata_ro_entry_t availableSceneModes = 420 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 421 if (!availableSceneModes.count) return NO_INIT; 422 { 423 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO); 424 bool addComma = true; 425 bool noSceneModes = false; 426 for (size_t i=0; i < availableSceneModes.count; i++) { 427 if (addComma) supportedSceneModes += ","; 428 addComma = true; 429 switch (availableSceneModes.data.u8[i]) { 430 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 431 noSceneModes = true; 432 break; 433 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 434 // Not in old API 435 addComma = false; 436 break; 437 case ANDROID_CONTROL_SCENE_MODE_ACTION: 438 supportedSceneModes += 439 CameraParameters::SCENE_MODE_ACTION; 440 break; 441 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT: 442 supportedSceneModes += 443 CameraParameters::SCENE_MODE_PORTRAIT; 444 break; 445 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE: 446 supportedSceneModes += 447 CameraParameters::SCENE_MODE_LANDSCAPE; 448 break; 449 case ANDROID_CONTROL_SCENE_MODE_NIGHT: 450 supportedSceneModes += 451 CameraParameters::SCENE_MODE_NIGHT; 452 break; 453 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT: 454 supportedSceneModes += 455 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT; 456 break; 457 case ANDROID_CONTROL_SCENE_MODE_THEATRE: 458 supportedSceneModes += 459 CameraParameters::SCENE_MODE_THEATRE; 460 break; 461 case ANDROID_CONTROL_SCENE_MODE_BEACH: 462 supportedSceneModes += 463 CameraParameters::SCENE_MODE_BEACH; 464 break; 465 case ANDROID_CONTROL_SCENE_MODE_SNOW: 466 supportedSceneModes += 467 CameraParameters::SCENE_MODE_SNOW; 468 break; 469 case ANDROID_CONTROL_SCENE_MODE_SUNSET: 470 supportedSceneModes += 471 CameraParameters::SCENE_MODE_SUNSET; 472 break; 473 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO: 474 supportedSceneModes += 475 CameraParameters::SCENE_MODE_STEADYPHOTO; 476 break; 477 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS: 478 supportedSceneModes += 479 CameraParameters::SCENE_MODE_FIREWORKS; 480 break; 481 case ANDROID_CONTROL_SCENE_MODE_SPORTS: 482 supportedSceneModes += 483 CameraParameters::SCENE_MODE_SPORTS; 484 break; 485 case ANDROID_CONTROL_SCENE_MODE_PARTY: 486 supportedSceneModes += 487 CameraParameters::SCENE_MODE_PARTY; 488 break; 489 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT: 490 supportedSceneModes += 491 CameraParameters::SCENE_MODE_CANDLELIGHT; 492 break; 493 case ANDROID_CONTROL_SCENE_MODE_BARCODE: 494 supportedSceneModes += 495 CameraParameters::SCENE_MODE_BARCODE; 496 break; 497 default: 498 ALOGW("%s: Camera %d: Unknown scene mode value: %d", 499 __FUNCTION__, cameraId, 500 availableSceneModes.data.u8[i]); 501 addComma = false; 502 break; 503 } 504 } 505 if (!noSceneModes) { 506 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 507 supportedSceneModes); 508 } 509 } 510 511 camera_metadata_ro_entry_t flashAvailable = 512 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 513 if (!flashAvailable.count) return NO_INIT; 514 515 camera_metadata_ro_entry_t availableAeModes = 516 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 517 if (!availableAeModes.count) return NO_INIT; 518 519 if (flashAvailable.data.u8[0]) { 520 flashMode = Parameters::FLASH_MODE_AUTO; 521 params.set(CameraParameters::KEY_FLASH_MODE, 522 CameraParameters::FLASH_MODE_AUTO); 523 524 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF); 525 supportedFlashModes = supportedFlashModes + 526 "," + CameraParameters::FLASH_MODE_AUTO + 527 "," + CameraParameters::FLASH_MODE_ON + 528 "," + CameraParameters::FLASH_MODE_TORCH; 529 for (size_t i=0; i < availableAeModes.count; i++) { 530 if (availableAeModes.data.u8[i] == 531 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) { 532 supportedFlashModes = supportedFlashModes + "," + 533 CameraParameters::FLASH_MODE_RED_EYE; 534 break; 535 } 536 } 537 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 538 supportedFlashModes); 539 } else { 540 flashMode = Parameters::FLASH_MODE_OFF; 541 params.set(CameraParameters::KEY_FLASH_MODE, 542 CameraParameters::FLASH_MODE_OFF); 543 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 544 CameraParameters::FLASH_MODE_OFF); 545 } 546 547 camera_metadata_ro_entry_t minFocusDistance = 548 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1); 549 if (!minFocusDistance.count) return NO_INIT; 550 551 camera_metadata_ro_entry_t availableAfModes = 552 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 553 if (!availableAfModes.count) return NO_INIT; 554 555 if (minFocusDistance.data.f[0] == 0) { 556 // Fixed-focus lens 557 focusMode = Parameters::FOCUS_MODE_FIXED; 558 params.set(CameraParameters::KEY_FOCUS_MODE, 559 CameraParameters::FOCUS_MODE_FIXED); 560 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 561 CameraParameters::FOCUS_MODE_FIXED); 562 } else { 563 focusMode = Parameters::FOCUS_MODE_AUTO; 564 params.set(CameraParameters::KEY_FOCUS_MODE, 565 CameraParameters::FOCUS_MODE_AUTO); 566 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_INFINITY); 567 bool addComma = true; 568 569 for (size_t i=0; i < availableAfModes.count; i++) { 570 if (addComma) supportedFocusModes += ","; 571 addComma = true; 572 switch (availableAfModes.data.u8[i]) { 573 case ANDROID_CONTROL_AF_AUTO: 574 supportedFocusModes += 575 CameraParameters::FOCUS_MODE_AUTO; 576 break; 577 case ANDROID_CONTROL_AF_MACRO: 578 supportedFocusModes += 579 CameraParameters::FOCUS_MODE_MACRO; 580 break; 581 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO: 582 supportedFocusModes += 583 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 584 break; 585 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE: 586 supportedFocusModes += 587 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 588 break; 589 case ANDROID_CONTROL_AF_EDOF: 590 supportedFocusModes += 591 CameraParameters::FOCUS_MODE_EDOF; 592 break; 593 // Not supported in old API 594 case ANDROID_CONTROL_AF_OFF: 595 addComma = false; 596 break; 597 default: 598 ALOGW("%s: Camera %d: Unknown AF mode value: %d", 599 __FUNCTION__, cameraId, availableAfModes.data.u8[i]); 600 addComma = false; 601 break; 602 } 603 } 604 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 605 supportedFocusModes); 606 } 607 608 camera_metadata_ro_entry_t max3aRegions = 609 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1); 610 if (!max3aRegions.count) return NO_INIT; 611 612 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, 613 max3aRegions.data.i32[0]); 614 params.set(CameraParameters::KEY_FOCUS_AREAS, 615 "(0,0,0,0,0)"); 616 focusingAreas.clear(); 617 focusingAreas.add(Parameters::Area(0,0,0,0,0)); 618 619 camera_metadata_ro_entry_t availableFocalLengths = 620 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS); 621 if (!availableFocalLengths.count) return NO_INIT; 622 623 float minFocalLength = availableFocalLengths.data.f[0]; 624 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength); 625 626 camera_metadata_ro_entry_t sensorSize = 627 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2); 628 if (!sensorSize.count) return NO_INIT; 629 630 // The fields of view here assume infinity focus, maximum wide angle 631 float horizFov = 180 / M_PI * 632 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength)); 633 float vertFov = 180 / M_PI * 634 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength)); 635 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 636 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 637 638 exposureCompensation = 0; 639 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 640 exposureCompensation); 641 642 camera_metadata_ro_entry_t exposureCompensationRange = 643 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2); 644 if (!exposureCompensationRange.count) return NO_INIT; 645 646 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 647 exposureCompensationRange.data.i32[1]); 648 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 649 exposureCompensationRange.data.i32[0]); 650 651 camera_metadata_ro_entry_t exposureCompensationStep = 652 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1); 653 if (!exposureCompensationStep.count) return NO_INIT; 654 655 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 656 (float)exposureCompensationStep.data.r[0].numerator / 657 exposureCompensationStep.data.r[0].denominator); 658 659 autoExposureLock = false; 660 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 661 CameraParameters::FALSE); 662 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 663 CameraParameters::TRUE); 664 665 autoWhiteBalanceLock = false; 666 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 667 CameraParameters::FALSE); 668 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 669 CameraParameters::TRUE); 670 671 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 672 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 673 max3aRegions.data.i32[0]); 674 params.set(CameraParameters::KEY_METERING_AREAS, 675 "(0,0,0,0,0)"); 676 677 zoom = 0; 678 params.set(CameraParameters::KEY_ZOOM, zoom); 679 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 680 681 camera_metadata_ro_entry_t maxDigitalZoom = 682 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1); 683 if (!maxDigitalZoom.count) return NO_INIT; 684 685 { 686 String8 zoomRatios; 687 float zoom = 1.f; 688 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 689 (NUM_ZOOM_STEPS-1); 690 bool addComma = false; 691 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 692 if (addComma) zoomRatios += ","; 693 addComma = true; 694 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 695 zoom += zoomIncrement; 696 } 697 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 698 } 699 700 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 701 CameraParameters::TRUE); 702 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 703 CameraParameters::TRUE); 704 705 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 706 "Infinity,Infinity,Infinity"); 707 708 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 709 fastInfo.maxFaces); 710 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 711 0); 712 713 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 714 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE); 715 716 params.set(CameraParameters::KEY_RECORDING_HINT, 717 CameraParameters::FALSE); 718 719 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 720 CameraParameters::TRUE); 721 722 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 723 CameraParameters::FALSE); 724 725 camera_metadata_ro_entry_t availableVideoStabilizationModes = 726 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 727 if (!availableVideoStabilizationModes.count) return NO_INIT; 728 729 if (availableVideoStabilizationModes.count > 1) { 730 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 731 CameraParameters::TRUE); 732 } else { 733 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 734 CameraParameters::FALSE); 735 } 736 737 // Set up initial state for non-Camera.Parameters state variables 738 739 storeMetadataInBuffers = true; 740 playShutterSound = true; 741 enableFaceDetect = false; 742 743 enableFocusMoveMessages = false; 744 afTriggerCounter = 1; 745 currentAfTriggerId = -1; 746 747 precaptureTriggerCounter = 1; 748 749 previewCallbackFlags = 0; 750 751 state = STOPPED; 752 753 paramsFlattened = params.flatten(); 754 755 return OK; 756} 757 758status_t Parameters::buildFastInfo() { 759 760 camera_metadata_ro_entry_t activeArraySize = 761 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2); 762 if (!activeArraySize.count) return NO_INIT; 763 int32_t arrayWidth = activeArraySize.data.i32[0]; 764 int32_t arrayHeight = activeArraySize.data.i32[1]; 765 766 camera_metadata_ro_entry_t availableFaceDetectModes = 767 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES); 768 if (!availableFaceDetectModes.count) return NO_INIT; 769 770 uint8_t bestFaceDetectMode = 771 ANDROID_STATS_FACE_DETECTION_OFF; 772 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) { 773 switch (availableFaceDetectModes.data.u8[i]) { 774 case ANDROID_STATS_FACE_DETECTION_OFF: 775 break; 776 case ANDROID_STATS_FACE_DETECTION_SIMPLE: 777 if (bestFaceDetectMode != 778 ANDROID_STATS_FACE_DETECTION_FULL) { 779 bestFaceDetectMode = 780 ANDROID_STATS_FACE_DETECTION_SIMPLE; 781 } 782 break; 783 case ANDROID_STATS_FACE_DETECTION_FULL: 784 bestFaceDetectMode = 785 ANDROID_STATS_FACE_DETECTION_FULL; 786 break; 787 default: 788 ALOGE("%s: Camera %d: Unknown face detect mode %d:", 789 __FUNCTION__, cameraId, 790 availableFaceDetectModes.data.u8[i]); 791 return NO_INIT; 792 } 793 } 794 795 camera_metadata_ro_entry_t maxFacesDetected = 796 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1); 797 if (!maxFacesDetected.count) return NO_INIT; 798 799 int32_t maxFaces = maxFacesDetected.data.i32[0]; 800 801 fastInfo.arrayWidth = arrayWidth; 802 fastInfo.arrayHeight = arrayHeight; 803 fastInfo.bestFaceDetectMode = bestFaceDetectMode; 804 fastInfo.maxFaces = maxFaces; 805 return OK; 806} 807 808camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag, 809 size_t minCount, size_t maxCount) const { 810 status_t res; 811 camera_metadata_ro_entry_t entry = info->find(tag); 812 813 if (CC_UNLIKELY( entry.count == 0 )) { 814 const char* tagSection = get_camera_metadata_section_name(tag); 815 if (tagSection == NULL) tagSection = "<unknown>"; 816 const char* tagName = get_camera_metadata_tag_name(tag); 817 if (tagName == NULL) tagName = "<unknown>"; 818 819 ALOGE("Error finding static metadata entry '%s.%s' (%x)", 820 tagSection, tagName, tag); 821 } else if (CC_UNLIKELY( 822 (minCount != 0 && entry.count < minCount) || 823 (maxCount != 0 && entry.count > maxCount) ) ) { 824 const char* tagSection = get_camera_metadata_section_name(tag); 825 if (tagSection == NULL) tagSection = "<unknown>"; 826 const char* tagName = get_camera_metadata_tag_name(tag); 827 if (tagName == NULL) tagName = "<unknown>"; 828 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 829 "Expected between %d and %d values, but got %d values", 830 tagSection, tagName, tag, minCount, maxCount, entry.count); 831 } 832 833 return entry; 834} 835 836status_t Parameters::set(const String8& params) { 837 status_t res; 838 839 CameraParameters newParams(params); 840 841 // TODO: Currently ignoring any changes to supposedly read-only parameters 842 // such as supported preview sizes, etc. Should probably produce an error if 843 // they're changed. 844 845 /** Extract and verify new parameters */ 846 847 size_t i; 848 849 Parameters validatedParams(*this); 850 851 // PREVIEW_SIZE 852 newParams.getPreviewSize(&validatedParams.previewWidth, 853 &validatedParams.previewHeight); 854 855 if (validatedParams.previewWidth != previewWidth || 856 validatedParams.previewHeight != previewHeight) { 857 if (state >= PREVIEW) { 858 ALOGE("%s: Preview size cannot be updated when preview " 859 "is active! (Currently %d x %d, requested %d x %d", 860 __FUNCTION__, 861 previewWidth, previewHeight, 862 validatedParams.previewWidth, validatedParams.previewHeight); 863 return BAD_VALUE; 864 } 865 camera_metadata_ro_entry_t availablePreviewSizes = 866 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 867 for (i = 0; i < availablePreviewSizes.count; i += 2 ) { 868 if ((availablePreviewSizes.data.i32[i] == 869 validatedParams.previewWidth) && 870 (availablePreviewSizes.data.i32[i+1] == 871 validatedParams.previewHeight)) break; 872 } 873 if (i == availablePreviewSizes.count) { 874 ALOGE("%s: Requested preview size %d x %d is not supported", 875 __FUNCTION__, validatedParams.previewWidth, 876 validatedParams.previewHeight); 877 return BAD_VALUE; 878 } 879 } 880 881 // PREVIEW_FPS_RANGE 882 bool fpsRangeChanged = false; 883 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0], 884 &validatedParams.previewFpsRange[1]); 885 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] || 886 validatedParams.previewFpsRange[1] != previewFpsRange[1]) { 887 fpsRangeChanged = true; 888 camera_metadata_ro_entry_t availablePreviewFpsRanges = 889 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 890 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) { 891 if ((availablePreviewFpsRanges.data.i32[i] == 892 validatedParams.previewFpsRange[0]) && 893 (availablePreviewFpsRanges.data.i32[i+1] == 894 validatedParams.previewFpsRange[1]) ) { 895 break; 896 } 897 } 898 if (i == availablePreviewFpsRanges.count) { 899 ALOGE("%s: Requested preview FPS range %d - %d is not supported", 900 __FUNCTION__, validatedParams.previewFpsRange[0], 901 validatedParams.previewFpsRange[1]); 902 return BAD_VALUE; 903 } 904 validatedParams.previewFps = validatedParams.previewFpsRange[0]; 905 } 906 907 // PREVIEW_FORMAT 908 validatedParams.previewFormat = 909 formatStringToEnum(newParams.getPreviewFormat()); 910 if (validatedParams.previewFormat != previewFormat) { 911 if (state >= PREVIEW) { 912 ALOGE("%s: Preview format cannot be updated when preview " 913 "is active!", __FUNCTION__); 914 return BAD_VALUE; 915 } 916 camera_metadata_ro_entry_t availableFormats = 917 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 918 for (i = 0; i < availableFormats.count; i++) { 919 if (availableFormats.data.i32[i] == validatedParams.previewFormat) 920 break; 921 } 922 if (i == availableFormats.count) { 923 ALOGE("%s: Requested preview format %s (0x%x) is not supported", 924 __FUNCTION__, newParams.getPreviewFormat(), 925 validatedParams.previewFormat); 926 return BAD_VALUE; 927 } 928 } 929 930 // PREVIEW_FRAME_RATE 931 // Deprecated, only use if the preview fps range is unchanged this time. 932 // The single-value FPS is the same as the minimum of the range. 933 if (!fpsRangeChanged) { 934 validatedParams.previewFps = newParams.getPreviewFrameRate(); 935 if (validatedParams.previewFps != previewFps) { 936 camera_metadata_ro_entry_t availableFrameRates = 937 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES); 938 for (i = 0; i < availableFrameRates.count; i+=2) { 939 if (availableFrameRates.data.i32[i] == 940 validatedParams.previewFps) break; 941 } 942 if (i == availableFrameRates.count) { 943 ALOGE("%s: Requested preview frame rate %d is not supported", 944 __FUNCTION__, validatedParams.previewFps); 945 return BAD_VALUE; 946 } 947 validatedParams.previewFpsRange[0] = 948 availableFrameRates.data.i32[i]; 949 validatedParams.previewFpsRange[1] = 950 availableFrameRates.data.i32[i+1]; 951 } 952 } 953 954 // PICTURE_SIZE 955 newParams.getPictureSize(&validatedParams.pictureWidth, 956 &validatedParams.pictureHeight); 957 if (validatedParams.pictureWidth == pictureWidth || 958 validatedParams.pictureHeight == pictureHeight) { 959 camera_metadata_ro_entry_t availablePictureSizes = 960 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES); 961 for (i = 0; i < availablePictureSizes.count; i+=2) { 962 if ((availablePictureSizes.data.i32[i] == 963 validatedParams.pictureWidth) && 964 (availablePictureSizes.data.i32[i+1] == 965 validatedParams.pictureHeight)) break; 966 } 967 if (i == availablePictureSizes.count) { 968 ALOGE("%s: Requested picture size %d x %d is not supported", 969 __FUNCTION__, validatedParams.pictureWidth, 970 validatedParams.pictureHeight); 971 return BAD_VALUE; 972 } 973 } 974 975 // JPEG_THUMBNAIL_WIDTH/HEIGHT 976 validatedParams.jpegThumbSize[0] = 977 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 978 validatedParams.jpegThumbSize[1] = 979 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 980 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] || 981 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) { 982 camera_metadata_ro_entry_t availableJpegThumbSizes = 983 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES); 984 for (i = 0; i < availableJpegThumbSizes.count; i+=2) { 985 if ((availableJpegThumbSizes.data.i32[i] == 986 validatedParams.jpegThumbSize[0]) && 987 (availableJpegThumbSizes.data.i32[i+1] == 988 validatedParams.jpegThumbSize[1])) break; 989 } 990 if (i == availableJpegThumbSizes.count) { 991 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported", 992 __FUNCTION__, validatedParams.jpegThumbSize[0], 993 validatedParams.jpegThumbSize[1]); 994 return BAD_VALUE; 995 } 996 } 997 998 // JPEG_THUMBNAIL_QUALITY 999 validatedParams.jpegThumbQuality = 1000 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 1001 if (validatedParams.jpegThumbQuality < 0 || 1002 validatedParams.jpegThumbQuality > 100) { 1003 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported", 1004 __FUNCTION__, validatedParams.jpegThumbQuality); 1005 return BAD_VALUE; 1006 } 1007 1008 // JPEG_QUALITY 1009 validatedParams.jpegQuality = 1010 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY); 1011 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) { 1012 ALOGE("%s: Requested JPEG quality %d is not supported", 1013 __FUNCTION__, validatedParams.jpegQuality); 1014 return BAD_VALUE; 1015 } 1016 1017 // ROTATION 1018 validatedParams.jpegRotation = 1019 newParams.getInt(CameraParameters::KEY_ROTATION); 1020 if (validatedParams.jpegRotation != 0 && 1021 validatedParams.jpegRotation != 90 && 1022 validatedParams.jpegRotation != 180 && 1023 validatedParams.jpegRotation != 270) { 1024 ALOGE("%s: Requested picture rotation angle %d is not supported", 1025 __FUNCTION__, validatedParams.jpegRotation); 1026 return BAD_VALUE; 1027 } 1028 1029 // GPS 1030 1031 const char *gpsLatStr = 1032 newParams.get(CameraParameters::KEY_GPS_LATITUDE); 1033 if (gpsLatStr != NULL) { 1034 const char *gpsLongStr = 1035 newParams.get(CameraParameters::KEY_GPS_LONGITUDE); 1036 const char *gpsAltitudeStr = 1037 newParams.get(CameraParameters::KEY_GPS_ALTITUDE); 1038 const char *gpsTimeStr = 1039 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP); 1040 const char *gpsProcMethodStr = 1041 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 1042 if (gpsLongStr == NULL || 1043 gpsAltitudeStr == NULL || 1044 gpsTimeStr == NULL || 1045 gpsProcMethodStr == NULL) { 1046 ALOGE("%s: Incomplete set of GPS parameters provided", 1047 __FUNCTION__); 1048 return BAD_VALUE; 1049 } 1050 char *endPtr; 1051 errno = 0; 1052 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr); 1053 if (errno || endPtr == gpsLatStr) { 1054 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr); 1055 return BAD_VALUE; 1056 } 1057 errno = 0; 1058 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr); 1059 if (errno || endPtr == gpsLongStr) { 1060 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr); 1061 return BAD_VALUE; 1062 } 1063 errno = 0; 1064 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr); 1065 if (errno || endPtr == gpsAltitudeStr) { 1066 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__, 1067 gpsAltitudeStr); 1068 return BAD_VALUE; 1069 } 1070 errno = 0; 1071 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10); 1072 if (errno || endPtr == gpsTimeStr) { 1073 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr); 1074 return BAD_VALUE; 1075 } 1076 validatedParams.gpsProcessingMethod = gpsProcMethodStr; 1077 1078 validatedParams.gpsEnabled = true; 1079 } else { 1080 validatedParams.gpsEnabled = false; 1081 } 1082 1083 // WHITE_BALANCE 1084 validatedParams.wbMode = wbModeStringToEnum( 1085 newParams.get(CameraParameters::KEY_WHITE_BALANCE) ); 1086 if (validatedParams.wbMode != wbMode) { 1087 camera_metadata_ro_entry_t availableWbModes = 1088 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 1089 for (i = 0; i < availableWbModes.count; i++) { 1090 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break; 1091 } 1092 if (i == availableWbModes.count) { 1093 ALOGE("%s: Requested white balance mode %s is not supported", 1094 __FUNCTION__, 1095 newParams.get(CameraParameters::KEY_WHITE_BALANCE)); 1096 return BAD_VALUE; 1097 } 1098 } 1099 1100 // EFFECT 1101 validatedParams.effectMode = effectModeStringToEnum( 1102 newParams.get(CameraParameters::KEY_EFFECT) ); 1103 if (validatedParams.effectMode != effectMode) { 1104 camera_metadata_ro_entry_t availableEffectModes = 1105 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 1106 for (i = 0; i < availableEffectModes.count; i++) { 1107 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break; 1108 } 1109 if (i == availableEffectModes.count) { 1110 ALOGE("%s: Requested effect mode \"%s\" is not supported", 1111 __FUNCTION__, 1112 newParams.get(CameraParameters::KEY_EFFECT) ); 1113 return BAD_VALUE; 1114 } 1115 } 1116 1117 // ANTIBANDING 1118 validatedParams.antibandingMode = abModeStringToEnum( 1119 newParams.get(CameraParameters::KEY_ANTIBANDING) ); 1120 if (validatedParams.antibandingMode != antibandingMode) { 1121 camera_metadata_ro_entry_t availableAbModes = 1122 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 1123 for (i = 0; i < availableAbModes.count; i++) { 1124 if (validatedParams.antibandingMode == availableAbModes.data.u8[i]) 1125 break; 1126 } 1127 if (i == availableAbModes.count) { 1128 ALOGE("%s: Requested antibanding mode \"%s\" is not supported", 1129 __FUNCTION__, 1130 newParams.get(CameraParameters::KEY_ANTIBANDING)); 1131 return BAD_VALUE; 1132 } 1133 } 1134 1135 // SCENE_MODE 1136 validatedParams.sceneMode = sceneModeStringToEnum( 1137 newParams.get(CameraParameters::KEY_SCENE_MODE) ); 1138 if (validatedParams.sceneMode != sceneMode && 1139 validatedParams.sceneMode != 1140 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) { 1141 camera_metadata_ro_entry_t availableSceneModes = 1142 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 1143 for (i = 0; i < availableSceneModes.count; i++) { 1144 if (validatedParams.sceneMode == availableSceneModes.data.u8[i]) 1145 break; 1146 } 1147 if (i == availableSceneModes.count) { 1148 ALOGE("%s: Requested scene mode \"%s\" is not supported", 1149 __FUNCTION__, 1150 newParams.get(CameraParameters::KEY_SCENE_MODE)); 1151 return BAD_VALUE; 1152 } 1153 } 1154 1155 // FLASH_MODE 1156 validatedParams.flashMode = flashModeStringToEnum( 1157 newParams.get(CameraParameters::KEY_FLASH_MODE) ); 1158 if (validatedParams.flashMode != flashMode) { 1159 camera_metadata_ro_entry_t flashAvailable = 1160 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 1161 if (!flashAvailable.data.u8[0] && 1162 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) { 1163 ALOGE("%s: Requested flash mode \"%s\" is not supported: " 1164 "No flash on device", __FUNCTION__, 1165 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1166 return BAD_VALUE; 1167 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) { 1168 camera_metadata_ro_entry_t availableAeModes = 1169 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 1170 for (i = 0; i < availableAeModes.count; i++) { 1171 if (validatedParams.flashMode == availableAeModes.data.u8[i]) 1172 break; 1173 } 1174 if (i == availableAeModes.count) { 1175 ALOGE("%s: Requested flash mode \"%s\" is not supported", 1176 __FUNCTION__, 1177 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1178 return BAD_VALUE; 1179 } 1180 } else if (validatedParams.flashMode == -1) { 1181 ALOGE("%s: Requested flash mode \"%s\" is unknown", 1182 __FUNCTION__, 1183 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1184 return BAD_VALUE; 1185 } 1186 } 1187 1188 // FOCUS_MODE 1189 validatedParams.focusMode = focusModeStringToEnum( 1190 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1191 if (validatedParams.focusMode != focusMode) { 1192 validatedParams.currentAfTriggerId = -1; 1193 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) { 1194 camera_metadata_ro_entry_t minFocusDistance = 1195 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE); 1196 if (minFocusDistance.data.f[0] == 0) { 1197 ALOGE("%s: Requested focus mode \"%s\" is not available: " 1198 "fixed focus lens", 1199 __FUNCTION__, 1200 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1201 return BAD_VALUE; 1202 } else if (validatedParams.focusMode != 1203 Parameters::FOCUS_MODE_INFINITY) { 1204 camera_metadata_ro_entry_t availableFocusModes = 1205 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1206 for (i = 0; i < availableFocusModes.count; i++) { 1207 if (validatedParams.focusMode == 1208 availableFocusModes.data.u8[i]) break; 1209 } 1210 if (i == availableFocusModes.count) { 1211 ALOGE("%s: Requested focus mode \"%s\" is not supported", 1212 __FUNCTION__, 1213 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1214 return BAD_VALUE; 1215 } 1216 } 1217 } 1218 } else { 1219 validatedParams.currentAfTriggerId = currentAfTriggerId; 1220 } 1221 1222 // FOCUS_AREAS 1223 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS), 1224 &validatedParams.focusingAreas); 1225 size_t max3aRegions = 1226 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0]; 1227 if (res == OK) res = validateAreas(validatedParams.focusingAreas, 1228 max3aRegions); 1229 if (res != OK) { 1230 ALOGE("%s: Requested focus areas are malformed: %s", 1231 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS)); 1232 return BAD_VALUE; 1233 } 1234 1235 // EXPOSURE_COMPENSATION 1236 validatedParams.exposureCompensation = 1237 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1238 camera_metadata_ro_entry_t exposureCompensationRange = 1239 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE); 1240 if ((validatedParams.exposureCompensation < 1241 exposureCompensationRange.data.i32[0]) || 1242 (validatedParams.exposureCompensation > 1243 exposureCompensationRange.data.i32[1])) { 1244 ALOGE("%s: Requested exposure compensation index is out of bounds: %d", 1245 __FUNCTION__, validatedParams.exposureCompensation); 1246 return BAD_VALUE; 1247 } 1248 1249 // AUTO_EXPOSURE_LOCK (always supported) 1250 validatedParams.autoExposureLock = boolFromString( 1251 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 1252 1253 // AUTO_WHITEBALANCE_LOCK (always supported) 1254 validatedParams.autoWhiteBalanceLock = boolFromString( 1255 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 1256 1257 // METERING_AREAS 1258 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS), 1259 &validatedParams.meteringAreas); 1260 if (res == OK) { 1261 res = validateAreas(validatedParams.meteringAreas, max3aRegions); 1262 } 1263 if (res != OK) { 1264 ALOGE("%s: Requested metering areas are malformed: %s", 1265 __FUNCTION__, 1266 newParams.get(CameraParameters::KEY_METERING_AREAS)); 1267 return BAD_VALUE; 1268 } 1269 1270 // ZOOM 1271 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM); 1272 if (validatedParams.zoom < 0 || validatedParams.zoom > (int)NUM_ZOOM_STEPS) { 1273 ALOGE("%s: Requested zoom level %d is not supported", 1274 __FUNCTION__, validatedParams.zoom); 1275 return BAD_VALUE; 1276 } 1277 1278 // VIDEO_SIZE 1279 newParams.getVideoSize(&validatedParams.videoWidth, 1280 &validatedParams.videoHeight); 1281 if (validatedParams.videoWidth != videoWidth || 1282 validatedParams.videoHeight != videoHeight) { 1283 if (state == RECORD) { 1284 ALOGE("%s: Video size cannot be updated when recording is active!", 1285 __FUNCTION__); 1286 return BAD_VALUE; 1287 } 1288 camera_metadata_ro_entry_t availableVideoSizes = 1289 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 1290 for (i = 0; i < availableVideoSizes.count; i += 2 ) { 1291 if ((availableVideoSizes.data.i32[i] == 1292 validatedParams.videoWidth) && 1293 (availableVideoSizes.data.i32[i+1] == 1294 validatedParams.videoHeight)) break; 1295 } 1296 if (i == availableVideoSizes.count) { 1297 ALOGE("%s: Requested video size %d x %d is not supported", 1298 __FUNCTION__, validatedParams.videoWidth, 1299 validatedParams.videoHeight); 1300 return BAD_VALUE; 1301 } 1302 } 1303 1304 // RECORDING_HINT (always supported) 1305 validatedParams.recordingHint = boolFromString( 1306 newParams.get(CameraParameters::KEY_RECORDING_HINT) ); 1307 1308 // VIDEO_STABILIZATION 1309 validatedParams.videoStabilization = boolFromString( 1310 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) ); 1311 camera_metadata_ro_entry_t availableVideoStabilizationModes = 1312 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 1313 if (validatedParams.videoStabilization && 1314 availableVideoStabilizationModes.count == 1) { 1315 ALOGE("%s: Video stabilization not supported", __FUNCTION__); 1316 } 1317 1318 /** Update internal parameters */ 1319 1320 validatedParams.paramsFlattened = params; 1321 *this = validatedParams; 1322 1323 return OK; 1324} 1325 1326status_t Parameters::updateRequest(CameraMetadata *request) const { 1327 ATRACE_CALL(); 1328 status_t res; 1329 1330 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL; 1331 res = request->update(ANDROID_REQUEST_METADATA_MODE, 1332 &metadataMode, 1); 1333 if (res != OK) return res; 1334 1335 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 1336 previewFpsRange, 2); 1337 if (res != OK) return res; 1338 1339 res = request->update(ANDROID_CONTROL_AWB_MODE, 1340 &wbMode, 1); 1341 if (res != OK) return res; 1342 1343 uint8_t reqWbLock = autoWhiteBalanceLock ? 1344 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF; 1345 res = request->update(ANDROID_CONTROL_AWB_LOCK, 1346 &reqWbLock, 1); 1347 1348 res = request->update(ANDROID_CONTROL_EFFECT_MODE, 1349 &effectMode, 1); 1350 if (res != OK) return res; 1351 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, 1352 &antibandingMode, 1); 1353 if (res != OK) return res; 1354 1355 uint8_t reqControlMode = 1356 (sceneMode == ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) ? 1357 ANDROID_CONTROL_AUTO : ANDROID_CONTROL_USE_SCENE_MODE; 1358 res = request->update(ANDROID_CONTROL_MODE, 1359 &reqControlMode, 1); 1360 if (res != OK) return res; 1361 if (reqControlMode == ANDROID_CONTROL_USE_SCENE_MODE) { 1362 res = request->update(ANDROID_CONTROL_SCENE_MODE, 1363 &sceneMode, 1); 1364 if (res != OK) return res; 1365 } 1366 1367 uint8_t reqFlashMode = ANDROID_FLASH_OFF; 1368 uint8_t reqAeMode; 1369 switch (flashMode) { 1370 case Parameters::FLASH_MODE_OFF: 1371 reqAeMode = ANDROID_CONTROL_AE_ON; break; 1372 case Parameters::FLASH_MODE_AUTO: 1373 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break; 1374 case Parameters::FLASH_MODE_ON: 1375 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break; 1376 case Parameters::FLASH_MODE_TORCH: 1377 reqAeMode = ANDROID_CONTROL_AE_ON; 1378 reqFlashMode = ANDROID_FLASH_TORCH; 1379 break; 1380 case Parameters::FLASH_MODE_RED_EYE: 1381 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break; 1382 default: 1383 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__, 1384 cameraId, flashMode); 1385 return BAD_VALUE; 1386 } 1387 res = request->update(ANDROID_FLASH_MODE, 1388 &reqFlashMode, 1); 1389 if (res != OK) return res; 1390 res = request->update(ANDROID_CONTROL_AE_MODE, 1391 &reqAeMode, 1); 1392 if (res != OK) return res; 1393 1394 uint8_t reqAeLock = autoExposureLock ? 1395 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF; 1396 res = request->update(ANDROID_CONTROL_AE_LOCK, 1397 &reqAeLock, 1); 1398 1399 float reqFocusDistance = 0; // infinity focus in diopters 1400 uint8_t reqFocusMode; 1401 switch (focusMode) { 1402 case Parameters::FOCUS_MODE_AUTO: 1403 case Parameters::FOCUS_MODE_MACRO: 1404 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1405 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1406 case Parameters::FOCUS_MODE_EDOF: 1407 reqFocusMode = focusMode; 1408 break; 1409 case Parameters::FOCUS_MODE_INFINITY: 1410 case Parameters::FOCUS_MODE_FIXED: 1411 reqFocusMode = ANDROID_CONTROL_AF_OFF; 1412 break; 1413 default: 1414 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__, 1415 cameraId, focusMode); 1416 return BAD_VALUE; 1417 } 1418 res = request->update(ANDROID_LENS_FOCUS_DISTANCE, 1419 &reqFocusDistance, 1); 1420 if (res != OK) return res; 1421 res = request->update(ANDROID_CONTROL_AF_MODE, 1422 &reqFocusMode, 1); 1423 if (res != OK) return res; 1424 1425 size_t reqFocusingAreasSize = focusingAreas.size() * 5; 1426 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize]; 1427 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) { 1428 if (focusingAreas[i].weight != 0) { 1429 reqFocusingAreas[i + 0] = 1430 normalizedXToArray(focusingAreas[i].left); 1431 reqFocusingAreas[i + 1] = 1432 normalizedYToArray(focusingAreas[i].top); 1433 reqFocusingAreas[i + 2] = 1434 normalizedXToArray(focusingAreas[i].right); 1435 reqFocusingAreas[i + 3] = 1436 normalizedYToArray(focusingAreas[i].bottom); 1437 } else { 1438 reqFocusingAreas[i + 0] = 0; 1439 reqFocusingAreas[i + 1] = 0; 1440 reqFocusingAreas[i + 2] = 0; 1441 reqFocusingAreas[i + 3] = 0; 1442 } 1443 reqFocusingAreas[i + 4] = focusingAreas[i].weight; 1444 } 1445 res = request->update(ANDROID_CONTROL_AF_REGIONS, 1446 reqFocusingAreas, reqFocusingAreasSize); 1447 if (res != OK) return res; 1448 delete[] reqFocusingAreas; 1449 1450 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION, 1451 &exposureCompensation, 1); 1452 if (res != OK) return res; 1453 1454 size_t reqMeteringAreasSize = meteringAreas.size() * 5; 1455 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize]; 1456 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) { 1457 if (meteringAreas[i].weight != 0) { 1458 reqMeteringAreas[i + 0] = 1459 normalizedXToArray(meteringAreas[i].left); 1460 reqMeteringAreas[i + 1] = 1461 normalizedYToArray(meteringAreas[i].top); 1462 reqMeteringAreas[i + 2] = 1463 normalizedXToArray(meteringAreas[i].right); 1464 reqMeteringAreas[i + 3] = 1465 normalizedYToArray(meteringAreas[i].bottom); 1466 } else { 1467 reqMeteringAreas[i + 0] = 0; 1468 reqMeteringAreas[i + 1] = 0; 1469 reqMeteringAreas[i + 2] = 0; 1470 reqMeteringAreas[i + 3] = 0; 1471 } 1472 reqMeteringAreas[i + 4] = meteringAreas[i].weight; 1473 } 1474 res = request->update(ANDROID_CONTROL_AE_REGIONS, 1475 reqMeteringAreas, reqMeteringAreasSize); 1476 if (res != OK) return res; 1477 1478 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 1479 reqMeteringAreas, reqMeteringAreasSize); 1480 if (res != OK) return res; 1481 delete[] reqMeteringAreas; 1482 1483 // Need to convert zoom index into a crop rectangle. The rectangle is 1484 // chosen to maximize its area on the sensor 1485 1486 camera_metadata_ro_entry_t maxDigitalZoom = 1487 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM); 1488 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) / 1489 (NUM_ZOOM_STEPS-1); 1490 float zoomRatio = 1 + zoomIncrement * zoom; 1491 1492 float zoomLeft, zoomTop, zoomWidth, zoomHeight; 1493 if (previewWidth >= previewHeight) { 1494 zoomWidth = fastInfo.arrayWidth / zoomRatio; 1495 zoomHeight = zoomWidth * 1496 previewHeight / previewWidth; 1497 } else { 1498 zoomHeight = fastInfo.arrayHeight / zoomRatio; 1499 zoomWidth = zoomHeight * 1500 previewWidth / previewHeight; 1501 } 1502 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2; 1503 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2; 1504 1505 int32_t reqCropRegion[3] = { zoomLeft, zoomTop, zoomWidth }; 1506 res = request->update(ANDROID_SCALER_CROP_REGION, 1507 reqCropRegion, 3); 1508 if (res != OK) return res; 1509 1510 // TODO: Decide how to map recordingHint, or whether just to ignore it 1511 1512 uint8_t reqVstabMode = videoStabilization ? 1513 ANDROID_CONTROL_VIDEO_STABILIZATION_ON : 1514 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF; 1515 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 1516 &reqVstabMode, 1); 1517 if (res != OK) return res; 1518 1519 uint8_t reqFaceDetectMode = enableFaceDetect ? 1520 fastInfo.bestFaceDetectMode : 1521 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF; 1522 res = request->update(ANDROID_STATS_FACE_DETECT_MODE, 1523 &reqFaceDetectMode, 1); 1524 if (res != OK) return res; 1525 1526 return OK; 1527} 1528 1529const char* Parameters::getStateName(State state) { 1530#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break; 1531 switch(state) { 1532 CASE_ENUM_TO_CHAR(DISCONNECTED) 1533 CASE_ENUM_TO_CHAR(STOPPED) 1534 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW) 1535 CASE_ENUM_TO_CHAR(PREVIEW) 1536 CASE_ENUM_TO_CHAR(RECORD) 1537 CASE_ENUM_TO_CHAR(STILL_CAPTURE) 1538 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT) 1539 default: 1540 return "Unknown state!"; 1541 break; 1542 } 1543#undef CASE_ENUM_TO_CHAR 1544} 1545 1546int Parameters::formatStringToEnum(const char *format) { 1547 return 1548 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ? 1549 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16 1550 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ? 1551 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21 1552 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ? 1553 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2 1554 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ? 1555 HAL_PIXEL_FORMAT_YV12 : // YV12 1556 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ? 1557 HAL_PIXEL_FORMAT_RGB_565 : // RGB565 1558 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ? 1559 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888 1560 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ? 1561 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data 1562 -1; 1563} 1564 1565const char* Parameters::formatEnumToString(int format) { 1566 const char *fmt; 1567 switch(format) { 1568 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1569 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 1570 break; 1571 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1572 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 1573 break; 1574 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1575 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 1576 break; 1577 case HAL_PIXEL_FORMAT_YV12: // YV12 1578 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 1579 break; 1580 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 1581 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 1582 break; 1583 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 1584 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 1585 break; 1586 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1587 ALOGW("Raw sensor preview format requested."); 1588 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 1589 break; 1590 default: 1591 ALOGE("%s: Unknown preview format: %x", 1592 __FUNCTION__, format); 1593 fmt = NULL; 1594 break; 1595 } 1596 return fmt; 1597} 1598 1599int Parameters::wbModeStringToEnum(const char *wbMode) { 1600 return 1601 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ? 1602 ANDROID_CONTROL_AWB_AUTO : 1603 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ? 1604 ANDROID_CONTROL_AWB_INCANDESCENT : 1605 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ? 1606 ANDROID_CONTROL_AWB_FLUORESCENT : 1607 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ? 1608 ANDROID_CONTROL_AWB_WARM_FLUORESCENT : 1609 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ? 1610 ANDROID_CONTROL_AWB_DAYLIGHT : 1611 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ? 1612 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT : 1613 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ? 1614 ANDROID_CONTROL_AWB_TWILIGHT : 1615 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ? 1616 ANDROID_CONTROL_AWB_SHADE : 1617 -1; 1618} 1619 1620int Parameters::effectModeStringToEnum(const char *effectMode) { 1621 return 1622 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ? 1623 ANDROID_CONTROL_EFFECT_OFF : 1624 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ? 1625 ANDROID_CONTROL_EFFECT_MONO : 1626 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ? 1627 ANDROID_CONTROL_EFFECT_NEGATIVE : 1628 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ? 1629 ANDROID_CONTROL_EFFECT_SOLARIZE : 1630 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ? 1631 ANDROID_CONTROL_EFFECT_SEPIA : 1632 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ? 1633 ANDROID_CONTROL_EFFECT_POSTERIZE : 1634 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ? 1635 ANDROID_CONTROL_EFFECT_WHITEBOARD : 1636 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ? 1637 ANDROID_CONTROL_EFFECT_BLACKBOARD : 1638 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ? 1639 ANDROID_CONTROL_EFFECT_AQUA : 1640 -1; 1641} 1642 1643int Parameters::abModeStringToEnum(const char *abMode) { 1644 return 1645 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ? 1646 ANDROID_CONTROL_AE_ANTIBANDING_AUTO : 1647 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ? 1648 ANDROID_CONTROL_AE_ANTIBANDING_OFF : 1649 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ? 1650 ANDROID_CONTROL_AE_ANTIBANDING_50HZ : 1651 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ? 1652 ANDROID_CONTROL_AE_ANTIBANDING_60HZ : 1653 -1; 1654} 1655 1656int Parameters::sceneModeStringToEnum(const char *sceneMode) { 1657 return 1658 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ? 1659 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED : 1660 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ? 1661 ANDROID_CONTROL_SCENE_MODE_ACTION : 1662 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ? 1663 ANDROID_CONTROL_SCENE_MODE_PORTRAIT : 1664 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ? 1665 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE : 1666 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ? 1667 ANDROID_CONTROL_SCENE_MODE_NIGHT : 1668 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ? 1669 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT : 1670 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ? 1671 ANDROID_CONTROL_SCENE_MODE_THEATRE : 1672 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ? 1673 ANDROID_CONTROL_SCENE_MODE_BEACH : 1674 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ? 1675 ANDROID_CONTROL_SCENE_MODE_SNOW : 1676 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ? 1677 ANDROID_CONTROL_SCENE_MODE_SUNSET : 1678 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ? 1679 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO : 1680 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ? 1681 ANDROID_CONTROL_SCENE_MODE_FIREWORKS : 1682 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ? 1683 ANDROID_CONTROL_SCENE_MODE_SPORTS : 1684 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ? 1685 ANDROID_CONTROL_SCENE_MODE_PARTY : 1686 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ? 1687 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT : 1688 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ? 1689 ANDROID_CONTROL_SCENE_MODE_BARCODE: 1690 -1; 1691} 1692 1693Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum( 1694 const char *flashMode) { 1695 return 1696 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ? 1697 Parameters::FLASH_MODE_OFF : 1698 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ? 1699 Parameters::FLASH_MODE_AUTO : 1700 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ? 1701 Parameters::FLASH_MODE_ON : 1702 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ? 1703 Parameters::FLASH_MODE_RED_EYE : 1704 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ? 1705 Parameters::FLASH_MODE_TORCH : 1706 Parameters::FLASH_MODE_INVALID; 1707} 1708 1709Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum( 1710 const char *focusMode) { 1711 return 1712 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ? 1713 Parameters::FOCUS_MODE_AUTO : 1714 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ? 1715 Parameters::FOCUS_MODE_INFINITY : 1716 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ? 1717 Parameters::FOCUS_MODE_MACRO : 1718 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ? 1719 Parameters::FOCUS_MODE_FIXED : 1720 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ? 1721 Parameters::FOCUS_MODE_EDOF : 1722 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ? 1723 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO : 1724 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ? 1725 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE : 1726 Parameters::FOCUS_MODE_INVALID; 1727} 1728 1729status_t Parameters::parseAreas(const char *areasCStr, 1730 Vector<Parameters::Area> *areas) { 1731 static const size_t NUM_FIELDS = 5; 1732 areas->clear(); 1733 if (areasCStr == NULL) { 1734 // If no key exists, use default (0,0,0,0,0) 1735 areas->push(); 1736 return OK; 1737 } 1738 String8 areasStr(areasCStr); 1739 ssize_t areaStart = areasStr.find("(", 0) + 1; 1740 while (areaStart != 0) { 1741 const char* area = areasStr.string() + areaStart; 1742 char *numEnd; 1743 int vals[NUM_FIELDS]; 1744 for (size_t i = 0; i < NUM_FIELDS; i++) { 1745 errno = 0; 1746 vals[i] = strtol(area, &numEnd, 10); 1747 if (errno || numEnd == area) return BAD_VALUE; 1748 area = numEnd + 1; 1749 } 1750 areas->push(Parameters::Area( 1751 vals[0], vals[1], vals[2], vals[3], vals[4]) ); 1752 areaStart = areasStr.find("(", areaStart) + 1; 1753 } 1754 return OK; 1755} 1756 1757status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas, 1758 size_t maxRegions) { 1759 // Definition of valid area can be found in 1760 // include/camera/CameraParameters.h 1761 if (areas.size() == 0) return BAD_VALUE; 1762 if (areas.size() == 1) { 1763 if (areas[0].left == 0 && 1764 areas[0].top == 0 && 1765 areas[0].right == 0 && 1766 areas[0].bottom == 0 && 1767 areas[0].weight == 0) { 1768 // Single (0,0,0,0,0) entry is always valid (== driver decides) 1769 return OK; 1770 } 1771 } 1772 if (areas.size() > maxRegions) { 1773 ALOGE("%s: Too many areas requested: %d", 1774 __FUNCTION__, areas.size()); 1775 return BAD_VALUE; 1776 } 1777 1778 for (Vector<Parameters::Area>::const_iterator a = areas.begin(); 1779 a != areas.end(); a++) { 1780 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE; 1781 if (a->left < -1000 || a->left > 1000) return BAD_VALUE; 1782 if (a->top < -1000 || a->top > 1000) return BAD_VALUE; 1783 if (a->right < -1000 || a->right > 1000) return BAD_VALUE; 1784 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE; 1785 if (a->left >= a->right) return BAD_VALUE; 1786 if (a->top >= a->bottom) return BAD_VALUE; 1787 } 1788 return OK; 1789} 1790 1791bool Parameters::boolFromString(const char *boolStr) { 1792 return !boolStr ? false : 1793 !strcmp(boolStr, CameraParameters::TRUE) ? true : 1794 false; 1795} 1796 1797int Parameters::degToTransform(int degrees, bool mirror) { 1798 if (!mirror) { 1799 if (degrees == 0) return 0; 1800 else if (degrees == 90) return HAL_TRANSFORM_ROT_90; 1801 else if (degrees == 180) return HAL_TRANSFORM_ROT_180; 1802 else if (degrees == 270) return HAL_TRANSFORM_ROT_270; 1803 } else { // Do mirror (horizontal flip) 1804 if (degrees == 0) { // FLIP_H and ROT_0 1805 return HAL_TRANSFORM_FLIP_H; 1806 } else if (degrees == 90) { // FLIP_H and ROT_90 1807 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90; 1808 } else if (degrees == 180) { // FLIP_H and ROT_180 1809 return HAL_TRANSFORM_FLIP_V; 1810 } else if (degrees == 270) { // FLIP_H and ROT_270 1811 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90; 1812 } 1813 } 1814 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees); 1815 return -1; 1816} 1817 1818int Parameters::arrayXToNormalized(int width) const { 1819 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000; 1820} 1821 1822int Parameters::arrayYToNormalized(int height) const { 1823 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000; 1824} 1825 1826int Parameters::normalizedXToArray(int x) const { 1827 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000; 1828} 1829 1830int Parameters::normalizedYToArray(int y) const { 1831 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000; 1832} 1833 1834}; // namespace camera2 1835}; // namespace android 1836