Camera2Client.cpp revision 7f61084a428a5c7afbeff2fa9e9839baf9018020
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 "Camera2Client" 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 <cutils/properties.h> 25#include <gui/SurfaceTextureClient.h> 26#include <gui/Surface.h> 27 28#include <math.h> 29 30#include "Camera2Client.h" 31 32namespace android { 33 34#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 35#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 36 37static int getCallingPid() { 38 return IPCThreadState::self()->getCallingPid(); 39} 40 41static int getCallingUid() { 42 return IPCThreadState::self()->getCallingUid(); 43} 44 45// Interface used by CameraService 46 47Camera2Client::Camera2Client(const sp<CameraService>& cameraService, 48 const sp<ICameraClient>& cameraClient, 49 int cameraId, 50 int cameraFacing, 51 int clientPid): 52 Client(cameraService, cameraClient, 53 cameraId, cameraFacing, clientPid), 54 mState(NOT_INITIALIZED), 55 mPreviewStreamId(NO_PREVIEW_STREAM), 56 mPreviewRequest(NULL) 57{ 58 ATRACE_CALL(); 59 60 mDevice = new Camera2Device(cameraId); 61} 62 63status_t Camera2Client::initialize(camera_module_t *module) 64{ 65 ATRACE_CALL(); 66 status_t res; 67 68 res = mDevice->initialize(module); 69 if (res != OK) { 70 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)", 71 __FUNCTION__, mCameraId, strerror(-res), res); 72 return NO_INIT; 73 } 74 75 res = buildDefaultParameters(); 76 if (res != OK) { 77 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)", 78 __FUNCTION__, mCameraId, strerror(-res), res); 79 return NO_INIT; 80 } 81 82 if (gLogLevel >= 1) { 83 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__, 84 mCameraId); 85 ALOGD("%s", mParamsFlattened.string()); 86 } 87 88 mState = STOPPED; 89 90 return OK; 91} 92 93Camera2Client::~Camera2Client() { 94 ATRACE_CALL(); 95 mDestructionStarted = true; 96 97 disconnect(); 98 99} 100 101status_t Camera2Client::dump(int fd, const Vector<String16>& args) { 102 String8 result; 103 result.appendFormat("Client2[%d] (%p) PID: %d:\n", 104 mCameraId, 105 getCameraClient()->asBinder().get(), 106 mClientPid); 107 result.append(" State: "); 108#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break; 109 110 switch (mState) { 111 CASE_APPEND_ENUM(NOT_INITIALIZED) 112 CASE_APPEND_ENUM(STOPPED) 113 CASE_APPEND_ENUM(WAITING_FOR_PREVIEW_WINDOW) 114 CASE_APPEND_ENUM(PREVIEW) 115 CASE_APPEND_ENUM(RECORD) 116 CASE_APPEND_ENUM(STILL_CAPTURE) 117 default: result.append("UNKNOWN\n"); break; 118 } 119 120 result.append(" Current parameters:\n"); 121 result.appendFormat(" Preview size: %d x %d\n", 122 mParameters.previewWidth, mParameters.previewHeight); 123 result.appendFormat(" Preview FPS range: %d - %d\n", 124 mParameters.previewFpsRangeMin, mParameters.previewFpsRangeMax); 125 result.appendFormat(" Preview HAL pixel format: 0x%x\n", 126 mParameters.previewFormat); 127 result.appendFormat(" Picture size: %d x %d\n", 128 mParameters.pictureWidth, mParameters.pictureHeight); 129 result.appendFormat(" Jpeg thumbnail size: %d x %d\n", 130 mParameters.jpegThumbWidth, mParameters.jpegThumbHeight); 131 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n", 132 mParameters.jpegQuality, mParameters.jpegThumbQuality); 133 result.appendFormat(" Jpeg rotation: %d\n", mParameters.jpegRotation); 134 result.appendFormat(" GPS tags %s\n", 135 mParameters.gpsEnabled ? "enabled" : "disabled"); 136 if (mParameters.gpsEnabled) { 137 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n", 138 mParameters.gpsLatitude, mParameters.gpsLongitude, 139 mParameters.gpsAltitude); 140 result.appendFormat(" GPS timestamp: %lld\n", 141 mParameters.gpsTimestamp); 142 result.appendFormat(" GPS processing method: %s\n", 143 mParameters.gpsProcessingMethod.string()); 144 } 145 146 result.append(" White balance mode: "); 147 switch (mParameters.wbMode) { 148 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO) 149 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT) 150 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT) 151 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT) 152 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT) 153 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT) 154 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT) 155 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE) 156 default: result.append("UNKNOWN\n"); 157 } 158 159 result.append(" Effect mode: "); 160 switch (mParameters.effectMode) { 161 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF) 162 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO) 163 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE) 164 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE) 165 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA) 166 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE) 167 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD) 168 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD) 169 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA) 170 default: result.append("UNKNOWN\n"); 171 } 172 173 result.append(" Antibanding mode: "); 174 switch (mParameters.antibandingMode) { 175 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO) 176 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF) 177 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ) 178 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ) 179 default: result.append("UNKNOWN\n"); 180 } 181 182 result.append(" Scene mode: "); 183 switch (mParameters.sceneMode) { 184 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 185 result.append("AUTO\n"); break; 186 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION) 187 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT) 188 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE) 189 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT) 190 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT) 191 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE) 192 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH) 193 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW) 194 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET) 195 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO) 196 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS) 197 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS) 198 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY) 199 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT) 200 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE) 201 default: result.append("UNKNOWN\n"); 202 } 203 204 result.append(" Flash mode: "); 205 switch (mParameters.flashMode) { 206 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF) 207 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO) 208 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON) 209 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH) 210 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE) 211 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID) 212 default: result.append("UNKNOWN\n"); 213 } 214 215 result.append(" Focus mode: "); 216 switch (mParameters.focusMode) { 217 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO) 218 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO) 219 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) 220 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE) 221 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF) 222 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY) 223 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED) 224 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID) 225 default: result.append("UNKNOWN\n"); 226 } 227 228 result.append(" Focusing areas:\n"); 229 for (size_t i = 0; i < mParameters.focusingAreas.size(); i++) { 230 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 231 mParameters.focusingAreas[i].left, 232 mParameters.focusingAreas[i].top, 233 mParameters.focusingAreas[i].right, 234 mParameters.focusingAreas[i].bottom, 235 mParameters.focusingAreas[i].weight); 236 } 237 238 result.appendFormat(" Exposure compensation index: %d\n", 239 mParameters.exposureCompensation); 240 241 result.appendFormat(" AE lock %s, AWB lock %s\n", 242 mParameters.autoExposureLock ? "enabled" : "disabled", 243 mParameters.autoWhiteBalanceLock ? "enabled" : "disabled" ); 244 245 result.appendFormat(" Metering areas:\n"); 246 for (size_t i = 0; i < mParameters.meteringAreas.size(); i++) { 247 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 248 mParameters.meteringAreas[i].left, 249 mParameters.meteringAreas[i].top, 250 mParameters.meteringAreas[i].right, 251 mParameters.meteringAreas[i].bottom, 252 mParameters.meteringAreas[i].weight); 253 } 254 255 result.appendFormat(" Zoom index: %d\n", mParameters.zoom); 256 result.appendFormat(" Video size: %d x %d\n", mParameters.videoWidth, 257 mParameters.videoHeight); 258 259 result.appendFormat(" Recording hint is %s\n", 260 mParameters.recordingHint ? "set" : "not set"); 261 262 result.appendFormat(" Video stabilization is %s\n", 263 mParameters.videoStabilization ? "enabled" : "disabled"); 264 265 write(fd, result.string(), result.size()); 266 267 // TODO: Dump Camera2Device 268 269#undef CASE_APPEND_ENUM 270 return NO_ERROR; 271} 272 273// ICamera interface 274 275void Camera2Client::disconnect() { 276 ATRACE_CALL(); 277 if (mDevice == 0) return; 278 279 stopPreview(); 280 281 if (mPreviewStreamId != NO_PREVIEW_STREAM) { 282 mDevice->deleteStream(mPreviewStreamId); 283 mPreviewStreamId = NO_PREVIEW_STREAM; 284 } 285 286 CameraService::Client::disconnect(); 287} 288 289status_t Camera2Client::connect(const sp<ICameraClient>& client) { 290 ATRACE_CALL(); 291 return BAD_VALUE; 292} 293 294status_t Camera2Client::lock() { 295 ATRACE_CALL(); 296 return BAD_VALUE; 297} 298 299status_t Camera2Client::unlock() { 300 ATRACE_CALL(); 301 return BAD_VALUE; 302} 303 304status_t Camera2Client::setPreviewDisplay( 305 const sp<Surface>& surface) { 306 ATRACE_CALL(); 307 if (mState == PREVIEW) return INVALID_OPERATION; 308 309 sp<IBinder> binder; 310 sp<ANativeWindow> window; 311 if (surface != 0) { 312 binder = surface->asBinder(); 313 window = surface; 314 } 315 316 return setPreviewWindow(binder,window); 317} 318 319status_t Camera2Client::setPreviewTexture( 320 const sp<ISurfaceTexture>& surfaceTexture) { 321 ATRACE_CALL(); 322 if (mState == PREVIEW) return INVALID_OPERATION; 323 324 sp<IBinder> binder; 325 sp<ANativeWindow> window; 326 if (surfaceTexture != 0) { 327 binder = surfaceTexture->asBinder(); 328 window = new SurfaceTextureClient(surfaceTexture); 329 } 330 return setPreviewWindow(binder, window); 331} 332 333status_t Camera2Client::setPreviewWindow(const sp<IBinder>& binder, 334 const sp<ANativeWindow>& window) { 335 ATRACE_CALL(); 336 status_t res; 337 338 if (binder == mPreviewSurface) { 339 return NO_ERROR; 340 } 341 342 if (mPreviewStreamId != NO_PREVIEW_STREAM) { 343 res = mDevice->deleteStream(mPreviewStreamId); 344 if (res != OK) { 345 return res; 346 } 347 } 348 res = mDevice->createStream(window, 349 mParameters.previewWidth, mParameters.previewHeight, 350 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 351 &mPreviewStreamId); 352 if (res != OK) { 353 return res; 354 } 355 356 if (mState == WAITING_FOR_PREVIEW_WINDOW) { 357 return startPreview(); 358 } 359 360 return OK; 361} 362 363void Camera2Client::setPreviewCallbackFlag(int flag) { 364 ATRACE_CALL(); 365} 366 367status_t Camera2Client::startPreview() { 368 ATRACE_CALL(); 369 status_t res; 370 if (mState == PREVIEW) return INVALID_OPERATION; 371 372 if (mPreviewStreamId == NO_PREVIEW_STREAM) { 373 mState = WAITING_FOR_PREVIEW_WINDOW; 374 return OK; 375 } 376 377 if (mPreviewRequest == NULL) { 378 updatePreviewRequest(); 379 } 380 381 uint8_t outputStream = mPreviewStreamId; 382 383 camera_metadata_entry_t outputStreams; 384 res = find_camera_metadata_entry(mPreviewRequest, 385 ANDROID_REQUEST_OUTPUT_STREAMS, 386 &outputStreams); 387 if (res == NAME_NOT_FOUND) { 388 res = add_camera_metadata_entry(mPreviewRequest, 389 ANDROID_REQUEST_OUTPUT_STREAMS, 390 &outputStream, 1); 391 } else if (res == OK) { 392 res = update_camera_metadata_entry(mPreviewRequest, 393 outputStreams.index, &outputStream, 1, NULL); 394 } 395 396 if (res != OK) { 397 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)", 398 __FUNCTION__, mCameraId, strerror(-res), res); 399 mState = STOPPED; 400 return res; 401 } 402 403 res = mDevice->setStreamingRequest(mPreviewRequest); 404 if (res != OK) { 405 ALOGE("%s: Camera %d: Unable to set preview request to start preview: %s (%d)", 406 __FUNCTION__, mCameraId, strerror(-res), res); 407 mState = STOPPED; 408 return res; 409 } 410 mState = PREVIEW; 411 412 return OK; 413} 414 415void Camera2Client::stopPreview() { 416 ATRACE_CALL(); 417 if (mState != PREVIEW) return; 418 419 mDevice->setStreamingRequest(NULL); 420 mState = STOPPED; 421} 422 423bool Camera2Client::previewEnabled() { 424 ATRACE_CALL(); 425 return mState == PREVIEW; 426} 427 428status_t Camera2Client::storeMetaDataInBuffers(bool enabled) { 429 ATRACE_CALL(); 430 return BAD_VALUE; 431} 432 433status_t Camera2Client::startRecording() { 434 ATRACE_CALL(); 435 return BAD_VALUE; 436} 437 438void Camera2Client::stopRecording() { 439 ATRACE_CALL(); 440} 441 442bool Camera2Client::recordingEnabled() { 443 ATRACE_CALL(); 444 return BAD_VALUE; 445} 446 447void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) { 448 ATRACE_CALL(); 449} 450 451status_t Camera2Client::autoFocus() { 452 ATRACE_CALL(); 453 return OK; 454} 455 456status_t Camera2Client::cancelAutoFocus() { 457 ATRACE_CALL(); 458 return OK; 459} 460 461status_t Camera2Client::takePicture(int msgType) { 462 ATRACE_CALL(); 463 return BAD_VALUE; 464} 465 466status_t Camera2Client::setParameters(const String8& params) { 467 ATRACE_CALL(); 468 return OK; 469} 470 471String8 Camera2Client::getParameters() const { 472 ATRACE_CALL(); 473 // TODO: Deal with focus distances 474 return mParamsFlattened; 475} 476 477status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { 478 ATRACE_CALL(); 479 return OK; 480} 481 482/** Device-related methods */ 483 484camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag, 485 size_t minCount, size_t maxCount) { 486 status_t res; 487 camera_metadata_entry_t entry; 488 res = find_camera_metadata_entry(mDevice->info(), 489 tag, 490 &entry); 491 if (CC_UNLIKELY( res != OK )) { 492 const char* tagSection = get_camera_metadata_section_name(tag); 493 if (tagSection == NULL) tagSection = "<unknown>"; 494 const char* tagName = get_camera_metadata_tag_name(tag); 495 if (tagName == NULL) tagName = "<unknown>"; 496 497 ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)", 498 tagSection, tagName, tag, strerror(-res), res); 499 entry.count = 0; 500 entry.data.u8 = NULL; 501 } else if (CC_UNLIKELY( 502 (minCount != 0 && entry.count < minCount) || 503 (maxCount != 0 && entry.count > maxCount) ) ) { 504 const char* tagSection = get_camera_metadata_section_name(tag); 505 if (tagSection == NULL) tagSection = "<unknown>"; 506 const char* tagName = get_camera_metadata_tag_name(tag); 507 if (tagName == NULL) tagName = "<unknown>"; 508 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 509 "Expected between %d and %d values, but got %d values", 510 tagSection, tagName, tag, minCount, maxCount, entry.count); 511 entry.count = 0; 512 entry.data.u8 = NULL; 513 } 514 515 return entry; 516} 517 518/** Utility methods */ 519 520 521status_t Camera2Client::buildDefaultParameters() { 522 ATRACE_CALL(); 523 status_t res; 524 CameraParameters params; 525 526 camera_metadata_entry_t availableProcessedSizes = 527 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2); 528 if (!availableProcessedSizes.count) return NO_INIT; 529 530 // TODO: Pick more intelligently 531 mParameters.previewWidth = availableProcessedSizes.data.i32[0]; 532 mParameters.previewHeight = availableProcessedSizes.data.i32[1]; 533 mParameters.videoWidth = mParameters.previewWidth; 534 mParameters.videoHeight = mParameters.previewHeight; 535 536 params.setPreviewSize(mParameters.previewWidth, mParameters.previewHeight); 537 params.setVideoSize(mParameters.videoWidth, mParameters.videoHeight); 538 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, 539 String8::format("%dx%d", 540 mParameters.previewWidth, mParameters.previewHeight)); 541 { 542 String8 supportedPreviewSizes; 543 for (size_t i=0; i < availableProcessedSizes.count; i += 2) { 544 if (i != 0) supportedPreviewSizes += ","; 545 supportedPreviewSizes += String8::format("%dx%d", 546 availableProcessedSizes.data.i32[i], 547 availableProcessedSizes.data.i32[i+1]); 548 } 549 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 550 supportedPreviewSizes); 551 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, 552 supportedPreviewSizes); 553 } 554 555 camera_metadata_entry_t availableFpsRanges = 556 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 557 if (!availableFpsRanges.count) return NO_INIT; 558 559 mParameters.previewFpsRangeMin = availableFpsRanges.data.i32[0]; 560 mParameters.previewFpsRangeMax = availableFpsRanges.data.i32[1]; 561 562 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 563 String8::format("%d,%d", 564 mParameters.previewFpsRangeMin, 565 mParameters.previewFpsRangeMax)); 566 567 { 568 String8 supportedPreviewFpsRange; 569 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 570 if (i != 0) supportedPreviewFpsRange += ","; 571 supportedPreviewFpsRange += String8::format("(%d,%d)", 572 availableFpsRanges.data.i32[i], 573 availableFpsRanges.data.i32[i+1]); 574 } 575 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 576 supportedPreviewFpsRange); 577 } 578 579 mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 580 params.set(CameraParameters::KEY_PREVIEW_FORMAT, 581 formatEnumToString(mParameters.previewFormat)); // NV21 582 583 camera_metadata_entry_t availableFormats = 584 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 585 586 { 587 String8 supportedPreviewFormats; 588 bool addComma = false; 589 for (size_t i=0; i < availableFormats.count; i++) { 590 if (addComma) supportedPreviewFormats += ","; 591 addComma = true; 592 switch (availableFormats.data.i32[i]) { 593 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 594 supportedPreviewFormats += "yuv422sp"; 595 break; 596 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 597 supportedPreviewFormats += "yuv420sp"; 598 break; 599 case HAL_PIXEL_FORMAT_YCbCr_422_I: 600 supportedPreviewFormats += "yuv422i-yuyv"; 601 break; 602 case HAL_PIXEL_FORMAT_YV12: 603 supportedPreviewFormats += "yuv420p"; 604 break; 605 case HAL_PIXEL_FORMAT_RGB_565: 606 supportedPreviewFormats += "rgb565"; 607 break; 608 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats 609 case HAL_PIXEL_FORMAT_RAW_SENSOR: 610 addComma = false; 611 break; 612 default: 613 ALOGW("%s: Camera %d: Unknown preview format: %x", 614 __FUNCTION__, mCameraId, availableFormats.data.i32[i]); 615 addComma = false; 616 break; 617 } 618 } 619 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 620 supportedPreviewFormats); 621 } 622 623 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but 624 // still have to do something sane for them 625 626 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE, 627 mParameters.previewFpsRangeMin); 628 629 { 630 String8 supportedPreviewFrameRates; 631 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 632 if (i != 0) supportedPreviewFrameRates += ","; 633 supportedPreviewFrameRates += String8::format("%d", 634 availableFpsRanges.data.i32[i]); 635 } 636 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 637 supportedPreviewFrameRates); 638 } 639 640 camera_metadata_entry_t availableJpegSizes = 641 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2); 642 if (!availableJpegSizes.count) return NO_INIT; 643 644 // TODO: Pick maximum 645 mParameters.pictureWidth = availableJpegSizes.data.i32[0]; 646 mParameters.pictureHeight = availableJpegSizes.data.i32[1]; 647 648 params.setPictureSize(mParameters.pictureWidth, 649 mParameters.pictureHeight); 650 651 { 652 String8 supportedPictureSizes; 653 for (size_t i=0; i < availableJpegSizes.count; i += 2) { 654 if (i != 0) supportedPictureSizes += ","; 655 supportedPictureSizes += String8::format("%dx%d", 656 availableJpegSizes.data.i32[i], 657 availableJpegSizes.data.i32[i+1]); 658 } 659 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 660 supportedPictureSizes); 661 } 662 663 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 664 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 665 CameraParameters::PIXEL_FORMAT_JPEG); 666 667 camera_metadata_entry_t availableJpegThumbnailSizes = 668 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2); 669 if (!availableJpegThumbnailSizes.count) return NO_INIT; 670 671 // TODO: Pick default thumbnail size sensibly 672 mParameters.jpegThumbWidth = availableJpegThumbnailSizes.data.i32[0]; 673 mParameters.jpegThumbHeight = availableJpegThumbnailSizes.data.i32[1]; 674 675 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 676 mParameters.jpegThumbWidth); 677 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 678 mParameters.jpegThumbHeight); 679 680 { 681 String8 supportedJpegThumbSizes; 682 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) { 683 if (i != 0) supportedJpegThumbSizes += ","; 684 supportedJpegThumbSizes += String8::format("%dx%d", 685 availableJpegThumbnailSizes.data.i32[i], 686 availableJpegThumbnailSizes.data.i32[i+1]); 687 } 688 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 689 supportedJpegThumbSizes); 690 } 691 692 mParameters.jpegThumbQuality = 90; 693 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 694 mParameters.jpegThumbQuality); 695 mParameters.jpegQuality = 90; 696 params.set(CameraParameters::KEY_JPEG_QUALITY, 697 mParameters.jpegQuality); 698 mParameters.jpegRotation = 0; 699 params.set(CameraParameters::KEY_ROTATION, 700 mParameters.jpegRotation); 701 702 mParameters.gpsEnabled = false; 703 mParameters.gpsProcessingMethod = "unknown"; 704 // GPS fields in CameraParameters are not set by implementation 705 706 mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO; 707 params.set(CameraParameters::KEY_WHITE_BALANCE, 708 CameraParameters::WHITE_BALANCE_AUTO); 709 710 camera_metadata_entry_t availableWhiteBalanceModes = 711 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 712 { 713 String8 supportedWhiteBalance; 714 bool addComma = false; 715 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) { 716 if (addComma) supportedWhiteBalance += ","; 717 addComma = true; 718 switch (availableWhiteBalanceModes.data.u8[i]) { 719 case ANDROID_CONTROL_AWB_AUTO: 720 supportedWhiteBalance += "auto"; 721 break; 722 case ANDROID_CONTROL_AWB_INCANDESCENT: 723 supportedWhiteBalance += "incandescent"; 724 break; 725 case ANDROID_CONTROL_AWB_FLUORESCENT: 726 supportedWhiteBalance += "fluorescent"; 727 break; 728 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT: 729 supportedWhiteBalance += "warm-fluorescent"; 730 break; 731 case ANDROID_CONTROL_AWB_DAYLIGHT: 732 supportedWhiteBalance += "daylight"; 733 break; 734 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT: 735 supportedWhiteBalance += "cloudy-daylight"; 736 break; 737 case ANDROID_CONTROL_AWB_TWILIGHT: 738 supportedWhiteBalance += "twilight"; 739 break; 740 case ANDROID_CONTROL_AWB_SHADE: 741 supportedWhiteBalance += "shade"; 742 break; 743 // Skipping values not mappable to v1 API 744 case ANDROID_CONTROL_AWB_OFF: 745 addComma = false; 746 break; 747 default: 748 ALOGW("%s: Camera %d: Unknown white balance value: %d", 749 __FUNCTION__, mCameraId, 750 availableWhiteBalanceModes.data.u8[i]); 751 addComma = false; 752 break; 753 } 754 } 755 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 756 supportedWhiteBalance); 757 } 758 759 mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF; 760 params.set(CameraParameters::KEY_EFFECT, 761 CameraParameters::EFFECT_NONE); 762 763 camera_metadata_entry_t availableEffects = 764 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 765 if (!availableEffects.count) return NO_INIT; 766 { 767 String8 supportedEffects; 768 bool addComma = false; 769 for (size_t i=0; i < availableEffects.count; i++) { 770 if (addComma) supportedEffects += ","; 771 addComma = true; 772 switch (availableEffects.data.u8[i]) { 773 case ANDROID_CONTROL_EFFECT_OFF: 774 supportedEffects += "none"; 775 break; 776 case ANDROID_CONTROL_EFFECT_MONO: 777 supportedEffects += "mono"; 778 case ANDROID_CONTROL_EFFECT_NEGATIVE: 779 supportedEffects += "negative"; 780 break; 781 case ANDROID_CONTROL_EFFECT_SOLARIZE: 782 supportedEffects += "solarize"; 783 break; 784 case ANDROID_CONTROL_EFFECT_SEPIA: 785 supportedEffects += "sepia"; 786 break; 787 case ANDROID_CONTROL_EFFECT_POSTERIZE: 788 supportedEffects += "posterize"; 789 break; 790 case ANDROID_CONTROL_EFFECT_WHITEBOARD: 791 supportedEffects += "whiteboard"; 792 break; 793 case ANDROID_CONTROL_EFFECT_BLACKBOARD: 794 supportedEffects += "blackboard"; 795 break; 796 case ANDROID_CONTROL_EFFECT_AQUA: 797 supportedEffects += "aqua"; 798 break; 799 default: 800 ALOGW("%s: Camera %d: Unknown effect value: %d", 801 __FUNCTION__, mCameraId, availableEffects.data.u8[i]); 802 addComma = false; 803 break; 804 } 805 } 806 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects); 807 } 808 809 mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO; 810 params.set(CameraParameters::KEY_ANTIBANDING, 811 CameraParameters::ANTIBANDING_AUTO); 812 813 camera_metadata_entry_t availableAntibandingModes = 814 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 815 if (!availableAntibandingModes.count) return NO_INIT; 816 { 817 String8 supportedAntibanding; 818 bool addComma = false; 819 for (size_t i=0; i < availableAntibandingModes.count; i++) { 820 if (addComma) supportedAntibanding += ","; 821 addComma = true; 822 switch (availableAntibandingModes.data.u8[i]) { 823 case ANDROID_CONTROL_AE_ANTIBANDING_OFF: 824 supportedAntibanding += "off"; 825 break; 826 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ: 827 supportedAntibanding += "50hz"; 828 break; 829 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ: 830 supportedAntibanding += "60hz"; 831 break; 832 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO: 833 supportedAntibanding += "auto"; 834 break; 835 default: 836 ALOGW("%s: Camera %d: Unknown antibanding value: %d", 837 __FUNCTION__, mCameraId, 838 availableAntibandingModes.data.u8[i]); 839 addComma = false; 840 break; 841 } 842 } 843 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 844 supportedAntibanding); 845 } 846 847 mParameters.sceneMode = ANDROID_CONTROL_OFF; 848 params.set(CameraParameters::KEY_SCENE_MODE, 849 CameraParameters::SCENE_MODE_AUTO); 850 851 camera_metadata_entry_t availableSceneModes = 852 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 853 if (!availableSceneModes.count) return NO_INIT; 854 { 855 String8 supportedSceneModes("auto"); 856 bool addComma = true; 857 bool noSceneModes = false; 858 for (size_t i=0; i < availableSceneModes.count; i++) { 859 if (addComma) supportedSceneModes += ","; 860 addComma = true; 861 switch (availableSceneModes.data.u8[i]) { 862 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 863 noSceneModes = true; 864 break; 865 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 866 // Not in old API 867 addComma = false; 868 break; 869 case ANDROID_CONTROL_SCENE_MODE_ACTION: 870 supportedSceneModes += "action"; 871 break; 872 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT: 873 supportedSceneModes += "portrait"; 874 break; 875 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE: 876 supportedSceneModes += "landscape"; 877 break; 878 case ANDROID_CONTROL_SCENE_MODE_NIGHT: 879 supportedSceneModes += "night"; 880 break; 881 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT: 882 supportedSceneModes += "night-portrait"; 883 break; 884 case ANDROID_CONTROL_SCENE_MODE_THEATRE: 885 supportedSceneModes += "theatre"; 886 break; 887 case ANDROID_CONTROL_SCENE_MODE_BEACH: 888 supportedSceneModes += "beach"; 889 break; 890 case ANDROID_CONTROL_SCENE_MODE_SNOW: 891 supportedSceneModes += "snow"; 892 break; 893 case ANDROID_CONTROL_SCENE_MODE_SUNSET: 894 supportedSceneModes += "sunset"; 895 break; 896 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO: 897 supportedSceneModes += "steadyphoto"; 898 break; 899 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS: 900 supportedSceneModes += "fireworks"; 901 break; 902 case ANDROID_CONTROL_SCENE_MODE_SPORTS: 903 supportedSceneModes += "sports"; 904 break; 905 case ANDROID_CONTROL_SCENE_MODE_PARTY: 906 supportedSceneModes += "party"; 907 break; 908 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT: 909 supportedSceneModes += "candlelight"; 910 break; 911 case ANDROID_CONTROL_SCENE_MODE_BARCODE: 912 supportedSceneModes += "barcode"; 913 break; 914 default: 915 ALOGW("%s: Camera %d: Unknown scene mode value: %d", 916 __FUNCTION__, mCameraId, availableSceneModes.data.u8[i]); 917 addComma = false; 918 break; 919 } 920 } 921 if (!noSceneModes) { 922 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 923 supportedSceneModes); 924 } 925 } 926 927 camera_metadata_entry_t flashAvailable = 928 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 929 if (!flashAvailable.count) return NO_INIT; 930 931 camera_metadata_entry_t availableAeModes = 932 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 933 if (!availableAeModes.count) return NO_INIT; 934 935 if (flashAvailable.data.u8[0]) { 936 mParameters.flashMode = Parameters::FLASH_MODE_AUTO; 937 params.set(CameraParameters::KEY_FLASH_MODE, 938 CameraParameters::FLASH_MODE_AUTO); 939 940 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF); 941 supportedFlashModes = supportedFlashModes + 942 "," + CameraParameters::FLASH_MODE_AUTO + 943 "," + CameraParameters::FLASH_MODE_ON + 944 "," + CameraParameters::FLASH_MODE_TORCH; 945 for (size_t i=0; i < availableAeModes.count; i++) { 946 if (availableAeModes.data.u8[i] == 947 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) { 948 supportedFlashModes = supportedFlashModes + "," + 949 CameraParameters::FLASH_MODE_RED_EYE; 950 break; 951 } 952 } 953 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 954 supportedFlashModes); 955 } else { 956 mParameters.flashMode = Parameters::FLASH_MODE_OFF; 957 params.set(CameraParameters::KEY_FLASH_MODE, 958 CameraParameters::FLASH_MODE_OFF); 959 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 960 CameraParameters::FLASH_MODE_OFF); 961 } 962 963 camera_metadata_entry_t minFocusDistance = 964 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1); 965 if (!minFocusDistance.count) return NO_INIT; 966 967 camera_metadata_entry_t availableAfModes = 968 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 969 if (!availableAfModes.count) return NO_INIT; 970 971 if (minFocusDistance.data.f[0] == 0) { 972 // Fixed-focus lens 973 mParameters.focusMode = Parameters::FOCUS_MODE_FIXED; 974 params.set(CameraParameters::KEY_FOCUS_MODE, 975 CameraParameters::FOCUS_MODE_FIXED); 976 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 977 CameraParameters::FOCUS_MODE_FIXED); 978 } else { 979 mParameters.focusMode = Parameters::FOCUS_MODE_AUTO; 980 params.set(CameraParameters::KEY_FOCUS_MODE, 981 CameraParameters::FOCUS_MODE_AUTO); 982 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED); 983 supportedFocusModes = supportedFocusModes + "," + 984 CameraParameters::FOCUS_MODE_INFINITY; 985 bool addComma = true; 986 for (size_t i=0; i < availableAfModes.count; i++) { 987 if (addComma) supportedFocusModes += ","; 988 addComma = true; 989 switch (availableAfModes.data.u8[i]) { 990 case ANDROID_CONTROL_AF_AUTO: 991 supportedFocusModes += "auto"; 992 break; 993 case ANDROID_CONTROL_AF_MACRO: 994 supportedFocusModes += "macro"; 995 break; 996 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO: 997 supportedFocusModes += "continuous-video"; 998 break; 999 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE: 1000 supportedFocusModes += "continuous-picture"; 1001 break; 1002 case ANDROID_CONTROL_AF_EDOF: 1003 supportedFocusModes += "edof"; 1004 break; 1005 // Not supported in v1 API 1006 case ANDROID_CONTROL_AF_OFF: 1007 addComma = false; 1008 break; 1009 default: 1010 ALOGW("%s: Camera %d: Unknown AF mode value: %d", 1011 __FUNCTION__, mCameraId, availableAfModes.data.u8[i]); 1012 addComma = false; 1013 break; 1014 } 1015 } 1016 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 1017 supportedFocusModes); 1018 } 1019 1020 camera_metadata_entry_t max3aRegions = 1021 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1); 1022 if (!max3aRegions.count) return NO_INIT; 1023 1024 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, 1025 max3aRegions.data.i32[0]); 1026 params.set(CameraParameters::KEY_FOCUS_AREAS, 1027 "(0,0,0,0,0)"); 1028 mParameters.focusingAreas.clear(); 1029 mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0)); 1030 1031 camera_metadata_entry_t availableFocalLengths = 1032 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS); 1033 if (!availableFocalLengths.count) return NO_INIT; 1034 1035 float minFocalLength = availableFocalLengths.data.f[0]; 1036 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength); 1037 1038 camera_metadata_entry_t sensorSize = 1039 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2); 1040 if (!sensorSize.count) return NO_INIT; 1041 1042 // The fields of view here assume infinity focus, maximum wide angle 1043 float horizFov = 180 / M_PI * 1044 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength)); 1045 float vertFov = 180 / M_PI * 1046 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength)); 1047 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 1048 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 1049 1050 mParameters.exposureCompensation = 0; 1051 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 1052 mParameters.exposureCompensation); 1053 1054 camera_metadata_entry_t exposureCompensationRange = 1055 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2); 1056 if (!exposureCompensationRange.count) return NO_INIT; 1057 1058 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 1059 exposureCompensationRange.data.i32[1]); 1060 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 1061 exposureCompensationRange.data.i32[0]); 1062 1063 camera_metadata_entry_t exposureCompensationStep = 1064 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1); 1065 if (!exposureCompensationStep.count) return NO_INIT; 1066 1067 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 1068 exposureCompensationStep.data.r[0].numerator / 1069 exposureCompensationStep.data.r[0].denominator); 1070 1071 mParameters.autoExposureLock = false; 1072 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 1073 CameraParameters::FALSE); 1074 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 1075 CameraParameters::TRUE); 1076 1077 mParameters.autoWhiteBalanceLock = false; 1078 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 1079 CameraParameters::FALSE); 1080 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 1081 CameraParameters::TRUE); 1082 1083 mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 1084 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 1085 max3aRegions.data.i32[0]); 1086 params.set(CameraParameters::KEY_METERING_AREAS, 1087 "(0,0,0,0,0)"); 1088 1089 mParameters.zoom = 0; 1090 params.set(CameraParameters::KEY_ZOOM, mParameters.zoom); 1091 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 1092 1093 camera_metadata_entry_t maxDigitalZoom = 1094 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1); 1095 if (!maxDigitalZoom.count) return NO_INIT; 1096 1097 { 1098 String8 zoomRatios; 1099 float zoom = 1.f; 1100 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 1101 (NUM_ZOOM_STEPS-1); 1102 bool addComma = false; 1103 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 1104 if (addComma) zoomRatios += ","; 1105 addComma = true; 1106 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 1107 zoom += zoomIncrement; 1108 } 1109 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 1110 } 1111 1112 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 1113 CameraParameters::TRUE); 1114 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 1115 CameraParameters::TRUE); 1116 1117 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 1118 "Infinity,Infinity,Infinity"); 1119 1120 camera_metadata_entry_t maxFacesDetected = 1121 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1); 1122 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 1123 maxFacesDetected.data.i32[0]); 1124 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 1125 0); 1126 1127 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 1128 formatEnumToString(HAL_PIXEL_FORMAT_YCrCb_420_SP)); 1129 1130 params.set(CameraParameters::KEY_RECORDING_HINT, 1131 CameraParameters::FALSE); 1132 1133 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 1134 CameraParameters::TRUE); 1135 1136 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 1137 CameraParameters::FALSE); 1138 1139 camera_metadata_entry_t availableVideoStabilizationModes = 1140 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 1141 if (!availableVideoStabilizationModes.count) return NO_INIT; 1142 1143 if (availableVideoStabilizationModes.count > 1) { 1144 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 1145 CameraParameters::TRUE); 1146 } else { 1147 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 1148 CameraParameters::FALSE); 1149 } 1150 1151 mParamsFlattened = params.flatten(); 1152 1153 return OK; 1154} 1155 1156status_t Camera2Client::updatePreviewRequest() { 1157 ATRACE_CALL(); 1158 status_t res; 1159 if (mPreviewRequest == NULL) { 1160 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW, 1161 &mPreviewRequest); 1162 if (res != OK) { 1163 ALOGE("%s: Camera %d: Unable to create default preview request: " 1164 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1165 return res; 1166 } 1167 } 1168 // TODO: Adjust for params changes 1169 return OK; 1170} 1171 1172const char* Camera2Client::formatEnumToString(int format) { 1173 const char *fmt; 1174 switch(format) { 1175 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1176 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 1177 break; 1178 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1179 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 1180 break; 1181 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1182 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 1183 break; 1184 case HAL_PIXEL_FORMAT_YV12: // YV12 1185 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 1186 break; 1187 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 1188 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 1189 break; 1190 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 1191 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 1192 break; 1193 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1194 ALOGW("Raw sensor preview format requested."); 1195 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 1196 break; 1197 default: 1198 ALOGE("%s: Unknown preview format: %x", 1199 __FUNCTION__, format); 1200 fmt = NULL; 1201 break; 1202 } 1203 return fmt; 1204} 1205} // namespace android 1206