CameraService.cpp revision 4a73f3da3501db6e95473a4a653d6319c6d618e2
1/* 2** 3** Copyright (C) 2008, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18#define LOG_TAG "CameraService" 19 20#include <stdio.h> 21#include <sys/types.h> 22#include <pthread.h> 23 24#include <binder/IPCThreadState.h> 25#include <binder/IServiceManager.h> 26#include <binder/MemoryBase.h> 27#include <binder/MemoryHeapBase.h> 28#include <cutils/atomic.h> 29#include <hardware/hardware.h> 30#include <media/AudioSystem.h> 31#include <media/mediaplayer.h> 32#include <surfaceflinger/ISurface.h> 33#include <ui/Overlay.h> 34#include <utils/Errors.h> 35#include <utils/Log.h> 36#include <utils/String16.h> 37 38#include "CameraService.h" 39 40namespace android { 41 42// ---------------------------------------------------------------------------- 43// Logging support -- this is for debugging only 44// Use "adb shell dumpsys media.camera -v 1" to change it. 45static volatile int32_t gLogLevel = 0; 46 47#define LOG1(...) LOGD_IF(gLogLevel >= 1, __VA_ARGS__); 48#define LOG2(...) LOGD_IF(gLogLevel >= 2, __VA_ARGS__); 49 50static void setLogLevel(int level) { 51 android_atomic_write(level, &gLogLevel); 52} 53 54// ---------------------------------------------------------------------------- 55 56static int getCallingPid() { 57 return IPCThreadState::self()->getCallingPid(); 58} 59 60static int getCallingUid() { 61 return IPCThreadState::self()->getCallingUid(); 62} 63 64// ---------------------------------------------------------------------------- 65 66// This is ugly and only safe if we never re-create the CameraService, but 67// should be ok for now. 68static CameraService *gCameraService; 69 70CameraService::CameraService() 71:mSoundRef(0) 72{ 73 LOGI("CameraService started (pid=%d)", getpid()); 74 75 mNumberOfCameras = HAL_getNumberOfCameras(); 76 if (mNumberOfCameras > MAX_CAMERAS) { 77 LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).", 78 mNumberOfCameras, MAX_CAMERAS); 79 mNumberOfCameras = MAX_CAMERAS; 80 } 81 82 for (int i = 0; i < mNumberOfCameras; i++) { 83 setCameraFree(i); 84 } 85 86 gCameraService = this; 87} 88 89CameraService::~CameraService() { 90 for (int i = 0; i < mNumberOfCameras; i++) { 91 if (mBusy[i]) { 92 LOGE("camera %d is still in use in destructor!", i); 93 } 94 } 95 96 gCameraService = NULL; 97} 98 99int32_t CameraService::getNumberOfCameras() { 100 return mNumberOfCameras; 101} 102 103status_t CameraService::getCameraInfo(int cameraId, 104 struct CameraInfo* cameraInfo) { 105 if (cameraId < 0 || cameraId >= mNumberOfCameras) { 106 return BAD_VALUE; 107 } 108 109 HAL_getCameraInfo(cameraId, cameraInfo); 110 return OK; 111} 112 113sp<ICamera> CameraService::connect( 114 const sp<ICameraClient>& cameraClient, int cameraId) { 115 int callingPid = getCallingPid(); 116 LOG1("CameraService::connect E (pid %d, id %d)", callingPid, cameraId); 117 118 sp<Client> client; 119 if (cameraId < 0 || cameraId >= mNumberOfCameras) { 120 LOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).", 121 callingPid, cameraId); 122 return NULL; 123 } 124 125 Mutex::Autolock lock(mServiceLock); 126 if (mClient[cameraId] != 0) { 127 client = mClient[cameraId].promote(); 128 if (client != 0) { 129 if (cameraClient->asBinder() == client->getCameraClient()->asBinder()) { 130 LOG1("CameraService::connect X (pid %d) (the same client)", 131 callingPid); 132 return client; 133 } else { 134 LOGW("CameraService::connect X (pid %d) rejected (existing client).", 135 callingPid); 136 return NULL; 137 } 138 } 139 mClient[cameraId].clear(); 140 } 141 142 if (mBusy[cameraId]) { 143 LOGW("CameraService::connect X (pid %d) rejected" 144 " (camera %d is still busy).", callingPid, cameraId); 145 return NULL; 146 } 147 148 sp<CameraHardwareInterface> hardware = HAL_openCameraHardware(cameraId); 149 if (hardware == NULL) { 150 LOGE("Fail to open camera hardware (id=%d)", cameraId); 151 return NULL; 152 } 153 client = new Client(this, cameraClient, hardware, cameraId, callingPid); 154 mClient[cameraId] = client; 155 LOG1("CameraService::connect X"); 156 return client; 157} 158 159void CameraService::removeClient(const sp<ICameraClient>& cameraClient) { 160 int callingPid = getCallingPid(); 161 LOG1("CameraService::removeClient E (pid %d)", callingPid); 162 163 for (int i = 0; i < mNumberOfCameras; i++) { 164 // Declare this before the lock to make absolutely sure the 165 // destructor won't be called with the lock held. 166 sp<Client> client; 167 168 Mutex::Autolock lock(mServiceLock); 169 170 // This happens when we have already disconnected (or this is 171 // just another unused camera). 172 if (mClient[i] == 0) continue; 173 174 // Promote mClient. It can fail if we are called from this path: 175 // Client::~Client() -> disconnect() -> removeClient(). 176 client = mClient[i].promote(); 177 178 if (client == 0) { 179 mClient[i].clear(); 180 continue; 181 } 182 183 if (cameraClient->asBinder() == client->getCameraClient()->asBinder()) { 184 // Found our camera, clear and leave. 185 LOG1("removeClient: clear camera %d", i); 186 mClient[i].clear(); 187 break; 188 } 189 } 190 191 LOG1("CameraService::removeClient X (pid %d)", callingPid); 192} 193 194sp<CameraService::Client> CameraService::getClientById(int cameraId) { 195 if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL; 196 return mClient[cameraId].promote(); 197} 198 199status_t CameraService::onTransact( 200 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { 201 // Permission checks 202 switch (code) { 203 case BnCameraService::CONNECT: 204 const int pid = getCallingPid(); 205 const int self_pid = getpid(); 206 if (pid != self_pid) { 207 // we're called from a different process, do the real check 208 if (!checkCallingPermission( 209 String16("android.permission.CAMERA"))) { 210 const int uid = getCallingUid(); 211 LOGE("Permission Denial: " 212 "can't use the camera pid=%d, uid=%d", pid, uid); 213 return PERMISSION_DENIED; 214 } 215 } 216 break; 217 } 218 219 return BnCameraService::onTransact(code, data, reply, flags); 220} 221 222// The reason we need this busy bit is a new CameraService::connect() request 223// may come in while the previous Client's destructor has not been run or is 224// still running. If the last strong reference of the previous Client is gone 225// but the destructor has not been finished, we should not allow the new Client 226// to be created because we need to wait for the previous Client to tear down 227// the hardware first. 228void CameraService::setCameraBusy(int cameraId) { 229 android_atomic_write(1, &mBusy[cameraId]); 230} 231 232void CameraService::setCameraFree(int cameraId) { 233 android_atomic_write(0, &mBusy[cameraId]); 234} 235 236// We share the media players for shutter and recording sound for all clients. 237// A reference count is kept to determine when we will actually release the 238// media players. 239 240static MediaPlayer* newMediaPlayer(const char *file) { 241 MediaPlayer* mp = new MediaPlayer(); 242 if (mp->setDataSource(file, NULL) == NO_ERROR) { 243 mp->setAudioStreamType(AudioSystem::ENFORCED_AUDIBLE); 244 mp->prepare(); 245 } else { 246 LOGE("Failed to load CameraService sounds: %s", file); 247 return NULL; 248 } 249 return mp; 250} 251 252void CameraService::loadSound() { 253 Mutex::Autolock lock(mSoundLock); 254 LOG1("CameraService::loadSound ref=%d", mSoundRef); 255 if (mSoundRef++) return; 256 257 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg"); 258 mSoundPlayer[SOUND_RECORDING] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg"); 259} 260 261void CameraService::releaseSound() { 262 Mutex::Autolock lock(mSoundLock); 263 LOG1("CameraService::releaseSound ref=%d", mSoundRef); 264 if (--mSoundRef) return; 265 266 for (int i = 0; i < NUM_SOUNDS; i++) { 267 if (mSoundPlayer[i] != 0) { 268 mSoundPlayer[i]->disconnect(); 269 mSoundPlayer[i].clear(); 270 } 271 } 272} 273 274void CameraService::playSound(sound_kind kind) { 275 LOG1("playSound(%d)", kind); 276 Mutex::Autolock lock(mSoundLock); 277 sp<MediaPlayer> player = mSoundPlayer[kind]; 278 if (player != 0) { 279 // do not play the sound if stream volume is 0 280 // (typically because ringer mode is silent). 281 int index; 282 AudioSystem::getStreamVolumeIndex(AudioSystem::ENFORCED_AUDIBLE, &index); 283 if (index != 0) { 284 player->seekTo(0); 285 player->start(); 286 } 287 } 288} 289 290// ---------------------------------------------------------------------------- 291 292CameraService::Client::Client(const sp<CameraService>& cameraService, 293 const sp<ICameraClient>& cameraClient, 294 const sp<CameraHardwareInterface>& hardware, 295 int cameraId, int clientPid) { 296 int callingPid = getCallingPid(); 297 LOG1("Client::Client E (pid %d)", callingPid); 298 299 mCameraService = cameraService; 300 mCameraClient = cameraClient; 301 mHardware = hardware; 302 mCameraId = cameraId; 303 mClientPid = clientPid; 304 mUseOverlay = mHardware->useOverlay(); 305 mMsgEnabled = 0; 306 307 mHardware->setCallbacks(notifyCallback, 308 dataCallback, 309 dataCallbackTimestamp, 310 (void *)cameraId); 311 312 // Enable zoom, error, and focus messages by default 313 enableMsgType(CAMERA_MSG_ERROR | 314 CAMERA_MSG_ZOOM | 315 CAMERA_MSG_FOCUS); 316 mOverlayW = 0; 317 mOverlayH = 0; 318 319 // Callback is disabled by default 320 mPreviewCallbackFlag = FRAME_CALLBACK_FLAG_NOOP; 321 mOrientation = 0; 322 mOrientationChanged = false; 323 cameraService->setCameraBusy(cameraId); 324 cameraService->loadSound(); 325 LOG1("Client::Client X (pid %d)", callingPid); 326} 327 328static void *unregister_surface(void *arg) { 329 ISurface *surface = (ISurface *)arg; 330 surface->unregisterBuffers(); 331 IPCThreadState::self()->flushCommands(); 332 return NULL; 333} 334 335// tear down the client 336CameraService::Client::~Client() { 337 int callingPid = getCallingPid(); 338 LOG1("Client::~Client E (pid %d, this %p)", callingPid, this); 339 340 if (mSurface != 0 && !mUseOverlay) { 341 pthread_t thr; 342 // We unregister the buffers in a different thread because binder does 343 // not let us make sychronous transactions in a binder destructor (that 344 // is, upon our reaching a refcount of zero.) 345 pthread_create(&thr, 346 NULL, // attr 347 unregister_surface, 348 mSurface.get()); 349 pthread_join(thr, NULL); 350 } 351 352 // set mClientPid to let disconnet() tear down the hardware 353 mClientPid = callingPid; 354 disconnect(); 355 mCameraService->releaseSound(); 356 LOG1("Client::~Client X (pid %d, this %p)", callingPid, this); 357} 358 359// ---------------------------------------------------------------------------- 360 361status_t CameraService::Client::checkPid() const { 362 int callingPid = getCallingPid(); 363 if (callingPid == mClientPid) return NO_ERROR; 364 365 LOGW("attempt to use a locked camera from a different process" 366 " (old pid %d, new pid %d)", mClientPid, callingPid); 367 return EBUSY; 368} 369 370status_t CameraService::Client::checkPidAndHardware() const { 371 status_t result = checkPid(); 372 if (result != NO_ERROR) return result; 373 if (mHardware == 0) { 374 LOGE("attempt to use a camera after disconnect() (pid %d)", getCallingPid()); 375 return INVALID_OPERATION; 376 } 377 return NO_ERROR; 378} 379 380status_t CameraService::Client::lock() { 381 int callingPid = getCallingPid(); 382 LOG1("lock (pid %d)", callingPid); 383 Mutex::Autolock lock(mLock); 384 385 // lock camera to this client if the the camera is unlocked 386 if (mClientPid == 0) { 387 mClientPid = callingPid; 388 return NO_ERROR; 389 } 390 391 // returns NO_ERROR if the client already owns the camera, EBUSY otherwise 392 return checkPid(); 393} 394 395status_t CameraService::Client::unlock() { 396 int callingPid = getCallingPid(); 397 LOG1("unlock (pid %d)", callingPid); 398 Mutex::Autolock lock(mLock); 399 400 // allow anyone to use camera (after they lock the camera) 401 status_t result = checkPid(); 402 if (result == NO_ERROR) { 403 mClientPid = 0; 404 LOG1("clear mCameraClient (pid %d)", callingPid); 405 // we need to remove the reference to ICameraClient so that when the app 406 // goes away, the reference count goes to 0. 407 mCameraClient.clear(); 408 } 409 return result; 410} 411 412// connect a new client to the camera 413status_t CameraService::Client::connect(const sp<ICameraClient>& client) { 414 int callingPid = getCallingPid(); 415 LOG1("connect E (pid %d)", callingPid); 416 Mutex::Autolock lock(mLock); 417 418 if (mClientPid != 0 && checkPid() != NO_ERROR) { 419 LOGW("Tried to connect to a locked camera (old pid %d, new pid %d)", 420 mClientPid, callingPid); 421 return EBUSY; 422 } 423 424 if (mCameraClient != 0 && (client->asBinder() == mCameraClient->asBinder())) { 425 LOG1("Connect to the same client"); 426 return NO_ERROR; 427 } 428 429 mPreviewCallbackFlag = FRAME_CALLBACK_FLAG_NOOP; 430 mClientPid = callingPid; 431 mCameraClient = client; 432 433 LOG1("connect X (pid %d)", callingPid); 434 return NO_ERROR; 435} 436 437void CameraService::Client::disconnect() { 438 int callingPid = getCallingPid(); 439 LOG1("disconnect E (pid %d)", callingPid); 440 Mutex::Autolock lock(mLock); 441 442 if (checkPid() != NO_ERROR) { 443 LOGW("different client - don't disconnect"); 444 return; 445 } 446 447 if (mClientPid <= 0) { 448 LOG1("camera is unlocked (mClientPid = %d), don't tear down hardware", mClientPid); 449 return; 450 } 451 452 // Make sure disconnect() is done once and once only, whether it is called 453 // from the user directly, or called by the destructor. 454 if (mHardware == 0) return; 455 456 LOG1("hardware teardown"); 457 // Before destroying mHardware, we must make sure it's in the 458 // idle state. 459 // Turn off all messages. 460 disableMsgType(CAMERA_MSG_ALL_MSGS); 461 mHardware->stopPreview(); 462 mHardware->cancelPicture(); 463 // Release the hardware resources. 464 mHardware->release(); 465 // Release the held overlay resources. 466 if (mUseOverlay) { 467 mOverlayRef = 0; 468 } 469 mHardware.clear(); 470 471 mCameraService->removeClient(mCameraClient); 472 mCameraService->setCameraFree(mCameraId); 473 474 LOG1("disconnect X (pid %d)", callingPid); 475} 476 477// ---------------------------------------------------------------------------- 478 479// set the ISurface that the preview will use 480status_t CameraService::Client::setPreviewDisplay(const sp<ISurface>& surface) { 481 LOG1("setPreviewDisplay(%p) (pid %d)", surface.get(), getCallingPid()); 482 Mutex::Autolock lock(mLock); 483 status_t result = checkPidAndHardware(); 484 if (result != NO_ERROR) return result; 485 486 result = NO_ERROR; 487 488 // return if no change in surface. 489 // asBinder() is safe on NULL (returns NULL) 490 if (surface->asBinder() == mSurface->asBinder()) { 491 return result; 492 } 493 494 if (mSurface != 0) { 495 LOG1("clearing old preview surface %p", mSurface.get()); 496 if (mUseOverlay) { 497 // Force the destruction of any previous overlay 498 sp<Overlay> dummy; 499 mHardware->setOverlay(dummy); 500 mOverlayRef = 0; 501 } else { 502 mSurface->unregisterBuffers(); 503 } 504 } 505 mSurface = surface; 506 mOverlayRef = 0; 507 // If preview has been already started, set overlay or register preview 508 // buffers now. 509 if (mHardware->previewEnabled()) { 510 if (mUseOverlay) { 511 result = setOverlay(); 512 } else if (mSurface != 0) { 513 result = registerPreviewBuffers(); 514 } 515 } 516 517 return result; 518} 519 520status_t CameraService::Client::registerPreviewBuffers() { 521 int w, h; 522 CameraParameters params(mHardware->getParameters()); 523 params.getPreviewSize(&w, &h); 524 525 // FIXME: don't use a hardcoded format here. 526 ISurface::BufferHeap buffers(w, h, w, h, 527 HAL_PIXEL_FORMAT_YCrCb_420_SP, 528 mOrientation, 529 0, 530 mHardware->getPreviewHeap()); 531 532 status_t result = mSurface->registerBuffers(buffers); 533 if (result != NO_ERROR) { 534 LOGE("registerBuffers failed with status %d", result); 535 } 536 return result; 537} 538 539status_t CameraService::Client::setOverlay() { 540 int w, h; 541 CameraParameters params(mHardware->getParameters()); 542 params.getPreviewSize(&w, &h); 543 544 if (w != mOverlayW || h != mOverlayH || mOrientationChanged) { 545 // Force the destruction of any previous overlay 546 sp<Overlay> dummy; 547 mHardware->setOverlay(dummy); 548 mOverlayRef = 0; 549 mOrientationChanged = false; 550 } 551 552 status_t result = NO_ERROR; 553 if (mSurface == 0) { 554 result = mHardware->setOverlay(NULL); 555 } else { 556 if (mOverlayRef == 0) { 557 // FIXME: 558 // Surfaceflinger may hold onto the previous overlay reference for some 559 // time after we try to destroy it. retry a few times. In the future, we 560 // should make the destroy call block, or possibly specify that we can 561 // wait in the createOverlay call if the previous overlay is in the 562 // process of being destroyed. 563 for (int retry = 0; retry < 50; ++retry) { 564 mOverlayRef = mSurface->createOverlay(w, h, OVERLAY_FORMAT_DEFAULT, 565 mOrientation); 566 if (mOverlayRef != 0) break; 567 LOGW("Overlay create failed - retrying"); 568 usleep(20000); 569 } 570 if (mOverlayRef == 0) { 571 LOGE("Overlay Creation Failed!"); 572 return -EINVAL; 573 } 574 result = mHardware->setOverlay(new Overlay(mOverlayRef)); 575 } 576 } 577 if (result != NO_ERROR) { 578 LOGE("mHardware->setOverlay() failed with status %d\n", result); 579 return result; 580 } 581 582 mOverlayW = w; 583 mOverlayH = h; 584 585 return result; 586} 587 588// set the preview callback flag to affect how the received frames from 589// preview are handled. 590void CameraService::Client::setPreviewCallbackFlag(int callback_flag) { 591 LOG1("setPreviewCallbackFlag(%d) (pid %d)", callback_flag, getCallingPid()); 592 Mutex::Autolock lock(mLock); 593 if (checkPidAndHardware() != NO_ERROR) return; 594 595 mPreviewCallbackFlag = callback_flag; 596 597 // If we don't use overlay, we always need the preview frame for display. 598 // If we do use overlay, we only need the preview frame if the user 599 // wants the data. 600 if (mUseOverlay) { 601 if(mPreviewCallbackFlag & FRAME_CALLBACK_FLAG_ENABLE_MASK) { 602 enableMsgType(CAMERA_MSG_PREVIEW_FRAME); 603 } else { 604 disableMsgType(CAMERA_MSG_PREVIEW_FRAME); 605 } 606 } 607} 608 609// start preview mode 610status_t CameraService::Client::startPreview() { 611 LOG1("startPreview (pid %d)", getCallingPid()); 612 return startCameraMode(CAMERA_PREVIEW_MODE); 613} 614 615// start recording mode 616status_t CameraService::Client::startRecording() { 617 LOG1("startRecording (pid %d)", getCallingPid()); 618 return startCameraMode(CAMERA_RECORDING_MODE); 619} 620 621// start preview or recording 622status_t CameraService::Client::startCameraMode(camera_mode mode) { 623 LOG1("startCameraMode(%d)", mode); 624 Mutex::Autolock lock(mLock); 625 status_t result = checkPidAndHardware(); 626 if (result != NO_ERROR) return result; 627 628 switch(mode) { 629 case CAMERA_PREVIEW_MODE: 630 if (mSurface == 0) { 631 LOG1("mSurface is not set yet."); 632 // still able to start preview in this case. 633 } 634 return startPreviewMode(); 635 case CAMERA_RECORDING_MODE: 636 if (mSurface == 0) { 637 LOGE("mSurface must be set before startRecordingMode."); 638 return INVALID_OPERATION; 639 } 640 return startRecordingMode(); 641 default: 642 return UNKNOWN_ERROR; 643 } 644} 645 646status_t CameraService::Client::startPreviewMode() { 647 LOG1("startPreviewMode"); 648 status_t result = NO_ERROR; 649 650 // if preview has been enabled, nothing needs to be done 651 if (mHardware->previewEnabled()) { 652 return NO_ERROR; 653 } 654 655 if (mUseOverlay) { 656 // If preview display has been set, set overlay now. 657 if (mSurface != 0) { 658 result = setOverlay(); 659 } 660 if (result != NO_ERROR) return result; 661 result = mHardware->startPreview(); 662 } else { 663 enableMsgType(CAMERA_MSG_PREVIEW_FRAME); 664 result = mHardware->startPreview(); 665 if (result != NO_ERROR) return result; 666 // If preview display has been set, register preview buffers now. 667 if (mSurface != 0) { 668 // Unregister here because the surface may be previously registered 669 // with the raw (snapshot) heap. 670 mSurface->unregisterBuffers(); 671 result = registerPreviewBuffers(); 672 } 673 } 674 return result; 675} 676 677status_t CameraService::Client::startRecordingMode() { 678 LOG1("startRecordingMode"); 679 status_t result = NO_ERROR; 680 681 // if recording has been enabled, nothing needs to be done 682 if (mHardware->recordingEnabled()) { 683 return NO_ERROR; 684 } 685 686 // if preview has not been started, start preview first 687 if (!mHardware->previewEnabled()) { 688 result = startPreviewMode(); 689 if (result != NO_ERROR) { 690 return result; 691 } 692 } 693 694 // start recording mode 695 enableMsgType(CAMERA_MSG_VIDEO_FRAME); 696 mCameraService->playSound(SOUND_RECORDING); 697 result = mHardware->startRecording(); 698 if (result != NO_ERROR) { 699 LOGE("mHardware->startRecording() failed with status %d", result); 700 } 701 return result; 702} 703 704// stop preview mode 705void CameraService::Client::stopPreview() { 706 LOG1("stopPreview (pid %d)", getCallingPid()); 707 Mutex::Autolock lock(mLock); 708 if (checkPidAndHardware() != NO_ERROR) return; 709 710 disableMsgType(CAMERA_MSG_PREVIEW_FRAME); 711 mHardware->stopPreview(); 712 713 if (mSurface != 0 && !mUseOverlay) { 714 mSurface->unregisterBuffers(); 715 } 716 717 mPreviewBuffer.clear(); 718} 719 720// stop recording mode 721void CameraService::Client::stopRecording() { 722 LOG1("stopRecording (pid %d)", getCallingPid()); 723 Mutex::Autolock lock(mLock); 724 if (checkPidAndHardware() != NO_ERROR) return; 725 726 mCameraService->playSound(SOUND_RECORDING); 727 disableMsgType(CAMERA_MSG_VIDEO_FRAME); 728 mHardware->stopRecording(); 729 730 mPreviewBuffer.clear(); 731} 732 733// release a recording frame 734void CameraService::Client::releaseRecordingFrame(const sp<IMemory>& mem) { 735 Mutex::Autolock lock(mLock); 736 if (checkPidAndHardware() != NO_ERROR) return; 737 mHardware->releaseRecordingFrame(mem); 738} 739 740bool CameraService::Client::previewEnabled() { 741 LOG1("previewEnabled (pid %d)", getCallingPid()); 742 743 Mutex::Autolock lock(mLock); 744 if (checkPidAndHardware() != NO_ERROR) return false; 745 return mHardware->previewEnabled(); 746} 747 748bool CameraService::Client::recordingEnabled() { 749 LOG1("recordingEnabled (pid %d)", getCallingPid()); 750 751 Mutex::Autolock lock(mLock); 752 if (checkPidAndHardware() != NO_ERROR) return false; 753 return mHardware->recordingEnabled(); 754} 755 756status_t CameraService::Client::autoFocus() { 757 LOG1("autoFocus (pid %d)", getCallingPid()); 758 759 Mutex::Autolock lock(mLock); 760 status_t result = checkPidAndHardware(); 761 if (result != NO_ERROR) return result; 762 763 return mHardware->autoFocus(); 764} 765 766status_t CameraService::Client::cancelAutoFocus() { 767 LOG1("cancelAutoFocus (pid %d)", getCallingPid()); 768 769 Mutex::Autolock lock(mLock); 770 status_t result = checkPidAndHardware(); 771 if (result != NO_ERROR) return result; 772 773 return mHardware->cancelAutoFocus(); 774} 775 776// take a picture - image is returned in callback 777status_t CameraService::Client::takePicture() { 778 LOG1("takePicture (pid %d)", getCallingPid()); 779 780 Mutex::Autolock lock(mLock); 781 status_t result = checkPidAndHardware(); 782 if (result != NO_ERROR) return result; 783 784 enableMsgType(CAMERA_MSG_SHUTTER | 785 CAMERA_MSG_POSTVIEW_FRAME | 786 CAMERA_MSG_RAW_IMAGE | 787 CAMERA_MSG_COMPRESSED_IMAGE); 788 789 return mHardware->takePicture(); 790} 791 792// set preview/capture parameters - key/value pairs 793status_t CameraService::Client::setParameters(const String8& params) { 794 LOG1("setParameters (pid %d) (%s)", getCallingPid(), params.string()); 795 796 Mutex::Autolock lock(mLock); 797 status_t result = checkPidAndHardware(); 798 if (result != NO_ERROR) return result; 799 800 CameraParameters p(params); 801 return mHardware->setParameters(p); 802} 803 804// get preview/capture parameters - key/value pairs 805String8 CameraService::Client::getParameters() const { 806 Mutex::Autolock lock(mLock); 807 if (checkPidAndHardware() != NO_ERROR) return String8(); 808 809 String8 params(mHardware->getParameters().flatten()); 810 LOG1("getParameters (pid %d) (%s)", getCallingPid(), params.string()); 811 return params; 812} 813 814status_t CameraService::Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { 815 LOG1("sendCommand (pid %d)", getCallingPid()); 816 int orientation; 817 Mutex::Autolock lock(mLock); 818 status_t result = checkPidAndHardware(); 819 if (result != NO_ERROR) return result; 820 821 if (cmd == CAMERA_CMD_SET_DISPLAY_ORIENTATION) { 822 // The orientation cannot be set during preview. 823 if (mHardware->previewEnabled()) { 824 return INVALID_OPERATION; 825 } 826 switch (arg1) { 827 case 0: 828 orientation = ISurface::BufferHeap::ROT_0; 829 break; 830 case 90: 831 orientation = ISurface::BufferHeap::ROT_90; 832 break; 833 case 180: 834 orientation = ISurface::BufferHeap::ROT_180; 835 break; 836 case 270: 837 orientation = ISurface::BufferHeap::ROT_270; 838 break; 839 default: 840 return BAD_VALUE; 841 } 842 if (mOrientation != orientation) { 843 mOrientation = orientation; 844 if (mOverlayRef != 0) mOrientationChanged = true; 845 } 846 return OK; 847 } 848 849 return mHardware->sendCommand(cmd, arg1, arg2); 850} 851 852// ---------------------------------------------------------------------------- 853 854void CameraService::Client::enableMsgType(int32_t msgType) { 855 android_atomic_or(msgType, &mMsgEnabled); 856 mHardware->enableMsgType(msgType); 857} 858 859void CameraService::Client::disableMsgType(int32_t msgType) { 860 android_atomic_and(~msgType, &mMsgEnabled); 861 mHardware->disableMsgType(msgType); 862} 863 864#define CHECK_MESSAGE_INTERVAL 10 // 10ms 865bool CameraService::Client::lockIfMessageWanted(int32_t msgType) { 866 int sleepCount = 0; 867 while (mMsgEnabled & msgType) { 868 if (mLock.tryLock() == NO_ERROR) { 869 if (sleepCount > 0) { 870 LOG1("lockIfMessageWanted(%d): waited for %d ms", 871 msgType, sleepCount * CHECK_MESSAGE_INTERVAL); 872 } 873 return true; 874 } 875 if (sleepCount++ == 0) { 876 LOG1("lockIfMessageWanted(%d): enter sleep", msgType); 877 } 878 usleep(CHECK_MESSAGE_INTERVAL * 1000); 879 } 880 LOGW("lockIfMessageWanted(%d): dropped unwanted message", msgType); 881 return false; 882} 883 884// ---------------------------------------------------------------------------- 885 886// Converts from a raw pointer to the client to a strong pointer during a 887// hardware callback. This requires the callbacks only happen when the client 888// is still alive. 889sp<CameraService::Client> CameraService::Client::getClientFromCookie(void* user) { 890 sp<Client> client = gCameraService->getClientById((int) user); 891 892 // This could happen if the Client is in the process of shutting down (the 893 // last strong reference is gone, but the destructor hasn't finished 894 // stopping the hardware). 895 if (client == 0) return NULL; 896 897 // The checks below are not necessary and are for debugging only. 898 if (client->mCameraService.get() != gCameraService) { 899 LOGE("mismatch service!"); 900 return NULL; 901 } 902 903 if (client->mHardware == 0) { 904 LOGE("mHardware == 0: callback after disconnect()?"); 905 return NULL; 906 } 907 908 return client; 909} 910 911// Callback messages can be dispatched to internal handlers or pass to our 912// client's callback functions, depending on the message type. 913// 914// notifyCallback: 915// CAMERA_MSG_SHUTTER handleShutter 916// (others) c->notifyCallback 917// dataCallback: 918// CAMERA_MSG_PREVIEW_FRAME handlePreviewData 919// CAMERA_MSG_POSTVIEW_FRAME handlePostview 920// CAMERA_MSG_RAW_IMAGE handleRawPicture 921// CAMERA_MSG_COMPRESSED_IMAGE handleCompressedPicture 922// (others) c->dataCallback 923// dataCallbackTimestamp 924// (others) c->dataCallbackTimestamp 925// 926// NOTE: the *Callback functions grab mLock of the client before passing 927// control to handle* functions. So the handle* functions must release the 928// lock before calling the ICameraClient's callbacks, so those callbacks can 929// invoke methods in the Client class again (For example, the preview frame 930// callback may want to releaseRecordingFrame). The handle* functions must 931// release the lock after all accesses to member variables, so it must be 932// handled very carefully. 933 934void CameraService::Client::notifyCallback(int32_t msgType, int32_t ext1, 935 int32_t ext2, void* user) { 936 LOG2("notifyCallback(%d)", msgType); 937 938 sp<Client> client = getClientFromCookie(user); 939 if (client == 0) return; 940 if (!client->lockIfMessageWanted(msgType)) return; 941 942 switch (msgType) { 943 case CAMERA_MSG_SHUTTER: 944 // ext1 is the dimension of the yuv picture. 945 client->handleShutter((image_rect_type *)ext1); 946 break; 947 default: 948 client->handleGenericNotify(msgType, ext1, ext2); 949 break; 950 } 951} 952 953void CameraService::Client::dataCallback(int32_t msgType, 954 const sp<IMemory>& dataPtr, void* user) { 955 LOG2("dataCallback(%d)", msgType); 956 957 sp<Client> client = getClientFromCookie(user); 958 if (client == 0) return; 959 if (!client->lockIfMessageWanted(msgType)) return; 960 961 if (dataPtr == 0) { 962 LOGE("Null data returned in data callback"); 963 client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0); 964 return; 965 } 966 967 switch (msgType) { 968 case CAMERA_MSG_PREVIEW_FRAME: 969 client->handlePreviewData(dataPtr); 970 break; 971 case CAMERA_MSG_POSTVIEW_FRAME: 972 client->handlePostview(dataPtr); 973 break; 974 case CAMERA_MSG_RAW_IMAGE: 975 client->handleRawPicture(dataPtr); 976 break; 977 case CAMERA_MSG_COMPRESSED_IMAGE: 978 client->handleCompressedPicture(dataPtr); 979 break; 980 default: 981 client->handleGenericData(msgType, dataPtr); 982 break; 983 } 984} 985 986void CameraService::Client::dataCallbackTimestamp(nsecs_t timestamp, 987 int32_t msgType, const sp<IMemory>& dataPtr, void* user) { 988 LOG2("dataCallbackTimestamp(%d)", msgType); 989 990 sp<Client> client = getClientFromCookie(user); 991 if (client == 0) return; 992 if (!client->lockIfMessageWanted(msgType)) return; 993 994 if (dataPtr == 0) { 995 LOGE("Null data returned in data with timestamp callback"); 996 client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0); 997 return; 998 } 999 1000 client->handleGenericDataTimestamp(timestamp, msgType, dataPtr); 1001} 1002 1003// snapshot taken callback 1004// "size" is the width and height of yuv picture for registerBuffer. 1005// If it is NULL, use the picture size from parameters. 1006void CameraService::Client::handleShutter(image_rect_type *size) { 1007 mCameraService->playSound(SOUND_SHUTTER); 1008 1009 // Screen goes black after the buffer is unregistered. 1010 if (mSurface != 0 && !mUseOverlay) { 1011 mSurface->unregisterBuffers(); 1012 } 1013 1014 sp<ICameraClient> c = mCameraClient; 1015 if (c != 0) { 1016 mLock.unlock(); 1017 c->notifyCallback(CAMERA_MSG_SHUTTER, 0, 0); 1018 if (!lockIfMessageWanted(CAMERA_MSG_SHUTTER)) return; 1019 } 1020 disableMsgType(CAMERA_MSG_SHUTTER); 1021 1022 // It takes some time before yuvPicture callback to be called. 1023 // Register the buffer for raw image here to reduce latency. 1024 if (mSurface != 0 && !mUseOverlay) { 1025 int w, h; 1026 CameraParameters params(mHardware->getParameters()); 1027 if (size == NULL) { 1028 params.getPictureSize(&w, &h); 1029 } else { 1030 w = size->width; 1031 h = size->height; 1032 w &= ~1; 1033 h &= ~1; 1034 LOG1("Snapshot image width=%d, height=%d", w, h); 1035 } 1036 // FIXME: don't use hardcoded format constants here 1037 ISurface::BufferHeap buffers(w, h, w, h, 1038 HAL_PIXEL_FORMAT_YCrCb_420_SP, mOrientation, 0, 1039 mHardware->getRawHeap()); 1040 1041 mSurface->registerBuffers(buffers); 1042 IPCThreadState::self()->flushCommands(); 1043 } 1044 1045 mLock.unlock(); 1046} 1047 1048// preview callback - frame buffer update 1049void CameraService::Client::handlePreviewData(const sp<IMemory>& mem) { 1050 ssize_t offset; 1051 size_t size; 1052 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); 1053 1054 if (!mUseOverlay) { 1055 if (mSurface != 0) { 1056 mSurface->postBuffer(offset); 1057 } 1058 } 1059 1060 // local copy of the callback flags 1061 int flags = mPreviewCallbackFlag; 1062 1063 // is callback enabled? 1064 if (!(flags & FRAME_CALLBACK_FLAG_ENABLE_MASK)) { 1065 // If the enable bit is off, the copy-out and one-shot bits are ignored 1066 LOG2("frame callback is disabled"); 1067 mLock.unlock(); 1068 return; 1069 } 1070 1071 // hold a strong pointer to the client 1072 sp<ICameraClient> c = mCameraClient; 1073 1074 // clear callback flags if no client or one-shot mode 1075 if (c == 0 || (mPreviewCallbackFlag & FRAME_CALLBACK_FLAG_ONE_SHOT_MASK)) { 1076 LOG2("Disable preview callback"); 1077 mPreviewCallbackFlag &= ~(FRAME_CALLBACK_FLAG_ONE_SHOT_MASK | 1078 FRAME_CALLBACK_FLAG_COPY_OUT_MASK | 1079 FRAME_CALLBACK_FLAG_ENABLE_MASK); 1080 if (mUseOverlay) { 1081 disableMsgType(CAMERA_MSG_PREVIEW_FRAME); 1082 } 1083 } 1084 1085 if (c != 0) { 1086 // Is the received frame copied out or not? 1087 if (flags & FRAME_CALLBACK_FLAG_COPY_OUT_MASK) { 1088 LOG2("frame is copied"); 1089 copyFrameAndPostCopiedFrame(c, heap, offset, size); 1090 } else { 1091 LOG2("frame is forwarded"); 1092 mLock.unlock(); 1093 c->dataCallback(CAMERA_MSG_PREVIEW_FRAME, mem); 1094 } 1095 } else { 1096 mLock.unlock(); 1097 } 1098} 1099 1100// picture callback - postview image ready 1101void CameraService::Client::handlePostview(const sp<IMemory>& mem) { 1102 disableMsgType(CAMERA_MSG_POSTVIEW_FRAME); 1103 1104 sp<ICameraClient> c = mCameraClient; 1105 mLock.unlock(); 1106 if (c != 0) { 1107 c->dataCallback(CAMERA_MSG_POSTVIEW_FRAME, mem); 1108 } 1109} 1110 1111// picture callback - raw image ready 1112void CameraService::Client::handleRawPicture(const sp<IMemory>& mem) { 1113 disableMsgType(CAMERA_MSG_RAW_IMAGE); 1114 1115 ssize_t offset; 1116 size_t size; 1117 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); 1118 1119 // Put the YUV version of the snapshot in the preview display. 1120 if (mSurface != 0 && !mUseOverlay) { 1121 mSurface->postBuffer(offset); 1122 } 1123 1124 sp<ICameraClient> c = mCameraClient; 1125 mLock.unlock(); 1126 if (c != 0) { 1127 c->dataCallback(CAMERA_MSG_RAW_IMAGE, mem); 1128 } 1129} 1130 1131// picture callback - compressed picture ready 1132void CameraService::Client::handleCompressedPicture(const sp<IMemory>& mem) { 1133 disableMsgType(CAMERA_MSG_COMPRESSED_IMAGE); 1134 1135 sp<ICameraClient> c = mCameraClient; 1136 mLock.unlock(); 1137 if (c != 0) { 1138 c->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, mem); 1139 } 1140} 1141 1142 1143void CameraService::Client::handleGenericNotify(int32_t msgType, 1144 int32_t ext1, int32_t ext2) { 1145 sp<ICameraClient> c = mCameraClient; 1146 mLock.unlock(); 1147 if (c != 0) { 1148 c->notifyCallback(msgType, ext1, ext2); 1149 } 1150} 1151 1152void CameraService::Client::handleGenericData(int32_t msgType, 1153 const sp<IMemory>& dataPtr) { 1154 sp<ICameraClient> c = mCameraClient; 1155 mLock.unlock(); 1156 if (c != 0) { 1157 c->dataCallback(msgType, dataPtr); 1158 } 1159} 1160 1161void CameraService::Client::handleGenericDataTimestamp(nsecs_t timestamp, 1162 int32_t msgType, const sp<IMemory>& dataPtr) { 1163 sp<ICameraClient> c = mCameraClient; 1164 mLock.unlock(); 1165 if (c != 0) { 1166 c->dataCallbackTimestamp(timestamp, msgType, dataPtr); 1167 } 1168} 1169 1170void CameraService::Client::copyFrameAndPostCopiedFrame( 1171 const sp<ICameraClient>& client, const sp<IMemoryHeap>& heap, 1172 size_t offset, size_t size) { 1173 LOG2("copyFrameAndPostCopiedFrame"); 1174 // It is necessary to copy out of pmem before sending this to 1175 // the callback. For efficiency, reuse the same MemoryHeapBase 1176 // provided it's big enough. Don't allocate the memory or 1177 // perform the copy if there's no callback. 1178 // hold the preview lock while we grab a reference to the preview buffer 1179 sp<MemoryHeapBase> previewBuffer; 1180 1181 if (mPreviewBuffer == 0) { 1182 mPreviewBuffer = new MemoryHeapBase(size, 0, NULL); 1183 } else if (size > mPreviewBuffer->virtualSize()) { 1184 mPreviewBuffer.clear(); 1185 mPreviewBuffer = new MemoryHeapBase(size, 0, NULL); 1186 } 1187 if (mPreviewBuffer == 0) { 1188 LOGE("failed to allocate space for preview buffer"); 1189 mLock.unlock(); 1190 return; 1191 } 1192 previewBuffer = mPreviewBuffer; 1193 1194 memcpy(previewBuffer->base(), (uint8_t *)heap->base() + offset, size); 1195 1196 sp<MemoryBase> frame = new MemoryBase(previewBuffer, 0, size); 1197 if (frame == 0) { 1198 LOGE("failed to allocate space for frame callback"); 1199 mLock.unlock(); 1200 return; 1201 } 1202 1203 mLock.unlock(); 1204 client->dataCallback(CAMERA_MSG_PREVIEW_FRAME, frame); 1205} 1206 1207// ---------------------------------------------------------------------------- 1208 1209static const int kDumpLockRetries = 50; 1210static const int kDumpLockSleep = 60000; 1211 1212static bool tryLock(Mutex& mutex) 1213{ 1214 bool locked = false; 1215 for (int i = 0; i < kDumpLockRetries; ++i) { 1216 if (mutex.tryLock() == NO_ERROR) { 1217 locked = true; 1218 break; 1219 } 1220 usleep(kDumpLockSleep); 1221 } 1222 return locked; 1223} 1224 1225status_t CameraService::dump(int fd, const Vector<String16>& args) { 1226 static const char* kDeadlockedString = "CameraService may be deadlocked\n"; 1227 1228 const size_t SIZE = 256; 1229 char buffer[SIZE]; 1230 String8 result; 1231 if (checkCallingPermission(String16("android.permission.DUMP")) == false) { 1232 snprintf(buffer, SIZE, "Permission Denial: " 1233 "can't dump CameraService from pid=%d, uid=%d\n", 1234 getCallingPid(), 1235 getCallingUid()); 1236 result.append(buffer); 1237 write(fd, result.string(), result.size()); 1238 } else { 1239 bool locked = tryLock(mServiceLock); 1240 // failed to lock - CameraService is probably deadlocked 1241 if (!locked) { 1242 String8 result(kDeadlockedString); 1243 write(fd, result.string(), result.size()); 1244 } 1245 1246 bool hasClient = false; 1247 for (int i = 0; i < mNumberOfCameras; i++) { 1248 sp<Client> client = mClient[i].promote(); 1249 if (client == 0) continue; 1250 hasClient = true; 1251 sprintf(buffer, "Client[%d] (%p) PID: %d\n", 1252 i, 1253 client->getCameraClient()->asBinder().get(), 1254 client->mClientPid); 1255 result.append(buffer); 1256 write(fd, result.string(), result.size()); 1257 client->mHardware->dump(fd, args); 1258 } 1259 if (!hasClient) { 1260 result.append("No camera client yet.\n"); 1261 write(fd, result.string(), result.size()); 1262 } 1263 1264 if (locked) mServiceLock.unlock(); 1265 1266 // change logging level 1267 int n = args.size(); 1268 for (int i = 0; i + 1 < n; i++) { 1269 if (args[i] == String16("-v")) { 1270 String8 levelStr(args[i+1]); 1271 int level = atoi(levelStr.string()); 1272 sprintf(buffer, "Set Log Level to %d", level); 1273 result.append(buffer); 1274 setLogLevel(level); 1275 } 1276 } 1277 } 1278 return NO_ERROR; 1279} 1280 1281}; // namespace android 1282