Camera2Client.cpp revision 30e65e7e2ec01e13e45b5e38552a34d2fbb3f866
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#include <media/hardware/MetadataBufferType.h> 28 29#include <math.h> 30 31#include "Camera2Client.h" 32 33namespace android { 34 35#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 36#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 37 38static int getCallingPid() { 39 return IPCThreadState::self()->getCallingPid(); 40} 41 42static int getCallingUid() { 43 return IPCThreadState::self()->getCallingUid(); 44} 45 46// Interface used by CameraService 47 48Camera2Client::Camera2Client(const sp<CameraService>& cameraService, 49 const sp<ICameraClient>& cameraClient, 50 int cameraId, 51 int cameraFacing, 52 int clientPid): 53 Client(cameraService, cameraClient, 54 cameraId, cameraFacing, clientPid), 55 mDeviceInfo(NULL), 56 mPreviewStreamId(NO_STREAM), 57 mPreviewRequest(NULL), 58 mCallbackStreamId(NO_STREAM), 59 mCallbackHeapId(0), 60 mCaptureStreamId(NO_STREAM), 61 mCaptureRequest(NULL), 62 mRecordingStreamId(NO_STREAM), 63 mRecordingRequest(NULL), 64 mRecordingHeapCount(kDefaultRecordingHeapCount) 65{ 66 ATRACE_CALL(); 67 68 mDevice = new Camera2Device(cameraId); 69 70 LockedParameters::Key k(mParameters); 71 k.mParameters.state = DISCONNECTED; 72} 73 74status_t Camera2Client::checkPid(const char* checkLocation) const { 75 int callingPid = getCallingPid(); 76 if (callingPid == mClientPid) return NO_ERROR; 77 78 ALOGE("%s: attempt to use a locked camera from a different process" 79 " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid); 80 return PERMISSION_DENIED; 81} 82 83status_t Camera2Client::initialize(camera_module_t *module) 84{ 85 ATRACE_CALL(); 86 ALOGV("%s: E", __FUNCTION__); 87 status_t res; 88 89 res = mDevice->initialize(module); 90 if (res != OK) { 91 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)", 92 __FUNCTION__, mCameraId, strerror(-res), res); 93 return NO_INIT; 94 } 95 96 res = mDevice->setNotifyCallback(this); 97 res = mDevice->setFrameListener(this); 98 99 res = buildDeviceInfo(); 100 res = buildDefaultParameters(); 101 if (res != OK) { 102 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)", 103 __FUNCTION__, mCameraId, strerror(-res), res); 104 return NO_INIT; 105 } 106 107 if (gLogLevel >= 1) { 108 LockedParameters::Key k(mParameters); 109 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__, 110 mCameraId); 111 ALOGD("%s", k.mParameters.paramsFlattened.string()); 112 } 113 114 return OK; 115} 116 117Camera2Client::~Camera2Client() { 118 ATRACE_CALL(); 119 ALOGV("%s: Camera %d: Shutting down", __FUNCTION__, mCameraId); 120 121 mDestructionStarted = true; 122 123 // Rewrite mClientPid to allow shutdown by CameraService 124 mClientPid = getCallingPid(); 125 disconnect(); 126} 127 128status_t Camera2Client::dump(int fd, const Vector<String16>& args) { 129 String8 result; 130 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n", 131 mCameraId, 132 getCameraClient()->asBinder().get(), 133 mClientPid); 134 result.append(" State: "); 135#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break; 136 137 const Parameters& p = mParameters.unsafeUnlock(); 138 139 result.append(getStateName(p.state)); 140 141 result.append("\n Current parameters:\n"); 142 result.appendFormat(" Preview size: %d x %d\n", 143 p.previewWidth, p.previewHeight); 144 result.appendFormat(" Preview FPS range: %d - %d\n", 145 p.previewFpsRange[0], p.previewFpsRange[1]); 146 result.appendFormat(" Preview HAL pixel format: 0x%x\n", 147 p.previewFormat); 148 result.appendFormat(" Preview transform: %x\n", 149 p.previewTransform); 150 result.appendFormat(" Picture size: %d x %d\n", 151 p.pictureWidth, p.pictureHeight); 152 result.appendFormat(" Jpeg thumbnail size: %d x %d\n", 153 p.jpegThumbSize[0], p.jpegThumbSize[1]); 154 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n", 155 p.jpegQuality, p.jpegThumbQuality); 156 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation); 157 result.appendFormat(" GPS tags %s\n", 158 p.gpsEnabled ? "enabled" : "disabled"); 159 if (p.gpsEnabled) { 160 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n", 161 p.gpsCoordinates[0], p.gpsCoordinates[1], 162 p.gpsCoordinates[2]); 163 result.appendFormat(" GPS timestamp: %lld\n", 164 p.gpsTimestamp); 165 result.appendFormat(" GPS processing method: %s\n", 166 p.gpsProcessingMethod.string()); 167 } 168 169 result.append(" White balance mode: "); 170 switch (p.wbMode) { 171 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO) 172 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT) 173 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT) 174 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT) 175 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT) 176 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT) 177 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT) 178 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE) 179 default: result.append("UNKNOWN\n"); 180 } 181 182 result.append(" Effect mode: "); 183 switch (p.effectMode) { 184 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF) 185 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO) 186 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE) 187 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE) 188 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA) 189 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE) 190 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD) 191 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD) 192 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA) 193 default: result.append("UNKNOWN\n"); 194 } 195 196 result.append(" Antibanding mode: "); 197 switch (p.antibandingMode) { 198 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO) 199 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF) 200 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ) 201 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ) 202 default: result.append("UNKNOWN\n"); 203 } 204 205 result.append(" Scene mode: "); 206 switch (p.sceneMode) { 207 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 208 result.append("AUTO\n"); break; 209 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION) 210 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT) 211 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE) 212 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT) 213 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT) 214 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE) 215 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH) 216 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW) 217 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET) 218 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO) 219 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS) 220 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS) 221 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY) 222 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT) 223 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE) 224 default: result.append("UNKNOWN\n"); 225 } 226 227 result.append(" Flash mode: "); 228 switch (p.flashMode) { 229 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF) 230 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO) 231 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON) 232 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH) 233 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE) 234 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID) 235 default: result.append("UNKNOWN\n"); 236 } 237 238 result.append(" Focus mode: "); 239 switch (p.focusMode) { 240 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO) 241 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO) 242 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) 243 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE) 244 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF) 245 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY) 246 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED) 247 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID) 248 default: result.append("UNKNOWN\n"); 249 } 250 251 result.append(" Focusing areas:\n"); 252 for (size_t i = 0; i < p.focusingAreas.size(); i++) { 253 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 254 p.focusingAreas[i].left, 255 p.focusingAreas[i].top, 256 p.focusingAreas[i].right, 257 p.focusingAreas[i].bottom, 258 p.focusingAreas[i].weight); 259 } 260 261 result.appendFormat(" Exposure compensation index: %d\n", 262 p.exposureCompensation); 263 264 result.appendFormat(" AE lock %s, AWB lock %s\n", 265 p.autoExposureLock ? "enabled" : "disabled", 266 p.autoWhiteBalanceLock ? "enabled" : "disabled" ); 267 268 result.appendFormat(" Metering areas:\n"); 269 for (size_t i = 0; i < p.meteringAreas.size(); i++) { 270 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 271 p.meteringAreas[i].left, 272 p.meteringAreas[i].top, 273 p.meteringAreas[i].right, 274 p.meteringAreas[i].bottom, 275 p.meteringAreas[i].weight); 276 } 277 278 result.appendFormat(" Zoom index: %d\n", p.zoom); 279 result.appendFormat(" Video size: %d x %d\n", p.videoWidth, 280 p.videoHeight); 281 282 result.appendFormat(" Recording hint is %s\n", 283 p.recordingHint ? "set" : "not set"); 284 285 result.appendFormat(" Video stabilization is %s\n", 286 p.videoStabilization ? "enabled" : "disabled"); 287 288 result.append(" Current streams:\n"); 289 result.appendFormat(" Preview stream ID: %d\n", mPreviewStreamId); 290 result.appendFormat(" Capture stream ID: %d\n", mCaptureStreamId); 291 result.appendFormat(" Recording stream ID: %d\n", mRecordingStreamId); 292 293 result.append(" Current requests:\n"); 294 if (mPreviewRequest != NULL) { 295 result.append(" Preview request:\n"); 296 write(fd, result.string(), result.size()); 297 dump_indented_camera_metadata(mPreviewRequest, fd, 2, 6); 298 } else { 299 result.append(" Preview request: undefined\n"); 300 write(fd, result.string(), result.size()); 301 } 302 303 if (mCaptureRequest != NULL) { 304 result = " Capture request:\n"; 305 write(fd, result.string(), result.size()); 306 dump_indented_camera_metadata(mCaptureRequest, fd, 2, 6); 307 } else { 308 result = " Capture request: undefined\n"; 309 write(fd, result.string(), result.size()); 310 } 311 312 if (mRecordingRequest != NULL) { 313 result = " Recording request:\n"; 314 write(fd, result.string(), result.size()); 315 dump_indented_camera_metadata(mRecordingRequest, fd, 2, 6); 316 } else { 317 result = " Recording request: undefined\n"; 318 write(fd, result.string(), result.size()); 319 } 320 321 result = " Device dump:\n"; 322 write(fd, result.string(), result.size()); 323 324 status_t res = mDevice->dump(fd, args); 325 if (res != OK) { 326 result = String8::format(" Error dumping device: %s (%d)", 327 strerror(-res), res); 328 write(fd, result.string(), result.size()); 329 } 330 331#undef CASE_APPEND_ENUM 332 return NO_ERROR; 333} 334 335const char* Camera2Client::getStateName(State state) { 336#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break; 337 switch(state) { 338 CASE_ENUM_TO_CHAR(DISCONNECTED) 339 CASE_ENUM_TO_CHAR(STOPPED) 340 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW) 341 CASE_ENUM_TO_CHAR(PREVIEW) 342 CASE_ENUM_TO_CHAR(RECORD) 343 CASE_ENUM_TO_CHAR(STILL_CAPTURE) 344 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT) 345 default: 346 return "Unknown state!"; 347 break; 348 } 349#undef CASE_ENUM_TO_CHAR 350} 351 352// ICamera interface 353 354void Camera2Client::disconnect() { 355 ATRACE_CALL(); 356 ALOGV("%s: E", __FUNCTION__); 357 Mutex::Autolock icl(mICameraLock); 358 status_t res; 359 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 360 361 if (mDevice == 0) return; 362 363 stopPreviewL(); 364 365 if (mPreviewStreamId != NO_STREAM) { 366 mDevice->deleteStream(mPreviewStreamId); 367 mPreviewStreamId = NO_STREAM; 368 } 369 370 if (mCaptureStreamId != NO_STREAM) { 371 mDevice->deleteStream(mCaptureStreamId); 372 mCaptureStreamId = NO_STREAM; 373 } 374 375 if (mRecordingStreamId != NO_STREAM) { 376 mDevice->deleteStream(mRecordingStreamId); 377 mRecordingStreamId = NO_STREAM; 378 } 379 380 if (mCallbackStreamId != NO_STREAM) { 381 mDevice->deleteStream(mCallbackStreamId); 382 mCallbackStreamId = NO_STREAM; 383 } 384 385 mDevice.clear(); 386 LockedParameters::Key k(mParameters); 387 k.mParameters.state = DISCONNECTED; 388 389 if (mDeviceInfo != NULL) { 390 delete mDeviceInfo; 391 mDeviceInfo = NULL; 392 } 393 394 CameraService::Client::disconnect(); 395} 396 397status_t Camera2Client::connect(const sp<ICameraClient>& client) { 398 ATRACE_CALL(); 399 ALOGV("%s: E", __FUNCTION__); 400 Mutex::Autolock icl(mICameraLock); 401 402 if (mClientPid != 0 && getCallingPid() != mClientPid) { 403 ALOGE("%s: Camera %d: Connection attempt from pid %d; " 404 "current locked to pid %d", __FUNCTION__, 405 mCameraId, getCallingPid(), mClientPid); 406 return BAD_VALUE; 407 } 408 409 mClientPid = getCallingPid(); 410 411 Mutex::Autolock iccl(mICameraClientLock); 412 mCameraClient = client; 413 414 LockedParameters::Key k(mParameters); 415 k.mParameters.state = STOPPED; 416 417 return OK; 418} 419 420status_t Camera2Client::lock() { 421 ATRACE_CALL(); 422 ALOGV("%s: E", __FUNCTION__); 423 Mutex::Autolock icl(mICameraLock); 424 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d", 425 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 426 427 if (mClientPid == 0) { 428 mClientPid = getCallingPid(); 429 return OK; 430 } 431 432 if (mClientPid != getCallingPid()) { 433 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d", 434 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 435 return EBUSY; 436 } 437 438 return OK; 439} 440 441status_t Camera2Client::unlock() { 442 ATRACE_CALL(); 443 ALOGV("%s: E", __FUNCTION__); 444 Mutex::Autolock icl(mICameraLock); 445 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d", 446 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 447 448 // TODO: Check for uninterruptable conditions 449 450 if (mClientPid == getCallingPid()) { 451 Mutex::Autolock iccl(mICameraClientLock); 452 453 mClientPid = 0; 454 mCameraClient.clear(); 455 return OK; 456 } 457 458 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d", 459 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 460 return EBUSY; 461} 462 463status_t Camera2Client::setPreviewDisplay( 464 const sp<Surface>& surface) { 465 ATRACE_CALL(); 466 ALOGV("%s: E", __FUNCTION__); 467 Mutex::Autolock icl(mICameraLock); 468 status_t res; 469 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 470 471 sp<IBinder> binder; 472 sp<ANativeWindow> window; 473 if (surface != 0) { 474 binder = surface->asBinder(); 475 window = surface; 476 } 477 478 return setPreviewWindowL(binder,window); 479} 480 481status_t Camera2Client::setPreviewTexture( 482 const sp<ISurfaceTexture>& surfaceTexture) { 483 ATRACE_CALL(); 484 ALOGV("%s: E", __FUNCTION__); 485 Mutex::Autolock icl(mICameraLock); 486 status_t res; 487 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 488 489 sp<IBinder> binder; 490 sp<ANativeWindow> window; 491 if (surfaceTexture != 0) { 492 binder = surfaceTexture->asBinder(); 493 window = new SurfaceTextureClient(surfaceTexture); 494 } 495 return setPreviewWindowL(binder, window); 496} 497 498status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder, 499 sp<ANativeWindow> window) { 500 ATRACE_CALL(); 501 status_t res; 502 503 if (binder == mPreviewSurface) { 504 ALOGV("%s: Camera %d: New window is same as old window", 505 __FUNCTION__, mCameraId); 506 return NO_ERROR; 507 } 508 509 LockedParameters::Key k(mParameters); 510 switch (k.mParameters.state) { 511 case DISCONNECTED: 512 case RECORD: 513 case STILL_CAPTURE: 514 case VIDEO_SNAPSHOT: 515 ALOGE("%s: Camera %d: Cannot set preview display while in state %s", 516 __FUNCTION__, mCameraId, getStateName(k.mParameters.state)); 517 return INVALID_OPERATION; 518 case STOPPED: 519 case WAITING_FOR_PREVIEW_WINDOW: 520 // OK 521 break; 522 case PREVIEW: 523 // Already running preview - need to stop and create a new stream 524 // TODO: Optimize this so that we don't wait for old stream to drain 525 // before spinning up new stream 526 mDevice->setStreamingRequest(NULL); 527 k.mParameters.state = WAITING_FOR_PREVIEW_WINDOW; 528 break; 529 } 530 531 if (mPreviewStreamId != NO_STREAM) { 532 res = mDevice->waitUntilDrained(); 533 if (res != OK) { 534 ALOGE("%s: Error waiting for preview to drain: %s (%d)", 535 __FUNCTION__, strerror(-res), res); 536 return res; 537 } 538 res = mDevice->deleteStream(mPreviewStreamId); 539 if (res != OK) { 540 ALOGE("%s: Unable to delete old preview stream: %s (%d)", 541 __FUNCTION__, strerror(-res), res); 542 return res; 543 } 544 mPreviewStreamId = NO_STREAM; 545 } 546 547 mPreviewSurface = binder; 548 mPreviewWindow = window; 549 550 if (k.mParameters.state == WAITING_FOR_PREVIEW_WINDOW) { 551 return startPreviewL(k.mParameters, false); 552 } 553 554 return OK; 555} 556 557void Camera2Client::setPreviewCallbackFlag(int flag) { 558 ATRACE_CALL(); 559 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag); 560 Mutex::Autolock icl(mICameraLock); 561 status_t res; 562 if ( checkPid(__FUNCTION__) != OK) return; 563 564 LockedParameters::Key k(mParameters); 565 setPreviewCallbackFlagL(k.mParameters, flag); 566} 567 568void Camera2Client::setPreviewCallbackFlagL(Parameters ¶ms, int flag) { 569 status_t res = OK; 570 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) { 571 ALOGV("%s: setting oneshot", __FUNCTION__); 572 params.previewCallbackOneShot = true; 573 } 574 if (params.previewCallbackFlags != (uint32_t)flag) { 575 params.previewCallbackFlags = flag; 576 switch(params.state) { 577 case PREVIEW: 578 res = startPreviewL(params, true); 579 break; 580 case RECORD: 581 case VIDEO_SNAPSHOT: 582 res = startRecordingL(params, true); 583 break; 584 default: 585 break; 586 } 587 if (res != OK) { 588 ALOGE("%s: Camera %d: Unable to refresh request in state %s", 589 __FUNCTION__, mCameraId, getStateName(params.state)); 590 } 591 } 592 593} 594 595status_t Camera2Client::startPreview() { 596 ATRACE_CALL(); 597 ALOGV("%s: E", __FUNCTION__); 598 Mutex::Autolock icl(mICameraLock); 599 status_t res; 600 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 601 LockedParameters::Key k(mParameters); 602 return startPreviewL(k.mParameters, false); 603} 604 605status_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) { 606 ATRACE_CALL(); 607 status_t res; 608 if (params.state >= PREVIEW && !restart) { 609 ALOGE("%s: Can't start preview in state %s", 610 __FUNCTION__, getStateName(params.state)); 611 return INVALID_OPERATION; 612 } 613 614 if (mPreviewWindow == 0) { 615 params.state = WAITING_FOR_PREVIEW_WINDOW; 616 return OK; 617 } 618 params.state = STOPPED; 619 620 res = updatePreviewStream(params); 621 if (res != OK) { 622 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)", 623 __FUNCTION__, mCameraId, strerror(-res), res); 624 return res; 625 } 626 bool callbacksEnabled = params.previewCallbackFlags & 627 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK; 628 if (callbacksEnabled) { 629 res = updateCallbackStream(params); 630 if (res != OK) { 631 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)", 632 __FUNCTION__, mCameraId, strerror(-res), res); 633 return res; 634 } 635 } 636 637 if (mPreviewRequest == NULL) { 638 res = updatePreviewRequest(params); 639 if (res != OK) { 640 ALOGE("%s: Camera %d: Unable to create preview request: %s (%d)", 641 __FUNCTION__, mCameraId, strerror(-res), res); 642 return res; 643 } 644 } 645 646 if (callbacksEnabled) { 647 uint8_t outputStreams[2] = 648 { mPreviewStreamId, mCallbackStreamId }; 649 res = updateEntry(mPreviewRequest, 650 ANDROID_REQUEST_OUTPUT_STREAMS, 651 outputStreams, 2); 652 } else { 653 res = updateEntry(mPreviewRequest, 654 ANDROID_REQUEST_OUTPUT_STREAMS, 655 &mPreviewStreamId, 1); 656 } 657 if (res != OK) { 658 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)", 659 __FUNCTION__, mCameraId, strerror(-res), res); 660 return res; 661 } 662 res = sort_camera_metadata(mPreviewRequest); 663 if (res != OK) { 664 ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)", 665 __FUNCTION__, mCameraId, strerror(-res), res); 666 return res; 667 } 668 669 res = mDevice->setStreamingRequest(mPreviewRequest); 670 if (res != OK) { 671 ALOGE("%s: Camera %d: Unable to set preview request to start preview: " 672 "%s (%d)", 673 __FUNCTION__, mCameraId, strerror(-res), res); 674 return res; 675 } 676 params.state = PREVIEW; 677 678 return OK; 679} 680 681void Camera2Client::stopPreview() { 682 ATRACE_CALL(); 683 ALOGV("%s: E", __FUNCTION__); 684 Mutex::Autolock icl(mICameraLock); 685 status_t res; 686 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 687 stopPreviewL(); 688} 689 690void Camera2Client::stopPreviewL() { 691 ATRACE_CALL(); 692 State state; 693 { 694 LockedParameters::Key k(mParameters); 695 state = k.mParameters.state; 696 } 697 698 switch (state) { 699 case DISCONNECTED: 700 ALOGE("%s: Camera %d: Call before initialized", 701 __FUNCTION__, mCameraId); 702 break; 703 case STOPPED: 704 break; 705 case STILL_CAPTURE: 706 ALOGE("%s: Camera %d: Cannot stop preview during still capture.", 707 __FUNCTION__, mCameraId); 708 break; 709 case RECORD: 710 // no break - identical to preview 711 case PREVIEW: 712 mDevice->setStreamingRequest(NULL); 713 mDevice->waitUntilDrained(); 714 // no break 715 case WAITING_FOR_PREVIEW_WINDOW: { 716 LockedParameters::Key k(mParameters); 717 k.mParameters.state = STOPPED; 718 commandStopFaceDetectionL(k.mParameters); 719 break; 720 } 721 default: 722 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId, 723 state); 724 } 725} 726 727bool Camera2Client::previewEnabled() { 728 ATRACE_CALL(); 729 Mutex::Autolock icl(mICameraLock); 730 status_t res; 731 if ( (res = checkPid(__FUNCTION__) ) != OK) return false; 732 733 LockedParameters::Key k(mParameters); 734 return k.mParameters.state == PREVIEW; 735} 736 737status_t Camera2Client::storeMetaDataInBuffers(bool enabled) { 738 ATRACE_CALL(); 739 Mutex::Autolock icl(mICameraLock); 740 status_t res; 741 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 742 743 LockedParameters::Key k(mParameters); 744 switch (k.mParameters.state) { 745 case RECORD: 746 case VIDEO_SNAPSHOT: 747 ALOGE("%s: Camera %d: Can't be called in state %s", 748 __FUNCTION__, mCameraId, getStateName(k.mParameters.state)); 749 return INVALID_OPERATION; 750 default: 751 // OK 752 break; 753 } 754 755 k.mParameters.storeMetadataInBuffers = enabled; 756 757 return OK; 758} 759 760status_t Camera2Client::startRecording() { 761 ATRACE_CALL(); 762 ALOGV("%s: E", __FUNCTION__); 763 Mutex::Autolock icl(mICameraLock); 764 status_t res; 765 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 766 LockedParameters::Key k(mParameters); 767 768 return startRecordingL(k.mParameters, false); 769} 770 771status_t Camera2Client::startRecordingL(Parameters ¶ms, bool restart) { 772 status_t res; 773 switch (params.state) { 774 case STOPPED: 775 res = startPreviewL(params, false); 776 if (res != OK) return res; 777 break; 778 case PREVIEW: 779 // Ready to go 780 break; 781 case RECORD: 782 case VIDEO_SNAPSHOT: 783 // OK to call this when recording is already on, just skip unless 784 // we're looking to restart 785 if (!restart) return OK; 786 break; 787 default: 788 ALOGE("%s: Camera %d: Can't start recording in state %s", 789 __FUNCTION__, mCameraId, getStateName(params.state)); 790 return INVALID_OPERATION; 791 }; 792 793 if (!params.storeMetadataInBuffers) { 794 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but " 795 "non-metadata recording mode requested!", __FUNCTION__, 796 mCameraId); 797 return INVALID_OPERATION; 798 } 799 800 res = updateRecordingStream(params); 801 if (res != OK) { 802 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)", 803 __FUNCTION__, mCameraId, strerror(-res), res); 804 return res; 805 } 806 bool callbacksEnabled = params.previewCallbackFlags & 807 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK; 808 if (callbacksEnabled) { 809 res = updateCallbackStream(params); 810 if (res != OK) { 811 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)", 812 __FUNCTION__, mCameraId, strerror(-res), res); 813 return res; 814 } 815 } 816 817 if (mRecordingRequest == NULL) { 818 res = updateRecordingRequest(params); 819 if (res != OK) { 820 ALOGE("%s: Camera %d: Unable to create recording request: %s (%d)", 821 __FUNCTION__, mCameraId, strerror(-res), res); 822 return res; 823 } 824 } 825 826 if (callbacksEnabled) { 827 uint8_t outputStreams[3] = 828 { mPreviewStreamId, mRecordingStreamId, mCallbackStreamId }; 829 res = updateEntry(mRecordingRequest, 830 ANDROID_REQUEST_OUTPUT_STREAMS, 831 outputStreams, 3); 832 } else { 833 uint8_t outputStreams[2] = { mPreviewStreamId, mRecordingStreamId }; 834 res = updateEntry(mRecordingRequest, 835 ANDROID_REQUEST_OUTPUT_STREAMS, 836 outputStreams, 2); 837 } 838 if (res != OK) { 839 ALOGE("%s: Camera %d: Unable to set up recording request: %s (%d)", 840 __FUNCTION__, mCameraId, strerror(-res), res); 841 return res; 842 } 843 res = sort_camera_metadata(mRecordingRequest); 844 if (res != OK) { 845 ALOGE("%s: Camera %d: Error sorting recording request: %s (%d)", 846 __FUNCTION__, mCameraId, strerror(-res), res); 847 return res; 848 } 849 850 res = mDevice->setStreamingRequest(mRecordingRequest); 851 if (res != OK) { 852 ALOGE("%s: Camera %d: Unable to set recording request to start " 853 "recording: %s (%d)", __FUNCTION__, mCameraId, 854 strerror(-res), res); 855 return res; 856 } 857 if (params.state < RECORD) { 858 params.state = RECORD; 859 } 860 861 return OK; 862} 863 864void Camera2Client::stopRecording() { 865 ATRACE_CALL(); 866 ALOGV("%s: E", __FUNCTION__); 867 Mutex::Autolock icl(mICameraLock); 868 LockedParameters::Key k(mParameters); 869 870 status_t res; 871 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 872 873 switch (k.mParameters.state) { 874 case RECORD: 875 // OK to stop 876 break; 877 case STOPPED: 878 case PREVIEW: 879 case STILL_CAPTURE: 880 case VIDEO_SNAPSHOT: 881 default: 882 ALOGE("%s: Camera %d: Can't stop recording in state %s", 883 __FUNCTION__, mCameraId, getStateName(k.mParameters.state)); 884 return; 885 }; 886 887 // Back to preview. Since record can only be reached through preview, 888 // all preview stream setup should be up to date. 889 res = mDevice->setStreamingRequest(mPreviewRequest); 890 if (res != OK) { 891 ALOGE("%s: Camera %d: Unable to switch back to preview request: " 892 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 893 return; 894 } 895 896 // TODO: Should recording heap be freed? Can't do it yet since requests 897 // could still be in flight. 898 899 k.mParameters.state = PREVIEW; 900} 901 902bool Camera2Client::recordingEnabled() { 903 ATRACE_CALL(); 904 Mutex::Autolock icl(mICameraLock); 905 906 if ( checkPid(__FUNCTION__) != OK) return false; 907 908 return recordingEnabledL(); 909} 910 911bool Camera2Client::recordingEnabledL() { 912 ATRACE_CALL(); 913 LockedParameters::Key k(mParameters); 914 915 return (k.mParameters.state == RECORD || k.mParameters.state == VIDEO_SNAPSHOT); 916} 917 918void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) { 919 ATRACE_CALL(); 920 Mutex::Autolock icl(mICameraLock); 921 status_t res; 922 if ( checkPid(__FUNCTION__) != OK) return; 923 924 LockedParameters::Key k(mParameters); 925 926 // Make sure this is for the current heap 927 ssize_t offset; 928 size_t size; 929 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); 930 if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) { 931 ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release " 932 "(got %x, expected %x)", __FUNCTION__, mCameraId, 933 heap->getHeapID(), mRecordingHeap->mHeap->getHeapID()); 934 return; 935 } 936 uint8_t *data = (uint8_t*)heap->getBase() + offset; 937 uint32_t type = *(uint32_t*)data; 938 if (type != kMetadataBufferTypeGrallocSource) { 939 ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)", 940 __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource); 941 return; 942 } 943 944 // Release the buffer back to the recording queue 945 946 buffer_handle_t imgHandle = *(buffer_handle_t*)(data + 4); 947 948 size_t itemIndex; 949 for (itemIndex = 0; itemIndex < mRecordingBuffers.size(); itemIndex++) { 950 const BufferItemConsumer::BufferItem item = mRecordingBuffers[itemIndex]; 951 if (item.mBuf != BufferItemConsumer::INVALID_BUFFER_SLOT && 952 item.mGraphicBuffer->handle == imgHandle) { 953 break; 954 } 955 } 956 if (itemIndex == mRecordingBuffers.size()) { 957 ALOGE("%s: Camera %d: Can't find buffer_handle_t %p in list of " 958 "outstanding buffers", __FUNCTION__, mCameraId, imgHandle); 959 return; 960 } 961 962 ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId, 963 imgHandle); 964 965 res = mRecordingConsumer->releaseBuffer(mRecordingBuffers[itemIndex]); 966 if (res != OK) { 967 ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):" 968 "%s (%d)", 969 __FUNCTION__, mCameraId, imgHandle, strerror(-res), res); 970 return; 971 } 972 mRecordingBuffers.replaceAt(itemIndex); 973 974 mRecordingHeapFree++; 975} 976 977status_t Camera2Client::autoFocus() { 978 ATRACE_CALL(); 979 Mutex::Autolock icl(mICameraLock); 980 status_t res; 981 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 982 983 int triggerId; 984 { 985 LockedParameters::Key k(mParameters); 986 k.mParameters.currentAfTriggerId = ++k.mParameters.afTriggerCounter; 987 triggerId = k.mParameters.currentAfTriggerId; 988 } 989 990 mDevice->triggerAutofocus(triggerId); 991 992 return OK; 993} 994 995status_t Camera2Client::cancelAutoFocus() { 996 ATRACE_CALL(); 997 Mutex::Autolock icl(mICameraLock); 998 status_t res; 999 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1000 1001 int triggerId; 1002 { 1003 LockedParameters::Key k(mParameters); 1004 triggerId = ++k.mParameters.afTriggerCounter; 1005 } 1006 1007 mDevice->triggerCancelAutofocus(triggerId); 1008 1009 return OK; 1010} 1011 1012status_t Camera2Client::takePicture(int msgType) { 1013 ATRACE_CALL(); 1014 Mutex::Autolock icl(mICameraLock); 1015 status_t res; 1016 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1017 1018 LockedParameters::Key k(mParameters); 1019 switch (k.mParameters.state) { 1020 case DISCONNECTED: 1021 case STOPPED: 1022 case WAITING_FOR_PREVIEW_WINDOW: 1023 ALOGE("%s: Camera %d: Cannot take picture without preview enabled", 1024 __FUNCTION__, mCameraId); 1025 return INVALID_OPERATION; 1026 case PREVIEW: 1027 case RECORD: 1028 // Good to go for takePicture 1029 break; 1030 case STILL_CAPTURE: 1031 case VIDEO_SNAPSHOT: 1032 ALOGE("%s: Camera %d: Already taking a picture", 1033 __FUNCTION__, mCameraId); 1034 return INVALID_OPERATION; 1035 } 1036 1037 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId); 1038 1039 res = updateCaptureStream(k.mParameters); 1040 if (res != OK) { 1041 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)", 1042 __FUNCTION__, mCameraId, strerror(-res), res); 1043 return res; 1044 } 1045 1046 if (mCaptureRequest == NULL) { 1047 res = updateCaptureRequest(k.mParameters); 1048 if (res != OK) { 1049 ALOGE("%s: Camera %d: Can't create still image capture request: " 1050 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1051 return res; 1052 } 1053 } 1054 1055 camera_metadata_entry_t outputStreams; 1056 1057 bool callbacksEnabled = k.mParameters.previewCallbackFlags & 1058 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK; 1059 bool recordingEnabled = (k.mParameters.state == RECORD); 1060 1061 int streamSwitch = (callbacksEnabled ? 0x2 : 0x0) + 1062 (recordingEnabled ? 0x1 : 0x0); 1063 switch ( streamSwitch ) { 1064 case 0: { // No recording, callbacks 1065 uint8_t streamIds[2] = { mPreviewStreamId, mCaptureStreamId }; 1066 res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS, 1067 &streamIds, 2); 1068 break; 1069 } 1070 case 1: { // Recording 1071 uint8_t streamIds[3] = { mPreviewStreamId, mRecordingStreamId, 1072 mCaptureStreamId }; 1073 res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS, 1074 &streamIds, 3); 1075 break; 1076 } 1077 case 2: { // Callbacks 1078 uint8_t streamIds[3] = { mPreviewStreamId, mCallbackStreamId, 1079 mCaptureStreamId }; 1080 res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS, 1081 &streamIds, 3); 1082 break; 1083 } 1084 case 3: { // Both 1085 uint8_t streamIds[4] = { mPreviewStreamId, mCallbackStreamId, 1086 mRecordingStreamId, mCaptureStreamId }; 1087 res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS, 1088 &streamIds, 4); 1089 break; 1090 } 1091 }; 1092 if (res != OK) { 1093 ALOGE("%s: Camera %d: Unable to set up still image capture request: " 1094 "%s (%d)", 1095 __FUNCTION__, mCameraId, strerror(-res), res); 1096 return res; 1097 } 1098 res = sort_camera_metadata(mCaptureRequest); 1099 if (res != OK) { 1100 ALOGE("%s: Camera %d: Unable to sort capture request: %s (%d)", 1101 __FUNCTION__, mCameraId, strerror(-res), res); 1102 return res; 1103 } 1104 1105 camera_metadata_t *captureCopy = clone_camera_metadata(mCaptureRequest); 1106 if (captureCopy == NULL) { 1107 ALOGE("%s: Camera %d: Unable to copy capture request for HAL device", 1108 __FUNCTION__, mCameraId); 1109 return NO_MEMORY; 1110 } 1111 1112 if (k.mParameters.state == PREVIEW) { 1113 res = mDevice->setStreamingRequest(NULL); 1114 if (res != OK) { 1115 ALOGE("%s: Camera %d: Unable to stop preview for still capture: " 1116 "%s (%d)", 1117 __FUNCTION__, mCameraId, strerror(-res), res); 1118 return res; 1119 } 1120 } 1121 // TODO: Capture should be atomic with setStreamingRequest here 1122 res = mDevice->capture(captureCopy); 1123 if (res != OK) { 1124 ALOGE("%s: Camera %d: Unable to submit still image capture request: " 1125 "%s (%d)", 1126 __FUNCTION__, mCameraId, strerror(-res), res); 1127 return res; 1128 } 1129 1130 switch (k.mParameters.state) { 1131 case PREVIEW: 1132 k.mParameters.state = STILL_CAPTURE; 1133 res = commandStopFaceDetectionL(k.mParameters); 1134 if (res != OK) { 1135 ALOGE("%s: Camera %d: Unable to stop face detection for still capture", 1136 __FUNCTION__, mCameraId); 1137 return res; 1138 } 1139 break; 1140 case RECORD: 1141 k.mParameters.state = VIDEO_SNAPSHOT; 1142 break; 1143 default: 1144 ALOGE("%s: Camera %d: Unknown state for still capture!", 1145 __FUNCTION__, mCameraId); 1146 return INVALID_OPERATION; 1147 } 1148 1149 return OK; 1150} 1151 1152status_t Camera2Client::setParameters(const String8& params) { 1153 ATRACE_CALL(); 1154 ALOGV("%s: E", __FUNCTION__); 1155 Mutex::Autolock icl(mICameraLock); 1156 status_t res; 1157 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1158 1159 LockedParameters::Key k(mParameters); 1160 1161 CameraParameters newParams(params); 1162 1163 // TODO: Currently ignoring any changes to supposedly read-only 1164 // parameters such as supported preview sizes, etc. Should probably 1165 // produce an error if they're changed. 1166 1167 /** Extract and verify new parameters */ 1168 1169 size_t i; 1170 1171 // PREVIEW_SIZE 1172 int previewWidth, previewHeight; 1173 newParams.getPreviewSize(&previewWidth, &previewHeight); 1174 1175 if (previewWidth != k.mParameters.previewWidth || 1176 previewHeight != k.mParameters.previewHeight) { 1177 if (k.mParameters.state >= PREVIEW) { 1178 ALOGE("%s: Preview size cannot be updated when preview " 1179 "is active! (Currently %d x %d, requested %d x %d", 1180 __FUNCTION__, 1181 k.mParameters.previewWidth, k.mParameters.previewHeight, 1182 previewWidth, previewHeight); 1183 return BAD_VALUE; 1184 } 1185 camera_metadata_entry_t availablePreviewSizes = 1186 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 1187 for (i = 0; i < availablePreviewSizes.count; i += 2 ) { 1188 if (availablePreviewSizes.data.i32[i] == previewWidth && 1189 availablePreviewSizes.data.i32[i+1] == previewHeight) break; 1190 } 1191 if (i == availablePreviewSizes.count) { 1192 ALOGE("%s: Requested preview size %d x %d is not supported", 1193 __FUNCTION__, previewWidth, previewHeight); 1194 return BAD_VALUE; 1195 } 1196 } 1197 1198 // PREVIEW_FPS_RANGE 1199 int previewFpsRange[2]; 1200 int previewFps = 0; 1201 bool fpsRangeChanged = false; 1202 newParams.getPreviewFpsRange(&previewFpsRange[0], &previewFpsRange[1]); 1203 if (previewFpsRange[0] != k.mParameters.previewFpsRange[0] || 1204 previewFpsRange[1] != k.mParameters.previewFpsRange[1]) { 1205 fpsRangeChanged = true; 1206 camera_metadata_entry_t availablePreviewFpsRanges = 1207 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 1208 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) { 1209 if ((availablePreviewFpsRanges.data.i32[i] == 1210 previewFpsRange[0]) && 1211 (availablePreviewFpsRanges.data.i32[i+1] == 1212 previewFpsRange[1]) ) { 1213 break; 1214 } 1215 } 1216 if (i == availablePreviewFpsRanges.count) { 1217 ALOGE("%s: Requested preview FPS range %d - %d is not supported", 1218 __FUNCTION__, previewFpsRange[0], previewFpsRange[1]); 1219 return BAD_VALUE; 1220 } 1221 previewFps = previewFpsRange[0]; 1222 } 1223 1224 // PREVIEW_FORMAT 1225 int previewFormat = formatStringToEnum(newParams.getPreviewFormat()); 1226 if (previewFormat != k.mParameters.previewFormat) { 1227 if (k.mParameters.state >= PREVIEW) { 1228 ALOGE("%s: Preview format cannot be updated when preview " 1229 "is active!", __FUNCTION__); 1230 return BAD_VALUE; 1231 } 1232 camera_metadata_entry_t availableFormats = 1233 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 1234 for (i = 0; i < availableFormats.count; i++) { 1235 if (availableFormats.data.i32[i] == previewFormat) break; 1236 } 1237 if (i == availableFormats.count) { 1238 ALOGE("%s: Requested preview format %s (0x%x) is not supported", 1239 __FUNCTION__, newParams.getPreviewFormat(), previewFormat); 1240 return BAD_VALUE; 1241 } 1242 } 1243 1244 // PREVIEW_FRAME_RATE 1245 // Deprecated, only use if the preview fps range is unchanged this time. 1246 // The single-value FPS is the same as the minimum of the range. 1247 if (!fpsRangeChanged) { 1248 previewFps = newParams.getPreviewFrameRate(); 1249 if (previewFps != k.mParameters.previewFps) { 1250 camera_metadata_entry_t availableFrameRates = 1251 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES); 1252 for (i = 0; i < availableFrameRates.count; i+=2) { 1253 if (availableFrameRates.data.i32[i] == previewFps) break; 1254 } 1255 if (i == availableFrameRates.count) { 1256 ALOGE("%s: Requested preview frame rate %d is not supported", 1257 __FUNCTION__, previewFps); 1258 return BAD_VALUE; 1259 } 1260 previewFpsRange[0] = availableFrameRates.data.i32[i]; 1261 previewFpsRange[1] = availableFrameRates.data.i32[i+1]; 1262 } 1263 } 1264 1265 // PICTURE_SIZE 1266 int pictureWidth, pictureHeight; 1267 newParams.getPictureSize(&pictureWidth, &pictureHeight); 1268 if (pictureWidth == k.mParameters.pictureWidth || 1269 pictureHeight == k.mParameters.pictureHeight) { 1270 camera_metadata_entry_t availablePictureSizes = 1271 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES); 1272 for (i = 0; i < availablePictureSizes.count; i+=2) { 1273 if (availablePictureSizes.data.i32[i] == pictureWidth && 1274 availablePictureSizes.data.i32[i+1] == pictureHeight) break; 1275 } 1276 if (i == availablePictureSizes.count) { 1277 ALOGE("%s: Requested picture size %d x %d is not supported", 1278 __FUNCTION__, pictureWidth, pictureHeight); 1279 return BAD_VALUE; 1280 } 1281 } 1282 1283 // JPEG_THUMBNAIL_WIDTH/HEIGHT 1284 int jpegThumbSize[2]; 1285 jpegThumbSize[0] = 1286 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 1287 jpegThumbSize[1] = 1288 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 1289 if (jpegThumbSize[0] != k.mParameters.jpegThumbSize[0] || 1290 jpegThumbSize[1] != k.mParameters.jpegThumbSize[1]) { 1291 camera_metadata_entry_t availableJpegThumbSizes = 1292 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES); 1293 for (i = 0; i < availableJpegThumbSizes.count; i+=2) { 1294 if (availableJpegThumbSizes.data.i32[i] == jpegThumbSize[0] && 1295 availableJpegThumbSizes.data.i32[i+1] == jpegThumbSize[1]) { 1296 break; 1297 } 1298 } 1299 if (i == availableJpegThumbSizes.count) { 1300 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported", 1301 __FUNCTION__, jpegThumbSize[0], jpegThumbSize[1]); 1302 return BAD_VALUE; 1303 } 1304 } 1305 1306 // JPEG_THUMBNAIL_QUALITY 1307 int jpegThumbQuality = 1308 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 1309 if (jpegThumbQuality < 0 || jpegThumbQuality > 100) { 1310 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported", 1311 __FUNCTION__, jpegThumbQuality); 1312 return BAD_VALUE; 1313 } 1314 1315 // JPEG_QUALITY 1316 int jpegQuality = 1317 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY); 1318 if (jpegQuality < 0 || jpegQuality > 100) { 1319 ALOGE("%s: Requested JPEG quality %d is not supported", 1320 __FUNCTION__, jpegQuality); 1321 return BAD_VALUE; 1322 } 1323 1324 // ROTATION 1325 int jpegRotation = 1326 newParams.getInt(CameraParameters::KEY_ROTATION); 1327 if (jpegRotation != 0 && 1328 jpegRotation != 90 && 1329 jpegRotation != 180 && 1330 jpegRotation != 270) { 1331 ALOGE("%s: Requested picture rotation angle %d is not supported", 1332 __FUNCTION__, jpegRotation); 1333 return BAD_VALUE; 1334 } 1335 1336 // GPS 1337 bool gpsEnabled = false; 1338 double gpsCoordinates[3] = {0,0,0}; 1339 int64_t gpsTimestamp = 0; 1340 String8 gpsProcessingMethod; 1341 const char *gpsLatStr = 1342 newParams.get(CameraParameters::KEY_GPS_LATITUDE); 1343 if (gpsLatStr != NULL) { 1344 const char *gpsLongStr = 1345 newParams.get(CameraParameters::KEY_GPS_LONGITUDE); 1346 const char *gpsAltitudeStr = 1347 newParams.get(CameraParameters::KEY_GPS_ALTITUDE); 1348 const char *gpsTimeStr = 1349 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP); 1350 const char *gpsProcMethodStr = 1351 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 1352 if (gpsLongStr == NULL || 1353 gpsAltitudeStr == NULL || 1354 gpsTimeStr == NULL || 1355 gpsProcMethodStr == NULL) { 1356 ALOGE("%s: Incomplete set of GPS parameters provided", 1357 __FUNCTION__); 1358 return BAD_VALUE; 1359 } 1360 char *endPtr; 1361 errno = 0; 1362 gpsCoordinates[0] = strtod(gpsLatStr, &endPtr); 1363 if (errno || endPtr == gpsLatStr) { 1364 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr); 1365 return BAD_VALUE; 1366 } 1367 errno = 0; 1368 gpsCoordinates[1] = strtod(gpsLongStr, &endPtr); 1369 if (errno || endPtr == gpsLongStr) { 1370 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr); 1371 return BAD_VALUE; 1372 } 1373 errno = 0; 1374 gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr); 1375 if (errno || endPtr == gpsAltitudeStr) { 1376 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__, 1377 gpsAltitudeStr); 1378 return BAD_VALUE; 1379 } 1380 errno = 0; 1381 gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10); 1382 if (errno || endPtr == gpsTimeStr) { 1383 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr); 1384 return BAD_VALUE; 1385 } 1386 gpsProcessingMethod = gpsProcMethodStr; 1387 1388 gpsEnabled = true; 1389 } 1390 1391 // WHITE_BALANCE 1392 int wbMode = wbModeStringToEnum( 1393 newParams.get(CameraParameters::KEY_WHITE_BALANCE) ); 1394 if (wbMode != k.mParameters.wbMode) { 1395 camera_metadata_entry_t availableWbModes = 1396 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 1397 for (i = 0; i < availableWbModes.count; i++) { 1398 if (wbMode == availableWbModes.data.u8[i]) break; 1399 } 1400 if (i == availableWbModes.count) { 1401 ALOGE("%s: Requested white balance mode %s is not supported", 1402 __FUNCTION__, 1403 newParams.get(CameraParameters::KEY_WHITE_BALANCE)); 1404 return BAD_VALUE; 1405 } 1406 } 1407 1408 // EFFECT 1409 int effectMode = effectModeStringToEnum( 1410 newParams.get(CameraParameters::KEY_EFFECT) ); 1411 if (effectMode != k.mParameters.effectMode) { 1412 camera_metadata_entry_t availableEffectModes = 1413 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 1414 for (i = 0; i < availableEffectModes.count; i++) { 1415 if (effectMode == availableEffectModes.data.u8[i]) break; 1416 } 1417 if (i == availableEffectModes.count) { 1418 ALOGE("%s: Requested effect mode \"%s\" is not supported", 1419 __FUNCTION__, 1420 newParams.get(CameraParameters::KEY_EFFECT) ); 1421 return BAD_VALUE; 1422 } 1423 } 1424 1425 // ANTIBANDING 1426 int antibandingMode = abModeStringToEnum( 1427 newParams.get(CameraParameters::KEY_ANTIBANDING) ); 1428 if (antibandingMode != k.mParameters.antibandingMode) { 1429 camera_metadata_entry_t availableAbModes = 1430 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 1431 for (i = 0; i < availableAbModes.count; i++) { 1432 if (antibandingMode == availableAbModes.data.u8[i]) break; 1433 } 1434 if (i == availableAbModes.count) { 1435 ALOGE("%s: Requested antibanding mode \"%s\" is not supported", 1436 __FUNCTION__, 1437 newParams.get(CameraParameters::KEY_ANTIBANDING)); 1438 return BAD_VALUE; 1439 } 1440 } 1441 1442 // SCENE_MODE 1443 int sceneMode = sceneModeStringToEnum( 1444 newParams.get(CameraParameters::KEY_SCENE_MODE) ); 1445 if (sceneMode != k.mParameters.sceneMode && 1446 sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) { 1447 camera_metadata_entry_t availableSceneModes = 1448 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 1449 for (i = 0; i < availableSceneModes.count; i++) { 1450 if (sceneMode == availableSceneModes.data.u8[i]) break; 1451 } 1452 if (i == availableSceneModes.count) { 1453 ALOGE("%s: Requested scene mode \"%s\" is not supported", 1454 __FUNCTION__, 1455 newParams.get(CameraParameters::KEY_SCENE_MODE)); 1456 return BAD_VALUE; 1457 } 1458 } 1459 1460 // FLASH_MODE 1461 Parameters::flashMode_t flashMode = flashModeStringToEnum( 1462 newParams.get(CameraParameters::KEY_FLASH_MODE) ); 1463 if (flashMode != k.mParameters.flashMode) { 1464 camera_metadata_entry_t flashAvailable = 1465 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 1466 if (!flashAvailable.data.u8[0] && 1467 flashMode != Parameters::FLASH_MODE_OFF) { 1468 ALOGE("%s: Requested flash mode \"%s\" is not supported: " 1469 "No flash on device", __FUNCTION__, 1470 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1471 return BAD_VALUE; 1472 } else if (flashMode == Parameters::FLASH_MODE_RED_EYE) { 1473 camera_metadata_entry_t availableAeModes = 1474 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 1475 for (i = 0; i < availableAeModes.count; i++) { 1476 if (flashMode == availableAeModes.data.u8[i]) break; 1477 } 1478 if (i == availableAeModes.count) { 1479 ALOGE("%s: Requested flash mode \"%s\" is not supported", 1480 __FUNCTION__, 1481 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1482 return BAD_VALUE; 1483 } 1484 } else if (flashMode == -1) { 1485 ALOGE("%s: Requested flash mode \"%s\" is unknown", 1486 __FUNCTION__, 1487 newParams.get(CameraParameters::KEY_FLASH_MODE)); 1488 return BAD_VALUE; 1489 } 1490 } 1491 1492 // FOCUS_MODE 1493 Parameters::focusMode_t focusMode = focusModeStringToEnum( 1494 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1495 if (focusMode != k.mParameters.focusMode) { 1496 if (focusMode != Parameters::FOCUS_MODE_FIXED) { 1497 camera_metadata_entry_t minFocusDistance = 1498 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE); 1499 if (minFocusDistance.data.f[0] == 0) { 1500 ALOGE("%s: Requested focus mode \"%s\" is not available: " 1501 "fixed focus lens", 1502 __FUNCTION__, 1503 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1504 return BAD_VALUE; 1505 } else if (focusMode != Parameters::FOCUS_MODE_INFINITY) { 1506 camera_metadata_entry_t availableFocusModes = 1507 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1508 for (i = 0; i < availableFocusModes.count; i++) { 1509 if (focusMode == availableFocusModes.data.u8[i]) break; 1510 } 1511 if (i == availableFocusModes.count) { 1512 ALOGE("%s: Requested focus mode \"%s\" is not supported", 1513 __FUNCTION__, 1514 newParams.get(CameraParameters::KEY_FOCUS_MODE)); 1515 return BAD_VALUE; 1516 } 1517 } 1518 } 1519 } 1520 1521 // FOCUS_AREAS 1522 Vector<Parameters::Area> focusingAreas; 1523 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS), 1524 &focusingAreas); 1525 size_t max3aRegions = 1526 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0]; 1527 if (res == OK) res = validateAreas(focusingAreas, max3aRegions); 1528 if (res != OK) { 1529 ALOGE("%s: Requested focus areas are malformed: %s", 1530 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS)); 1531 return BAD_VALUE; 1532 } 1533 1534 // EXPOSURE_COMPENSATION 1535 int exposureCompensation = 1536 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1537 camera_metadata_entry_t exposureCompensationRange = 1538 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE); 1539 if (exposureCompensation < exposureCompensationRange.data.i32[0] || 1540 exposureCompensation > exposureCompensationRange.data.i32[1]) { 1541 ALOGE("%s: Requested exposure compensation index is out of bounds: %d", 1542 __FUNCTION__, exposureCompensation); 1543 return BAD_VALUE; 1544 } 1545 1546 // AUTO_EXPOSURE_LOCK (always supported) 1547 bool autoExposureLock = boolFromString( 1548 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 1549 1550 // AUTO_WHITEBALANCE_LOCK (always supported) 1551 bool autoWhiteBalanceLock = boolFromString( 1552 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 1553 1554 // METERING_AREAS 1555 Vector<Parameters::Area> meteringAreas; 1556 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS), 1557 &meteringAreas); 1558 if (res == OK) res = validateAreas(focusingAreas, max3aRegions); 1559 if (res != OK) { 1560 ALOGE("%s: Requested metering areas are malformed: %s", 1561 __FUNCTION__, 1562 newParams.get(CameraParameters::KEY_METERING_AREAS)); 1563 return BAD_VALUE; 1564 } 1565 1566 // ZOOM 1567 int zoom = newParams.getInt(CameraParameters::KEY_ZOOM); 1568 if (zoom < 0 || zoom > (int)NUM_ZOOM_STEPS) { 1569 ALOGE("%s: Requested zoom level %d is not supported", 1570 __FUNCTION__, zoom); 1571 return BAD_VALUE; 1572 } 1573 1574 // VIDEO_SIZE 1575 int videoWidth, videoHeight; 1576 newParams.getVideoSize(&videoWidth, &videoHeight); 1577 if (videoWidth != k.mParameters.videoWidth || 1578 videoHeight != k.mParameters.videoHeight) { 1579 if (k.mParameters.state == RECORD) { 1580 ALOGE("%s: Video size cannot be updated when recording is active!", 1581 __FUNCTION__); 1582 return BAD_VALUE; 1583 } 1584 camera_metadata_entry_t availableVideoSizes = 1585 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); 1586 for (i = 0; i < availableVideoSizes.count; i += 2 ) { 1587 if (availableVideoSizes.data.i32[i] == videoWidth && 1588 availableVideoSizes.data.i32[i+1] == videoHeight) break; 1589 } 1590 if (i == availableVideoSizes.count) { 1591 ALOGE("%s: Requested video size %d x %d is not supported", 1592 __FUNCTION__, videoWidth, videoHeight); 1593 return BAD_VALUE; 1594 } 1595 } 1596 1597 // RECORDING_HINT (always supported) 1598 bool recordingHint = boolFromString( 1599 newParams.get(CameraParameters::KEY_RECORDING_HINT) ); 1600 1601 // VIDEO_STABILIZATION 1602 bool videoStabilization = boolFromString( 1603 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) ); 1604 camera_metadata_entry_t availableVideoStabilizationModes = 1605 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 1606 if (videoStabilization && availableVideoStabilizationModes.count == 1) { 1607 ALOGE("%s: Video stabilization not supported", __FUNCTION__); 1608 } 1609 1610 /** Update internal parameters */ 1611 1612 k.mParameters.previewWidth = previewWidth; 1613 k.mParameters.previewHeight = previewHeight; 1614 k.mParameters.previewFpsRange[0] = previewFpsRange[0]; 1615 k.mParameters.previewFpsRange[1] = previewFpsRange[1]; 1616 k.mParameters.previewFps = previewFps; 1617 k.mParameters.previewFormat = previewFormat; 1618 1619 k.mParameters.pictureWidth = pictureWidth; 1620 k.mParameters.pictureHeight = pictureHeight; 1621 1622 k.mParameters.jpegThumbSize[0] = jpegThumbSize[0]; 1623 k.mParameters.jpegThumbSize[1] = jpegThumbSize[1]; 1624 k.mParameters.jpegQuality = jpegQuality; 1625 k.mParameters.jpegThumbQuality = jpegThumbQuality; 1626 1627 k.mParameters.gpsEnabled = gpsEnabled; 1628 k.mParameters.gpsCoordinates[0] = gpsCoordinates[0]; 1629 k.mParameters.gpsCoordinates[1] = gpsCoordinates[1]; 1630 k.mParameters.gpsCoordinates[2] = gpsCoordinates[2]; 1631 k.mParameters.gpsTimestamp = gpsTimestamp; 1632 k.mParameters.gpsProcessingMethod = gpsProcessingMethod; 1633 1634 k.mParameters.wbMode = wbMode; 1635 k.mParameters.effectMode = effectMode; 1636 k.mParameters.antibandingMode = antibandingMode; 1637 k.mParameters.sceneMode = sceneMode; 1638 1639 k.mParameters.flashMode = flashMode; 1640 if (focusMode != k.mParameters.focusMode) { 1641 k.mParameters.currentAfTriggerId = -1; 1642 } 1643 k.mParameters.focusMode = focusMode; 1644 1645 k.mParameters.focusingAreas = focusingAreas; 1646 k.mParameters.exposureCompensation = exposureCompensation; 1647 k.mParameters.autoExposureLock = autoExposureLock; 1648 k.mParameters.autoWhiteBalanceLock = autoWhiteBalanceLock; 1649 k.mParameters.meteringAreas = meteringAreas; 1650 k.mParameters.zoom = zoom; 1651 1652 k.mParameters.videoWidth = videoWidth; 1653 k.mParameters.videoHeight = videoHeight; 1654 1655 k.mParameters.recordingHint = recordingHint; 1656 k.mParameters.videoStabilization = videoStabilization; 1657 1658 k.mParameters.paramsFlattened = params; 1659 1660 res = updateRequests(k.mParameters); 1661 1662 return res; 1663} 1664 1665String8 Camera2Client::getParameters() const { 1666 ATRACE_CALL(); 1667 Mutex::Autolock icl(mICameraLock); 1668 if ( checkPid(__FUNCTION__) != OK) return String8(); 1669 1670 LockedParameters::ReadKey k(mParameters); 1671 1672 // TODO: Deal with focus distances 1673 return k.mParameters.paramsFlattened; 1674} 1675 1676status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { 1677 ATRACE_CALL(); 1678 Mutex::Autolock icl(mICameraLock); 1679 status_t res; 1680 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1681 1682 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId, 1683 cmd, arg1, arg2); 1684 1685 switch (cmd) { 1686 case CAMERA_CMD_START_SMOOTH_ZOOM: 1687 return commandStartSmoothZoomL(); 1688 case CAMERA_CMD_STOP_SMOOTH_ZOOM: 1689 return commandStopSmoothZoomL(); 1690 case CAMERA_CMD_SET_DISPLAY_ORIENTATION: 1691 return commandSetDisplayOrientationL(arg1); 1692 case CAMERA_CMD_ENABLE_SHUTTER_SOUND: 1693 return commandEnableShutterSoundL(arg1 == 1); 1694 case CAMERA_CMD_PLAY_RECORDING_SOUND: 1695 return commandPlayRecordingSoundL(); 1696 case CAMERA_CMD_START_FACE_DETECTION: 1697 return commandStartFaceDetectionL(arg1); 1698 case CAMERA_CMD_STOP_FACE_DETECTION: { 1699 LockedParameters::Key k(mParameters); 1700 return commandStopFaceDetectionL(k.mParameters); 1701 } 1702 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG: 1703 return commandEnableFocusMoveMsgL(arg1 == 1); 1704 case CAMERA_CMD_PING: 1705 return commandPingL(); 1706 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT: 1707 return commandSetVideoBufferCountL(arg1); 1708 default: 1709 ALOGE("%s: Unknown command %d (arguments %d, %d)", 1710 __FUNCTION__, cmd, arg1, arg2); 1711 return BAD_VALUE; 1712 } 1713} 1714 1715status_t Camera2Client::commandStartSmoothZoomL() { 1716 ALOGE("%s: Unimplemented!", __FUNCTION__); 1717 return OK; 1718} 1719 1720status_t Camera2Client::commandStopSmoothZoomL() { 1721 ALOGE("%s: Unimplemented!", __FUNCTION__); 1722 return OK; 1723} 1724 1725status_t Camera2Client::commandSetDisplayOrientationL(int degrees) { 1726 LockedParameters::Key k(mParameters); 1727 int transform = degToTransform(degrees, 1728 mCameraFacing == CAMERA_FACING_FRONT); 1729 if (transform == -1) { 1730 ALOGE("%s: Camera %d: Error setting %d as display orientation value", 1731 __FUNCTION__, mCameraId, degrees); 1732 return BAD_VALUE; 1733 } 1734 if (transform != k.mParameters.previewTransform && 1735 mPreviewStreamId != NO_STREAM) { 1736 mDevice->setStreamTransform(mPreviewStreamId, transform); 1737 } 1738 k.mParameters.previewTransform = transform; 1739 return OK; 1740} 1741 1742status_t Camera2Client::commandEnableShutterSoundL(bool enable) { 1743 LockedParameters::Key k(mParameters); 1744 if (enable) { 1745 k.mParameters.playShutterSound = true; 1746 return OK; 1747 } 1748 1749 // Disabling shutter sound may not be allowed. In that case only 1750 // allow the mediaserver process to disable the sound. 1751 char value[PROPERTY_VALUE_MAX]; 1752 property_get("ro.camera.sound.forced", value, "0"); 1753 if (strncmp(value, "0", 2) != 0) { 1754 // Disabling shutter sound is not allowed. Deny if the current 1755 // process is not mediaserver. 1756 if (getCallingPid() != getpid()) { 1757 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)", 1758 getCallingPid()); 1759 return PERMISSION_DENIED; 1760 } 1761 } 1762 1763 k.mParameters.playShutterSound = false; 1764 return OK; 1765} 1766 1767status_t Camera2Client::commandPlayRecordingSoundL() { 1768 mCameraService->playSound(CameraService::SOUND_RECORDING); 1769 return OK; 1770} 1771 1772status_t Camera2Client::commandStartFaceDetectionL(int type) { 1773 ALOGV("%s: Camera %d: Starting face detection", 1774 __FUNCTION__, mCameraId); 1775 status_t res; 1776 LockedParameters::Key k(mParameters); 1777 switch (k.mParameters.state) { 1778 case DISCONNECTED: 1779 case STOPPED: 1780 case WAITING_FOR_PREVIEW_WINDOW: 1781 case STILL_CAPTURE: 1782 ALOGE("%s: Camera %d: Cannot start face detection without preview active", 1783 __FUNCTION__, mCameraId); 1784 return INVALID_OPERATION; 1785 case PREVIEW: 1786 case RECORD: 1787 case VIDEO_SNAPSHOT: 1788 // Good to go for starting face detect 1789 break; 1790 } 1791 // Ignoring type 1792 if (mDeviceInfo->bestFaceDetectMode == ANDROID_STATS_FACE_DETECTION_OFF) { 1793 ALOGE("%s: Camera %d: Face detection not supported", 1794 __FUNCTION__, mCameraId); 1795 return INVALID_OPERATION; 1796 } 1797 if (k.mParameters.enableFaceDetect) return OK; 1798 1799 k.mParameters.enableFaceDetect = true; 1800 1801 res = updateRequests(k.mParameters); 1802 1803 return res; 1804} 1805 1806status_t Camera2Client::commandStopFaceDetectionL(Parameters ¶ms) { 1807 status_t res = OK; 1808 ALOGV("%s: Camera %d: Stopping face detection", 1809 __FUNCTION__, mCameraId); 1810 1811 if (!params.enableFaceDetect) return OK; 1812 1813 params.enableFaceDetect = false; 1814 1815 if (params.state == PREVIEW || params.state == RECORD || 1816 params.state == VIDEO_SNAPSHOT) { 1817 res = updateRequests(params); 1818 } 1819 1820 return res; 1821} 1822 1823status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) { 1824 LockedParameters::Key k(mParameters); 1825 k.mParameters.enableFocusMoveMessages = enable; 1826 1827 return OK; 1828} 1829 1830status_t Camera2Client::commandPingL() { 1831 // Always ping back if access is proper and device is alive 1832 LockedParameters::Key k(mParameters); 1833 if (k.mParameters.state != DISCONNECTED) { 1834 return OK; 1835 } else { 1836 return NO_INIT; 1837 } 1838} 1839 1840status_t Camera2Client::commandSetVideoBufferCountL(size_t count) { 1841 if (recordingEnabledL()) { 1842 ALOGE("%s: Camera %d: Error setting video buffer count after " 1843 "recording was started", __FUNCTION__, mCameraId); 1844 return INVALID_OPERATION; 1845 } 1846 1847 // 32 is the current upper limit on the video buffer count for BufferQueue 1848 if (count > 32) { 1849 ALOGE("%s: Camera %d: Error setting %d as video buffer count value", 1850 __FUNCTION__, mCameraId, count); 1851 return BAD_VALUE; 1852 } 1853 1854 // Need to reallocate memory for heap 1855 if (mRecordingHeapCount != count) { 1856 if (mRecordingHeap != 0) { 1857 mRecordingHeap.clear(); 1858 mRecordingHeap = NULL; 1859 } 1860 mRecordingHeapCount = count; 1861 } 1862 1863 return OK; 1864} 1865 1866/** Device-related methods */ 1867 1868void Camera2Client::notifyError(int errorCode, int arg1, int arg2) { 1869 ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2); 1870} 1871 1872void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) { 1873 ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__, 1874 frameNumber, timestamp); 1875} 1876 1877void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) { 1878 ALOGV("%s: Autofocus state now %d, last trigger %d", 1879 __FUNCTION__, newState, triggerId); 1880 bool sendCompletedMessage = false; 1881 bool sendMovingMessage = false; 1882 1883 bool success = false; 1884 bool afInMotion = false; 1885 { 1886 LockedParameters::Key k(mParameters); 1887 switch (k.mParameters.focusMode) { 1888 case Parameters::FOCUS_MODE_AUTO: 1889 case Parameters::FOCUS_MODE_MACRO: 1890 // Don't send notifications upstream if they're not for the current AF 1891 // trigger. For example, if cancel was called in between, or if we 1892 // already sent a notification about this AF call. 1893 if (triggerId != k.mParameters.currentAfTriggerId) break; 1894 switch (newState) { 1895 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1896 success = true; 1897 // no break 1898 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1899 sendCompletedMessage = true; 1900 k.mParameters.currentAfTriggerId = -1; 1901 break; 1902 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 1903 // Just starting focusing, ignore 1904 break; 1905 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1906 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1907 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1908 default: 1909 // Unexpected in AUTO/MACRO mode 1910 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d", 1911 __FUNCTION__, newState); 1912 break; 1913 } 1914 break; 1915 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1916 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1917 switch (newState) { 1918 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1919 success = true; 1920 // no break 1921 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1922 // Don't send notifications upstream if they're not for 1923 // the current AF trigger. For example, if cancel was 1924 // called in between, or if we already sent a 1925 // notification about this AF call. 1926 // Send both a 'AF done' callback and a 'AF move' callback 1927 if (triggerId != k.mParameters.currentAfTriggerId) break; 1928 sendCompletedMessage = true; 1929 afInMotion = false; 1930 if (k.mParameters.enableFocusMoveMessages && 1931 k.mParameters.afInMotion) { 1932 sendMovingMessage = true; 1933 } 1934 k.mParameters.currentAfTriggerId = -1; 1935 break; 1936 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1937 // Cancel was called, or we switched state; care if 1938 // currently moving 1939 afInMotion = false; 1940 if (k.mParameters.enableFocusMoveMessages && 1941 k.mParameters.afInMotion) { 1942 sendMovingMessage = true; 1943 } 1944 break; 1945 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1946 // Start passive scan, inform upstream 1947 afInMotion = true; 1948 // no break 1949 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1950 // Stop passive scan, inform upstream 1951 if (k.mParameters.enableFocusMoveMessages) { 1952 sendMovingMessage = true; 1953 } 1954 break; 1955 } 1956 k.mParameters.afInMotion = afInMotion; 1957 break; 1958 case Parameters::FOCUS_MODE_EDOF: 1959 case Parameters::FOCUS_MODE_INFINITY: 1960 case Parameters::FOCUS_MODE_FIXED: 1961 default: 1962 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) { 1963 ALOGE("%s: Unexpected AF state change %d (ID %d) in focus mode %d", 1964 __FUNCTION__, newState, triggerId, k.mParameters.focusMode); 1965 } 1966 } 1967 } 1968 if (sendMovingMessage) { 1969 Mutex::Autolock iccl(mICameraClientLock); 1970 if (mCameraClient != 0) { 1971 mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE, 1972 afInMotion ? 1 : 0, 0); 1973 } 1974 } 1975 if (sendCompletedMessage) { 1976 Mutex::Autolock iccl(mICameraClientLock); 1977 if (mCameraClient != 0) { 1978 mCameraClient->notifyCallback(CAMERA_MSG_FOCUS, success ? 1 : 0, 0); 1979 } 1980 } 1981} 1982 1983void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) { 1984 ALOGV("%s: Autoexposure state now %d, last trigger %d", 1985 __FUNCTION__, newState, triggerId); 1986} 1987 1988void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) { 1989 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d", 1990 __FUNCTION__, newState, triggerId); 1991} 1992 1993void Camera2Client::onNewFrameAvailable() { 1994 status_t res; 1995 camera_metadata_t *frame = NULL; 1996 do { 1997 res = mDevice->getNextFrame(&frame); 1998 if (res != OK) { 1999 ALOGE("%s: Camera %d: Error getting next frame: %s (%d)", 2000 __FUNCTION__, mCameraId, strerror(-res), res); 2001 return; 2002 } 2003 if (frame != NULL) { 2004 camera_metadata_entry_t entry; 2005 res = find_camera_metadata_entry(frame, ANDROID_REQUEST_FRAME_COUNT, 2006 &entry); 2007 if (res != OK) { 2008 ALOGE("%s: Camera %d: Error reading frame number: %s (%d)", 2009 __FUNCTION__, mCameraId, strerror(-res), res); 2010 break; 2011 } 2012 2013 res = processFrameFaceDetect(frame); 2014 if (res != OK) break; 2015 2016 free_camera_metadata(frame); 2017 } 2018 } while (frame != NULL); 2019 2020 if (frame != NULL) { 2021 free_camera_metadata(frame); 2022 } 2023 return; 2024} 2025 2026status_t Camera2Client::processFrameFaceDetect(camera_metadata_t *frame) { 2027 status_t res; 2028 camera_metadata_entry_t entry; 2029 bool enableFaceDetect; 2030 { 2031 LockedParameters::Key k(mParameters); 2032 enableFaceDetect = k.mParameters.enableFaceDetect; 2033 } 2034 res = find_camera_metadata_entry(frame, ANDROID_STATS_FACE_DETECT_MODE, 2035 &entry); 2036 // TODO: Remove this check once things are more compliant. For now, assume that 2037 // if we can't find the face detect mode, then it's probably not working. 2038 if (res == NAME_NOT_FOUND) { 2039 return OK; 2040 } else if (res != OK) { 2041 ALOGE("%s: Camera %d: Error reading face mode: %s (%d)", 2042 __FUNCTION__, mCameraId, strerror(-res), res); 2043 return res; 2044 } 2045 uint8_t faceDetectMode = entry.data.u8[0]; 2046 2047 if (enableFaceDetect && faceDetectMode != ANDROID_STATS_FACE_DETECTION_OFF) { 2048 res = find_camera_metadata_entry(frame, ANDROID_STATS_FACE_RECTANGLES, 2049 &entry); 2050 if (res != OK) { 2051 ALOGE("%s: Camera %d: Error reading face rectangles: %s (%d)", 2052 __FUNCTION__, mCameraId, strerror(-res), res); 2053 return res; 2054 } 2055 camera_frame_metadata metadata; 2056 metadata.number_of_faces = entry.count / 4; 2057 if (metadata.number_of_faces > 2058 mDeviceInfo->maxFaces) { 2059 ALOGE("%s: Camera %d: More faces than expected! (Got %d, max %d)", 2060 __FUNCTION__, mCameraId, 2061 metadata.number_of_faces, mDeviceInfo->maxFaces); 2062 return res; 2063 } 2064 int32_t *faceRects = entry.data.i32; 2065 2066 res = find_camera_metadata_entry(frame, ANDROID_STATS_FACE_SCORES, 2067 &entry); 2068 if (res != OK) { 2069 ALOGE("%s: Camera %d: Error reading face scores: %s (%d)", 2070 __FUNCTION__, mCameraId, strerror(-res), res); 2071 return res; 2072 } 2073 uint8_t *faceScores = entry.data.u8; 2074 2075 int32_t *faceLandmarks = NULL; 2076 int32_t *faceIds = NULL; 2077 2078 if (faceDetectMode == ANDROID_STATS_FACE_DETECTION_FULL) { 2079 res = find_camera_metadata_entry(frame, ANDROID_STATS_FACE_LANDMARKS, 2080 &entry); 2081 if (res != OK) { 2082 ALOGE("%s: Camera %d: Error reading face landmarks: %s (%d)", 2083 __FUNCTION__, mCameraId, strerror(-res), res); 2084 return res; 2085 } 2086 faceLandmarks = entry.data.i32; 2087 2088 res = find_camera_metadata_entry(frame, ANDROID_STATS_FACE_IDS, 2089 &entry); 2090 if (res != OK) { 2091 ALOGE("%s: Camera %d: Error reading face IDs: %s (%d)", 2092 __FUNCTION__, mCameraId, strerror(-res), res); 2093 return res; 2094 } 2095 faceIds = entry.data.i32; 2096 } 2097 2098 Vector<camera_face_t> faces; 2099 faces.setCapacity(metadata.number_of_faces); 2100 2101 for (int i = 0; i < metadata.number_of_faces; i++) { 2102 camera_face_t face; 2103 2104 face.rect[0] = arrayXToNormalized(faceRects[i*4 + 0]); 2105 face.rect[1] = arrayYToNormalized(faceRects[i*4 + 1]); 2106 face.rect[2] = arrayXToNormalized(faceRects[i*4 + 2]); 2107 face.rect[3] = arrayYToNormalized(faceRects[i*4 + 3]); 2108 2109 face.score = faceScores[i]; 2110 if (faceDetectMode == ANDROID_STATS_FACE_DETECTION_FULL) { 2111 face.id = faceIds[i]; 2112 face.left_eye[0] = arrayXToNormalized(faceLandmarks[i*6 + 0]); 2113 face.left_eye[1] = arrayYToNormalized(faceLandmarks[i*6 + 1]); 2114 face.right_eye[0] = arrayXToNormalized(faceLandmarks[i*6 + 2]); 2115 face.right_eye[1] = arrayYToNormalized(faceLandmarks[i*6 + 3]); 2116 face.mouth[0] = arrayXToNormalized(faceLandmarks[i*6 + 4]); 2117 face.mouth[1] = arrayYToNormalized(faceLandmarks[i*6 + 5]); 2118 } else { 2119 face.id = 0; 2120 face.left_eye[0] = face.left_eye[1] = -2000; 2121 face.right_eye[0] = face.right_eye[1] = -2000; 2122 face.mouth[0] = face.mouth[1] = -2000; 2123 } 2124 faces.push_back(face); 2125 } 2126 2127 metadata.faces = faces.editArray(); 2128 { 2129 Mutex::Autolock iccl(mICameraClientLock); 2130 if (mCameraClient != NULL) { 2131 mCameraClient->dataCallback(CAMERA_MSG_PREVIEW_METADATA, 2132 NULL, &metadata); 2133 } 2134 } 2135 } 2136 return OK; 2137} 2138 2139void Camera2Client::onCallbackAvailable() { 2140 ATRACE_CALL(); 2141 status_t res; 2142 ALOGV("%s: Camera %d: Preview callback available", __FUNCTION__, mCameraId); 2143 2144 int callbackHeapId; 2145 sp<Camera2Heap> callbackHeap; 2146 size_t heapIdx; 2147 2148 CpuConsumer::LockedBuffer imgBuffer; 2149 ALOGV("%s: Getting buffer", __FUNCTION__); 2150 res = mCallbackConsumer->lockNextBuffer(&imgBuffer); 2151 if (res != OK) { 2152 ALOGE("%s: Camera %d: Error receiving next callback buffer: " 2153 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 2154 return; 2155 } 2156 2157 { 2158 LockedParameters::Key k(mParameters); 2159 2160 if ( k.mParameters.state != PREVIEW && k.mParameters.state != RECORD 2161 && k.mParameters.state != VIDEO_SNAPSHOT) { 2162 ALOGV("%s: Camera %d: No longer streaming", 2163 __FUNCTION__, mCameraId); 2164 mCallbackConsumer->unlockBuffer(imgBuffer); 2165 return; 2166 } 2167 2168 if (! (k.mParameters.previewCallbackFlags & 2169 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ) { 2170 ALOGV("%s: No longer enabled, dropping", __FUNCTION__); 2171 mCallbackConsumer->unlockBuffer(imgBuffer); 2172 return; 2173 } 2174 if ((k.mParameters.previewCallbackFlags & 2175 CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) && 2176 !k.mParameters.previewCallbackOneShot) { 2177 ALOGV("%s: One shot mode, already sent, dropping", __FUNCTION__); 2178 mCallbackConsumer->unlockBuffer(imgBuffer); 2179 return; 2180 } 2181 2182 if (imgBuffer.format != k.mParameters.previewFormat) { 2183 ALOGE("%s: Camera %d: Unexpected format for callback: " 2184 "%x, expected %x", __FUNCTION__, mCameraId, 2185 imgBuffer.format, k.mParameters.previewFormat); 2186 mCallbackConsumer->unlockBuffer(imgBuffer); 2187 return; 2188 } 2189 2190 size_t bufferSize = calculateBufferSize(imgBuffer.width, imgBuffer.height, 2191 imgBuffer.format, imgBuffer.stride); 2192 size_t currentBufferSize = (mCallbackHeap == 0) ? 2193 0 : (mCallbackHeap->mHeap->getSize() / kCallbackHeapCount); 2194 if (bufferSize != currentBufferSize) { 2195 mCallbackHeap.clear(); 2196 mCallbackHeap = new Camera2Heap(bufferSize, kCallbackHeapCount, 2197 "Camera2Client::CallbackHeap"); 2198 if (mCallbackHeap->mHeap->getSize() == 0) { 2199 ALOGE("%s: Camera %d: Unable to allocate memory for callbacks", 2200 __FUNCTION__, mCameraId); 2201 mCallbackConsumer->unlockBuffer(imgBuffer); 2202 return; 2203 } 2204 2205 mCallbackHeapHead = 0; 2206 mCallbackHeapFree = kCallbackHeapCount; 2207 mCallbackHeapId++; 2208 } 2209 2210 if (mCallbackHeapFree == 0) { 2211 ALOGE("%s: Camera %d: No free callback buffers, dropping frame", 2212 __FUNCTION__, mCameraId); 2213 mCallbackConsumer->unlockBuffer(imgBuffer); 2214 return; 2215 } 2216 heapIdx = mCallbackHeapHead; 2217 callbackHeap = mCallbackHeap; 2218 callbackHeapId = mCallbackHeapId; 2219 2220 mCallbackHeapHead = (mCallbackHeapHead + 1) & kCallbackHeapCount; 2221 mCallbackHeapFree--; 2222 2223 // TODO: Get rid of this memcpy by passing the gralloc queue all the way 2224 // to app 2225 2226 ssize_t offset; 2227 size_t size; 2228 sp<IMemoryHeap> heap = 2229 mCallbackHeap->mBuffers[heapIdx]->getMemory(&offset, 2230 &size); 2231 uint8_t *data = (uint8_t*)heap->getBase() + offset; 2232 memcpy(data, imgBuffer.data, bufferSize); 2233 2234 ALOGV("%s: Freeing buffer", __FUNCTION__); 2235 mCallbackConsumer->unlockBuffer(imgBuffer); 2236 2237 // In one-shot mode, stop sending callbacks after the first one 2238 if (k.mParameters.previewCallbackFlags & 2239 CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) { 2240 ALOGV("%s: clearing oneshot", __FUNCTION__); 2241 k.mParameters.previewCallbackOneShot = false; 2242 } 2243 } 2244 2245 // Call outside parameter lock to allow re-entrancy from notification 2246 { 2247 Mutex::Autolock iccl(mICameraClientLock); 2248 if (mCameraClient != 0) { 2249 ALOGV("%s: Camera %d: Invoking client data callback", 2250 __FUNCTION__, mCameraId); 2251 mCameraClient->dataCallback(CAMERA_MSG_PREVIEW_FRAME, 2252 callbackHeap->mBuffers[heapIdx], NULL); 2253 } 2254 } 2255 2256 LockedParameters::Key k(mParameters); 2257 // Only increment free if we're still using the same heap 2258 if (mCallbackHeapId == callbackHeapId) { 2259 mCallbackHeapFree++; 2260 } 2261 2262 ALOGV("%s: exit", __FUNCTION__); 2263} 2264 2265void Camera2Client::onCaptureAvailable() { 2266 ATRACE_CALL(); 2267 status_t res; 2268 sp<Camera2Heap> captureHeap; 2269 ALOGV("%s: Camera %d: Still capture available", __FUNCTION__, mCameraId); 2270 2271 { 2272 LockedParameters::Key k(mParameters); 2273 CpuConsumer::LockedBuffer imgBuffer; 2274 2275 res = mCaptureConsumer->lockNextBuffer(&imgBuffer); 2276 if (res != OK) { 2277 ALOGE("%s: Camera %d: Error receiving still image buffer: %s (%d)", 2278 __FUNCTION__, mCameraId, strerror(-res), res); 2279 return; 2280 } 2281 2282 // TODO: Signal errors here upstream 2283 if (k.mParameters.state != STILL_CAPTURE && 2284 k.mParameters.state != VIDEO_SNAPSHOT) { 2285 ALOGE("%s: Camera %d: Still image produced unexpectedly!", 2286 __FUNCTION__, mCameraId); 2287 mCaptureConsumer->unlockBuffer(imgBuffer); 2288 return; 2289 } 2290 2291 if (imgBuffer.format != HAL_PIXEL_FORMAT_BLOB) { 2292 ALOGE("%s: Camera %d: Unexpected format for still image: " 2293 "%x, expected %x", __FUNCTION__, mCameraId, 2294 imgBuffer.format, 2295 HAL_PIXEL_FORMAT_BLOB); 2296 mCaptureConsumer->unlockBuffer(imgBuffer); 2297 return; 2298 } 2299 2300 // TODO: Optimize this to avoid memcopy 2301 void* captureMemory = mCaptureHeap->mHeap->getBase(); 2302 size_t size = mCaptureHeap->mHeap->getSize(); 2303 memcpy(captureMemory, imgBuffer.data, size); 2304 2305 mCaptureConsumer->unlockBuffer(imgBuffer); 2306 2307 switch (k.mParameters.state) { 2308 case STILL_CAPTURE: 2309 k.mParameters.state = STOPPED; 2310 break; 2311 case VIDEO_SNAPSHOT: 2312 k.mParameters.state = RECORD; 2313 break; 2314 default: 2315 ALOGE("%s: Camera %d: Unexpected state %d", __FUNCTION__, 2316 mCameraId, k.mParameters.state); 2317 break; 2318 } 2319 2320 captureHeap = mCaptureHeap; 2321 } 2322 // Call outside parameter locks to allow re-entrancy from notification 2323 Mutex::Autolock iccl(mICameraClientLock); 2324 if (mCameraClient != 0) { 2325 mCameraClient->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, 2326 captureHeap->mBuffers[0], NULL); 2327 } 2328} 2329 2330void Camera2Client::onRecordingFrameAvailable() { 2331 ATRACE_CALL(); 2332 status_t res; 2333 sp<Camera2Heap> recordingHeap; 2334 size_t heapIdx = 0; 2335 nsecs_t timestamp; 2336 { 2337 LockedParameters::Key k(mParameters); 2338 2339 BufferItemConsumer::BufferItem imgBuffer; 2340 res = mRecordingConsumer->acquireBuffer(&imgBuffer); 2341 if (res != OK) { 2342 ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)", 2343 __FUNCTION__, mCameraId, strerror(-res), res); 2344 return; 2345 } 2346 timestamp = imgBuffer.mTimestamp; 2347 2348 mRecordingFrameCount++; 2349 ALOGV("OnRecordingFrame: Frame %d", mRecordingFrameCount); 2350 2351 // TODO: Signal errors here upstream 2352 if (k.mParameters.state != RECORD && 2353 k.mParameters.state != VIDEO_SNAPSHOT) { 2354 ALOGV("%s: Camera %d: Discarding recording image buffers received after " 2355 "recording done", 2356 __FUNCTION__, mCameraId); 2357 mRecordingConsumer->releaseBuffer(imgBuffer); 2358 return; 2359 } 2360 2361 if (mRecordingHeap == 0) { 2362 const size_t bufferSize = 4 + sizeof(buffer_handle_t); 2363 ALOGV("%s: Camera %d: Creating recording heap with %d buffers of " 2364 "size %d bytes", __FUNCTION__, mCameraId, 2365 mRecordingHeapCount, bufferSize); 2366 2367 mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount, 2368 "Camera2Client::RecordingHeap"); 2369 if (mRecordingHeap->mHeap->getSize() == 0) { 2370 ALOGE("%s: Camera %d: Unable to allocate memory for recording", 2371 __FUNCTION__, mCameraId); 2372 mRecordingConsumer->releaseBuffer(imgBuffer); 2373 return; 2374 } 2375 for (size_t i = 0; i < mRecordingBuffers.size(); i++) { 2376 if (mRecordingBuffers[i].mBuf != 2377 BufferItemConsumer::INVALID_BUFFER_SLOT) { 2378 ALOGE("%s: Camera %d: Non-empty recording buffers list!", 2379 __FUNCTION__, mCameraId); 2380 } 2381 } 2382 mRecordingBuffers.clear(); 2383 mRecordingBuffers.setCapacity(mRecordingHeapCount); 2384 mRecordingBuffers.insertAt(0, mRecordingHeapCount); 2385 2386 mRecordingHeapHead = 0; 2387 mRecordingHeapFree = mRecordingHeapCount; 2388 } 2389 2390 if ( mRecordingHeapFree == 0) { 2391 ALOGE("%s: Camera %d: No free recording buffers, dropping frame", 2392 __FUNCTION__, mCameraId); 2393 mRecordingConsumer->releaseBuffer(imgBuffer); 2394 return; 2395 } 2396 2397 heapIdx = mRecordingHeapHead; 2398 mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount; 2399 mRecordingHeapFree--; 2400 2401 ALOGV("%s: Camera %d: Timestamp %lld", 2402 __FUNCTION__, mCameraId, timestamp); 2403 2404 ssize_t offset; 2405 size_t size; 2406 sp<IMemoryHeap> heap = 2407 mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset, 2408 &size); 2409 2410 uint8_t *data = (uint8_t*)heap->getBase() + offset; 2411 uint32_t type = kMetadataBufferTypeGrallocSource; 2412 *((uint32_t*)data) = type; 2413 *((buffer_handle_t*)(data + 4)) = imgBuffer.mGraphicBuffer->handle; 2414 ALOGV("%s: Camera %d: Sending out buffer_handle_t %p", 2415 __FUNCTION__, mCameraId, imgBuffer.mGraphicBuffer->handle); 2416 mRecordingBuffers.replaceAt(imgBuffer, heapIdx); 2417 recordingHeap = mRecordingHeap; 2418 } 2419 2420 // Call outside locked parameters to allow re-entrancy from notification 2421 Mutex::Autolock iccl(mICameraClientLock); 2422 if (mCameraClient != 0) { 2423 mCameraClient->dataCallbackTimestamp(timestamp, 2424 CAMERA_MSG_VIDEO_FRAME, 2425 recordingHeap->mBuffers[heapIdx]); 2426 } 2427} 2428 2429camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag, 2430 size_t minCount, size_t maxCount) { 2431 status_t res; 2432 camera_metadata_entry_t entry; 2433 res = find_camera_metadata_entry(mDevice->info(), 2434 tag, 2435 &entry); 2436 if (CC_UNLIKELY( res != OK )) { 2437 const char* tagSection = get_camera_metadata_section_name(tag); 2438 if (tagSection == NULL) tagSection = "<unknown>"; 2439 const char* tagName = get_camera_metadata_tag_name(tag); 2440 if (tagName == NULL) tagName = "<unknown>"; 2441 2442 ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)", 2443 tagSection, tagName, tag, strerror(-res), res); 2444 entry.count = 0; 2445 entry.data.u8 = NULL; 2446 } else if (CC_UNLIKELY( 2447 (minCount != 0 && entry.count < minCount) || 2448 (maxCount != 0 && entry.count > maxCount) ) ) { 2449 const char* tagSection = get_camera_metadata_section_name(tag); 2450 if (tagSection == NULL) tagSection = "<unknown>"; 2451 const char* tagName = get_camera_metadata_tag_name(tag); 2452 if (tagName == NULL) tagName = "<unknown>"; 2453 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 2454 "Expected between %d and %d values, but got %d values", 2455 tagSection, tagName, tag, minCount, maxCount, entry.count); 2456 entry.count = 0; 2457 entry.data.u8 = NULL; 2458 } 2459 2460 return entry; 2461} 2462 2463/** Utility methods */ 2464 2465status_t Camera2Client::buildDeviceInfo() { 2466 if (mDeviceInfo != NULL) { 2467 delete mDeviceInfo; 2468 } 2469 DeviceInfo *deviceInfo = new DeviceInfo; 2470 mDeviceInfo = deviceInfo; 2471 2472 camera_metadata_entry_t activeArraySize = 2473 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2); 2474 if (!activeArraySize.count) return NO_INIT; 2475 deviceInfo->arrayWidth = activeArraySize.data.i32[0]; 2476 deviceInfo->arrayHeight = activeArraySize.data.i32[1]; 2477 2478 camera_metadata_entry_t availableFaceDetectModes = 2479 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES); 2480 if (!availableFaceDetectModes.count) return NO_INIT; 2481 2482 deviceInfo->bestFaceDetectMode = 2483 ANDROID_STATS_FACE_DETECTION_OFF; 2484 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) { 2485 switch (availableFaceDetectModes.data.u8[i]) { 2486 case ANDROID_STATS_FACE_DETECTION_OFF: 2487 break; 2488 case ANDROID_STATS_FACE_DETECTION_SIMPLE: 2489 if (deviceInfo->bestFaceDetectMode != 2490 ANDROID_STATS_FACE_DETECTION_FULL) { 2491 deviceInfo->bestFaceDetectMode = 2492 ANDROID_STATS_FACE_DETECTION_SIMPLE; 2493 } 2494 break; 2495 case ANDROID_STATS_FACE_DETECTION_FULL: 2496 deviceInfo->bestFaceDetectMode = 2497 ANDROID_STATS_FACE_DETECTION_FULL; 2498 break; 2499 default: 2500 ALOGE("%s: Camera %d: Unknown face detect mode %d:", 2501 __FUNCTION__, mCameraId, 2502 availableFaceDetectModes.data.u8[i]); 2503 return NO_INIT; 2504 } 2505 } 2506 2507 camera_metadata_entry_t maxFacesDetected = 2508 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1); 2509 if (!maxFacesDetected.count) return NO_INIT; 2510 2511 deviceInfo->maxFaces = maxFacesDetected.data.i32[0]; 2512 2513 return OK; 2514} 2515 2516status_t Camera2Client::buildDefaultParameters() { 2517 ATRACE_CALL(); 2518 LockedParameters::Key k(mParameters); 2519 2520 status_t res; 2521 CameraParameters params; 2522 2523 camera_metadata_entry_t availableProcessedSizes = 2524 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2); 2525 if (!availableProcessedSizes.count) return NO_INIT; 2526 2527 // TODO: Pick more intelligently 2528 k.mParameters.previewWidth = availableProcessedSizes.data.i32[0]; 2529 k.mParameters.previewHeight = availableProcessedSizes.data.i32[1]; 2530 k.mParameters.videoWidth = k.mParameters.previewWidth; 2531 k.mParameters.videoHeight = k.mParameters.previewHeight; 2532 2533 params.setPreviewSize(k.mParameters.previewWidth, k.mParameters.previewHeight); 2534 params.setVideoSize(k.mParameters.videoWidth, k.mParameters.videoHeight); 2535 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, 2536 String8::format("%dx%d", 2537 k.mParameters.previewWidth, k.mParameters.previewHeight)); 2538 { 2539 String8 supportedPreviewSizes; 2540 for (size_t i=0; i < availableProcessedSizes.count; i += 2) { 2541 if (i != 0) supportedPreviewSizes += ","; 2542 supportedPreviewSizes += String8::format("%dx%d", 2543 availableProcessedSizes.data.i32[i], 2544 availableProcessedSizes.data.i32[i+1]); 2545 } 2546 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 2547 supportedPreviewSizes); 2548 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, 2549 supportedPreviewSizes); 2550 } 2551 2552 camera_metadata_entry_t availableFpsRanges = 2553 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 2554 if (!availableFpsRanges.count) return NO_INIT; 2555 2556 k.mParameters.previewFpsRange[0] = availableFpsRanges.data.i32[0]; 2557 k.mParameters.previewFpsRange[1] = availableFpsRanges.data.i32[1]; 2558 2559 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 2560 String8::format("%d,%d", 2561 k.mParameters.previewFpsRange[0], 2562 k.mParameters.previewFpsRange[1])); 2563 2564 { 2565 String8 supportedPreviewFpsRange; 2566 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 2567 if (i != 0) supportedPreviewFpsRange += ","; 2568 supportedPreviewFpsRange += String8::format("(%d,%d)", 2569 availableFpsRanges.data.i32[i], 2570 availableFpsRanges.data.i32[i+1]); 2571 } 2572 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 2573 supportedPreviewFpsRange); 2574 } 2575 2576 k.mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 2577 params.set(CameraParameters::KEY_PREVIEW_FORMAT, 2578 formatEnumToString(k.mParameters.previewFormat)); // NV21 2579 2580 k.mParameters.previewTransform = degToTransform(0, 2581 mCameraFacing == CAMERA_FACING_FRONT); 2582 2583 camera_metadata_entry_t availableFormats = 2584 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 2585 2586 { 2587 String8 supportedPreviewFormats; 2588 bool addComma = false; 2589 for (size_t i=0; i < availableFormats.count; i++) { 2590 if (addComma) supportedPreviewFormats += ","; 2591 addComma = true; 2592 switch (availableFormats.data.i32[i]) { 2593 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 2594 supportedPreviewFormats += 2595 CameraParameters::PIXEL_FORMAT_YUV422SP; 2596 break; 2597 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 2598 supportedPreviewFormats += 2599 CameraParameters::PIXEL_FORMAT_YUV420SP; 2600 break; 2601 case HAL_PIXEL_FORMAT_YCbCr_422_I: 2602 supportedPreviewFormats += 2603 CameraParameters::PIXEL_FORMAT_YUV422I; 2604 break; 2605 case HAL_PIXEL_FORMAT_YV12: 2606 supportedPreviewFormats += 2607 CameraParameters::PIXEL_FORMAT_YUV420P; 2608 break; 2609 case HAL_PIXEL_FORMAT_RGB_565: 2610 supportedPreviewFormats += 2611 CameraParameters::PIXEL_FORMAT_RGB565; 2612 break; 2613 case HAL_PIXEL_FORMAT_RGBA_8888: 2614 supportedPreviewFormats += 2615 CameraParameters::PIXEL_FORMAT_RGBA8888; 2616 break; 2617 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats 2618 case HAL_PIXEL_FORMAT_RAW_SENSOR: 2619 case HAL_PIXEL_FORMAT_BLOB: 2620 addComma = false; 2621 break; 2622 2623 default: 2624 ALOGW("%s: Camera %d: Unknown preview format: %x", 2625 __FUNCTION__, mCameraId, availableFormats.data.i32[i]); 2626 addComma = false; 2627 break; 2628 } 2629 } 2630 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 2631 supportedPreviewFormats); 2632 } 2633 2634 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but 2635 // still have to do something sane for them 2636 2637 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE, 2638 k.mParameters.previewFpsRange[0]); 2639 2640 { 2641 String8 supportedPreviewFrameRates; 2642 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 2643 if (i != 0) supportedPreviewFrameRates += ","; 2644 supportedPreviewFrameRates += String8::format("%d", 2645 availableFpsRanges.data.i32[i]); 2646 } 2647 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 2648 supportedPreviewFrameRates); 2649 } 2650 2651 camera_metadata_entry_t availableJpegSizes = 2652 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2); 2653 if (!availableJpegSizes.count) return NO_INIT; 2654 2655 // TODO: Pick maximum 2656 k.mParameters.pictureWidth = availableJpegSizes.data.i32[0]; 2657 k.mParameters.pictureHeight = availableJpegSizes.data.i32[1]; 2658 2659 params.setPictureSize(k.mParameters.pictureWidth, 2660 k.mParameters.pictureHeight); 2661 2662 { 2663 String8 supportedPictureSizes; 2664 for (size_t i=0; i < availableJpegSizes.count; i += 2) { 2665 if (i != 0) supportedPictureSizes += ","; 2666 supportedPictureSizes += String8::format("%dx%d", 2667 availableJpegSizes.data.i32[i], 2668 availableJpegSizes.data.i32[i+1]); 2669 } 2670 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 2671 supportedPictureSizes); 2672 } 2673 2674 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 2675 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 2676 CameraParameters::PIXEL_FORMAT_JPEG); 2677 2678 camera_metadata_entry_t availableJpegThumbnailSizes = 2679 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2); 2680 if (!availableJpegThumbnailSizes.count) return NO_INIT; 2681 2682 // TODO: Pick default thumbnail size sensibly 2683 k.mParameters.jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0]; 2684 k.mParameters.jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1]; 2685 2686 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 2687 k.mParameters.jpegThumbSize[0]); 2688 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 2689 k.mParameters.jpegThumbSize[1]); 2690 2691 { 2692 String8 supportedJpegThumbSizes; 2693 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) { 2694 if (i != 0) supportedJpegThumbSizes += ","; 2695 supportedJpegThumbSizes += String8::format("%dx%d", 2696 availableJpegThumbnailSizes.data.i32[i], 2697 availableJpegThumbnailSizes.data.i32[i+1]); 2698 } 2699 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 2700 supportedJpegThumbSizes); 2701 } 2702 2703 k.mParameters.jpegThumbQuality = 90; 2704 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 2705 k.mParameters.jpegThumbQuality); 2706 k.mParameters.jpegQuality = 90; 2707 params.set(CameraParameters::KEY_JPEG_QUALITY, 2708 k.mParameters.jpegQuality); 2709 k.mParameters.jpegRotation = 0; 2710 params.set(CameraParameters::KEY_ROTATION, 2711 k.mParameters.jpegRotation); 2712 2713 k.mParameters.gpsEnabled = false; 2714 k.mParameters.gpsProcessingMethod = "unknown"; 2715 // GPS fields in CameraParameters are not set by implementation 2716 2717 k.mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO; 2718 params.set(CameraParameters::KEY_WHITE_BALANCE, 2719 CameraParameters::WHITE_BALANCE_AUTO); 2720 2721 camera_metadata_entry_t availableWhiteBalanceModes = 2722 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 2723 { 2724 String8 supportedWhiteBalance; 2725 bool addComma = false; 2726 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) { 2727 if (addComma) supportedWhiteBalance += ","; 2728 addComma = true; 2729 switch (availableWhiteBalanceModes.data.u8[i]) { 2730 case ANDROID_CONTROL_AWB_AUTO: 2731 supportedWhiteBalance += 2732 CameraParameters::WHITE_BALANCE_AUTO; 2733 break; 2734 case ANDROID_CONTROL_AWB_INCANDESCENT: 2735 supportedWhiteBalance += 2736 CameraParameters::WHITE_BALANCE_INCANDESCENT; 2737 break; 2738 case ANDROID_CONTROL_AWB_FLUORESCENT: 2739 supportedWhiteBalance += 2740 CameraParameters::WHITE_BALANCE_FLUORESCENT; 2741 break; 2742 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT: 2743 supportedWhiteBalance += 2744 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT; 2745 break; 2746 case ANDROID_CONTROL_AWB_DAYLIGHT: 2747 supportedWhiteBalance += 2748 CameraParameters::WHITE_BALANCE_DAYLIGHT; 2749 break; 2750 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT: 2751 supportedWhiteBalance += 2752 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT; 2753 break; 2754 case ANDROID_CONTROL_AWB_TWILIGHT: 2755 supportedWhiteBalance += 2756 CameraParameters::WHITE_BALANCE_TWILIGHT; 2757 break; 2758 case ANDROID_CONTROL_AWB_SHADE: 2759 supportedWhiteBalance += 2760 CameraParameters::WHITE_BALANCE_SHADE; 2761 break; 2762 // Skipping values not mappable to v1 API 2763 case ANDROID_CONTROL_AWB_OFF: 2764 addComma = false; 2765 break; 2766 default: 2767 ALOGW("%s: Camera %d: Unknown white balance value: %d", 2768 __FUNCTION__, mCameraId, 2769 availableWhiteBalanceModes.data.u8[i]); 2770 addComma = false; 2771 break; 2772 } 2773 } 2774 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 2775 supportedWhiteBalance); 2776 } 2777 2778 k.mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF; 2779 params.set(CameraParameters::KEY_EFFECT, 2780 CameraParameters::EFFECT_NONE); 2781 2782 camera_metadata_entry_t availableEffects = 2783 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 2784 if (!availableEffects.count) return NO_INIT; 2785 { 2786 String8 supportedEffects; 2787 bool addComma = false; 2788 for (size_t i=0; i < availableEffects.count; i++) { 2789 if (addComma) supportedEffects += ","; 2790 addComma = true; 2791 switch (availableEffects.data.u8[i]) { 2792 case ANDROID_CONTROL_EFFECT_OFF: 2793 supportedEffects += 2794 CameraParameters::EFFECT_NONE; 2795 break; 2796 case ANDROID_CONTROL_EFFECT_MONO: 2797 supportedEffects += 2798 CameraParameters::EFFECT_MONO; 2799 break; 2800 case ANDROID_CONTROL_EFFECT_NEGATIVE: 2801 supportedEffects += 2802 CameraParameters::EFFECT_NEGATIVE; 2803 break; 2804 case ANDROID_CONTROL_EFFECT_SOLARIZE: 2805 supportedEffects += 2806 CameraParameters::EFFECT_SOLARIZE; 2807 break; 2808 case ANDROID_CONTROL_EFFECT_SEPIA: 2809 supportedEffects += 2810 CameraParameters::EFFECT_SEPIA; 2811 break; 2812 case ANDROID_CONTROL_EFFECT_POSTERIZE: 2813 supportedEffects += 2814 CameraParameters::EFFECT_POSTERIZE; 2815 break; 2816 case ANDROID_CONTROL_EFFECT_WHITEBOARD: 2817 supportedEffects += 2818 CameraParameters::EFFECT_WHITEBOARD; 2819 break; 2820 case ANDROID_CONTROL_EFFECT_BLACKBOARD: 2821 supportedEffects += 2822 CameraParameters::EFFECT_BLACKBOARD; 2823 break; 2824 case ANDROID_CONTROL_EFFECT_AQUA: 2825 supportedEffects += 2826 CameraParameters::EFFECT_AQUA; 2827 break; 2828 default: 2829 ALOGW("%s: Camera %d: Unknown effect value: %d", 2830 __FUNCTION__, mCameraId, availableEffects.data.u8[i]); 2831 addComma = false; 2832 break; 2833 } 2834 } 2835 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects); 2836 } 2837 2838 k.mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO; 2839 params.set(CameraParameters::KEY_ANTIBANDING, 2840 CameraParameters::ANTIBANDING_AUTO); 2841 2842 camera_metadata_entry_t availableAntibandingModes = 2843 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 2844 if (!availableAntibandingModes.count) return NO_INIT; 2845 { 2846 String8 supportedAntibanding; 2847 bool addComma = false; 2848 for (size_t i=0; i < availableAntibandingModes.count; i++) { 2849 if (addComma) supportedAntibanding += ","; 2850 addComma = true; 2851 switch (availableAntibandingModes.data.u8[i]) { 2852 case ANDROID_CONTROL_AE_ANTIBANDING_OFF: 2853 supportedAntibanding += 2854 CameraParameters::ANTIBANDING_OFF; 2855 break; 2856 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ: 2857 supportedAntibanding += 2858 CameraParameters::ANTIBANDING_50HZ; 2859 break; 2860 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ: 2861 supportedAntibanding += 2862 CameraParameters::ANTIBANDING_60HZ; 2863 break; 2864 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO: 2865 supportedAntibanding += 2866 CameraParameters::ANTIBANDING_AUTO; 2867 break; 2868 default: 2869 ALOGW("%s: Camera %d: Unknown antibanding value: %d", 2870 __FUNCTION__, mCameraId, 2871 availableAntibandingModes.data.u8[i]); 2872 addComma = false; 2873 break; 2874 } 2875 } 2876 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 2877 supportedAntibanding); 2878 } 2879 2880 k.mParameters.sceneMode = ANDROID_CONTROL_OFF; 2881 params.set(CameraParameters::KEY_SCENE_MODE, 2882 CameraParameters::SCENE_MODE_AUTO); 2883 2884 camera_metadata_entry_t availableSceneModes = 2885 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 2886 if (!availableSceneModes.count) return NO_INIT; 2887 { 2888 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO); 2889 bool addComma = true; 2890 bool noSceneModes = false; 2891 for (size_t i=0; i < availableSceneModes.count; i++) { 2892 if (addComma) supportedSceneModes += ","; 2893 addComma = true; 2894 switch (availableSceneModes.data.u8[i]) { 2895 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 2896 noSceneModes = true; 2897 break; 2898 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 2899 // Not in old API 2900 addComma = false; 2901 break; 2902 case ANDROID_CONTROL_SCENE_MODE_ACTION: 2903 supportedSceneModes += 2904 CameraParameters::SCENE_MODE_ACTION; 2905 break; 2906 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT: 2907 supportedSceneModes += 2908 CameraParameters::SCENE_MODE_PORTRAIT; 2909 break; 2910 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE: 2911 supportedSceneModes += 2912 CameraParameters::SCENE_MODE_LANDSCAPE; 2913 break; 2914 case ANDROID_CONTROL_SCENE_MODE_NIGHT: 2915 supportedSceneModes += 2916 CameraParameters::SCENE_MODE_NIGHT; 2917 break; 2918 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT: 2919 supportedSceneModes += 2920 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT; 2921 break; 2922 case ANDROID_CONTROL_SCENE_MODE_THEATRE: 2923 supportedSceneModes += 2924 CameraParameters::SCENE_MODE_THEATRE; 2925 break; 2926 case ANDROID_CONTROL_SCENE_MODE_BEACH: 2927 supportedSceneModes += 2928 CameraParameters::SCENE_MODE_BEACH; 2929 break; 2930 case ANDROID_CONTROL_SCENE_MODE_SNOW: 2931 supportedSceneModes += 2932 CameraParameters::SCENE_MODE_SNOW; 2933 break; 2934 case ANDROID_CONTROL_SCENE_MODE_SUNSET: 2935 supportedSceneModes += 2936 CameraParameters::SCENE_MODE_SUNSET; 2937 break; 2938 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO: 2939 supportedSceneModes += 2940 CameraParameters::SCENE_MODE_STEADYPHOTO; 2941 break; 2942 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS: 2943 supportedSceneModes += 2944 CameraParameters::SCENE_MODE_FIREWORKS; 2945 break; 2946 case ANDROID_CONTROL_SCENE_MODE_SPORTS: 2947 supportedSceneModes += 2948 CameraParameters::SCENE_MODE_SPORTS; 2949 break; 2950 case ANDROID_CONTROL_SCENE_MODE_PARTY: 2951 supportedSceneModes += 2952 CameraParameters::SCENE_MODE_PARTY; 2953 break; 2954 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT: 2955 supportedSceneModes += 2956 CameraParameters::SCENE_MODE_CANDLELIGHT; 2957 break; 2958 case ANDROID_CONTROL_SCENE_MODE_BARCODE: 2959 supportedSceneModes += 2960 CameraParameters::SCENE_MODE_BARCODE; 2961 break; 2962 default: 2963 ALOGW("%s: Camera %d: Unknown scene mode value: %d", 2964 __FUNCTION__, mCameraId, 2965 availableSceneModes.data.u8[i]); 2966 addComma = false; 2967 break; 2968 } 2969 } 2970 if (!noSceneModes) { 2971 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 2972 supportedSceneModes); 2973 } 2974 } 2975 2976 camera_metadata_entry_t flashAvailable = 2977 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 2978 if (!flashAvailable.count) return NO_INIT; 2979 2980 camera_metadata_entry_t availableAeModes = 2981 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 2982 if (!availableAeModes.count) return NO_INIT; 2983 2984 if (flashAvailable.data.u8[0]) { 2985 k.mParameters.flashMode = Parameters::FLASH_MODE_AUTO; 2986 params.set(CameraParameters::KEY_FLASH_MODE, 2987 CameraParameters::FLASH_MODE_AUTO); 2988 2989 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF); 2990 supportedFlashModes = supportedFlashModes + 2991 "," + CameraParameters::FLASH_MODE_AUTO + 2992 "," + CameraParameters::FLASH_MODE_ON + 2993 "," + CameraParameters::FLASH_MODE_TORCH; 2994 for (size_t i=0; i < availableAeModes.count; i++) { 2995 if (availableAeModes.data.u8[i] == 2996 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) { 2997 supportedFlashModes = supportedFlashModes + "," + 2998 CameraParameters::FLASH_MODE_RED_EYE; 2999 break; 3000 } 3001 } 3002 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 3003 supportedFlashModes); 3004 } else { 3005 k.mParameters.flashMode = Parameters::FLASH_MODE_OFF; 3006 params.set(CameraParameters::KEY_FLASH_MODE, 3007 CameraParameters::FLASH_MODE_OFF); 3008 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 3009 CameraParameters::FLASH_MODE_OFF); 3010 } 3011 3012 camera_metadata_entry_t minFocusDistance = 3013 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1); 3014 if (!minFocusDistance.count) return NO_INIT; 3015 3016 camera_metadata_entry_t availableAfModes = 3017 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 3018 if (!availableAfModes.count) return NO_INIT; 3019 3020 if (minFocusDistance.data.f[0] == 0) { 3021 // Fixed-focus lens 3022 k.mParameters.focusMode = Parameters::FOCUS_MODE_FIXED; 3023 params.set(CameraParameters::KEY_FOCUS_MODE, 3024 CameraParameters::FOCUS_MODE_FIXED); 3025 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 3026 CameraParameters::FOCUS_MODE_FIXED); 3027 } else { 3028 k.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO; 3029 params.set(CameraParameters::KEY_FOCUS_MODE, 3030 CameraParameters::FOCUS_MODE_AUTO); 3031 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_INFINITY); 3032 bool addComma = true; 3033 3034 for (size_t i=0; i < availableAfModes.count; i++) { 3035 if (addComma) supportedFocusModes += ","; 3036 addComma = true; 3037 switch (availableAfModes.data.u8[i]) { 3038 case ANDROID_CONTROL_AF_AUTO: 3039 supportedFocusModes += 3040 CameraParameters::FOCUS_MODE_AUTO; 3041 break; 3042 case ANDROID_CONTROL_AF_MACRO: 3043 supportedFocusModes += 3044 CameraParameters::FOCUS_MODE_MACRO; 3045 break; 3046 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO: 3047 supportedFocusModes += 3048 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO; 3049 break; 3050 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE: 3051 supportedFocusModes += 3052 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE; 3053 break; 3054 case ANDROID_CONTROL_AF_EDOF: 3055 supportedFocusModes += 3056 CameraParameters::FOCUS_MODE_EDOF; 3057 break; 3058 // Not supported in old API 3059 case ANDROID_CONTROL_AF_OFF: 3060 addComma = false; 3061 break; 3062 default: 3063 ALOGW("%s: Camera %d: Unknown AF mode value: %d", 3064 __FUNCTION__, mCameraId, availableAfModes.data.u8[i]); 3065 addComma = false; 3066 break; 3067 } 3068 } 3069 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 3070 supportedFocusModes); 3071 } 3072 3073 camera_metadata_entry_t max3aRegions = 3074 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1); 3075 if (!max3aRegions.count) return NO_INIT; 3076 3077 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, 3078 max3aRegions.data.i32[0]); 3079 params.set(CameraParameters::KEY_FOCUS_AREAS, 3080 "(0,0,0,0,0)"); 3081 k.mParameters.focusingAreas.clear(); 3082 k.mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0)); 3083 3084 camera_metadata_entry_t availableFocalLengths = 3085 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS); 3086 if (!availableFocalLengths.count) return NO_INIT; 3087 3088 float minFocalLength = availableFocalLengths.data.f[0]; 3089 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength); 3090 3091 camera_metadata_entry_t sensorSize = 3092 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2); 3093 if (!sensorSize.count) return NO_INIT; 3094 3095 // The fields of view here assume infinity focus, maximum wide angle 3096 float horizFov = 180 / M_PI * 3097 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength)); 3098 float vertFov = 180 / M_PI * 3099 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength)); 3100 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 3101 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 3102 3103 k.mParameters.exposureCompensation = 0; 3104 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 3105 k.mParameters.exposureCompensation); 3106 3107 camera_metadata_entry_t exposureCompensationRange = 3108 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2); 3109 if (!exposureCompensationRange.count) return NO_INIT; 3110 3111 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 3112 exposureCompensationRange.data.i32[1]); 3113 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 3114 exposureCompensationRange.data.i32[0]); 3115 3116 camera_metadata_entry_t exposureCompensationStep = 3117 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1); 3118 if (!exposureCompensationStep.count) return NO_INIT; 3119 3120 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 3121 (float)exposureCompensationStep.data.r[0].numerator / 3122 exposureCompensationStep.data.r[0].denominator); 3123 3124 k.mParameters.autoExposureLock = false; 3125 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 3126 CameraParameters::FALSE); 3127 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 3128 CameraParameters::TRUE); 3129 3130 k.mParameters.autoWhiteBalanceLock = false; 3131 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 3132 CameraParameters::FALSE); 3133 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 3134 CameraParameters::TRUE); 3135 3136 k.mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 3137 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 3138 max3aRegions.data.i32[0]); 3139 params.set(CameraParameters::KEY_METERING_AREAS, 3140 "(0,0,0,0,0)"); 3141 3142 k.mParameters.zoom = 0; 3143 params.set(CameraParameters::KEY_ZOOM, k.mParameters.zoom); 3144 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 3145 3146 camera_metadata_entry_t maxDigitalZoom = 3147 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1); 3148 if (!maxDigitalZoom.count) return NO_INIT; 3149 3150 { 3151 String8 zoomRatios; 3152 float zoom = 1.f; 3153 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 3154 (NUM_ZOOM_STEPS-1); 3155 bool addComma = false; 3156 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 3157 if (addComma) zoomRatios += ","; 3158 addComma = true; 3159 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 3160 zoom += zoomIncrement; 3161 } 3162 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 3163 } 3164 3165 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 3166 CameraParameters::TRUE); 3167 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 3168 CameraParameters::TRUE); 3169 3170 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 3171 "Infinity,Infinity,Infinity"); 3172 3173 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 3174 mDeviceInfo->maxFaces); 3175 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 3176 0); 3177 3178 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 3179 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE); 3180 3181 params.set(CameraParameters::KEY_RECORDING_HINT, 3182 CameraParameters::FALSE); 3183 3184 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 3185 CameraParameters::TRUE); 3186 3187 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 3188 CameraParameters::FALSE); 3189 3190 camera_metadata_entry_t availableVideoStabilizationModes = 3191 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 3192 if (!availableVideoStabilizationModes.count) return NO_INIT; 3193 3194 if (availableVideoStabilizationModes.count > 1) { 3195 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 3196 CameraParameters::TRUE); 3197 } else { 3198 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 3199 CameraParameters::FALSE); 3200 } 3201 3202 // Set up initial state for non-Camera.Parameters state variables 3203 3204 k.mParameters.storeMetadataInBuffers = true; 3205 k.mParameters.playShutterSound = true; 3206 k.mParameters.enableFaceDetect = false; 3207 3208 k.mParameters.enableFocusMoveMessages = false; 3209 k.mParameters.afTriggerCounter = 0; 3210 k.mParameters.currentAfTriggerId = -1; 3211 3212 k.mParameters.previewCallbackFlags = 0; 3213 3214 k.mParameters.state = STOPPED; 3215 3216 k.mParameters.paramsFlattened = params.flatten(); 3217 3218 return OK; 3219} 3220 3221status_t Camera2Client::updateRequests(const Parameters ¶ms) { 3222 status_t res; 3223 3224 res = updatePreviewRequest(params); 3225 if (res != OK) { 3226 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)", 3227 __FUNCTION__, mCameraId, strerror(-res), res); 3228 return res; 3229 } 3230 res = updateCaptureRequest(params); 3231 if (res != OK) { 3232 ALOGE("%s: Camera %d: Unable to update capture request: %s (%d)", 3233 __FUNCTION__, mCameraId, strerror(-res), res); 3234 return res; 3235 } 3236 3237 res = updateRecordingRequest(params); 3238 if (res != OK) { 3239 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)", 3240 __FUNCTION__, mCameraId, strerror(-res), res); 3241 return res; 3242 } 3243 3244 if (params.state == PREVIEW) { 3245 res = mDevice->setStreamingRequest(mPreviewRequest); 3246 if (res != OK) { 3247 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)", 3248 __FUNCTION__, mCameraId, strerror(-res), res); 3249 return res; 3250 } 3251 } else if (params.state == RECORD || params.state == VIDEO_SNAPSHOT) { 3252 res = mDevice->setStreamingRequest(mRecordingRequest); 3253 if (res != OK) { 3254 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)", 3255 __FUNCTION__, mCameraId, strerror(-res), res); 3256 return res; 3257 } 3258 } 3259 return res; 3260} 3261 3262status_t Camera2Client::updatePreviewStream(const Parameters ¶ms) { 3263 ATRACE_CALL(); 3264 status_t res; 3265 3266 if (mPreviewStreamId != NO_STREAM) { 3267 // Check if stream parameters have to change 3268 uint32_t currentWidth, currentHeight; 3269 res = mDevice->getStreamInfo(mPreviewStreamId, 3270 ¤tWidth, ¤tHeight, 0); 3271 if (res != OK) { 3272 ALOGE("%s: Camera %d: Error querying preview stream info: " 3273 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3274 return res; 3275 } 3276 if (currentWidth != (uint32_t)params.previewWidth || 3277 currentHeight != (uint32_t)params.previewHeight) { 3278 ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d", 3279 __FUNCTION__, mCameraId, currentWidth, currentHeight, 3280 params.previewWidth, params.previewHeight); 3281 res = mDevice->waitUntilDrained(); 3282 if (res != OK) { 3283 ALOGE("%s: Camera %d: Error waiting for preview to drain: " 3284 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3285 return res; 3286 } 3287 res = mDevice->deleteStream(mPreviewStreamId); 3288 if (res != OK) { 3289 ALOGE("%s: Camera %d: Unable to delete old output stream " 3290 "for preview: %s (%d)", __FUNCTION__, mCameraId, 3291 strerror(-res), res); 3292 return res; 3293 } 3294 mPreviewStreamId = NO_STREAM; 3295 } 3296 } 3297 3298 if (mPreviewStreamId == NO_STREAM) { 3299 res = mDevice->createStream(mPreviewWindow, 3300 params.previewWidth, params.previewHeight, 3301 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, 3302 &mPreviewStreamId); 3303 if (res != OK) { 3304 ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)", 3305 __FUNCTION__, mCameraId, strerror(-res), res); 3306 return res; 3307 } 3308 } 3309 3310 res = mDevice->setStreamTransform(mPreviewStreamId, 3311 params.previewTransform); 3312 if (res != OK) { 3313 ALOGE("%s: Camera %d: Unable to set preview stream transform: " 3314 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3315 return res; 3316 } 3317 3318 return OK; 3319} 3320 3321status_t Camera2Client::updatePreviewRequest(const Parameters ¶ms) { 3322 ATRACE_CALL(); 3323 status_t res; 3324 if (mPreviewRequest == NULL) { 3325 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW, 3326 &mPreviewRequest); 3327 if (res != OK) { 3328 ALOGE("%s: Camera %d: Unable to create default preview request: " 3329 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3330 return res; 3331 } 3332 } 3333 3334 res = updateRequestCommon(mPreviewRequest, params); 3335 if (res != OK) { 3336 ALOGE("%s: Camera %d: Unable to update common entries of preview " 3337 "request: %s (%d)", __FUNCTION__, mCameraId, 3338 strerror(-res), res); 3339 return res; 3340 } 3341 3342 return OK; 3343} 3344 3345status_t Camera2Client::updateCallbackStream(const Parameters ¶ms) { 3346 status_t res; 3347 3348 if (mCallbackConsumer == 0) { 3349 // Create CPU buffer queue endpoint 3350 mCallbackConsumer = new CpuConsumer(kCallbackHeapCount); 3351 mCallbackWaiter = new CallbackWaiter(this); 3352 mCallbackConsumer->setFrameAvailableListener(mCallbackWaiter); 3353 mCallbackConsumer->setName(String8("Camera2Client::CallbackConsumer")); 3354 mCallbackWindow = new SurfaceTextureClient( 3355 mCallbackConsumer->getProducerInterface()); 3356 } 3357 3358 if (mCallbackStreamId != NO_STREAM) { 3359 // Check if stream parameters have to change 3360 uint32_t currentWidth, currentHeight, currentFormat; 3361 res = mDevice->getStreamInfo(mCallbackStreamId, 3362 ¤tWidth, ¤tHeight, ¤tFormat); 3363 if (res != OK) { 3364 ALOGE("%s: Camera %d: Error querying callback output stream info: " 3365 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3366 return res; 3367 } 3368 if (currentWidth != (uint32_t)params.previewWidth || 3369 currentHeight != (uint32_t)params.previewHeight || 3370 currentFormat != (uint32_t)params.previewFormat) { 3371 // Since size should only change while preview is not running, 3372 // assuming that all existing use of old callback stream is 3373 // completed. 3374 res = mDevice->deleteStream(mCallbackStreamId); 3375 if (res != OK) { 3376 ALOGE("%s: Camera %d: Unable to delete old output stream " 3377 "for callbacks: %s (%d)", __FUNCTION__, mCameraId, 3378 strerror(-res), res); 3379 return res; 3380 } 3381 mCallbackStreamId = NO_STREAM; 3382 } 3383 } 3384 3385 if (mCallbackStreamId == NO_STREAM) { 3386 ALOGV("Creating callback stream: %d %d format 0x%x", 3387 params.previewWidth, params.previewHeight, 3388 params.previewFormat); 3389 res = mDevice->createStream(mCallbackWindow, 3390 params.previewWidth, params.previewHeight, 3391 params.previewFormat, 0, &mCallbackStreamId); 3392 if (res != OK) { 3393 ALOGE("%s: Camera %d: Can't create output stream for callbacks: " 3394 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3395 return res; 3396 } 3397 } 3398 3399 return OK; 3400} 3401 3402 3403status_t Camera2Client::updateCaptureStream(const Parameters ¶ms) { 3404 ATRACE_CALL(); 3405 status_t res; 3406 // Find out buffer size for JPEG 3407 camera_metadata_entry_t maxJpegSize = 3408 staticInfo(ANDROID_JPEG_MAX_SIZE); 3409 if (maxJpegSize.count == 0) { 3410 ALOGE("%s: Camera %d: Can't find ANDROID_JPEG_MAX_SIZE!", 3411 __FUNCTION__, mCameraId); 3412 return INVALID_OPERATION; 3413 } 3414 3415 if (mCaptureConsumer == 0) { 3416 // Create CPU buffer queue endpoint 3417 mCaptureConsumer = new CpuConsumer(1); 3418 mCaptureConsumer->setFrameAvailableListener(new CaptureWaiter(this)); 3419 mCaptureConsumer->setName(String8("Camera2Client::CaptureConsumer")); 3420 mCaptureWindow = new SurfaceTextureClient( 3421 mCaptureConsumer->getProducerInterface()); 3422 // Create memory for API consumption 3423 mCaptureHeap = new Camera2Heap(maxJpegSize.data.i32[0], 1, 3424 "Camera2Client::CaptureHeap"); 3425 if (mCaptureHeap->mHeap->getSize() == 0) { 3426 ALOGE("%s: Camera %d: Unable to allocate memory for capture", 3427 __FUNCTION__, mCameraId); 3428 return NO_MEMORY; 3429 } 3430 } 3431 3432 if (mCaptureStreamId != NO_STREAM) { 3433 // Check if stream parameters have to change 3434 uint32_t currentWidth, currentHeight; 3435 res = mDevice->getStreamInfo(mCaptureStreamId, 3436 ¤tWidth, ¤tHeight, 0); 3437 if (res != OK) { 3438 ALOGE("%s: Camera %d: Error querying capture output stream info: " 3439 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3440 return res; 3441 } 3442 if (currentWidth != (uint32_t)params.pictureWidth || 3443 currentHeight != (uint32_t)params.pictureHeight) { 3444 res = mDevice->deleteStream(mCaptureStreamId); 3445 if (res != OK) { 3446 ALOGE("%s: Camera %d: Unable to delete old output stream " 3447 "for capture: %s (%d)", __FUNCTION__, mCameraId, 3448 strerror(-res), res); 3449 return res; 3450 } 3451 mCaptureStreamId = NO_STREAM; 3452 } 3453 } 3454 3455 if (mCaptureStreamId == NO_STREAM) { 3456 // Create stream for HAL production 3457 res = mDevice->createStream(mCaptureWindow, 3458 params.pictureWidth, params.pictureHeight, 3459 HAL_PIXEL_FORMAT_BLOB, maxJpegSize.data.i32[0], 3460 &mCaptureStreamId); 3461 if (res != OK) { 3462 ALOGE("%s: Camera %d: Can't create output stream for capture: " 3463 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3464 return res; 3465 } 3466 3467 } 3468 return OK; 3469} 3470 3471status_t Camera2Client::updateCaptureRequest(const Parameters ¶ms) { 3472 ATRACE_CALL(); 3473 status_t res; 3474 if (mCaptureRequest == NULL) { 3475 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_STILL_CAPTURE, 3476 &mCaptureRequest); 3477 if (res != OK) { 3478 ALOGE("%s: Camera %d: Unable to create default still image request:" 3479 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3480 return res; 3481 } 3482 } 3483 3484 res = updateRequestCommon(mCaptureRequest, params); 3485 if (res != OK) { 3486 ALOGE("%s: Camera %d: Unable to update common entries of capture " 3487 "request: %s (%d)", __FUNCTION__, mCameraId, 3488 strerror(-res), res); 3489 return res; 3490 } 3491 3492 res = updateEntry(mCaptureRequest, 3493 ANDROID_JPEG_THUMBNAIL_SIZE, 3494 params.jpegThumbSize, 2); 3495 if (res != OK) return res; 3496 res = updateEntry(mCaptureRequest, 3497 ANDROID_JPEG_THUMBNAIL_QUALITY, 3498 ¶ms.jpegThumbQuality, 1); 3499 if (res != OK) return res; 3500 res = updateEntry(mCaptureRequest, 3501 ANDROID_JPEG_QUALITY, 3502 ¶ms.jpegQuality, 1); 3503 if (res != OK) return res; 3504 res = updateEntry(mCaptureRequest, 3505 ANDROID_JPEG_ORIENTATION, 3506 ¶ms.jpegRotation, 1); 3507 if (res != OK) return res; 3508 3509 if (params.gpsEnabled) { 3510 res = updateEntry(mCaptureRequest, 3511 ANDROID_JPEG_GPS_COORDINATES, 3512 params.gpsCoordinates, 3); 3513 if (res != OK) return res; 3514 res = updateEntry(mCaptureRequest, 3515 ANDROID_JPEG_GPS_TIMESTAMP, 3516 ¶ms.gpsTimestamp, 1); 3517 if (res != OK) return res; 3518 res = updateEntry(mCaptureRequest, 3519 ANDROID_JPEG_GPS_PROCESSING_METHOD, 3520 params.gpsProcessingMethod.string(), 3521 params.gpsProcessingMethod.size()); 3522 if (res != OK) return res; 3523 } else { 3524 res = deleteEntry(mCaptureRequest, 3525 ANDROID_JPEG_GPS_COORDINATES); 3526 if (res != OK) return res; 3527 res = deleteEntry(mCaptureRequest, 3528 ANDROID_JPEG_GPS_TIMESTAMP); 3529 if (res != OK) return res; 3530 res = deleteEntry(mCaptureRequest, 3531 ANDROID_JPEG_GPS_PROCESSING_METHOD); 3532 if (res != OK) return res; 3533 } 3534 3535 return OK; 3536} 3537 3538status_t Camera2Client::updateRecordingRequest(const Parameters ¶ms) { 3539 ATRACE_CALL(); 3540 status_t res; 3541 if (mRecordingRequest == NULL) { 3542 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD, 3543 &mRecordingRequest); 3544 if (res != OK) { 3545 ALOGE("%s: Camera %d: Unable to create default recording request:" 3546 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3547 return res; 3548 } 3549 } 3550 3551 res = updateRequestCommon(mRecordingRequest, params); 3552 if (res != OK) { 3553 ALOGE("%s: Camera %d: Unable to update common entries of recording " 3554 "request: %s (%d)", __FUNCTION__, mCameraId, 3555 strerror(-res), res); 3556 return res; 3557 } 3558 3559 return OK; 3560} 3561 3562status_t Camera2Client::updateRecordingStream(const Parameters ¶ms) { 3563 status_t res; 3564 3565 if (mRecordingConsumer == 0) { 3566 // Create CPU buffer queue endpoint. We need one more buffer here so that we can 3567 // always acquire and free a buffer when the heap is full; otherwise the consumer 3568 // will have buffers in flight we'll never clear out. 3569 mRecordingConsumer = new BufferItemConsumer( 3570 GRALLOC_USAGE_HW_VIDEO_ENCODER, 3571 mRecordingHeapCount + 1, 3572 true); 3573 mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this)); 3574 mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer")); 3575 mRecordingWindow = new SurfaceTextureClient( 3576 mRecordingConsumer->getProducerInterface()); 3577 // Allocate memory later, since we don't know buffer size until receipt 3578 } 3579 3580 if (mRecordingStreamId != NO_STREAM) { 3581 // Check if stream parameters have to change 3582 uint32_t currentWidth, currentHeight; 3583 res = mDevice->getStreamInfo(mRecordingStreamId, 3584 ¤tWidth, ¤tHeight, 0); 3585 if (res != OK) { 3586 ALOGE("%s: Camera %d: Error querying recording output stream info: " 3587 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3588 return res; 3589 } 3590 if (currentWidth != (uint32_t)params.videoWidth || 3591 currentHeight != (uint32_t)params.videoHeight) { 3592 // TODO: Should wait to be sure previous recording has finished 3593 res = mDevice->deleteStream(mRecordingStreamId); 3594 if (res != OK) { 3595 ALOGE("%s: Camera %d: Unable to delete old output stream " 3596 "for recording: %s (%d)", __FUNCTION__, mCameraId, 3597 strerror(-res), res); 3598 return res; 3599 } 3600 mRecordingStreamId = NO_STREAM; 3601 } 3602 } 3603 3604 if (mRecordingStreamId == NO_STREAM) { 3605 mRecordingFrameCount = 0; 3606 res = mDevice->createStream(mRecordingWindow, 3607 params.videoWidth, params.videoHeight, 3608 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId); 3609 if (res != OK) { 3610 ALOGE("%s: Camera %d: Can't create output stream for recording: " 3611 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 3612 return res; 3613 } 3614 } 3615 3616 return OK; 3617} 3618 3619status_t Camera2Client::updateRequestCommon(camera_metadata_t *request, 3620 const Parameters ¶ms) { 3621 ATRACE_CALL(); 3622 status_t res; 3623 res = updateEntry(request, 3624 ANDROID_CONTROL_AE_TARGET_FPS_RANGE, params.previewFpsRange, 2); 3625 if (res != OK) return res; 3626 3627 uint8_t wbMode = params.autoWhiteBalanceLock ? 3628 ANDROID_CONTROL_AWB_LOCKED : params.wbMode; 3629 res = updateEntry(request, 3630 ANDROID_CONTROL_AWB_MODE, &wbMode, 1); 3631 if (res != OK) return res; 3632 res = updateEntry(request, 3633 ANDROID_CONTROL_EFFECT_MODE, ¶ms.effectMode, 1); 3634 if (res != OK) return res; 3635 res = updateEntry(request, 3636 ANDROID_CONTROL_AE_ANTIBANDING_MODE, 3637 ¶ms.antibandingMode, 1); 3638 if (res != OK) return res; 3639 3640 uint8_t controlMode = 3641 (params.sceneMode == ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) ? 3642 ANDROID_CONTROL_AUTO : ANDROID_CONTROL_USE_SCENE_MODE; 3643 res = updateEntry(request, 3644 ANDROID_CONTROL_MODE, &controlMode, 1); 3645 if (res != OK) return res; 3646 if (controlMode == ANDROID_CONTROL_USE_SCENE_MODE) { 3647 res = updateEntry(request, 3648 ANDROID_CONTROL_SCENE_MODE, 3649 ¶ms.sceneMode, 1); 3650 if (res != OK) return res; 3651 } 3652 3653 uint8_t flashMode = ANDROID_FLASH_OFF; 3654 uint8_t aeMode; 3655 switch (params.flashMode) { 3656 case Parameters::FLASH_MODE_OFF: 3657 aeMode = ANDROID_CONTROL_AE_ON; break; 3658 case Parameters::FLASH_MODE_AUTO: 3659 aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break; 3660 case Parameters::FLASH_MODE_ON: 3661 aeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break; 3662 case Parameters::FLASH_MODE_TORCH: 3663 aeMode = ANDROID_CONTROL_AE_ON; 3664 flashMode = ANDROID_FLASH_TORCH; 3665 break; 3666 case Parameters::FLASH_MODE_RED_EYE: 3667 aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break; 3668 default: 3669 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__, 3670 mCameraId, params.flashMode); 3671 return BAD_VALUE; 3672 } 3673 if (params.autoExposureLock) aeMode = ANDROID_CONTROL_AE_LOCKED; 3674 3675 res = updateEntry(request, 3676 ANDROID_FLASH_MODE, &flashMode, 1); 3677 if (res != OK) return res; 3678 res = updateEntry(request, 3679 ANDROID_CONTROL_AE_MODE, &aeMode, 1); 3680 if (res != OK) return res; 3681 3682 float focusDistance = 0; // infinity focus in diopters 3683 uint8_t focusMode; 3684 switch (params.focusMode) { 3685 case Parameters::FOCUS_MODE_AUTO: 3686 case Parameters::FOCUS_MODE_MACRO: 3687 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 3688 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 3689 case Parameters::FOCUS_MODE_EDOF: 3690 focusMode = params.focusMode; 3691 break; 3692 case Parameters::FOCUS_MODE_INFINITY: 3693 case Parameters::FOCUS_MODE_FIXED: 3694 focusMode = ANDROID_CONTROL_AF_OFF; 3695 break; 3696 default: 3697 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__, 3698 mCameraId, params.focusMode); 3699 return BAD_VALUE; 3700 } 3701 res = updateEntry(request, 3702 ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1); 3703 if (res != OK) return res; 3704 res = updateEntry(request, 3705 ANDROID_CONTROL_AF_MODE, &focusMode, 1); 3706 if (res != OK) return res; 3707 3708 size_t focusingAreasSize = params.focusingAreas.size() * 5; 3709 int32_t *focusingAreas = new int32_t[focusingAreasSize]; 3710 for (size_t i = 0; i < focusingAreasSize; i += 5) { 3711 focusingAreas[i + 0] = params.focusingAreas[i].left; 3712 focusingAreas[i + 1] = params.focusingAreas[i].top; 3713 focusingAreas[i + 2] = params.focusingAreas[i].right; 3714 focusingAreas[i + 3] = params.focusingAreas[i].bottom; 3715 focusingAreas[i + 4] = params.focusingAreas[i].weight; 3716 } 3717 res = updateEntry(request, 3718 ANDROID_CONTROL_AF_REGIONS, focusingAreas,focusingAreasSize); 3719 if (res != OK) return res; 3720 delete[] focusingAreas; 3721 3722 res = updateEntry(request, 3723 ANDROID_CONTROL_AE_EXP_COMPENSATION, 3724 ¶ms.exposureCompensation, 1); 3725 if (res != OK) return res; 3726 3727 size_t meteringAreasSize = params.meteringAreas.size() * 5; 3728 int32_t *meteringAreas = new int32_t[meteringAreasSize]; 3729 for (size_t i = 0; i < meteringAreasSize; i += 5) { 3730 meteringAreas[i + 0] = params.meteringAreas[i].left; 3731 meteringAreas[i + 1] = params.meteringAreas[i].top; 3732 meteringAreas[i + 2] = params.meteringAreas[i].right; 3733 meteringAreas[i + 3] = params.meteringAreas[i].bottom; 3734 meteringAreas[i + 4] = params.meteringAreas[i].weight; 3735 } 3736 res = updateEntry(request, 3737 ANDROID_CONTROL_AE_REGIONS, meteringAreas, meteringAreasSize); 3738 if (res != OK) return res; 3739 3740 res = updateEntry(request, 3741 ANDROID_CONTROL_AWB_REGIONS, meteringAreas, meteringAreasSize); 3742 if (res != OK) return res; 3743 delete[] meteringAreas; 3744 3745 // Need to convert zoom index into a crop rectangle. The rectangle is 3746 // chosen to maximize its area on the sensor 3747 3748 camera_metadata_entry_t maxDigitalZoom = 3749 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM); 3750 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) / 3751 (NUM_ZOOM_STEPS-1); 3752 float zoomRatio = 1 + zoomIncrement * params.zoom; 3753 3754 float zoomLeft, zoomTop, zoomWidth, zoomHeight; 3755 if (params.previewWidth >= params.previewHeight) { 3756 zoomWidth = mDeviceInfo->arrayWidth / zoomRatio; 3757 zoomHeight = zoomWidth * 3758 params.previewHeight / params.previewWidth; 3759 } else { 3760 zoomHeight = mDeviceInfo->arrayHeight / zoomRatio; 3761 zoomWidth = zoomHeight * 3762 params.previewWidth / params.previewHeight; 3763 } 3764 zoomLeft = (mDeviceInfo->arrayWidth - zoomWidth) / 2; 3765 zoomTop = (mDeviceInfo->arrayHeight - zoomHeight) / 2; 3766 3767 int32_t cropRegion[3] = { zoomLeft, zoomTop, zoomWidth }; 3768 res = updateEntry(request, 3769 ANDROID_SCALER_CROP_REGION, cropRegion, 3); 3770 if (res != OK) return res; 3771 3772 // TODO: Decide how to map recordingHint, or whether just to ignore it 3773 3774 uint8_t vstabMode = params.videoStabilization ? 3775 ANDROID_CONTROL_VIDEO_STABILIZATION_ON : 3776 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF; 3777 res = updateEntry(request, 3778 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 3779 &vstabMode, 1); 3780 if (res != OK) return res; 3781 3782 uint8_t faceDetectMode = params.enableFaceDetect ? 3783 mDeviceInfo->bestFaceDetectMode : 3784 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF; 3785 res = updateEntry(request, 3786 ANDROID_STATS_FACE_DETECT_MODE, 3787 &faceDetectMode, 1); 3788 if (res != OK) return res; 3789 3790 return OK; 3791} 3792 3793int Camera2Client::arrayXToNormalized(int width) const { 3794 return width * 2000 / (mDeviceInfo->arrayWidth - 1) - 1000; 3795} 3796 3797int Camera2Client::arrayYToNormalized(int height) const { 3798 return height * 2000 / (mDeviceInfo->arrayHeight - 1) - 1000; 3799} 3800 3801status_t Camera2Client::updateEntry(camera_metadata_t *buffer, 3802 uint32_t tag, const void *data, size_t data_count) { 3803 camera_metadata_entry_t entry; 3804 status_t res; 3805 res = find_camera_metadata_entry(buffer, tag, &entry); 3806 if (res == NAME_NOT_FOUND) { 3807 res = add_camera_metadata_entry(buffer, 3808 tag, data, data_count); 3809 } else if (res == OK) { 3810 res = update_camera_metadata_entry(buffer, 3811 entry.index, data, data_count, NULL); 3812 } 3813 3814 if (res != OK) { 3815 ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)", 3816 __FUNCTION__, get_camera_metadata_section_name(tag), 3817 get_camera_metadata_tag_name(tag), tag, strerror(-res), res); 3818 } 3819 return res; 3820} 3821 3822status_t Camera2Client::deleteEntry(camera_metadata_t *buffer, uint32_t tag) { 3823 camera_metadata_entry_t entry; 3824 status_t res; 3825 res = find_camera_metadata_entry(buffer, tag, &entry); 3826 if (res == NAME_NOT_FOUND) { 3827 return OK; 3828 } else if (res != OK) { 3829 ALOGE("%s: Error looking for entry %s.%s (%x): %s %d", 3830 __FUNCTION__, 3831 get_camera_metadata_section_name(tag), 3832 get_camera_metadata_tag_name(tag), tag, strerror(-res), res); 3833 return res; 3834 } 3835 res = delete_camera_metadata_entry(buffer, entry.index); 3836 if (res != OK) { 3837 ALOGE("%s: Error deleting entry %s.%s (%x): %s %d", 3838 __FUNCTION__, 3839 get_camera_metadata_section_name(tag), 3840 get_camera_metadata_tag_name(tag), tag, strerror(-res), res); 3841 } 3842 return res; 3843} 3844 3845int Camera2Client::formatStringToEnum(const char *format) { 3846 return 3847 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ? 3848 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16 3849 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ? 3850 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21 3851 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ? 3852 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2 3853 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ? 3854 HAL_PIXEL_FORMAT_YV12 : // YV12 3855 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ? 3856 HAL_PIXEL_FORMAT_RGB_565 : // RGB565 3857 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ? 3858 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888 3859 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ? 3860 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data 3861 -1; 3862} 3863 3864const char* Camera2Client::formatEnumToString(int format) { 3865 const char *fmt; 3866 switch(format) { 3867 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 3868 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 3869 break; 3870 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 3871 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 3872 break; 3873 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 3874 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 3875 break; 3876 case HAL_PIXEL_FORMAT_YV12: // YV12 3877 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 3878 break; 3879 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 3880 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 3881 break; 3882 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 3883 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 3884 break; 3885 case HAL_PIXEL_FORMAT_RAW_SENSOR: 3886 ALOGW("Raw sensor preview format requested."); 3887 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 3888 break; 3889 default: 3890 ALOGE("%s: Unknown preview format: %x", 3891 __FUNCTION__, format); 3892 fmt = NULL; 3893 break; 3894 } 3895 return fmt; 3896} 3897 3898int Camera2Client::wbModeStringToEnum(const char *wbMode) { 3899 return 3900 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ? 3901 ANDROID_CONTROL_AWB_AUTO : 3902 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ? 3903 ANDROID_CONTROL_AWB_INCANDESCENT : 3904 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ? 3905 ANDROID_CONTROL_AWB_FLUORESCENT : 3906 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ? 3907 ANDROID_CONTROL_AWB_WARM_FLUORESCENT : 3908 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ? 3909 ANDROID_CONTROL_AWB_DAYLIGHT : 3910 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ? 3911 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT : 3912 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ? 3913 ANDROID_CONTROL_AWB_TWILIGHT : 3914 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ? 3915 ANDROID_CONTROL_AWB_SHADE : 3916 -1; 3917} 3918 3919int Camera2Client::effectModeStringToEnum(const char *effectMode) { 3920 return 3921 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ? 3922 ANDROID_CONTROL_EFFECT_OFF : 3923 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ? 3924 ANDROID_CONTROL_EFFECT_MONO : 3925 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ? 3926 ANDROID_CONTROL_EFFECT_NEGATIVE : 3927 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ? 3928 ANDROID_CONTROL_EFFECT_SOLARIZE : 3929 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ? 3930 ANDROID_CONTROL_EFFECT_SEPIA : 3931 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ? 3932 ANDROID_CONTROL_EFFECT_POSTERIZE : 3933 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ? 3934 ANDROID_CONTROL_EFFECT_WHITEBOARD : 3935 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ? 3936 ANDROID_CONTROL_EFFECT_BLACKBOARD : 3937 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ? 3938 ANDROID_CONTROL_EFFECT_AQUA : 3939 -1; 3940} 3941 3942int Camera2Client::abModeStringToEnum(const char *abMode) { 3943 return 3944 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ? 3945 ANDROID_CONTROL_AE_ANTIBANDING_AUTO : 3946 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ? 3947 ANDROID_CONTROL_AE_ANTIBANDING_OFF : 3948 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ? 3949 ANDROID_CONTROL_AE_ANTIBANDING_50HZ : 3950 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ? 3951 ANDROID_CONTROL_AE_ANTIBANDING_60HZ : 3952 -1; 3953} 3954 3955int Camera2Client::sceneModeStringToEnum(const char *sceneMode) { 3956 return 3957 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ? 3958 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED : 3959 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ? 3960 ANDROID_CONTROL_SCENE_MODE_ACTION : 3961 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ? 3962 ANDROID_CONTROL_SCENE_MODE_PORTRAIT : 3963 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ? 3964 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE : 3965 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ? 3966 ANDROID_CONTROL_SCENE_MODE_NIGHT : 3967 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ? 3968 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT : 3969 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ? 3970 ANDROID_CONTROL_SCENE_MODE_THEATRE : 3971 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ? 3972 ANDROID_CONTROL_SCENE_MODE_BEACH : 3973 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ? 3974 ANDROID_CONTROL_SCENE_MODE_SNOW : 3975 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ? 3976 ANDROID_CONTROL_SCENE_MODE_SUNSET : 3977 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ? 3978 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO : 3979 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ? 3980 ANDROID_CONTROL_SCENE_MODE_FIREWORKS : 3981 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ? 3982 ANDROID_CONTROL_SCENE_MODE_SPORTS : 3983 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ? 3984 ANDROID_CONTROL_SCENE_MODE_PARTY : 3985 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ? 3986 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT : 3987 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ? 3988 ANDROID_CONTROL_SCENE_MODE_BARCODE: 3989 -1; 3990} 3991 3992Camera2Client::Parameters::flashMode_t Camera2Client::flashModeStringToEnum( 3993 const char *flashMode) { 3994 return 3995 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ? 3996 Parameters::FLASH_MODE_OFF : 3997 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ? 3998 Parameters::FLASH_MODE_AUTO : 3999 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ? 4000 Parameters::FLASH_MODE_ON : 4001 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ? 4002 Parameters::FLASH_MODE_RED_EYE : 4003 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ? 4004 Parameters::FLASH_MODE_TORCH : 4005 Parameters::FLASH_MODE_INVALID; 4006} 4007 4008Camera2Client::Parameters::focusMode_t Camera2Client::focusModeStringToEnum( 4009 const char *focusMode) { 4010 return 4011 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ? 4012 Parameters::FOCUS_MODE_AUTO : 4013 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ? 4014 Parameters::FOCUS_MODE_INFINITY : 4015 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ? 4016 Parameters::FOCUS_MODE_MACRO : 4017 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ? 4018 Parameters::FOCUS_MODE_FIXED : 4019 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ? 4020 Parameters::FOCUS_MODE_EDOF : 4021 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ? 4022 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO : 4023 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ? 4024 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE : 4025 Parameters::FOCUS_MODE_INVALID; 4026} 4027 4028status_t Camera2Client::parseAreas(const char *areasCStr, 4029 Vector<Parameters::Area> *areas) { 4030 static const size_t NUM_FIELDS = 5; 4031 areas->clear(); 4032 if (areasCStr == NULL) { 4033 // If no key exists, use default (0,0,0,0,0) 4034 areas->push(); 4035 return OK; 4036 } 4037 String8 areasStr(areasCStr); 4038 ssize_t areaStart = areasStr.find("(", 0) + 1; 4039 while (areaStart != 0) { 4040 const char* area = areasStr.string() + areaStart; 4041 char *numEnd; 4042 int vals[NUM_FIELDS]; 4043 for (size_t i = 0; i < NUM_FIELDS; i++) { 4044 errno = 0; 4045 vals[i] = strtol(area, &numEnd, 10); 4046 if (errno || numEnd == area) return BAD_VALUE; 4047 area = numEnd + 1; 4048 } 4049 areas->push(Parameters::Area( 4050 vals[0], vals[1], vals[2], vals[3], vals[4]) ); 4051 areaStart = areasStr.find("(", areaStart) + 1; 4052 } 4053 return OK; 4054} 4055 4056status_t Camera2Client::validateAreas(const Vector<Parameters::Area> &areas, 4057 size_t maxRegions) { 4058 // Definition of valid area can be found in 4059 // include/camera/CameraParameters.h 4060 if (areas.size() == 0) return BAD_VALUE; 4061 if (areas.size() == 1) { 4062 if (areas[0].left == 0 && 4063 areas[0].top == 0 && 4064 areas[0].right == 0 && 4065 areas[0].bottom == 0 && 4066 areas[0].weight == 0) { 4067 // Single (0,0,0,0,0) entry is always valid (== driver decides) 4068 return OK; 4069 } 4070 } 4071 if (areas.size() > maxRegions) { 4072 ALOGE("%s: Too many areas requested: %d", 4073 __FUNCTION__, areas.size()); 4074 return BAD_VALUE; 4075 } 4076 4077 for (Vector<Parameters::Area>::const_iterator a = areas.begin(); 4078 a != areas.end(); a++) { 4079 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE; 4080 if (a->left < -1000 || a->left > 1000) return BAD_VALUE; 4081 if (a->top < -1000 || a->top > 1000) return BAD_VALUE; 4082 if (a->right < -1000 || a->right > 1000) return BAD_VALUE; 4083 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE; 4084 if (a->left >= a->right) return BAD_VALUE; 4085 if (a->top >= a->bottom) return BAD_VALUE; 4086 } 4087 return OK; 4088} 4089 4090bool Camera2Client::boolFromString(const char *boolStr) { 4091 return !boolStr ? false : 4092 !strcmp(boolStr, CameraParameters::TRUE) ? true : 4093 false; 4094} 4095 4096int Camera2Client::degToTransform(int degrees, bool mirror) { 4097 if (!mirror) { 4098 if (degrees == 0) return 0; 4099 else if (degrees == 90) return HAL_TRANSFORM_ROT_90; 4100 else if (degrees == 180) return HAL_TRANSFORM_ROT_180; 4101 else if (degrees == 270) return HAL_TRANSFORM_ROT_270; 4102 } else { // Do mirror (horizontal flip) 4103 if (degrees == 0) { // FLIP_H and ROT_0 4104 return HAL_TRANSFORM_FLIP_H; 4105 } else if (degrees == 90) { // FLIP_H and ROT_90 4106 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90; 4107 } else if (degrees == 180) { // FLIP_H and ROT_180 4108 return HAL_TRANSFORM_FLIP_V; 4109 } else if (degrees == 270) { // FLIP_H and ROT_270 4110 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90; 4111 } 4112 } 4113 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees); 4114 return -1; 4115} 4116 4117size_t Camera2Client::calculateBufferSize(int width, int height, 4118 int format, int stride) { 4119 switch (format) { 4120 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 4121 return width * height * 2; 4122 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 4123 return width * height * 3 / 2; 4124 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 4125 return width * height * 2; 4126 case HAL_PIXEL_FORMAT_YV12: { // YV12 4127 size_t ySize = stride * height; 4128 size_t uvStride = (stride / 2 + 0xF) & ~0x10; 4129 size_t uvSize = uvStride * height / 2; 4130 return ySize + uvSize * 2; 4131 } 4132 case HAL_PIXEL_FORMAT_RGB_565: 4133 return width * height * 2; 4134 case HAL_PIXEL_FORMAT_RGBA_8888: 4135 return width * height * 4; 4136 case HAL_PIXEL_FORMAT_RAW_SENSOR: 4137 return width * height * 2; 4138 default: 4139 ALOGE("%s: Unknown preview format: %x", 4140 __FUNCTION__, format); 4141 return 0; 4142 } 4143} 4144 4145} // namespace android 4146