Parameters.cpp revision e538206d15282afbc5b168d60b1026a5dfcd13c0
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 zslMode = false; 752 753 lightFx = LIGHTFX_NONE; 754 755 state = STOPPED; 756 757 paramsFlattened = params.flatten(); 758 759 return OK; 760} 761 762status_t Parameters::buildFastInfo() { 763 764 camera_metadata_ro_entry_t activeArraySize = 765 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2); 766 if (!activeArraySize.count) return NO_INIT; 767 int32_t arrayWidth = activeArraySize.data.i32[0]; 768 int32_t arrayHeight = activeArraySize.data.i32[1]; 769 770 camera_metadata_ro_entry_t availableFaceDetectModes = 771 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES); 772 if (!availableFaceDetectModes.count) return NO_INIT; 773 774 uint8_t bestFaceDetectMode = 775 ANDROID_STATS_FACE_DETECTION_OFF; 776 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) { 777 switch (availableFaceDetectModes.data.u8[i]) { 778 case ANDROID_STATS_FACE_DETECTION_OFF: 779 break; 780 case ANDROID_STATS_FACE_DETECTION_SIMPLE: 781 if (bestFaceDetectMode != 782 ANDROID_STATS_FACE_DETECTION_FULL) { 783 bestFaceDetectMode = 784 ANDROID_STATS_FACE_DETECTION_SIMPLE; 785 } 786 break; 787 case ANDROID_STATS_FACE_DETECTION_FULL: 788 bestFaceDetectMode = 789 ANDROID_STATS_FACE_DETECTION_FULL; 790 break; 791 default: 792 ALOGE("%s: Camera %d: Unknown face detect mode %d:", 793 __FUNCTION__, cameraId, 794 availableFaceDetectModes.data.u8[i]); 795 return NO_INIT; 796 } 797 } 798 799 camera_metadata_ro_entry_t maxFacesDetected = 800 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1); 801 if (!maxFacesDetected.count) return NO_INIT; 802 803 int32_t maxFaces = maxFacesDetected.data.i32[0]; 804 805 fastInfo.arrayWidth = arrayWidth; 806 fastInfo.arrayHeight = arrayHeight; 807 fastInfo.bestFaceDetectMode = bestFaceDetectMode; 808 fastInfo.maxFaces = maxFaces; 809 return OK; 810} 811 812camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag, 813 size_t minCount, size_t maxCount) const { 814 status_t res; 815 camera_metadata_ro_entry_t entry = info->find(tag); 816 817 if (CC_UNLIKELY( entry.count == 0 )) { 818 const char* tagSection = get_camera_metadata_section_name(tag); 819 if (tagSection == NULL) tagSection = "<unknown>"; 820 const char* tagName = get_camera_metadata_tag_name(tag); 821 if (tagName == NULL) tagName = "<unknown>"; 822 823 ALOGE("Error finding static metadata entry '%s.%s' (%x)", 824 tagSection, tagName, tag); 825 } else if (CC_UNLIKELY( 826 (minCount != 0 && entry.count < minCount) || 827 (maxCount != 0 && entry.count > maxCount) ) ) { 828 const char* tagSection = get_camera_metadata_section_name(tag); 829 if (tagSection == NULL) tagSection = "<unknown>"; 830 const char* tagName = get_camera_metadata_tag_name(tag); 831 if (tagName == NULL) tagName = "<unknown>"; 832 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 833 "Expected between %d and %d values, but got %d values", 834 tagSection, tagName, tag, minCount, maxCount, entry.count); 835 } 836 837 return entry; 838} 839 840status_t Parameters::set(const String8& params) { 841 status_t res; 842 843 CameraParameters newParams(params); 844 845 // TODO: Currently ignoring any changes to supposedly read-only parameters 846 // such as supported preview sizes, etc. Should probably produce an error if 847 // they're changed. 848 849 /** Extract and verify new parameters */ 850 851 size_t i; 852 853 Parameters validatedParams(*this); 854 855 // PREVIEW_SIZE 856 newParams.getPreviewSize(&validatedParams.previewWidth, 857 &validatedParams.previewHeight); 858 859 if (validatedParams.previewWidth != previewWidth || 860 validatedParams.previewHeight != previewHeight) { 861 if (state >= PREVIEW) { 862 ALOGE("%s: Preview size cannot be updated when preview " 863 "is active! (Currently %d x %d, requested %d x %d", 864 __FUNCTION__, 865 previewWidth, previewHeight, 866 validatedParams.previewWidth, validatedParams.previewHeight); 867 return BAD_VALUE; 868 } 869 camera_metadata_ro_entry_t availablePreviewSizes = 870 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 871 for (i = 0; i < availablePreviewSizes.count; i += 2 ) { 872 if ((availablePreviewSizes.data.i32[i] == 873 validatedParams.previewWidth) && 874 (availablePreviewSizes.data.i32[i+1] == 875 validatedParams.previewHeight)) break; 876 } 877 if (i == availablePreviewSizes.count) { 878 ALOGE("%s: Requested preview size %d x %d is not supported", 879 __FUNCTION__, validatedParams.previewWidth, 880 validatedParams.previewHeight); 881 return BAD_VALUE; 882 } 883 } 884 885 // PREVIEW_FPS_RANGE 886 bool fpsRangeChanged = false; 887 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0], 888 &validatedParams.previewFpsRange[1]); 889 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] || 890 validatedParams.previewFpsRange[1] != previewFpsRange[1]) { 891 fpsRangeChanged = true; 892 camera_metadata_ro_entry_t availablePreviewFpsRanges = 893 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 894 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) { 895 if ((availablePreviewFpsRanges.data.i32[i] == 896 validatedParams.previewFpsRange[0]) && 897 (availablePreviewFpsRanges.data.i32[i+1] == 898 validatedParams.previewFpsRange[1]) ) { 899 break; 900 } 901 } 902 if (i == availablePreviewFpsRanges.count) { 903 ALOGE("%s: Requested preview FPS range %d - %d is not supported", 904 __FUNCTION__, validatedParams.previewFpsRange[0], 905 validatedParams.previewFpsRange[1]); 906 return BAD_VALUE; 907 } 908 validatedParams.previewFps = validatedParams.previewFpsRange[0]; 909 } 910 911 // PREVIEW_FORMAT 912 validatedParams.previewFormat = 913 formatStringToEnum(newParams.getPreviewFormat()); 914 if (validatedParams.previewFormat != previewFormat) { 915 if (state >= PREVIEW) { 916 ALOGE("%s: Preview format cannot be updated when preview " 917 "is active!", __FUNCTION__); 918 return BAD_VALUE; 919 } 920 camera_metadata_ro_entry_t availableFormats = 921 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 922 for (i = 0; i < availableFormats.count; i++) { 923 if (availableFormats.data.i32[i] == validatedParams.previewFormat) 924 break; 925 } 926 if (i == availableFormats.count) { 927 ALOGE("%s: Requested preview format %s (0x%x) is not supported", 928 __FUNCTION__, newParams.getPreviewFormat(), 929 validatedParams.previewFormat); 930 return BAD_VALUE; 931 } 932 } 933 934 // PREVIEW_FRAME_RATE 935 // Deprecated, only use if the preview fps range is unchanged this time. 936 // The single-value FPS is the same as the minimum of the range. 937 if (!fpsRangeChanged) { 938 validatedParams.previewFps = newParams.getPreviewFrameRate(); 939 if (validatedParams.previewFps != previewFps) { 940 camera_metadata_ro_entry_t availableFrameRates = 941 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES); 942 for (i = 0; i < availableFrameRates.count; i+=2) { 943 if (availableFrameRates.data.i32[i] == 944 validatedParams.previewFps) break; 945 } 946 if (i == availableFrameRates.count) { 947 ALOGE("%s: Requested preview frame rate %d is not supported", 948 __FUNCTION__, validatedParams.previewFps); 949 return BAD_VALUE; 950 } 951 validatedParams.previewFpsRange[0] = 952 availableFrameRates.data.i32[i]; 953 validatedParams.previewFpsRange[1] = 954 availableFrameRates.data.i32[i+1]; 955 } 956 } 957 958 // PICTURE_SIZE 959 newParams.getPictureSize(&validatedParams.pictureWidth, 960 &validatedParams.pictureHeight); 961 if (validatedParams.pictureWidth == pictureWidth || 962 validatedParams.pictureHeight == pictureHeight) { 963 camera_metadata_ro_entry_t availablePictureSizes = 964 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES); 965 for (i = 0; i < availablePictureSizes.count; i+=2) { 966 if ((availablePictureSizes.data.i32[i] == 967 validatedParams.pictureWidth) && 968 (availablePictureSizes.data.i32[i+1] == 969 validatedParams.pictureHeight)) break; 970 } 971 if (i == availablePictureSizes.count) { 972 ALOGE("%s: Requested picture size %d x %d is not supported", 973 __FUNCTION__, validatedParams.pictureWidth, 974 validatedParams.pictureHeight); 975 return BAD_VALUE; 976 } 977 } 978 979 // JPEG_THUMBNAIL_WIDTH/HEIGHT 980 validatedParams.jpegThumbSize[0] = 981 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 982 validatedParams.jpegThumbSize[1] = 983 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 984 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] || 985 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) { 986 camera_metadata_ro_entry_t availableJpegThumbSizes = 987 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES); 988 for (i = 0; i < availableJpegThumbSizes.count; i+=2) { 989 if ((availableJpegThumbSizes.data.i32[i] == 990 validatedParams.jpegThumbSize[0]) && 991 (availableJpegThumbSizes.data.i32[i+1] == 992 validatedParams.jpegThumbSize[1])) break; 993 } 994 if (i == availableJpegThumbSizes.count) { 995 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported", 996 __FUNCTION__, validatedParams.jpegThumbSize[0], 997 validatedParams.jpegThumbSize[1]); 998 return BAD_VALUE; 999 } 1000 } 1001 1002 // JPEG_THUMBNAIL_QUALITY 1003 validatedParams.jpegThumbQuality = 1004 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 1005 if (validatedParams.jpegThumbQuality < 0 || 1006 validatedParams.jpegThumbQuality > 100) { 1007 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported", 1008 __FUNCTION__, validatedParams.jpegThumbQuality); 1009 return BAD_VALUE; 1010 } 1011 1012 // JPEG_QUALITY 1013 validatedParams.jpegQuality = 1014 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY); 1015 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) { 1016 ALOGE("%s: Requested JPEG quality %d is not supported", 1017 __FUNCTION__, validatedParams.jpegQuality); 1018 return BAD_VALUE; 1019 } 1020 1021 // ROTATION 1022 validatedParams.jpegRotation = 1023 newParams.getInt(CameraParameters::KEY_ROTATION); 1024 if (validatedParams.jpegRotation != 0 && 1025 validatedParams.jpegRotation != 90 && 1026 validatedParams.jpegRotation != 180 && 1027 validatedParams.jpegRotation != 270) { 1028 ALOGE("%s: Requested picture rotation angle %d is not supported", 1029 __FUNCTION__, validatedParams.jpegRotation); 1030 return BAD_VALUE; 1031 } 1032 1033 // GPS 1034 1035 const char *gpsLatStr = 1036 newParams.get(CameraParameters::KEY_GPS_LATITUDE); 1037 if (gpsLatStr != NULL) { 1038 const char *gpsLongStr = 1039 newParams.get(CameraParameters::KEY_GPS_LONGITUDE); 1040 const char *gpsAltitudeStr = 1041 newParams.get(CameraParameters::KEY_GPS_ALTITUDE); 1042 const char *gpsTimeStr = 1043 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP); 1044 const char *gpsProcMethodStr = 1045 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 1046 if (gpsLongStr == NULL || 1047 gpsAltitudeStr == NULL || 1048 gpsTimeStr == NULL || 1049 gpsProcMethodStr == NULL) { 1050 ALOGE("%s: Incomplete set of GPS parameters provided", 1051 __FUNCTION__); 1052 return BAD_VALUE; 1053 } 1054 char *endPtr; 1055 errno = 0; 1056 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr); 1057 if (errno || endPtr == gpsLatStr) { 1058 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr); 1059 return BAD_VALUE; 1060 } 1061 errno = 0; 1062 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr); 1063 if (errno || endPtr == gpsLongStr) { 1064 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr); 1065 return BAD_VALUE; 1066 } 1067 errno = 0; 1068 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr); 1069 if (errno || endPtr == gpsAltitudeStr) { 1070 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__, 1071 gpsAltitudeStr); 1072 return BAD_VALUE; 1073 } 1074 errno = 0; 1075 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10); 1076 if (errno || endPtr == gpsTimeStr) { 1077 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr); 1078 return BAD_VALUE; 1079 } 1080 validatedParams.gpsProcessingMethod = gpsProcMethodStr; 1081 1082 validatedParams.gpsEnabled = true; 1083 } else { 1084 validatedParams.gpsEnabled = false; 1085 } 1086 1087 // WHITE_BALANCE 1088 validatedParams.wbMode = wbModeStringToEnum( 1089 newParams.get(CameraParameters::KEY_WHITE_BALANCE) ); 1090 if (validatedParams.wbMode != wbMode) { 1091 camera_metadata_ro_entry_t availableWbModes = 1092 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 1093 for (i = 0; i < availableWbModes.count; i++) { 1094 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break; 1095 } 1096 if (i == availableWbModes.count) { 1097 ALOGE("%s: Requested white balance mode %s is not supported", 1098 __FUNCTION__, 1099 newParams.get(CameraParameters::KEY_WHITE_BALANCE)); 1100 return BAD_VALUE; 1101 } 1102 } 1103 1104 // EFFECT 1105 validatedParams.effectMode = effectModeStringToEnum( 1106 newParams.get(CameraParameters::KEY_EFFECT) ); 1107 if (validatedParams.effectMode != effectMode) { 1108 camera_metadata_ro_entry_t availableEffectModes = 1109 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 1110 for (i = 0; i < availableEffectModes.count; i++) { 1111 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break; 1112 } 1113 if (i == availableEffectModes.count) { 1114 ALOGE("%s: Requested effect mode \"%s\" is not supported", 1115 __FUNCTION__, 1116 newParams.get(CameraParameters::KEY_EFFECT) ); 1117 return BAD_VALUE; 1118 } 1119 } 1120 1121 // ANTIBANDING 1122 validatedParams.antibandingMode = abModeStringToEnum( 1123 newParams.get(CameraParameters::KEY_ANTIBANDING) ); 1124 if (validatedParams.antibandingMode != antibandingMode) { 1125 camera_metadata_ro_entry_t availableAbModes = 1126 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 1127 for (i = 0; i < availableAbModes.count; i++) { 1128 if (validatedParams.antibandingMode == availableAbModes.data.u8[i]) 1129 break; 1130 } 1131 if (i == availableAbModes.count) { 1132 ALOGE("%s: Requested antibanding mode \"%s\" is not supported", 1133 __FUNCTION__, 1134 newParams.get(CameraParameters::KEY_ANTIBANDING)); 1135 return BAD_VALUE; 1136 } 1137 } 1138 1139 // SCENE_MODE 1140 validatedParams.sceneMode = sceneModeStringToEnum( 1141 newParams.get(CameraParameters::KEY_SCENE_MODE) ); 1142 if (validatedParams.sceneMode != sceneMode && 1143 validatedParams.sceneMode != 1144 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) { 1145 camera_metadata_ro_entry_t availableSceneModes = 1146 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 1147 for (i = 0; i < availableSceneModes.count; i++) { 1148 if (validatedParams.sceneMode == availableSceneModes.data.u8[i]) 1149 break; 1150 } 1151 if (i == availableSceneModes.count) { 1152 ALOGE("%s: Requested scene mode \"%s\" is not supported", 1153 __FUNCTION__, 1154 newParams.get(CameraParameters::KEY_SCENE_MODE)); 1155 return BAD_VALUE; 1156 } 1157 } 1158 1159 // FLASH_MODE 1160 validatedParams.flashMode = flashModeStringToEnum( 1161 newParams.get(CameraParameters::KEY_FLASH_MODE) ); 1162 if (validatedParams.flashMode != flashMode) { 1163 camera_metadata_ro_entry_t flashAvailable = 1164 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 1165 if (!flashAvailable.data.u8[0] && 1166 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) { 1167 ALOGE("%s: Requested flash mode \"%s\" is not supported: " 1168 "No flash on device", __FUNCTION__, 1169 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1170 return BAD_VALUE; 1171 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) { 1172 camera_metadata_ro_entry_t availableAeModes = 1173 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 1174 for (i = 0; i < availableAeModes.count; i++) { 1175 if (validatedParams.flashMode == availableAeModes.data.u8[i]) 1176 break; 1177 } 1178 if (i == availableAeModes.count) { 1179 ALOGE("%s: Requested flash mode \"%s\" is not supported", 1180 __FUNCTION__, 1181 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1182 return BAD_VALUE; 1183 } 1184 } else if (validatedParams.flashMode == -1) { 1185 ALOGE("%s: Requested flash mode \"%s\" is unknown", 1186 __FUNCTION__, 1187 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1188 return BAD_VALUE; 1189 } 1190 } 1191 1192 // FOCUS_MODE 1193 validatedParams.focusMode = focusModeStringToEnum( 1194 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1195 if (validatedParams.focusMode != focusMode) { 1196 validatedParams.currentAfTriggerId = -1; 1197 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) { 1198 camera_metadata_ro_entry_t minFocusDistance = 1199 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE); 1200 if (minFocusDistance.data.f[0] == 0) { 1201 ALOGE("%s: Requested focus mode \"%s\" is not available: " 1202 "fixed focus lens", 1203 __FUNCTION__, 1204 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1205 return BAD_VALUE; 1206 } else if (validatedParams.focusMode != 1207 Parameters::FOCUS_MODE_INFINITY) { 1208 camera_metadata_ro_entry_t availableFocusModes = 1209 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1210 for (i = 0; i < availableFocusModes.count; i++) { 1211 if (validatedParams.focusMode == 1212 availableFocusModes.data.u8[i]) break; 1213 } 1214 if (i == availableFocusModes.count) { 1215 ALOGE("%s: Requested focus mode \"%s\" is not supported", 1216 __FUNCTION__, 1217 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1218 return BAD_VALUE; 1219 } 1220 } 1221 } 1222 } else { 1223 validatedParams.currentAfTriggerId = currentAfTriggerId; 1224 } 1225 1226 // FOCUS_AREAS 1227 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS), 1228 &validatedParams.focusingAreas); 1229 size_t max3aRegions = 1230 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0]; 1231 if (res == OK) res = validateAreas(validatedParams.focusingAreas, 1232 max3aRegions); 1233 if (res != OK) { 1234 ALOGE("%s: Requested focus areas are malformed: %s", 1235 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS)); 1236 return BAD_VALUE; 1237 } 1238 1239 // EXPOSURE_COMPENSATION 1240 validatedParams.exposureCompensation = 1241 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1242 camera_metadata_ro_entry_t exposureCompensationRange = 1243 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE); 1244 if ((validatedParams.exposureCompensation < 1245 exposureCompensationRange.data.i32[0]) || 1246 (validatedParams.exposureCompensation > 1247 exposureCompensationRange.data.i32[1])) { 1248 ALOGE("%s: Requested exposure compensation index is out of bounds: %d", 1249 __FUNCTION__, validatedParams.exposureCompensation); 1250 return BAD_VALUE; 1251 } 1252 1253 // AUTO_EXPOSURE_LOCK (always supported) 1254 validatedParams.autoExposureLock = boolFromString( 1255 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 1256 1257 // AUTO_WHITEBALANCE_LOCK (always supported) 1258 validatedParams.autoWhiteBalanceLock = boolFromString( 1259 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 1260 1261 // METERING_AREAS 1262 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS), 1263 &validatedParams.meteringAreas); 1264 if (res == OK) { 1265 res = validateAreas(validatedParams.meteringAreas, max3aRegions); 1266 } 1267 if (res != OK) { 1268 ALOGE("%s: Requested metering areas are malformed: %s", 1269 __FUNCTION__, 1270 newParams.get(CameraParameters::KEY_METERING_AREAS)); 1271 return BAD_VALUE; 1272 } 1273 1274 // ZOOM 1275 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM); 1276 if (validatedParams.zoom < 0 || validatedParams.zoom > (int)NUM_ZOOM_STEPS) { 1277 ALOGE("%s: Requested zoom level %d is not supported", 1278 __FUNCTION__, validatedParams.zoom); 1279 return BAD_VALUE; 1280 } 1281 1282 // VIDEO_SIZE 1283 newParams.getVideoSize(&validatedParams.videoWidth, 1284 &validatedParams.videoHeight); 1285 if (validatedParams.videoWidth != videoWidth || 1286 validatedParams.videoHeight != videoHeight) { 1287 if (state == RECORD) { 1288 ALOGE("%s: Video size cannot be updated when recording is active!", 1289 __FUNCTION__); 1290 return BAD_VALUE; 1291 } 1292 camera_metadata_ro_entry_t availableVideoSizes = 1293 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 1294 for (i = 0; i < availableVideoSizes.count; i += 2 ) { 1295 if ((availableVideoSizes.data.i32[i] == 1296 validatedParams.videoWidth) && 1297 (availableVideoSizes.data.i32[i+1] == 1298 validatedParams.videoHeight)) break; 1299 } 1300 if (i == availableVideoSizes.count) { 1301 ALOGE("%s: Requested video size %d x %d is not supported", 1302 __FUNCTION__, validatedParams.videoWidth, 1303 validatedParams.videoHeight); 1304 return BAD_VALUE; 1305 } 1306 } 1307 1308 // RECORDING_HINT (always supported) 1309 validatedParams.recordingHint = boolFromString( 1310 newParams.get(CameraParameters::KEY_RECORDING_HINT) ); 1311 1312 // VIDEO_STABILIZATION 1313 validatedParams.videoStabilization = boolFromString( 1314 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) ); 1315 camera_metadata_ro_entry_t availableVideoStabilizationModes = 1316 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 1317 if (validatedParams.videoStabilization && 1318 availableVideoStabilizationModes.count == 1) { 1319 ALOGE("%s: Video stabilization not supported", __FUNCTION__); 1320 } 1321 1322 // LIGHTFX 1323 validatedParams.lightFx = lightFxStringToEnum( 1324 newParams.get(CameraParameters::KEY_LIGHTFX)); 1325 1326 /** Update internal parameters */ 1327 1328 validatedParams.paramsFlattened = params; 1329 *this = validatedParams; 1330 1331 return OK; 1332} 1333 1334status_t Parameters::updateRequest(CameraMetadata *request) const { 1335 ATRACE_CALL(); 1336 status_t res; 1337 1338 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL; 1339 res = request->update(ANDROID_REQUEST_METADATA_MODE, 1340 &metadataMode, 1); 1341 if (res != OK) return res; 1342 1343 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 1344 previewFpsRange, 2); 1345 if (res != OK) return res; 1346 1347 res = request->update(ANDROID_CONTROL_AWB_MODE, 1348 &wbMode, 1); 1349 if (res != OK) return res; 1350 1351 uint8_t reqWbLock = autoWhiteBalanceLock ? 1352 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF; 1353 res = request->update(ANDROID_CONTROL_AWB_LOCK, 1354 &reqWbLock, 1); 1355 1356 res = request->update(ANDROID_CONTROL_EFFECT_MODE, 1357 &effectMode, 1); 1358 if (res != OK) return res; 1359 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, 1360 &antibandingMode, 1); 1361 if (res != OK) return res; 1362 1363 uint8_t reqControlMode = 1364 (sceneMode == ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) ? 1365 ANDROID_CONTROL_AUTO : ANDROID_CONTROL_USE_SCENE_MODE; 1366 res = request->update(ANDROID_CONTROL_MODE, 1367 &reqControlMode, 1); 1368 if (res != OK) return res; 1369 if (reqControlMode == ANDROID_CONTROL_USE_SCENE_MODE) { 1370 res = request->update(ANDROID_CONTROL_SCENE_MODE, 1371 &sceneMode, 1); 1372 if (res != OK) return res; 1373 } 1374 1375 uint8_t reqFlashMode = ANDROID_FLASH_OFF; 1376 uint8_t reqAeMode; 1377 switch (flashMode) { 1378 case Parameters::FLASH_MODE_OFF: 1379 reqAeMode = ANDROID_CONTROL_AE_ON; break; 1380 case Parameters::FLASH_MODE_AUTO: 1381 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break; 1382 case Parameters::FLASH_MODE_ON: 1383 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break; 1384 case Parameters::FLASH_MODE_TORCH: 1385 reqAeMode = ANDROID_CONTROL_AE_ON; 1386 reqFlashMode = ANDROID_FLASH_TORCH; 1387 break; 1388 case Parameters::FLASH_MODE_RED_EYE: 1389 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break; 1390 default: 1391 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__, 1392 cameraId, flashMode); 1393 return BAD_VALUE; 1394 } 1395 res = request->update(ANDROID_FLASH_MODE, 1396 &reqFlashMode, 1); 1397 if (res != OK) return res; 1398 res = request->update(ANDROID_CONTROL_AE_MODE, 1399 &reqAeMode, 1); 1400 if (res != OK) return res; 1401 1402 uint8_t reqAeLock = autoExposureLock ? 1403 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF; 1404 res = request->update(ANDROID_CONTROL_AE_LOCK, 1405 &reqAeLock, 1); 1406 1407 float reqFocusDistance = 0; // infinity focus in diopters 1408 uint8_t reqFocusMode; 1409 switch (focusMode) { 1410 case Parameters::FOCUS_MODE_AUTO: 1411 case Parameters::FOCUS_MODE_MACRO: 1412 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1413 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1414 case Parameters::FOCUS_MODE_EDOF: 1415 reqFocusMode = focusMode; 1416 break; 1417 case Parameters::FOCUS_MODE_INFINITY: 1418 case Parameters::FOCUS_MODE_FIXED: 1419 reqFocusMode = ANDROID_CONTROL_AF_OFF; 1420 break; 1421 default: 1422 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__, 1423 cameraId, focusMode); 1424 return BAD_VALUE; 1425 } 1426 res = request->update(ANDROID_LENS_FOCUS_DISTANCE, 1427 &reqFocusDistance, 1); 1428 if (res != OK) return res; 1429 res = request->update(ANDROID_CONTROL_AF_MODE, 1430 &reqFocusMode, 1); 1431 if (res != OK) return res; 1432 1433 size_t reqFocusingAreasSize = focusingAreas.size() * 5; 1434 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize]; 1435 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) { 1436 if (focusingAreas[i].weight != 0) { 1437 reqFocusingAreas[i + 0] = 1438 normalizedXToArray(focusingAreas[i].left); 1439 reqFocusingAreas[i + 1] = 1440 normalizedYToArray(focusingAreas[i].top); 1441 reqFocusingAreas[i + 2] = 1442 normalizedXToArray(focusingAreas[i].right); 1443 reqFocusingAreas[i + 3] = 1444 normalizedYToArray(focusingAreas[i].bottom); 1445 } else { 1446 reqFocusingAreas[i + 0] = 0; 1447 reqFocusingAreas[i + 1] = 0; 1448 reqFocusingAreas[i + 2] = 0; 1449 reqFocusingAreas[i + 3] = 0; 1450 } 1451 reqFocusingAreas[i + 4] = focusingAreas[i].weight; 1452 } 1453 res = request->update(ANDROID_CONTROL_AF_REGIONS, 1454 reqFocusingAreas, reqFocusingAreasSize); 1455 if (res != OK) return res; 1456 delete[] reqFocusingAreas; 1457 1458 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION, 1459 &exposureCompensation, 1); 1460 if (res != OK) return res; 1461 1462 size_t reqMeteringAreasSize = meteringAreas.size() * 5; 1463 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize]; 1464 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) { 1465 if (meteringAreas[i].weight != 0) { 1466 reqMeteringAreas[i + 0] = 1467 normalizedXToArray(meteringAreas[i].left); 1468 reqMeteringAreas[i + 1] = 1469 normalizedYToArray(meteringAreas[i].top); 1470 reqMeteringAreas[i + 2] = 1471 normalizedXToArray(meteringAreas[i].right); 1472 reqMeteringAreas[i + 3] = 1473 normalizedYToArray(meteringAreas[i].bottom); 1474 } else { 1475 reqMeteringAreas[i + 0] = 0; 1476 reqMeteringAreas[i + 1] = 0; 1477 reqMeteringAreas[i + 2] = 0; 1478 reqMeteringAreas[i + 3] = 0; 1479 } 1480 reqMeteringAreas[i + 4] = meteringAreas[i].weight; 1481 } 1482 res = request->update(ANDROID_CONTROL_AE_REGIONS, 1483 reqMeteringAreas, reqMeteringAreasSize); 1484 if (res != OK) return res; 1485 1486 res = request->update(ANDROID_CONTROL_AWB_REGIONS, 1487 reqMeteringAreas, reqMeteringAreasSize); 1488 if (res != OK) return res; 1489 delete[] reqMeteringAreas; 1490 1491 // Need to convert zoom index into a crop rectangle. The rectangle is 1492 // chosen to maximize its area on the sensor 1493 1494 camera_metadata_ro_entry_t maxDigitalZoom = 1495 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM); 1496 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) / 1497 (NUM_ZOOM_STEPS-1); 1498 float zoomRatio = 1 + zoomIncrement * zoom; 1499 1500 float zoomLeft, zoomTop, zoomWidth, zoomHeight; 1501 if (previewWidth >= previewHeight) { 1502 zoomWidth = fastInfo.arrayWidth / zoomRatio; 1503 zoomHeight = zoomWidth * 1504 previewHeight / previewWidth; 1505 } else { 1506 zoomHeight = fastInfo.arrayHeight / zoomRatio; 1507 zoomWidth = zoomHeight * 1508 previewWidth / previewHeight; 1509 } 1510 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2; 1511 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2; 1512 1513 int32_t reqCropRegion[3] = { zoomLeft, zoomTop, zoomWidth }; 1514 res = request->update(ANDROID_SCALER_CROP_REGION, 1515 reqCropRegion, 3); 1516 if (res != OK) return res; 1517 1518 // TODO: Decide how to map recordingHint, or whether just to ignore it 1519 1520 uint8_t reqVstabMode = videoStabilization ? 1521 ANDROID_CONTROL_VIDEO_STABILIZATION_ON : 1522 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF; 1523 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 1524 &reqVstabMode, 1); 1525 if (res != OK) return res; 1526 1527 uint8_t reqFaceDetectMode = enableFaceDetect ? 1528 fastInfo.bestFaceDetectMode : 1529 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF; 1530 res = request->update(ANDROID_STATS_FACE_DETECT_MODE, 1531 &reqFaceDetectMode, 1); 1532 if (res != OK) return res; 1533 1534 return OK; 1535} 1536 1537const char* Parameters::getStateName(State state) { 1538#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break; 1539 switch(state) { 1540 CASE_ENUM_TO_CHAR(DISCONNECTED) 1541 CASE_ENUM_TO_CHAR(STOPPED) 1542 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW) 1543 CASE_ENUM_TO_CHAR(PREVIEW) 1544 CASE_ENUM_TO_CHAR(RECORD) 1545 CASE_ENUM_TO_CHAR(STILL_CAPTURE) 1546 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT) 1547 default: 1548 return "Unknown state!"; 1549 break; 1550 } 1551#undef CASE_ENUM_TO_CHAR 1552} 1553 1554int Parameters::formatStringToEnum(const char *format) { 1555 return 1556 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ? 1557 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16 1558 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ? 1559 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21 1560 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ? 1561 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2 1562 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ? 1563 HAL_PIXEL_FORMAT_YV12 : // YV12 1564 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ? 1565 HAL_PIXEL_FORMAT_RGB_565 : // RGB565 1566 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ? 1567 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888 1568 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ? 1569 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data 1570 -1; 1571} 1572 1573const char* Parameters::formatEnumToString(int format) { 1574 const char *fmt; 1575 switch(format) { 1576 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1577 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 1578 break; 1579 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1580 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 1581 break; 1582 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1583 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 1584 break; 1585 case HAL_PIXEL_FORMAT_YV12: // YV12 1586 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 1587 break; 1588 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 1589 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 1590 break; 1591 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 1592 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 1593 break; 1594 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1595 ALOGW("Raw sensor preview format requested."); 1596 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 1597 break; 1598 default: 1599 ALOGE("%s: Unknown preview format: %x", 1600 __FUNCTION__, format); 1601 fmt = NULL; 1602 break; 1603 } 1604 return fmt; 1605} 1606 1607int Parameters::wbModeStringToEnum(const char *wbMode) { 1608 return 1609 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ? 1610 ANDROID_CONTROL_AWB_AUTO : 1611 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ? 1612 ANDROID_CONTROL_AWB_INCANDESCENT : 1613 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ? 1614 ANDROID_CONTROL_AWB_FLUORESCENT : 1615 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ? 1616 ANDROID_CONTROL_AWB_WARM_FLUORESCENT : 1617 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ? 1618 ANDROID_CONTROL_AWB_DAYLIGHT : 1619 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ? 1620 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT : 1621 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ? 1622 ANDROID_CONTROL_AWB_TWILIGHT : 1623 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ? 1624 ANDROID_CONTROL_AWB_SHADE : 1625 -1; 1626} 1627 1628int Parameters::effectModeStringToEnum(const char *effectMode) { 1629 return 1630 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ? 1631 ANDROID_CONTROL_EFFECT_OFF : 1632 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ? 1633 ANDROID_CONTROL_EFFECT_MONO : 1634 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ? 1635 ANDROID_CONTROL_EFFECT_NEGATIVE : 1636 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ? 1637 ANDROID_CONTROL_EFFECT_SOLARIZE : 1638 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ? 1639 ANDROID_CONTROL_EFFECT_SEPIA : 1640 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ? 1641 ANDROID_CONTROL_EFFECT_POSTERIZE : 1642 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ? 1643 ANDROID_CONTROL_EFFECT_WHITEBOARD : 1644 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ? 1645 ANDROID_CONTROL_EFFECT_BLACKBOARD : 1646 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ? 1647 ANDROID_CONTROL_EFFECT_AQUA : 1648 -1; 1649} 1650 1651int Parameters::abModeStringToEnum(const char *abMode) { 1652 return 1653 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ? 1654 ANDROID_CONTROL_AE_ANTIBANDING_AUTO : 1655 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ? 1656 ANDROID_CONTROL_AE_ANTIBANDING_OFF : 1657 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ? 1658 ANDROID_CONTROL_AE_ANTIBANDING_50HZ : 1659 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ? 1660 ANDROID_CONTROL_AE_ANTIBANDING_60HZ : 1661 -1; 1662} 1663 1664int Parameters::sceneModeStringToEnum(const char *sceneMode) { 1665 return 1666 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ? 1667 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED : 1668 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ? 1669 ANDROID_CONTROL_SCENE_MODE_ACTION : 1670 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ? 1671 ANDROID_CONTROL_SCENE_MODE_PORTRAIT : 1672 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ? 1673 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE : 1674 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ? 1675 ANDROID_CONTROL_SCENE_MODE_NIGHT : 1676 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ? 1677 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT : 1678 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ? 1679 ANDROID_CONTROL_SCENE_MODE_THEATRE : 1680 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ? 1681 ANDROID_CONTROL_SCENE_MODE_BEACH : 1682 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ? 1683 ANDROID_CONTROL_SCENE_MODE_SNOW : 1684 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ? 1685 ANDROID_CONTROL_SCENE_MODE_SUNSET : 1686 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ? 1687 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO : 1688 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ? 1689 ANDROID_CONTROL_SCENE_MODE_FIREWORKS : 1690 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ? 1691 ANDROID_CONTROL_SCENE_MODE_SPORTS : 1692 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ? 1693 ANDROID_CONTROL_SCENE_MODE_PARTY : 1694 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ? 1695 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT : 1696 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ? 1697 ANDROID_CONTROL_SCENE_MODE_BARCODE: 1698 -1; 1699} 1700 1701Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum( 1702 const char *flashMode) { 1703 return 1704 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ? 1705 Parameters::FLASH_MODE_OFF : 1706 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ? 1707 Parameters::FLASH_MODE_AUTO : 1708 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ? 1709 Parameters::FLASH_MODE_ON : 1710 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ? 1711 Parameters::FLASH_MODE_RED_EYE : 1712 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ? 1713 Parameters::FLASH_MODE_TORCH : 1714 Parameters::FLASH_MODE_INVALID; 1715} 1716 1717Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum( 1718 const char *focusMode) { 1719 return 1720 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ? 1721 Parameters::FOCUS_MODE_AUTO : 1722 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ? 1723 Parameters::FOCUS_MODE_INFINITY : 1724 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ? 1725 Parameters::FOCUS_MODE_MACRO : 1726 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ? 1727 Parameters::FOCUS_MODE_FIXED : 1728 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ? 1729 Parameters::FOCUS_MODE_EDOF : 1730 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ? 1731 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO : 1732 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ? 1733 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE : 1734 Parameters::FOCUS_MODE_INVALID; 1735} 1736 1737Parameters::Parameters::lightFxMode_t Parameters::lightFxStringToEnum( 1738 const char *lightFxMode) { 1739 return 1740 !strcmp(lightFxMode, CameraParameters::LIGHTFX_LOWLIGHT) ? 1741 Parameters::LIGHTFX_LOWLIGHT : 1742 !strcmp(lightFxMode, CameraParameters::LIGHTFX_HDR) ? 1743 Parameters::LIGHTFX_HDR : 1744 Parameters::LIGHTFX_NONE; 1745} 1746 1747status_t Parameters::parseAreas(const char *areasCStr, 1748 Vector<Parameters::Area> *areas) { 1749 static const size_t NUM_FIELDS = 5; 1750 areas->clear(); 1751 if (areasCStr == NULL) { 1752 // If no key exists, use default (0,0,0,0,0) 1753 areas->push(); 1754 return OK; 1755 } 1756 String8 areasStr(areasCStr); 1757 ssize_t areaStart = areasStr.find("(", 0) + 1; 1758 while (areaStart != 0) { 1759 const char* area = areasStr.string() + areaStart; 1760 char *numEnd; 1761 int vals[NUM_FIELDS]; 1762 for (size_t i = 0; i < NUM_FIELDS; i++) { 1763 errno = 0; 1764 vals[i] = strtol(area, &numEnd, 10); 1765 if (errno || numEnd == area) return BAD_VALUE; 1766 area = numEnd + 1; 1767 } 1768 areas->push(Parameters::Area( 1769 vals[0], vals[1], vals[2], vals[3], vals[4]) ); 1770 areaStart = areasStr.find("(", areaStart) + 1; 1771 } 1772 return OK; 1773} 1774 1775status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas, 1776 size_t maxRegions) { 1777 // Definition of valid area can be found in 1778 // include/camera/CameraParameters.h 1779 if (areas.size() == 0) return BAD_VALUE; 1780 if (areas.size() == 1) { 1781 if (areas[0].left == 0 && 1782 areas[0].top == 0 && 1783 areas[0].right == 0 && 1784 areas[0].bottom == 0 && 1785 areas[0].weight == 0) { 1786 // Single (0,0,0,0,0) entry is always valid (== driver decides) 1787 return OK; 1788 } 1789 } 1790 if (areas.size() > maxRegions) { 1791 ALOGE("%s: Too many areas requested: %d", 1792 __FUNCTION__, areas.size()); 1793 return BAD_VALUE; 1794 } 1795 1796 for (Vector<Parameters::Area>::const_iterator a = areas.begin(); 1797 a != areas.end(); a++) { 1798 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE; 1799 if (a->left < -1000 || a->left > 1000) return BAD_VALUE; 1800 if (a->top < -1000 || a->top > 1000) return BAD_VALUE; 1801 if (a->right < -1000 || a->right > 1000) return BAD_VALUE; 1802 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE; 1803 if (a->left >= a->right) return BAD_VALUE; 1804 if (a->top >= a->bottom) return BAD_VALUE; 1805 } 1806 return OK; 1807} 1808 1809bool Parameters::boolFromString(const char *boolStr) { 1810 return !boolStr ? false : 1811 !strcmp(boolStr, CameraParameters::TRUE) ? true : 1812 false; 1813} 1814 1815int Parameters::degToTransform(int degrees, bool mirror) { 1816 if (!mirror) { 1817 if (degrees == 0) return 0; 1818 else if (degrees == 90) return HAL_TRANSFORM_ROT_90; 1819 else if (degrees == 180) return HAL_TRANSFORM_ROT_180; 1820 else if (degrees == 270) return HAL_TRANSFORM_ROT_270; 1821 } else { // Do mirror (horizontal flip) 1822 if (degrees == 0) { // FLIP_H and ROT_0 1823 return HAL_TRANSFORM_FLIP_H; 1824 } else if (degrees == 90) { // FLIP_H and ROT_90 1825 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90; 1826 } else if (degrees == 180) { // FLIP_H and ROT_180 1827 return HAL_TRANSFORM_FLIP_V; 1828 } else if (degrees == 270) { // FLIP_H and ROT_270 1829 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90; 1830 } 1831 } 1832 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees); 1833 return -1; 1834} 1835 1836int Parameters::arrayXToNormalized(int width) const { 1837 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000; 1838} 1839 1840int Parameters::arrayYToNormalized(int height) const { 1841 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000; 1842} 1843 1844int Parameters::normalizedXToArray(int x) const { 1845 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000; 1846} 1847 1848int Parameters::normalizedYToArray(int y) const { 1849 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000; 1850} 1851 1852}; // namespace camera2 1853}; // namespace android 1854