Camera2Client.cpp revision da6665cbd06ca58d3357c3002b7366d13e23f152
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 "Camera2Client.h" 30 31#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 32#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 33 34namespace android { 35 36using namespace camera2; 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 mSharedCameraClient(cameraClient), 56 mParameters(cameraId, cameraFacing), 57 mPreviewStreamId(NO_STREAM), 58 mRecordingStreamId(NO_STREAM), 59 mRecordingHeapCount(kDefaultRecordingHeapCount) 60{ 61 ATRACE_CALL(); 62 ALOGI("Camera %d: Opened", cameraId); 63 64 mDevice = new Camera2Device(cameraId); 65 66 SharedParameters::Lock l(mParameters); 67 l.mParameters.state = Parameters::DISCONNECTED; 68 69 char value[PROPERTY_VALUE_MAX]; 70 property_get("camera.zsl_mode", value, "0"); 71 if (!strcmp(value,"1")) { 72 ALOGI("Camera %d: Enabling ZSL mode", cameraId); 73 l.mParameters.zslMode = true; 74 } else { 75 l.mParameters.zslMode = false; 76 } 77} 78 79status_t Camera2Client::checkPid(const char* checkLocation) const { 80 int callingPid = getCallingPid(); 81 if (callingPid == mClientPid) return NO_ERROR; 82 83 ALOGE("%s: attempt to use a locked camera from a different process" 84 " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid); 85 return PERMISSION_DENIED; 86} 87 88status_t Camera2Client::initialize(camera_module_t *module) 89{ 90 ATRACE_CALL(); 91 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId); 92 status_t res; 93 94 res = mDevice->initialize(module); 95 if (res != OK) { 96 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)", 97 __FUNCTION__, mCameraId, strerror(-res), res); 98 return NO_INIT; 99 } 100 101 res = mDevice->setNotifyCallback(this); 102 103 SharedParameters::Lock l(mParameters); 104 105 res = l.mParameters.initialize(&(mDevice->info())); 106 if (res != OK) { 107 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)", 108 __FUNCTION__, mCameraId, strerror(-res), res); 109 return NO_INIT; 110 } 111 112 String8 threadName; 113 114 mFrameProcessor = new FrameProcessor(this); 115 threadName = String8::format("Camera2Client[%d]::FrameProcessor", 116 mCameraId); 117 mFrameProcessor->run(threadName.string()); 118 119 mCaptureSequencer = new CaptureSequencer(this); 120 threadName = String8::format("Camera2Client[%d]::CaptureSequencer", 121 mCameraId); 122 mCaptureSequencer->run(threadName.string()); 123 124 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer); 125 threadName = String8::format("Camera2Client[%d]::JpegProcessor", 126 mCameraId); 127 mJpegProcessor->run(threadName.string()); 128 129 mZslProcessor = new ZslProcessor(this, mCaptureSequencer); 130 threadName = String8::format("Camera2Client[%d]::ZslProcessor", 131 mCameraId); 132 mZslProcessor->run(threadName.string()); 133 134 mCallbackProcessor = new CallbackProcessor(this); 135 threadName = String8::format("Camera2Client[%d]::CallbackProcessor", 136 mCameraId); 137 mCallbackProcessor->run(threadName.string()); 138 139 if (gLogLevel >= 1) { 140 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__, 141 mCameraId); 142 ALOGD("%s", l.mParameters.paramsFlattened.string()); 143 } 144 145 return OK; 146} 147 148Camera2Client::~Camera2Client() { 149 ATRACE_CALL(); 150 ALOGV("Camera %d: Shutting down", mCameraId); 151 152 mDestructionStarted = true; 153 154 // Rewrite mClientPid to allow shutdown by CameraService 155 mClientPid = getCallingPid(); 156 disconnect(); 157 158 mFrameProcessor->requestExit(); 159 ALOGI("Camera %d: Closed", mCameraId); 160} 161 162status_t Camera2Client::dump(int fd, const Vector<String16>& args) { 163 String8 result; 164 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n", 165 mCameraId, 166 getCameraClient()->asBinder().get(), 167 mClientPid); 168 result.append(" State: "); 169#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break; 170 171 const Parameters& p = mParameters.unsafeAccess(); 172 173 result.append(Parameters::getStateName(p.state)); 174 175 result.append("\n Current parameters:\n"); 176 result.appendFormat(" Preview size: %d x %d\n", 177 p.previewWidth, p.previewHeight); 178 result.appendFormat(" Preview FPS range: %d - %d\n", 179 p.previewFpsRange[0], p.previewFpsRange[1]); 180 result.appendFormat(" Preview HAL pixel format: 0x%x\n", 181 p.previewFormat); 182 result.appendFormat(" Preview transform: %x\n", 183 p.previewTransform); 184 result.appendFormat(" Picture size: %d x %d\n", 185 p.pictureWidth, p.pictureHeight); 186 result.appendFormat(" Jpeg thumbnail size: %d x %d\n", 187 p.jpegThumbSize[0], p.jpegThumbSize[1]); 188 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n", 189 p.jpegQuality, p.jpegThumbQuality); 190 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation); 191 result.appendFormat(" GPS tags %s\n", 192 p.gpsEnabled ? "enabled" : "disabled"); 193 if (p.gpsEnabled) { 194 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n", 195 p.gpsCoordinates[0], p.gpsCoordinates[1], 196 p.gpsCoordinates[2]); 197 result.appendFormat(" GPS timestamp: %lld\n", 198 p.gpsTimestamp); 199 result.appendFormat(" GPS processing method: %s\n", 200 p.gpsProcessingMethod.string()); 201 } 202 203 result.append(" White balance mode: "); 204 switch (p.wbMode) { 205 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO) 206 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT) 207 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT) 208 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT) 209 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT) 210 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT) 211 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT) 212 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE) 213 default: result.append("UNKNOWN\n"); 214 } 215 216 result.append(" Effect mode: "); 217 switch (p.effectMode) { 218 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF) 219 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO) 220 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE) 221 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE) 222 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA) 223 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE) 224 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD) 225 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD) 226 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA) 227 default: result.append("UNKNOWN\n"); 228 } 229 230 result.append(" Antibanding mode: "); 231 switch (p.antibandingMode) { 232 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO) 233 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF) 234 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ) 235 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ) 236 default: result.append("UNKNOWN\n"); 237 } 238 239 result.append(" Scene mode: "); 240 switch (p.sceneMode) { 241 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 242 result.append("AUTO\n"); break; 243 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION) 244 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT) 245 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE) 246 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT) 247 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT) 248 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE) 249 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH) 250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW) 251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET) 252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO) 253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS) 254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS) 255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY) 256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT) 257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE) 258 default: result.append("UNKNOWN\n"); 259 } 260 261 result.append(" Flash mode: "); 262 switch (p.flashMode) { 263 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF) 264 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO) 265 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON) 266 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH) 267 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE) 268 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID) 269 default: result.append("UNKNOWN\n"); 270 } 271 272 result.append(" Focus mode: "); 273 switch (p.focusMode) { 274 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO) 275 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO) 276 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) 277 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE) 278 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF) 279 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY) 280 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED) 281 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID) 282 default: result.append("UNKNOWN\n"); 283 } 284 285 result.append(" Focusing areas:\n"); 286 for (size_t i = 0; i < p.focusingAreas.size(); i++) { 287 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 288 p.focusingAreas[i].left, 289 p.focusingAreas[i].top, 290 p.focusingAreas[i].right, 291 p.focusingAreas[i].bottom, 292 p.focusingAreas[i].weight); 293 } 294 295 result.appendFormat(" Exposure compensation index: %d\n", 296 p.exposureCompensation); 297 298 result.appendFormat(" AE lock %s, AWB lock %s\n", 299 p.autoExposureLock ? "enabled" : "disabled", 300 p.autoWhiteBalanceLock ? "enabled" : "disabled" ); 301 302 result.appendFormat(" Metering areas:\n"); 303 for (size_t i = 0; i < p.meteringAreas.size(); i++) { 304 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 305 p.meteringAreas[i].left, 306 p.meteringAreas[i].top, 307 p.meteringAreas[i].right, 308 p.meteringAreas[i].bottom, 309 p.meteringAreas[i].weight); 310 } 311 312 result.appendFormat(" Zoom index: %d\n", p.zoom); 313 result.appendFormat(" Video size: %d x %d\n", p.videoWidth, 314 p.videoHeight); 315 316 result.appendFormat(" Recording hint is %s\n", 317 p.recordingHint ? "set" : "not set"); 318 319 result.appendFormat(" Video stabilization is %s\n", 320 p.videoStabilization ? "enabled" : "disabled"); 321 322 result.append(" Current streams:\n"); 323 result.appendFormat(" Preview stream ID: %d\n", 324 getPreviewStreamId()); 325 result.appendFormat(" Capture stream ID: %d\n", 326 getCaptureStreamId()); 327 result.appendFormat(" Recording stream ID: %d\n", 328 getRecordingStreamId()); 329 330 result.append(" Current requests:\n"); 331 if (mPreviewRequest.entryCount() != 0) { 332 result.append(" Preview request:\n"); 333 write(fd, result.string(), result.size()); 334 mPreviewRequest.dump(fd, 2, 6); 335 } else { 336 result.append(" Preview request: undefined\n"); 337 write(fd, result.string(), result.size()); 338 } 339 340 if (mRecordingRequest.entryCount() != 0) { 341 result = " Recording request:\n"; 342 write(fd, result.string(), result.size()); 343 mRecordingRequest.dump(fd, 2, 6); 344 } else { 345 result = " Recording request: undefined\n"; 346 write(fd, result.string(), result.size()); 347 } 348 349 mCaptureSequencer->dump(fd, args); 350 351 mFrameProcessor->dump(fd, args); 352 353 result = " Device dump:\n"; 354 write(fd, result.string(), result.size()); 355 356 status_t res = mDevice->dump(fd, args); 357 if (res != OK) { 358 result = String8::format(" Error dumping device: %s (%d)", 359 strerror(-res), res); 360 write(fd, result.string(), result.size()); 361 } 362 363#undef CASE_APPEND_ENUM 364 return NO_ERROR; 365} 366 367// ICamera interface 368 369void Camera2Client::disconnect() { 370 ATRACE_CALL(); 371 ALOGV("%s: E", __FUNCTION__); 372 Mutex::Autolock icl(mICameraLock); 373 status_t res; 374 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 375 376 if (mDevice == 0) return; 377 378 stopPreviewL(); 379 380 if (mPreviewStreamId != NO_STREAM) { 381 mDevice->deleteStream(mPreviewStreamId); 382 mPreviewStreamId = NO_STREAM; 383 } 384 385 mJpegProcessor->deleteStream(); 386 387 if (mRecordingStreamId != NO_STREAM) { 388 mDevice->deleteStream(mRecordingStreamId); 389 mRecordingStreamId = NO_STREAM; 390 } 391 392 mCallbackProcessor->deleteStream(); 393 394 mDevice.clear(); 395 SharedParameters::Lock l(mParameters); 396 l.mParameters.state = Parameters::DISCONNECTED; 397 398 CameraService::Client::disconnect(); 399} 400 401status_t Camera2Client::connect(const sp<ICameraClient>& client) { 402 ATRACE_CALL(); 403 ALOGV("%s: E", __FUNCTION__); 404 Mutex::Autolock icl(mICameraLock); 405 406 if (mClientPid != 0 && getCallingPid() != mClientPid) { 407 ALOGE("%s: Camera %d: Connection attempt from pid %d; " 408 "current locked to pid %d", __FUNCTION__, 409 mCameraId, getCallingPid(), mClientPid); 410 return BAD_VALUE; 411 } 412 413 mClientPid = getCallingPid(); 414 415 mCameraClient = client; 416 mSharedCameraClient = client; 417 418 SharedParameters::Lock l(mParameters); 419 l.mParameters.state = Parameters::STOPPED; 420 421 return OK; 422} 423 424status_t Camera2Client::lock() { 425 ATRACE_CALL(); 426 ALOGV("%s: E", __FUNCTION__); 427 Mutex::Autolock icl(mICameraLock); 428 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d", 429 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 430 431 if (mClientPid == 0) { 432 mClientPid = getCallingPid(); 433 return OK; 434 } 435 436 if (mClientPid != getCallingPid()) { 437 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d", 438 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 439 return EBUSY; 440 } 441 442 return OK; 443} 444 445status_t Camera2Client::unlock() { 446 ATRACE_CALL(); 447 ALOGV("%s: E", __FUNCTION__); 448 Mutex::Autolock icl(mICameraLock); 449 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d", 450 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 451 452 // TODO: Check for uninterruptable conditions 453 454 if (mClientPid == getCallingPid()) { 455 mClientPid = 0; 456 mCameraClient.clear(); 457 mSharedCameraClient.clear(); 458 return OK; 459 } 460 461 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d", 462 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 463 return EBUSY; 464} 465 466status_t Camera2Client::setPreviewDisplay( 467 const sp<Surface>& surface) { 468 ATRACE_CALL(); 469 ALOGV("%s: E", __FUNCTION__); 470 Mutex::Autolock icl(mICameraLock); 471 status_t res; 472 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 473 474 sp<IBinder> binder; 475 sp<ANativeWindow> window; 476 if (surface != 0) { 477 binder = surface->asBinder(); 478 window = surface; 479 } 480 481 return setPreviewWindowL(binder,window); 482} 483 484status_t Camera2Client::setPreviewTexture( 485 const sp<ISurfaceTexture>& surfaceTexture) { 486 ATRACE_CALL(); 487 ALOGV("%s: E", __FUNCTION__); 488 Mutex::Autolock icl(mICameraLock); 489 status_t res; 490 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 491 492 sp<IBinder> binder; 493 sp<ANativeWindow> window; 494 if (surfaceTexture != 0) { 495 binder = surfaceTexture->asBinder(); 496 window = new SurfaceTextureClient(surfaceTexture); 497 } 498 return setPreviewWindowL(binder, window); 499} 500 501status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder, 502 sp<ANativeWindow> window) { 503 ATRACE_CALL(); 504 status_t res; 505 506 if (binder == mPreviewSurface) { 507 ALOGV("%s: Camera %d: New window is same as old window", 508 __FUNCTION__, mCameraId); 509 return NO_ERROR; 510 } 511 512 SharedParameters::Lock l(mParameters); 513 switch (l.mParameters.state) { 514 case Parameters::DISCONNECTED: 515 case Parameters::RECORD: 516 case Parameters::STILL_CAPTURE: 517 case Parameters::VIDEO_SNAPSHOT: 518 ALOGE("%s: Camera %d: Cannot set preview display while in state %s", 519 __FUNCTION__, mCameraId, 520 Parameters::getStateName(l.mParameters.state)); 521 return INVALID_OPERATION; 522 case Parameters::STOPPED: 523 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 524 // OK 525 break; 526 case Parameters::PREVIEW: 527 // Already running preview - need to stop and create a new stream 528 // TODO: Optimize this so that we don't wait for old stream to drain 529 // before spinning up new stream 530 mDevice->clearStreamingRequest(); 531 l.mParameters.state = Parameters::WAITING_FOR_PREVIEW_WINDOW; 532 break; 533 } 534 535 if (mPreviewStreamId != NO_STREAM) { 536 res = mDevice->waitUntilDrained(); 537 if (res != OK) { 538 ALOGE("%s: Error waiting for preview to drain: %s (%d)", 539 __FUNCTION__, strerror(-res), res); 540 return res; 541 } 542 res = mDevice->deleteStream(mPreviewStreamId); 543 if (res != OK) { 544 ALOGE("%s: Unable to delete old preview stream: %s (%d)", 545 __FUNCTION__, strerror(-res), res); 546 return res; 547 } 548 mPreviewStreamId = NO_STREAM; 549 } 550 551 mPreviewSurface = binder; 552 mPreviewWindow = window; 553 554 if (l.mParameters.state == Parameters::WAITING_FOR_PREVIEW_WINDOW) { 555 return startPreviewL(l.mParameters, false); 556 } 557 558 return OK; 559} 560 561void Camera2Client::setPreviewCallbackFlag(int flag) { 562 ATRACE_CALL(); 563 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag); 564 Mutex::Autolock icl(mICameraLock); 565 status_t res; 566 if ( checkPid(__FUNCTION__) != OK) return; 567 568 SharedParameters::Lock l(mParameters); 569 setPreviewCallbackFlagL(l.mParameters, flag); 570} 571 572void Camera2Client::setPreviewCallbackFlagL(Parameters ¶ms, int flag) { 573 status_t res = OK; 574 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) { 575 ALOGV("%s: setting oneshot", __FUNCTION__); 576 params.previewCallbackOneShot = true; 577 } 578 if (params.previewCallbackFlags != (uint32_t)flag) { 579 params.previewCallbackFlags = flag; 580 switch(params.state) { 581 case Parameters::PREVIEW: 582 res = startPreviewL(params, true); 583 break; 584 case Parameters::RECORD: 585 case Parameters::VIDEO_SNAPSHOT: 586 res = startRecordingL(params, true); 587 break; 588 default: 589 break; 590 } 591 if (res != OK) { 592 ALOGE("%s: Camera %d: Unable to refresh request in state %s", 593 __FUNCTION__, mCameraId, 594 Parameters::getStateName(params.state)); 595 } 596 } 597 598} 599 600status_t Camera2Client::startPreview() { 601 ATRACE_CALL(); 602 ALOGV("%s: E", __FUNCTION__); 603 Mutex::Autolock icl(mICameraLock); 604 status_t res; 605 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 606 SharedParameters::Lock l(mParameters); 607 return startPreviewL(l.mParameters, false); 608} 609 610status_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) { 611 ATRACE_CALL(); 612 status_t res; 613 if (params.state >= Parameters::PREVIEW && !restart) { 614 ALOGE("%s: Can't start preview in state %s", 615 __FUNCTION__, 616 Parameters::getStateName(params.state)); 617 return INVALID_OPERATION; 618 } 619 620 if (mPreviewWindow == 0) { 621 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW; 622 return OK; 623 } 624 params.state = Parameters::STOPPED; 625 626 res = updatePreviewStream(params); 627 if (res != OK) { 628 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)", 629 __FUNCTION__, mCameraId, strerror(-res), res); 630 return res; 631 } 632 bool callbacksEnabled = params.previewCallbackFlags & 633 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK; 634 if (callbacksEnabled) { 635 res = mCallbackProcessor->updateStream(params); 636 if (res != OK) { 637 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)", 638 __FUNCTION__, mCameraId, strerror(-res), res); 639 return res; 640 } 641 } 642 if (params.zslMode) { 643 res = mZslProcessor->updateStream(params); 644 if (res != OK) { 645 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)", 646 __FUNCTION__, mCameraId, strerror(-res), res); 647 return res; 648 } 649 } 650 651 if (mPreviewRequest.entryCount() == 0) { 652 res = updatePreviewRequest(params); 653 if (res != OK) { 654 ALOGE("%s: Camera %d: Unable to create preview request: %s (%d)", 655 __FUNCTION__, mCameraId, strerror(-res), res); 656 return res; 657 } 658 } 659 660 Vector<uint8_t> outputStreams; 661 outputStreams.push(getPreviewStreamId()); 662 663 if (callbacksEnabled) { 664 outputStreams.push(getCallbackStreamId()); 665 } 666 if (params.zslMode) { 667 outputStreams.push(getZslStreamId()); 668 } 669 670 res = mPreviewRequest.update( 671 ANDROID_REQUEST_OUTPUT_STREAMS, 672 outputStreams); 673 674 if (res != OK) { 675 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)", 676 __FUNCTION__, mCameraId, strerror(-res), res); 677 return res; 678 } 679 res = mPreviewRequest.sort(); 680 if (res != OK) { 681 ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)", 682 __FUNCTION__, mCameraId, strerror(-res), res); 683 return res; 684 } 685 686 res = mDevice->setStreamingRequest(mPreviewRequest); 687 if (res != OK) { 688 ALOGE("%s: Camera %d: Unable to set preview request to start preview: " 689 "%s (%d)", 690 __FUNCTION__, mCameraId, strerror(-res), res); 691 return res; 692 } 693 params.state = Parameters::PREVIEW; 694 695 return OK; 696} 697 698void Camera2Client::stopPreview() { 699 ATRACE_CALL(); 700 ALOGV("%s: E", __FUNCTION__); 701 Mutex::Autolock icl(mICameraLock); 702 status_t res; 703 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 704 stopPreviewL(); 705} 706 707void Camera2Client::stopPreviewL() { 708 ATRACE_CALL(); 709 Parameters::State state; 710 { 711 SharedParameters::Lock l(mParameters); 712 state = l.mParameters.state; 713 } 714 715 switch (state) { 716 case Parameters::DISCONNECTED: 717 ALOGE("%s: Camera %d: Call before initialized", 718 __FUNCTION__, mCameraId); 719 break; 720 case Parameters::STOPPED: 721 break; 722 case Parameters::STILL_CAPTURE: 723 ALOGE("%s: Camera %d: Cannot stop preview during still capture.", 724 __FUNCTION__, mCameraId); 725 break; 726 case Parameters::RECORD: 727 // no break - identical to preview 728 case Parameters::PREVIEW: 729 mDevice->clearStreamingRequest(); 730 mDevice->waitUntilDrained(); 731 // no break 732 case Parameters::WAITING_FOR_PREVIEW_WINDOW: { 733 SharedParameters::Lock l(mParameters); 734 l.mParameters.state = Parameters::STOPPED; 735 commandStopFaceDetectionL(l.mParameters); 736 break; 737 } 738 default: 739 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId, 740 state); 741 } 742} 743 744bool Camera2Client::previewEnabled() { 745 ATRACE_CALL(); 746 Mutex::Autolock icl(mICameraLock); 747 status_t res; 748 if ( (res = checkPid(__FUNCTION__) ) != OK) return false; 749 750 SharedParameters::Lock l(mParameters); 751 return l.mParameters.state == Parameters::PREVIEW; 752} 753 754status_t Camera2Client::storeMetaDataInBuffers(bool enabled) { 755 ATRACE_CALL(); 756 Mutex::Autolock icl(mICameraLock); 757 status_t res; 758 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 759 760 SharedParameters::Lock l(mParameters); 761 switch (l.mParameters.state) { 762 case Parameters::RECORD: 763 case Parameters::VIDEO_SNAPSHOT: 764 ALOGE("%s: Camera %d: Can't be called in state %s", 765 __FUNCTION__, mCameraId, 766 Parameters::getStateName(l.mParameters.state)); 767 return INVALID_OPERATION; 768 default: 769 // OK 770 break; 771 } 772 773 l.mParameters.storeMetadataInBuffers = enabled; 774 775 return OK; 776} 777 778status_t Camera2Client::startRecording() { 779 ATRACE_CALL(); 780 ALOGV("%s: E", __FUNCTION__); 781 Mutex::Autolock icl(mICameraLock); 782 status_t res; 783 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 784 SharedParameters::Lock l(mParameters); 785 786 return startRecordingL(l.mParameters, false); 787} 788 789status_t Camera2Client::startRecordingL(Parameters ¶ms, bool restart) { 790 status_t res; 791 switch (params.state) { 792 case Parameters::STOPPED: 793 res = startPreviewL(params, false); 794 if (res != OK) return res; 795 break; 796 case Parameters::PREVIEW: 797 // Ready to go 798 break; 799 case Parameters::RECORD: 800 case Parameters::VIDEO_SNAPSHOT: 801 // OK to call this when recording is already on, just skip unless 802 // we're looking to restart 803 if (!restart) return OK; 804 break; 805 default: 806 ALOGE("%s: Camera %d: Can't start recording in state %s", 807 __FUNCTION__, mCameraId, 808 Parameters::getStateName(params.state)); 809 return INVALID_OPERATION; 810 }; 811 812 if (!params.storeMetadataInBuffers) { 813 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but " 814 "non-metadata recording mode requested!", __FUNCTION__, 815 mCameraId); 816 return INVALID_OPERATION; 817 } 818 819 res = updateRecordingStream(params); 820 if (res != OK) { 821 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)", 822 __FUNCTION__, mCameraId, strerror(-res), res); 823 return res; 824 } 825 bool callbacksEnabled = params.previewCallbackFlags & 826 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK; 827 if (callbacksEnabled) { 828 res = mCallbackProcessor->updateStream(params); 829 if (res != OK) { 830 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)", 831 __FUNCTION__, mCameraId, strerror(-res), res); 832 return res; 833 } 834 } 835 836 if (mRecordingRequest.entryCount() == 0) { 837 res = updateRecordingRequest(params); 838 if (res != OK) { 839 ALOGE("%s: Camera %d: Unable to create recording request: %s (%d)", 840 __FUNCTION__, mCameraId, strerror(-res), res); 841 return res; 842 } 843 } 844 845 if (callbacksEnabled) { 846 uint8_t outputStreams[3] ={ 847 getPreviewStreamId(), 848 getRecordingStreamId(), 849 getCallbackStreamId() 850 }; 851 res = mRecordingRequest.update( 852 ANDROID_REQUEST_OUTPUT_STREAMS, 853 outputStreams, 3); 854 } else { 855 uint8_t outputStreams[2] = { 856 getPreviewStreamId(), 857 getRecordingStreamId() 858 }; 859 res = mRecordingRequest.update( 860 ANDROID_REQUEST_OUTPUT_STREAMS, 861 outputStreams, 2); 862 } 863 if (res != OK) { 864 ALOGE("%s: Camera %d: Unable to set up recording request: %s (%d)", 865 __FUNCTION__, mCameraId, strerror(-res), res); 866 return res; 867 } 868 res = mRecordingRequest.sort(); 869 if (res != OK) { 870 ALOGE("%s: Camera %d: Error sorting recording request: %s (%d)", 871 __FUNCTION__, mCameraId, strerror(-res), res); 872 return res; 873 } 874 875 res = mDevice->setStreamingRequest(mRecordingRequest); 876 if (res != OK) { 877 ALOGE("%s: Camera %d: Unable to set recording request to start " 878 "recording: %s (%d)", __FUNCTION__, mCameraId, 879 strerror(-res), res); 880 return res; 881 } 882 if (params.state < Parameters::RECORD) { 883 params.state = Parameters::RECORD; 884 } 885 886 return OK; 887} 888 889void Camera2Client::stopRecording() { 890 ATRACE_CALL(); 891 ALOGV("%s: E", __FUNCTION__); 892 Mutex::Autolock icl(mICameraLock); 893 SharedParameters::Lock l(mParameters); 894 895 status_t res; 896 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 897 898 switch (l.mParameters.state) { 899 case Parameters::RECORD: 900 // OK to stop 901 break; 902 case Parameters::STOPPED: 903 case Parameters::PREVIEW: 904 case Parameters::STILL_CAPTURE: 905 case Parameters::VIDEO_SNAPSHOT: 906 default: 907 ALOGE("%s: Camera %d: Can't stop recording in state %s", 908 __FUNCTION__, mCameraId, 909 Parameters::getStateName(l.mParameters.state)); 910 return; 911 }; 912 913 // Back to preview. Since record can only be reached through preview, 914 // all preview stream setup should be up to date. 915 res = mDevice->setStreamingRequest(mPreviewRequest); 916 if (res != OK) { 917 ALOGE("%s: Camera %d: Unable to switch back to preview request: " 918 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 919 return; 920 } 921 922 // TODO: Should recording heap be freed? Can't do it yet since requests 923 // could still be in flight. 924 925 l.mParameters.state = Parameters::PREVIEW; 926} 927 928bool Camera2Client::recordingEnabled() { 929 ATRACE_CALL(); 930 Mutex::Autolock icl(mICameraLock); 931 932 if ( checkPid(__FUNCTION__) != OK) return false; 933 934 return recordingEnabledL(); 935} 936 937bool Camera2Client::recordingEnabledL() { 938 ATRACE_CALL(); 939 SharedParameters::Lock l(mParameters); 940 941 return (l.mParameters.state == Parameters::RECORD 942 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT); 943} 944 945void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) { 946 ATRACE_CALL(); 947 Mutex::Autolock icl(mICameraLock); 948 status_t res; 949 if ( checkPid(__FUNCTION__) != OK) return; 950 951 SharedParameters::Lock l(mParameters); 952 953 // Make sure this is for the current heap 954 ssize_t offset; 955 size_t size; 956 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); 957 if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) { 958 ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release " 959 "(got %x, expected %x)", __FUNCTION__, mCameraId, 960 heap->getHeapID(), mRecordingHeap->mHeap->getHeapID()); 961 return; 962 } 963 uint8_t *data = (uint8_t*)heap->getBase() + offset; 964 uint32_t type = *(uint32_t*)data; 965 if (type != kMetadataBufferTypeGrallocSource) { 966 ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)", 967 __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource); 968 return; 969 } 970 971 // Release the buffer back to the recording queue 972 973 buffer_handle_t imgHandle = *(buffer_handle_t*)(data + 4); 974 975 size_t itemIndex; 976 for (itemIndex = 0; itemIndex < mRecordingBuffers.size(); itemIndex++) { 977 const BufferItemConsumer::BufferItem item = mRecordingBuffers[itemIndex]; 978 if (item.mBuf != BufferItemConsumer::INVALID_BUFFER_SLOT && 979 item.mGraphicBuffer->handle == imgHandle) { 980 break; 981 } 982 } 983 if (itemIndex == mRecordingBuffers.size()) { 984 ALOGE("%s: Camera %d: Can't find buffer_handle_t %p in list of " 985 "outstanding buffers", __FUNCTION__, mCameraId, imgHandle); 986 return; 987 } 988 989 ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId, 990 imgHandle); 991 992 res = mRecordingConsumer->releaseBuffer(mRecordingBuffers[itemIndex]); 993 if (res != OK) { 994 ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):" 995 "%s (%d)", 996 __FUNCTION__, mCameraId, imgHandle, strerror(-res), res); 997 return; 998 } 999 mRecordingBuffers.replaceAt(itemIndex); 1000 1001 mRecordingHeapFree++; 1002} 1003 1004status_t Camera2Client::autoFocus() { 1005 ATRACE_CALL(); 1006 Mutex::Autolock icl(mICameraLock); 1007 status_t res; 1008 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1009 1010 int triggerId; 1011 { 1012 SharedParameters::Lock l(mParameters); 1013 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter; 1014 triggerId = l.mParameters.currentAfTriggerId; 1015 } 1016 1017 mDevice->triggerAutofocus(triggerId); 1018 1019 return OK; 1020} 1021 1022status_t Camera2Client::cancelAutoFocus() { 1023 ATRACE_CALL(); 1024 Mutex::Autolock icl(mICameraLock); 1025 status_t res; 1026 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1027 1028 int triggerId; 1029 { 1030 SharedParameters::Lock l(mParameters); 1031 triggerId = ++l.mParameters.afTriggerCounter; 1032 } 1033 1034 mDevice->triggerCancelAutofocus(triggerId); 1035 1036 return OK; 1037} 1038 1039status_t Camera2Client::takePicture(int msgType) { 1040 ATRACE_CALL(); 1041 Mutex::Autolock icl(mICameraLock); 1042 status_t res; 1043 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1044 1045 SharedParameters::Lock l(mParameters); 1046 switch (l.mParameters.state) { 1047 case Parameters::DISCONNECTED: 1048 case Parameters::STOPPED: 1049 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 1050 ALOGE("%s: Camera %d: Cannot take picture without preview enabled", 1051 __FUNCTION__, mCameraId); 1052 return INVALID_OPERATION; 1053 case Parameters::PREVIEW: 1054 // Good to go for takePicture 1055 res = commandStopFaceDetectionL(l.mParameters); 1056 if (res != OK) { 1057 ALOGE("%s: Camera %d: Unable to stop face detection for still capture", 1058 __FUNCTION__, mCameraId); 1059 return res; 1060 } 1061 l.mParameters.state = Parameters::STILL_CAPTURE; 1062 break; 1063 case Parameters::RECORD: 1064 // Good to go for video snapshot 1065 l.mParameters.state = Parameters::VIDEO_SNAPSHOT; 1066 break; 1067 case Parameters::STILL_CAPTURE: 1068 case Parameters::VIDEO_SNAPSHOT: 1069 ALOGE("%s: Camera %d: Already taking a picture", 1070 __FUNCTION__, mCameraId); 1071 return INVALID_OPERATION; 1072 } 1073 1074 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId); 1075 1076 res = mJpegProcessor->updateStream(l.mParameters); 1077 if (res != OK) { 1078 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)", 1079 __FUNCTION__, mCameraId, strerror(-res), res); 1080 return res; 1081 } 1082 1083 res = mCaptureSequencer->startCapture(); 1084 if (res != OK) { 1085 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)", 1086 __FUNCTION__, mCameraId, strerror(-res), res); 1087 } 1088 1089 return res; 1090} 1091 1092status_t Camera2Client::setParameters(const String8& params) { 1093 ATRACE_CALL(); 1094 ALOGV("%s: E", __FUNCTION__); 1095 Mutex::Autolock icl(mICameraLock); 1096 status_t res; 1097 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1098 1099 SharedParameters::Lock l(mParameters); 1100 1101 res = l.mParameters.set(params); 1102 if (res != OK) return res; 1103 1104 res = updateRequests(l.mParameters); 1105 1106 return res; 1107} 1108 1109String8 Camera2Client::getParameters() const { 1110 ATRACE_CALL(); 1111 Mutex::Autolock icl(mICameraLock); 1112 if ( checkPid(__FUNCTION__) != OK) return String8(); 1113 1114 SharedParameters::ReadLock l(mParameters); 1115 1116 // TODO: Deal with focus distances 1117 return l.mParameters.paramsFlattened; 1118} 1119 1120status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { 1121 ATRACE_CALL(); 1122 Mutex::Autolock icl(mICameraLock); 1123 status_t res; 1124 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1125 1126 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId, 1127 cmd, arg1, arg2); 1128 1129 switch (cmd) { 1130 case CAMERA_CMD_START_SMOOTH_ZOOM: 1131 return commandStartSmoothZoomL(); 1132 case CAMERA_CMD_STOP_SMOOTH_ZOOM: 1133 return commandStopSmoothZoomL(); 1134 case CAMERA_CMD_SET_DISPLAY_ORIENTATION: 1135 return commandSetDisplayOrientationL(arg1); 1136 case CAMERA_CMD_ENABLE_SHUTTER_SOUND: 1137 return commandEnableShutterSoundL(arg1 == 1); 1138 case CAMERA_CMD_PLAY_RECORDING_SOUND: 1139 return commandPlayRecordingSoundL(); 1140 case CAMERA_CMD_START_FACE_DETECTION: 1141 return commandStartFaceDetectionL(arg1); 1142 case CAMERA_CMD_STOP_FACE_DETECTION: { 1143 SharedParameters::Lock l(mParameters); 1144 return commandStopFaceDetectionL(l.mParameters); 1145 } 1146 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG: 1147 return commandEnableFocusMoveMsgL(arg1 == 1); 1148 case CAMERA_CMD_PING: 1149 return commandPingL(); 1150 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT: 1151 return commandSetVideoBufferCountL(arg1); 1152 default: 1153 ALOGE("%s: Unknown command %d (arguments %d, %d)", 1154 __FUNCTION__, cmd, arg1, arg2); 1155 return BAD_VALUE; 1156 } 1157} 1158 1159status_t Camera2Client::commandStartSmoothZoomL() { 1160 ALOGE("%s: Unimplemented!", __FUNCTION__); 1161 return OK; 1162} 1163 1164status_t Camera2Client::commandStopSmoothZoomL() { 1165 ALOGE("%s: Unimplemented!", __FUNCTION__); 1166 return OK; 1167} 1168 1169status_t Camera2Client::commandSetDisplayOrientationL(int degrees) { 1170 int transform = Parameters::degToTransform(degrees, 1171 mCameraFacing == CAMERA_FACING_FRONT); 1172 if (transform == -1) { 1173 ALOGE("%s: Camera %d: Error setting %d as display orientation value", 1174 __FUNCTION__, mCameraId, degrees); 1175 return BAD_VALUE; 1176 } 1177 SharedParameters::Lock l(mParameters); 1178 if (transform != l.mParameters.previewTransform && 1179 mPreviewStreamId != NO_STREAM) { 1180 mDevice->setStreamTransform(mPreviewStreamId, transform); 1181 } 1182 l.mParameters.previewTransform = transform; 1183 return OK; 1184} 1185 1186status_t Camera2Client::commandEnableShutterSoundL(bool enable) { 1187 SharedParameters::Lock l(mParameters); 1188 if (enable) { 1189 l.mParameters.playShutterSound = true; 1190 return OK; 1191 } 1192 1193 // Disabling shutter sound may not be allowed. In that case only 1194 // allow the mediaserver process to disable the sound. 1195 char value[PROPERTY_VALUE_MAX]; 1196 property_get("ro.camera.sound.forced", value, "0"); 1197 if (strncmp(value, "0", 2) != 0) { 1198 // Disabling shutter sound is not allowed. Deny if the current 1199 // process is not mediaserver. 1200 if (getCallingPid() != getpid()) { 1201 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)", 1202 getCallingPid()); 1203 return PERMISSION_DENIED; 1204 } 1205 } 1206 1207 l.mParameters.playShutterSound = false; 1208 return OK; 1209} 1210 1211status_t Camera2Client::commandPlayRecordingSoundL() { 1212 mCameraService->playSound(CameraService::SOUND_RECORDING); 1213 return OK; 1214} 1215 1216status_t Camera2Client::commandStartFaceDetectionL(int type) { 1217 ALOGV("%s: Camera %d: Starting face detection", 1218 __FUNCTION__, mCameraId); 1219 status_t res; 1220 SharedParameters::Lock l(mParameters); 1221 switch (l.mParameters.state) { 1222 case Parameters::DISCONNECTED: 1223 case Parameters::STOPPED: 1224 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 1225 case Parameters::STILL_CAPTURE: 1226 ALOGE("%s: Camera %d: Cannot start face detection without preview active", 1227 __FUNCTION__, mCameraId); 1228 return INVALID_OPERATION; 1229 case Parameters::PREVIEW: 1230 case Parameters::RECORD: 1231 case Parameters::VIDEO_SNAPSHOT: 1232 // Good to go for starting face detect 1233 break; 1234 } 1235 // Ignoring type 1236 if (l.mParameters.fastInfo.bestFaceDetectMode == 1237 ANDROID_STATS_FACE_DETECTION_OFF) { 1238 ALOGE("%s: Camera %d: Face detection not supported", 1239 __FUNCTION__, mCameraId); 1240 return INVALID_OPERATION; 1241 } 1242 if (l.mParameters.enableFaceDetect) return OK; 1243 1244 l.mParameters.enableFaceDetect = true; 1245 1246 res = updateRequests(l.mParameters); 1247 1248 return res; 1249} 1250 1251status_t Camera2Client::commandStopFaceDetectionL(Parameters ¶ms) { 1252 status_t res = OK; 1253 ALOGV("%s: Camera %d: Stopping face detection", 1254 __FUNCTION__, mCameraId); 1255 1256 if (!params.enableFaceDetect) return OK; 1257 1258 params.enableFaceDetect = false; 1259 1260 if (params.state == Parameters::PREVIEW 1261 || params.state == Parameters::RECORD 1262 || params.state == Parameters::VIDEO_SNAPSHOT) { 1263 res = updateRequests(params); 1264 } 1265 1266 return res; 1267} 1268 1269status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) { 1270 SharedParameters::Lock l(mParameters); 1271 l.mParameters.enableFocusMoveMessages = enable; 1272 1273 return OK; 1274} 1275 1276status_t Camera2Client::commandPingL() { 1277 // Always ping back if access is proper and device is alive 1278 SharedParameters::Lock l(mParameters); 1279 if (l.mParameters.state != Parameters::DISCONNECTED) { 1280 return OK; 1281 } else { 1282 return NO_INIT; 1283 } 1284} 1285 1286status_t Camera2Client::commandSetVideoBufferCountL(size_t count) { 1287 if (recordingEnabledL()) { 1288 ALOGE("%s: Camera %d: Error setting video buffer count after " 1289 "recording was started", __FUNCTION__, mCameraId); 1290 return INVALID_OPERATION; 1291 } 1292 1293 // 32 is the current upper limit on the video buffer count for BufferQueue 1294 if (count > 32) { 1295 ALOGE("%s: Camera %d: Error setting %d as video buffer count value", 1296 __FUNCTION__, mCameraId, count); 1297 return BAD_VALUE; 1298 } 1299 1300 // Need to reallocate memory for heap 1301 if (mRecordingHeapCount != count) { 1302 if (mRecordingHeap != 0) { 1303 mRecordingHeap.clear(); 1304 mRecordingHeap = NULL; 1305 } 1306 mRecordingHeapCount = count; 1307 } 1308 1309 return OK; 1310} 1311 1312/** Device-related methods */ 1313 1314void Camera2Client::notifyError(int errorCode, int arg1, int arg2) { 1315 ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2); 1316} 1317 1318void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) { 1319 ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__, 1320 frameNumber, timestamp); 1321} 1322 1323void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) { 1324 ALOGV("%s: Autofocus state now %d, last trigger %d", 1325 __FUNCTION__, newState, triggerId); 1326 bool sendCompletedMessage = false; 1327 bool sendMovingMessage = false; 1328 1329 bool success = false; 1330 bool afInMotion = false; 1331 { 1332 SharedParameters::Lock l(mParameters); 1333 switch (l.mParameters.focusMode) { 1334 case Parameters::FOCUS_MODE_AUTO: 1335 case Parameters::FOCUS_MODE_MACRO: 1336 // Don't send notifications upstream if they're not for the current AF 1337 // trigger. For example, if cancel was called in between, or if we 1338 // already sent a notification about this AF call. 1339 if (triggerId != l.mParameters.currentAfTriggerId) break; 1340 switch (newState) { 1341 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1342 success = true; 1343 // no break 1344 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1345 sendCompletedMessage = true; 1346 l.mParameters.currentAfTriggerId = -1; 1347 break; 1348 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 1349 // Just starting focusing, ignore 1350 break; 1351 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1352 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1353 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1354 default: 1355 // Unexpected in AUTO/MACRO mode 1356 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d", 1357 __FUNCTION__, newState); 1358 break; 1359 } 1360 break; 1361 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1362 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1363 switch (newState) { 1364 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1365 success = true; 1366 // no break 1367 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1368 // Don't send notifications upstream if they're not for 1369 // the current AF trigger. For example, if cancel was 1370 // called in between, or if we already sent a 1371 // notification about this AF call. 1372 // Send both a 'AF done' callback and a 'AF move' callback 1373 if (triggerId != l.mParameters.currentAfTriggerId) break; 1374 sendCompletedMessage = true; 1375 afInMotion = false; 1376 if (l.mParameters.enableFocusMoveMessages && 1377 l.mParameters.afInMotion) { 1378 sendMovingMessage = true; 1379 } 1380 l.mParameters.currentAfTriggerId = -1; 1381 break; 1382 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1383 // Cancel was called, or we switched state; care if 1384 // currently moving 1385 afInMotion = false; 1386 if (l.mParameters.enableFocusMoveMessages && 1387 l.mParameters.afInMotion) { 1388 sendMovingMessage = true; 1389 } 1390 break; 1391 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1392 // Start passive scan, inform upstream 1393 afInMotion = true; 1394 // no break 1395 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1396 // Stop passive scan, inform upstream 1397 if (l.mParameters.enableFocusMoveMessages) { 1398 sendMovingMessage = true; 1399 } 1400 break; 1401 } 1402 l.mParameters.afInMotion = afInMotion; 1403 break; 1404 case Parameters::FOCUS_MODE_EDOF: 1405 case Parameters::FOCUS_MODE_INFINITY: 1406 case Parameters::FOCUS_MODE_FIXED: 1407 default: 1408 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) { 1409 ALOGE("%s: Unexpected AF state change %d " 1410 "(ID %d) in focus mode %d", 1411 __FUNCTION__, newState, triggerId, 1412 l.mParameters.focusMode); 1413 } 1414 } 1415 } 1416 if (sendMovingMessage) { 1417 SharedCameraClient::Lock l(mSharedCameraClient); 1418 if (l.mCameraClient != 0) { 1419 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE, 1420 afInMotion ? 1 : 0, 0); 1421 } 1422 } 1423 if (sendCompletedMessage) { 1424 SharedCameraClient::Lock l(mSharedCameraClient); 1425 if (l.mCameraClient != 0) { 1426 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS, 1427 success ? 1 : 0, 0); 1428 } 1429 } 1430} 1431 1432void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) { 1433 ALOGV("%s: Autoexposure state now %d, last trigger %d", 1434 __FUNCTION__, newState, triggerId); 1435 mCaptureSequencer->notifyAutoExposure(newState, triggerId); 1436} 1437 1438void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) { 1439 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d", 1440 __FUNCTION__, newState, triggerId); 1441} 1442 1443int Camera2Client::getCameraId() const { 1444 return mCameraId; 1445} 1446 1447const sp<Camera2Device>& Camera2Client::getCameraDevice() { 1448 return mDevice; 1449} 1450 1451camera2::SharedParameters& Camera2Client::getParameters() { 1452 return mParameters; 1453} 1454 1455int Camera2Client::getPreviewStreamId() const { 1456 return mPreviewStreamId; 1457} 1458 1459int Camera2Client::getCaptureStreamId() const { 1460 return mJpegProcessor->getStreamId(); 1461} 1462 1463int Camera2Client::getCallbackStreamId() const { 1464 return mCallbackProcessor->getStreamId(); 1465} 1466 1467int Camera2Client::getRecordingStreamId() const { 1468 return mRecordingStreamId; 1469} 1470 1471int Camera2Client::getZslStreamId() const { 1472 return mZslProcessor->getStreamId(); 1473} 1474 1475status_t Camera2Client::registerFrameListener(int32_t id, 1476 wp<camera2::FrameProcessor::FilteredListener> listener) { 1477 return mFrameProcessor->registerListener(id, listener); 1478} 1479 1480status_t Camera2Client::removeFrameListener(int32_t id) { 1481 return mFrameProcessor->removeListener(id); 1482} 1483 1484Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client): 1485 mCameraClient(client.mCameraClient), 1486 mSharedClient(client) { 1487 mSharedClient.mCameraClientLock.lock(); 1488} 1489 1490Camera2Client::SharedCameraClient::Lock::~Lock() { 1491 mSharedClient.mCameraClientLock.unlock(); 1492} 1493 1494Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client): 1495 mCameraClient(client) { 1496} 1497 1498Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=( 1499 const sp<ICameraClient>&client) { 1500 Mutex::Autolock l(mCameraClientLock); 1501 mCameraClient = client; 1502 return *this; 1503} 1504 1505void Camera2Client::SharedCameraClient::clear() { 1506 Mutex::Autolock l(mCameraClientLock); 1507 mCameraClient.clear(); 1508} 1509 1510const int32_t Camera2Client::kPreviewRequestId; 1511const int32_t Camera2Client::kRecordRequestId; 1512const int32_t Camera2Client::kFirstCaptureRequestId; 1513 1514void Camera2Client::onRecordingFrameAvailable() { 1515 ATRACE_CALL(); 1516 status_t res; 1517 sp<Camera2Heap> recordingHeap; 1518 size_t heapIdx = 0; 1519 nsecs_t timestamp; 1520 { 1521 SharedParameters::Lock l(mParameters); 1522 1523 BufferItemConsumer::BufferItem imgBuffer; 1524 res = mRecordingConsumer->acquireBuffer(&imgBuffer); 1525 if (res != OK) { 1526 ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)", 1527 __FUNCTION__, mCameraId, strerror(-res), res); 1528 return; 1529 } 1530 timestamp = imgBuffer.mTimestamp; 1531 1532 mRecordingFrameCount++; 1533 ALOGV("OnRecordingFrame: Frame %d", mRecordingFrameCount); 1534 1535 // TODO: Signal errors here upstream 1536 if (l.mParameters.state != Parameters::RECORD && 1537 l.mParameters.state != Parameters::VIDEO_SNAPSHOT) { 1538 ALOGV("%s: Camera %d: Discarding recording image buffers received after " 1539 "recording done", 1540 __FUNCTION__, mCameraId); 1541 mRecordingConsumer->releaseBuffer(imgBuffer); 1542 return; 1543 } 1544 1545 if (mRecordingHeap == 0) { 1546 const size_t bufferSize = 4 + sizeof(buffer_handle_t); 1547 ALOGV("%s: Camera %d: Creating recording heap with %d buffers of " 1548 "size %d bytes", __FUNCTION__, mCameraId, 1549 mRecordingHeapCount, bufferSize); 1550 1551 mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount, 1552 "Camera2Client::RecordingHeap"); 1553 if (mRecordingHeap->mHeap->getSize() == 0) { 1554 ALOGE("%s: Camera %d: Unable to allocate memory for recording", 1555 __FUNCTION__, mCameraId); 1556 mRecordingConsumer->releaseBuffer(imgBuffer); 1557 return; 1558 } 1559 for (size_t i = 0; i < mRecordingBuffers.size(); i++) { 1560 if (mRecordingBuffers[i].mBuf != 1561 BufferItemConsumer::INVALID_BUFFER_SLOT) { 1562 ALOGE("%s: Camera %d: Non-empty recording buffers list!", 1563 __FUNCTION__, mCameraId); 1564 } 1565 } 1566 mRecordingBuffers.clear(); 1567 mRecordingBuffers.setCapacity(mRecordingHeapCount); 1568 mRecordingBuffers.insertAt(0, mRecordingHeapCount); 1569 1570 mRecordingHeapHead = 0; 1571 mRecordingHeapFree = mRecordingHeapCount; 1572 } 1573 1574 if ( mRecordingHeapFree == 0) { 1575 ALOGE("%s: Camera %d: No free recording buffers, dropping frame", 1576 __FUNCTION__, mCameraId); 1577 mRecordingConsumer->releaseBuffer(imgBuffer); 1578 return; 1579 } 1580 1581 heapIdx = mRecordingHeapHead; 1582 mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount; 1583 mRecordingHeapFree--; 1584 1585 ALOGV("%s: Camera %d: Timestamp %lld", 1586 __FUNCTION__, mCameraId, timestamp); 1587 1588 ssize_t offset; 1589 size_t size; 1590 sp<IMemoryHeap> heap = 1591 mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset, 1592 &size); 1593 1594 uint8_t *data = (uint8_t*)heap->getBase() + offset; 1595 uint32_t type = kMetadataBufferTypeGrallocSource; 1596 *((uint32_t*)data) = type; 1597 *((buffer_handle_t*)(data + 4)) = imgBuffer.mGraphicBuffer->handle; 1598 ALOGV("%s: Camera %d: Sending out buffer_handle_t %p", 1599 __FUNCTION__, mCameraId, imgBuffer.mGraphicBuffer->handle); 1600 mRecordingBuffers.replaceAt(imgBuffer, heapIdx); 1601 recordingHeap = mRecordingHeap; 1602 } 1603 1604 // Call outside locked parameters to allow re-entrancy from notification 1605 SharedCameraClient::Lock l(mSharedCameraClient); 1606 if (l.mCameraClient != 0) { 1607 l.mCameraClient->dataCallbackTimestamp(timestamp, 1608 CAMERA_MSG_VIDEO_FRAME, 1609 recordingHeap->mBuffers[heapIdx]); 1610 } 1611} 1612 1613/** Utility methods */ 1614 1615status_t Camera2Client::updateRequests(const Parameters ¶ms) { 1616 status_t res; 1617 1618 res = updatePreviewRequest(params); 1619 if (res != OK) { 1620 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)", 1621 __FUNCTION__, mCameraId, strerror(-res), res); 1622 return res; 1623 } 1624 res = updateRecordingRequest(params); 1625 if (res != OK) { 1626 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)", 1627 __FUNCTION__, mCameraId, strerror(-res), res); 1628 return res; 1629 } 1630 1631 if (params.state == Parameters::PREVIEW) { 1632 res = mDevice->setStreamingRequest(mPreviewRequest); 1633 if (res != OK) { 1634 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)", 1635 __FUNCTION__, mCameraId, strerror(-res), res); 1636 return res; 1637 } 1638 } else if (params.state == Parameters::RECORD || 1639 params.state == Parameters::VIDEO_SNAPSHOT) { 1640 res = mDevice->setStreamingRequest(mRecordingRequest); 1641 if (res != OK) { 1642 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)", 1643 __FUNCTION__, mCameraId, strerror(-res), res); 1644 return res; 1645 } 1646 } 1647 return res; 1648} 1649 1650status_t Camera2Client::updatePreviewStream(const Parameters ¶ms) { 1651 ATRACE_CALL(); 1652 status_t res; 1653 1654 if (mPreviewStreamId != NO_STREAM) { 1655 // Check if stream parameters have to change 1656 uint32_t currentWidth, currentHeight; 1657 res = mDevice->getStreamInfo(mPreviewStreamId, 1658 ¤tWidth, ¤tHeight, 0); 1659 if (res != OK) { 1660 ALOGE("%s: Camera %d: Error querying preview stream info: " 1661 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1662 return res; 1663 } 1664 if (currentWidth != (uint32_t)params.previewWidth || 1665 currentHeight != (uint32_t)params.previewHeight) { 1666 ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d", 1667 __FUNCTION__, mCameraId, currentWidth, currentHeight, 1668 params.previewWidth, params.previewHeight); 1669 res = mDevice->waitUntilDrained(); 1670 if (res != OK) { 1671 ALOGE("%s: Camera %d: Error waiting for preview to drain: " 1672 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1673 return res; 1674 } 1675 res = mDevice->deleteStream(mPreviewStreamId); 1676 if (res != OK) { 1677 ALOGE("%s: Camera %d: Unable to delete old output stream " 1678 "for preview: %s (%d)", __FUNCTION__, mCameraId, 1679 strerror(-res), res); 1680 return res; 1681 } 1682 mPreviewStreamId = NO_STREAM; 1683 } 1684 } 1685 1686 if (mPreviewStreamId == NO_STREAM) { 1687 res = mDevice->createStream(mPreviewWindow, 1688 params.previewWidth, params.previewHeight, 1689 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, 1690 &mPreviewStreamId); 1691 if (res != OK) { 1692 ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)", 1693 __FUNCTION__, mCameraId, strerror(-res), res); 1694 return res; 1695 } 1696 } 1697 1698 res = mDevice->setStreamTransform(mPreviewStreamId, 1699 params.previewTransform); 1700 if (res != OK) { 1701 ALOGE("%s: Camera %d: Unable to set preview stream transform: " 1702 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1703 return res; 1704 } 1705 1706 return OK; 1707} 1708 1709status_t Camera2Client::updatePreviewRequest(const Parameters ¶ms) { 1710 ATRACE_CALL(); 1711 status_t res; 1712 if (mPreviewRequest.entryCount() == 0) { 1713 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW, 1714 &mPreviewRequest); 1715 if (res != OK) { 1716 ALOGE("%s: Camera %d: Unable to create default preview request: " 1717 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1718 return res; 1719 } 1720 } 1721 1722 res = params.updateRequest(&mPreviewRequest); 1723 if (res != OK) { 1724 ALOGE("%s: Camera %d: Unable to update common entries of preview " 1725 "request: %s (%d)", __FUNCTION__, mCameraId, 1726 strerror(-res), res); 1727 return res; 1728 } 1729 1730 res = mPreviewRequest.update(ANDROID_REQUEST_ID, 1731 &kPreviewRequestId, 1); 1732 1733 return OK; 1734} 1735 1736status_t Camera2Client::updateRecordingRequest(const Parameters ¶ms) { 1737 ATRACE_CALL(); 1738 status_t res; 1739 if (mRecordingRequest.entryCount() == 0) { 1740 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD, 1741 &mRecordingRequest); 1742 if (res != OK) { 1743 ALOGE("%s: Camera %d: Unable to create default recording request:" 1744 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1745 return res; 1746 } 1747 } 1748 1749 res = params.updateRequest(&mRecordingRequest); 1750 if (res != OK) { 1751 ALOGE("%s: Camera %d: Unable to update common entries of recording " 1752 "request: %s (%d)", __FUNCTION__, mCameraId, 1753 strerror(-res), res); 1754 return res; 1755 } 1756 1757 return OK; 1758} 1759 1760status_t Camera2Client::updateRecordingStream(const Parameters ¶ms) { 1761 status_t res; 1762 1763 if (mRecordingConsumer == 0) { 1764 // Create CPU buffer queue endpoint. We need one more buffer here so that we can 1765 // always acquire and free a buffer when the heap is full; otherwise the consumer 1766 // will have buffers in flight we'll never clear out. 1767 mRecordingConsumer = new BufferItemConsumer( 1768 GRALLOC_USAGE_HW_VIDEO_ENCODER, 1769 mRecordingHeapCount + 1, 1770 true); 1771 mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this)); 1772 mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer")); 1773 mRecordingWindow = new SurfaceTextureClient( 1774 mRecordingConsumer->getProducerInterface()); 1775 // Allocate memory later, since we don't know buffer size until receipt 1776 } 1777 1778 if (mRecordingStreamId != NO_STREAM) { 1779 // Check if stream parameters have to change 1780 uint32_t currentWidth, currentHeight; 1781 res = mDevice->getStreamInfo(mRecordingStreamId, 1782 ¤tWidth, ¤tHeight, 0); 1783 if (res != OK) { 1784 ALOGE("%s: Camera %d: Error querying recording output stream info: " 1785 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1786 return res; 1787 } 1788 if (currentWidth != (uint32_t)params.videoWidth || 1789 currentHeight != (uint32_t)params.videoHeight) { 1790 // TODO: Should wait to be sure previous recording has finished 1791 res = mDevice->deleteStream(mRecordingStreamId); 1792 if (res != OK) { 1793 ALOGE("%s: Camera %d: Unable to delete old output stream " 1794 "for recording: %s (%d)", __FUNCTION__, mCameraId, 1795 strerror(-res), res); 1796 return res; 1797 } 1798 mRecordingStreamId = NO_STREAM; 1799 } 1800 } 1801 1802 if (mRecordingStreamId == NO_STREAM) { 1803 mRecordingFrameCount = 0; 1804 res = mDevice->createStream(mRecordingWindow, 1805 params.videoWidth, params.videoHeight, 1806 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId); 1807 if (res != OK) { 1808 ALOGE("%s: Camera %d: Can't create output stream for recording: " 1809 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1810 return res; 1811 } 1812 } 1813 1814 return OK; 1815} 1816 1817size_t Camera2Client::calculateBufferSize(int width, int height, 1818 int format, int stride) { 1819 switch (format) { 1820 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1821 return width * height * 2; 1822 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1823 return width * height * 3 / 2; 1824 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1825 return width * height * 2; 1826 case HAL_PIXEL_FORMAT_YV12: { // YV12 1827 size_t ySize = stride * height; 1828 size_t uvStride = (stride / 2 + 0xF) & ~0xF; 1829 size_t uvSize = uvStride * height / 2; 1830 return ySize + uvSize * 2; 1831 } 1832 case HAL_PIXEL_FORMAT_RGB_565: 1833 return width * height * 2; 1834 case HAL_PIXEL_FORMAT_RGBA_8888: 1835 return width * height * 4; 1836 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1837 return width * height * 2; 1838 default: 1839 ALOGE("%s: Unknown preview format: %x", 1840 __FUNCTION__, format); 1841 return 0; 1842 } 1843} 1844 1845} // namespace android 1846