libcameraservice.so : CameraService.cpp 分析

** Copyright (C) 2008, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0

**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

#define LOG_TAG "CameraService"

#include <stdio.h>
#include <sys/types.h>
#include <pthread.h>

#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <cutils/atomic.h>
#include <hardware/hardware.h>
#include <media/AudioSystem.h>
#include <media/mediaplayer.h>
#include <surfaceflinger/ISurface.h>
#include <ui/Overlay.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <utils/String16.h>

#include "CameraService.h"

namespace android {

#ifdef BOARD_USE_CAMERA_TEXTURE_STREAMING
#define DC_CAMERA_ID 8
#endif

// ----------------------------------------------------------------------------

// Logging support -- this is for debugging only

// Use "adb shell dumpsys media.camera -v 1" to change it.

static volatile int32_t gLogLevel = 0;       //如果设为2，则可以print消息

#define LOG1(...) LOGD_IF(gLogLevel >= 1, __VA_ARGS__);
#define LOG2(...) LOGD_IF(gLogLevel >= 2, __VA_ARGS__);

static void setLogLevel(int level) {     
    android_atomic_write(level, &gLogLevel);
}

// ----------------------------------------------------------------------------


static int getCallingPid() {
    return IPCThreadState::self()->getCallingPid();
}

static int getCallingUid() {
    return IPCThreadState::self()->getCallingUid();
}
//取得调用的pid和uid
// ----------------------------------------------------------------------------


// This is ugly and only safe if we never re-create the CameraService, but

// should be ok for now.

static CameraService *gCameraService;  //申明一个类

CameraService::CameraService()   //够造函数
:mSoundRef(0)
{
    LOGI("CameraService started (pid=%d)", getpid());

    mNumberOfCameras = HAL_getNumberOfCameras();  //调用camera HAL层，获得摄像头数
    if (mNumberOfCameras > MAX_CAMERAS) {
        LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
             mNumberOfCameras, MAX_CAMERAS);
        mNumberOfCameras = MAX_CAMERAS;
    }

    for (int i = 0; i < mNumberOfCameras; i++) {
        setCameraFree(i);  //释放内存
    }

    gCameraService = this;  //申请内存，赋值
}

CameraService::~CameraService() {   //析构函数
    for (int i = 0; i < mNumberOfCameras; i++) {
        if (mBusy[i]) {
            LOGE("camera %d is still in use in destructor!", i);
        }
    }

    gCameraService = NULL;   //释放内存
}

int32_t CameraService::getNumberOfCameras() {
    return mNumberOfCameras;   //获得摄像头数
}

status_t CameraService::getCameraInfo(int cameraId, 
                                      struct CameraInfo* cameraInfo) {  //摄像头信息，一个是facing，一个orientation
    if (cameraId < 0 || cameraId >= mNumberOfCameras) {
        return BAD_VALUE;
    }

    HAL_getCameraInfo(cameraId, cameraInfo);  //调用 HAL 获取 CameraInfo
    return OK;
}

sp<ICamera> CameraService::connect(
        const sp<ICameraClient>& cameraClient, int cameraId) { //与camera client 建立 connect
    int callingPid = getCallingPid();
    LOG1("CameraService::connect E (pid %d, id %d)", callingPid, cameraId);

    sp<Client> client;  //申明一个camera client
    if (cameraId < 0 || cameraId >= mNumberOfCameras) {
        LOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
            callingPid, cameraId);
        return NULL;
    }

    Mutex::Autolock lock(mServiceLock);
    if (mClient[cameraId] != 0) {
        client = mClient[cameraId].promote();
        if (client != 0) {
            if (cameraClient

// start preview mode


status_t CameraService::Client::startPreview() { //开始预览
    LOG1("startPreview (pid %d)", getCallingPid());
    return startCameraMode(CAMERA_PREVIEW_MODE); 
}

// start recording mode


status_t CameraService::Client::startRecording() { //开始录像
    LOG1("startRecording (pid %d)", getCallingPid());
    return startCameraMode(CAMERA_RECORDING_MODE);
}

// start preview or recording


status_t CameraService::Client::startCameraMode(camera_mode mode) {
    LOG1("startCameraMode(%d)", mode);   
    Mutex::Autolock lock(mLock);
    status_t result = checkPidAndHardware();
    if (result != NO_ERROR) return result;

    switch(mode) {
        case CAMERA_PREVIEW_MODE:   
            if (mSurface == 0) {
                LOG1("mSurface is not set yet.");
                // still able to start preview in this case.


            }
            return startPreviewMode(); //调用下面的
        case CAMERA_RECORDING_MODE:
            if (mSurface == 0) {
                LOGE("mSurface must be set before startRecordingMode.");
                return INVALID_OPERATION;
            }
            return startRecordingMode();
        default:
            return UNKNOWN_ERROR;
    }
}

status_t CameraService::Client::startPreviewMode() { 
    LOG1("startPreviewMode");
    status_t result = NO_ERROR;

    // if preview has been enabled, nothing needs to be done


    if (mHardware->previewEnabled()) {
        return NO_ERROR;
    }

    if (mUseOverlay) {
        // If preview display has been set, set overlay now.


        if (mSurface != 0) {
            result = setOverlay();
        }
        if (result != NO_ERROR) return result;
        result = mHardware->startPreview();  //正式调用HAL的 startpreview
    } else {
        enableMsgType(CAMERA_MSG_PREVIEW_FRAME);
        result = mHardware->startPreview();
        if (result != NO_ERROR) return result;
        // If preview display has been set, register preview buffers now.


        if (mSurface != 0) {
           // Unregister here because the surface may be previously registered


           // with the raw (snapshot) heap.


           mSurface->unregisterBuffers();
#ifdef BOARD_USE_CAMERA_TEXTURE_STREAMING
           mSurface->destroyTextureStreamSource();
#endif
           result = registerPreviewBuffers(); //调用上面的，实现framebuffer = preview + surface
        }
    }
    return result;
}

status_t CameraService::Client::startRecordingMode() {
    LOG1("startRecordingMode");
    status_t result = NO_ERROR;

    // if recording has been enabled, nothing needs to be done


    if (mHardware->recordingEnabled()) {
        return NO_ERROR;
    }

    // if preview has not been started, start preview first


    if (!mHardware->previewEnabled()) {
        result = startPreviewMode();
        if (result != NO_ERROR) {
            return result;
        }
    }

    // start recording mode


    enableMsgType(CAMERA_MSG_VIDEO_FRAME);  //发出录像消息
    mCameraService->playSound(SOUND_RECORDING);  //调用上面的函数，打开录音
    result = mHardware->startRecording();   //开始录像
    if (result != NO_ERROR) {
        LOGE("mHardware->startRecording() failed with status %d", result);
    }
    return result;
}

// stop preview mode


void CameraService::Client::stopPreview() {
    LOG1("stopPreview (pid %d)", getCallingPid());
    Mutex::Autolock lock(mLock);
    if (checkPidAndHardware() != NO_ERROR) return;

    disableMsgType(CAMERA_MSG_PREVIEW_FRAME);  //停止发消息
    mHardware->stopPreview();  //调用HAL的 stopPreview

    if (mSurface != 0 && !mUseOverlay) {
        mSurface->unregisterBuffers(); //释放内存
#ifdef BOARD_USE_CAMERA_TEXTURE_STREAMING
        mSurface->destroyTextureStreamSource();
#endif

    }

    mPreviewBuffer.clear();  //清空preview buffer
}

// stop recording mode


void CameraService::Client::stopRecording() {
    LOG1("stopRecording (pid %d)", getCallingPid());
    Mutex::Autolock lock(mLock);
    if (checkPidAndHardware() != NO_ERROR) return;

    mCameraService->playSound(SOUND_RECORDING);  
    disableMsgType(CAMERA_MSG_VIDEO_FRAME);  //停止发送录像消息
    mHardware->stopRecording();  //调用HAL 的stopRecording

    mPreviewBuffer.clear();
}

// release a recording frame


void CameraService::Client::releaseRecordingFrame(const sp<IMemory>& mem) {
    Mutex::Autolock lock(mLock);
    if (checkPidAndHardware() != NO_ERROR) return;
    mHardware->releaseRecordingFrame(mem); //调用HAL的函数，但是HAL 现在此函数为空，需要继续跟
}

bool CameraService::Client::previewEnabled() {
    LOG1("previewEnabled (pid %d)", getCallingPid());

    Mutex::Autolock lock(mLock);
    if (checkPidAndHardware() != NO_ERROR) return false;
    return mHardware->previewEnabled(); //调用HAL 的previewEnabled()
}

bool CameraService::Client::recordingEnabled() {
    LOG1("recordingEnabled (pid %d)", getCallingPid());

    Mutex::Autolock lock(mLock);
    if (checkPidAndHardware() != NO_ERROR) return false;
    return mHardware->recordingEnabled();  //调用HAL
}

status_t CameraService::Client::autoFocus() {
    LOG1("autoFocus (pid %d)", getCallingPid());

    Mutex::Autolock lock(mLock);
    status_t result = checkPidAndHardware();
    if (result != NO_ERROR) return result;

    return mHardware->autoFocus();  //调用HAL
}

status_t CameraService::Client::cancelAutoFocus() {
    LOG1("cancelAutoFocus (pid %d)", getCallingPid());

    Mutex::Autolock lock(mLock);
    status_t result = checkPidAndHardware();
    if (result != NO_ERROR) return result;

    return mHardware->cancelAutoFocus();  //调用HAL
}

// take a picture - image is returned in callback


status_t CameraService::Client::takePicture() {
    LOG1("takePicture (pid %d)", getCallingPid());

 // Mutex::Autolock lock(mLock);


    status_t result = checkPidAndHardware();
    if (result != NO_ERROR) return result;

    enableMsgType(CAMERA_MSG_SHUTTER |  //发出这些消息
                  CAMERA_MSG_POSTVIEW_FRAME |
                  CAMERA_MSG_RAW_IMAGE |
                  CAMERA_MSG_COMPRESSED_IMAGE);

    return mHardware->takePicture();   //调用HAL
}

// set preview/capture parameters - key/value pairs


status_t CameraService::Client::setParameters(const String8& params) {
    LOG1("setParameters (pid %d) (%s)", getCallingPid(), params.string());

    Mutex::Autolock lock(mLock);
    status_t result = checkPidAndHardware();
    if (result != NO_ERROR) return result;

    CameraParameters p(params);
    return mHardware->setParameters(p);  // 调用HAL
}

// get preview/capture parameters - key/value pairs


String8 CameraService::Client::getParameters() const {
    Mutex::Autolock lock(mLock);
    if (checkPidAndHardware() != NO_ERROR) return String8();

    String8 params(mHardware->getParameters().flatten()); //调用HAL
    LOG1("getParameters (pid %d) (%s)", getCallingPid(), params.string());
    return params; //返回参数值
}

status_t CameraService::Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
    LOG1("sendCommand (pid %d)", getCallingPid());
    int orientation;
    Mutex::Autolock lock(mLock);
    status_t result = checkPidAndHardware();
    if (result != NO_ERROR) return result;

    if (cmd == CAMERA_CMD_SET_DISPLAY_ORIENTATION) {
        // The orientation cannot be set during preview.


        if (mHardware->previewEnabled()) {
            return INVALID_OPERATION;
        }
        // Mirror the preview if the camera is front-facing.


        orientation = getOrientation(arg1, mCameraFacing == CAMERA_FACING_FRONT);    //获得orientation
        if (orientation == -1) return BAD_VALUE;

        if (mOrientation != orientation) {
            mOrientation = orientation;
            if (mOverlayRef != 0) mOrientationChanged = true;
        }
        return OK;
    }

    return mHardware->sendCommand(cmd, arg1, arg2); //调用HAL，
}

// ----------------------------------------------------------------------------



void CameraService::Client::enableMsgType(int32_t msgType) {
    android_atomic_or(msgType, &mMsgEnabled);
    mHardware->enableMsgType(msgType);  //调用HAL ，使能消息
}

void CameraService::Client::disableMsgType(int32_t msgType) {
    android_atomic_and(~msgType, &mMsgEnabled);
    mHardware->disableMsgType(msgType); //调用HAL ，禁止消息
}

#define CHECK_MESSAGE_INTERVAL 10 // 10ms


bool CameraService::Client::lockIfMessageWanted(int32_t msgType) {
    int sleepCount = 0;
    while (mMsgEnabled & msgType) {
        if (mLock.tryLock() == NO_ERROR) {
            if (sleepCount > 0) {
                LOG1("lockIfMessageWanted(%d): waited for %d ms",
                    msgType, sleepCount * CHECK_MESSAGE_INTERVAL);
            }
            return true;
        }
        if (sleepCount++ == 0) {
            LOG1("lockIfMessageWanted(%d): enter sleep", msgType);
        }
        usleep(CHECK_MESSAGE_INTERVAL * 1000);
    }
    LOGW("lockIfMessageWanted(%d): dropped unwanted message", msgType);
    return false;
}

// ----------------------------------------------------------------------------



// Converts from a raw pointer to the client to a strong pointer during a


// hardware callback. This requires the callbacks only happen when the client


// is still alive.


sp<CameraService::Client> CameraService::Client::getClientFromCookie(void* user) {
    sp<Client> client = gCameraService->getClientById((int) user);

//client 赋值

    // This could happen if the Client is in the process of shutting down (the


    // last strong reference is gone, but the destructor hasn't finished


    // stopping the hardware).


    if (client == 0) return NULL;

    // The checks below are not necessary and are for debugging only.


    if (client->mCameraService.get() != gCameraService) {
        LOGE("mismatch service!");
        return NULL;
    }

    if (client->mHardware == 0) {
        LOGE("mHardware == 0: callback after disconnect()?");
        return NULL;
    }

    return client;
}

// Callback messages can be dispatched to internal handlers or pass to our


// client's callback functions, depending on the message type.


//


// notifyCallback:


// CAMERA_MSG_SHUTTER handleShutter


// (others) c->notifyCallback


// dataCallback:


// CAMERA_MSG_PREVIEW_FRAME handlePreviewData


// CAMERA_MSG_POSTVIEW_FRAME handlePostview


// CAMERA_MSG_RAW_IMAGE handleRawPicture


// CAMERA_MSG_COMPRESSED_IMAGE handleCompressedPicture


// (others) c->dataCallback


// dataCallbackTimestamp


// (others) c->dataCallbackTimestamp


//


// NOTE: the *Callback functions grab mLock of the client before passing


// control to handle* functions. So the handle* functions must release the


// lock before calling the ICameraClient's callbacks, so those callbacks can


// invoke methods in the Client class again (For example, the preview frame


// callback may want to releaseRecordingFrame). The handle* functions must


// release the lock after all accesses to member variables, so it must be


// handled very carefully.



void CameraService::Client::notifyCallback(int32_t msgType, int32_t ext1,
        int32_t ext2, void* user) {
    LOG2("notifyCallback(%d)", msgType);

    sp<Client> client = getClientFromCookie(user);
    if (client == 0) return;
    if (!client->lockIfMessageWanted(msgType)) return;

    switch (msgType) {
        case CAMERA_MSG_SHUTTER:
            // ext1 is the dimension of the yuv picture.


            client->handleShutter((image_rect_type *)ext1); //调用下面的函数
            break;
        default:
            client->handleGenericNotify(msgType, ext1, ext2); //调用下面的函数
            break;
    }
}

void CameraService::Client::dataCallback(int32_t msgType,
        const sp<IMemory>& dataPtr, void* user) {
    LOG2("dataCallback(%d)", msgType);

    sp<Client> client = getClientFromCookie(user);
    if (client == 0) return;
    if (!client->lockIfMessageWanted(msgType)) return;

    if (dataPtr == 0) {
        LOGE("Null data returned in data callback");
        client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
        return;
    }

    switch (msgType) {
        case CAMERA_MSG_PREVIEW_FRAME:
            client->handlePreviewData(dataPtr); //回调函数，从HAL 中反馈回来，会发来一个消息，一个buffer，，让cameraservice执行相应动作，具体见下面函数
            break;
        case CAMERA_MSG_POSTVIEW_FRAME:
            client->handlePostview(dataPtr);
            break;
        case CAMERA_MSG_RAW_IMAGE:
            client->handleRawPicture(dataPtr);
            break;
        case CAMERA_MSG_COMPRESSED_IMAGE:
            client->handleCompressedPicture(dataPtr);
            break;
        default:
            client->handleGenericData(msgType, dataPtr);
            break;
    }
}

void CameraService::Client::dataCallbackTimestamp(nsecs_t timestamp,
        int32_t msgType, const sp<IMemory>& dataPtr, void* user) {
    LOG2("dataCallbackTimestamp(%d)", msgType);

    sp<Client> client = getClientFromCookie(user);
    if (client == 0) return;
    if (!client->lockIfMessageWanted(msgType)) return;

    if (dataPtr == 0) {
        LOGE("Null data returned in data with timestamp callback");
        client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
        return;
    }

    client->handleGenericDataTimestamp(timestamp, msgType, dataPtr);
}//带时间戳的callback，支持录像功能

// snapshot taken callback


// "size" is the width and height of yuv picture for registerBuffer.


// If it is NULL, use the picture size from parameters.


void CameraService::Client::handleShutter(image_rect_type *size) {
    mCameraService->playSound(SOUND_SHUTTER);

    // Screen goes black after the buffer is unregistered.


    if (mSurface != 0 && !mUseOverlay) {
        mSurface->unregisterBuffers();
#ifdef BOARD_USE_CAMERA_TEXTURE_STREAMING
        mSurface->destroyTextureStreamSource();
#endif

    }

    sp<ICameraClient> c = mCameraClient;
    if (c != 0) {
        mLock.unlock();
        c->notifyCallback(CAMERA_MSG_SHUTTER, 0, 0);
        if (!lockIfMessageWanted(CAMERA_MSG_SHUTTER)) return;
    }
    disableMsgType(CAMERA_MSG_SHUTTER);

    // It takes some time before yuvPicture callback to be called.


    // Register the buffer for raw image here to reduce latency.


    if (mSurface != 0 && !mUseOverlay) {
        int w, h;
        CameraParameters params(mHardware->getParameters());
        if (size == NULL) {
            params.getPictureSize(&w, &h);
        } else {
            w = size->width;
            h = size->height;
            w &= ~1;
            h &= ~1;
            LOG1("Snapshot image width=%d, height=%d", w, h);
        }
        // FIXME: don't use hardcoded format constants here


        ISurface::BufferHeap buffers(w, h, w, h,
            HAL_PIXEL_FORMAT_YCrCb_420_SP, mOrientation, 0,
            mHardware->getRawHeap());//调用HAL ，获取原始图像数据 

        mSurface->registerBuffers(buffers); //取surface数据
        IPCThreadState::self()->flushCommands();
    }

    mLock.unlock();
}

// preview callback - frame buffer update


void CameraService::Client::handlePreviewData(const sp<IMemory>& mem) {
    ssize_t offset;
    size_t size;
    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);

    if (!mUseOverlay) {
        if (mSurface != 0) {
#ifdef BOARD_USE_CAMERA_TEXTURE_STREAMING
            unsigned int frame_id;
            memcpy(&frame_id, (uint8_t *)heap->base() + offset,
                sizeof(unsigned int));
            mSurface->displayTextureStreamBuffer(frame_id);
#else
            mSurface->postBuffer(offset);
#endif
        }
    }

    // local copy of the callback flags


    int flags = mPreviewCallbackFlag;

    // is callback enabled?


    if (!(flags & FRAME_CALLBACK_FLAG_ENABLE_MASK)) {
        // If the enable bit is off, the copy-out and one-shot bits are ignored


        LOG2("frame callback is disabled");
        mLock.unlock();
        return;
    }

    // hold a strong pointer to the client


    sp<ICameraClient> c = mCameraClient;

    // clear callback flags if no client or one-shot mode


    if (c == 0 || (mPreviewCallbackFlag & FRAME_CALLBACK_FLAG_ONE_SHOT_MASK)) {
        LOG2("Disable preview callback");
        mPreviewCallbackFlag &= ~(FRAME_CALLBACK_FLAG_ONE_SHOT_MASK |
                                  FRAME_CALLBACK_FLAG_COPY_OUT_MASK |
                                  FRAME_CALLBACK_FLAG_ENABLE_MASK);
        if (mUseOverlay) {
            disableMsgType(CAMERA_MSG_PREVIEW_FRAME);
        }
    }

    if (c != 0) {
        // Is the received frame copied out or not?


        if (flags & FRAME_CALLBACK_FLAG_COPY_OUT_MASK) {
            LOG2("frame is copied");
            copyFrameAndPostCopiedFrame(c, heap, offset, size);
        } else {
            LOG2("frame is forwarded");
            mLock.unlock();
            c->dataCallback(CAMERA_MSG_PREVIEW_FRAME, mem);
        }
    } else {
        mLock.unlock();
    }
}

// picture callback - postview image ready


void CameraService::Client::handlePostview(const sp<IMemory>& mem) {
    disableMsgType(CAMERA_MSG_POSTVIEW_FRAME);

    sp<ICameraClient> c = mCameraClient;
    mLock.unlock();
    if (c != 0) {
        c->dataCallback(CAMERA_MSG_POSTVIEW_FRAME, mem);
    }
}

// picture callback - raw image ready


void CameraService::Client::handleRawPicture(const sp<IMemory>& mem) {
    disableMsgType(CAMERA_MSG_RAW_IMAGE);

    ssize_t offset;
    size_t size;
    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);

    // Put the YUV version of the snapshot in the preview display.


    if (mSurface != 0 && !mUseOverlay) {
        mSurface->postBuffer(offset);
    }

    sp<ICameraClient> c = mCameraClient;
    mLock.unlock();
    if (c != 0) {
        c->dataCallback(CAMERA_MSG_RAW_IMAGE, mem);
    }
}

// picture callback - compressed picture ready


void CameraService::Client::handleCompressedPicture(const sp<IMemory>& mem) {
    disableMsgType(CAMERA_MSG_COMPRESSED_IMAGE);

    sp<ICameraClient> c = mCameraClient;
    mLock.unlock();
    if (c != 0) {
        c->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, mem);
    }
}


void CameraService::Client::handleGenericNotify(int32_t msgType,
    int32_t ext1, int32_t ext2) {
    sp<ICameraClient> c = mCameraClient;
    mLock.unlock();
    if (c != 0) {
        c->notifyCallback(msgType, ext1, ext2);
    }
}

void CameraService::Client::handleGenericData(int32_t msgType,
    const sp<IMemory>& dataPtr) {
    sp<ICameraClient> c = mCameraClient;
    mLock.unlock();
    if (c != 0) {
        c->dataCallback(msgType, dataPtr);
    }
}

void CameraService::Client::handleGenericDataTimestamp(nsecs_t timestamp,
    int32_t msgType, const sp<IMemory>& dataPtr) {
    sp<ICameraClient> c = mCameraClient;
    mLock.unlock();
    if (c != 0) {
        c->dataCallbackTimestamp(timestamp, msgType, dataPtr);
    }
}

void CameraService::Client::copyFrameAndPostCopiedFrame(
        const sp<ICameraClient>& client, const sp<IMemoryHeap>& heap,
        size_t offset, size_t size) {
    LOG2("copyFrameAndPostCopiedFrame");
    // It is necessary to copy out of pmem before sending this to


    // the callback. For efficiency, reuse the same MemoryHeapBase


    // provided it's big enough. Don't allocate the memory or


    // perform the copy if there's no callback.


    // hold the preview lock while we grab a reference to the preview buffer


    sp<MemoryHeapBase> previewBuffer;

    if (mPreviewBuffer == 0) {
        mPreviewBuffer = new MemoryHeapBase(size, 0, NULL);
    } else if (size > mPreviewBuffer->virtualSize()) {
        mPreviewBuffer.clear();
        mPreviewBuffer = new MemoryHeapBase(size, 0, NULL);
    }
    if (mPreviewBuffer == 0) {
        LOGE("failed to allocate space for preview buffer");
        mLock.unlock();
        return;
    }
    previewBuffer = mPreviewBuffer;

    memcpy(previewBuffer->base(), (uint8_t *)heap->base() + offset, size);

    sp<MemoryBase> frame = new MemoryBase(previewBuffer, 0, size);
    if (frame == 0) {
        LOGE("failed to allocate space for frame callback");
        mLock.unlock();
        return;
    }

    mLock.unlock();
    client->dataCallback(CAMERA_MSG_PREVIEW_FRAME, frame);
}

int CameraService::Client::getOrientation(int degrees, bool mirror) {  
    if (!mirror) {
        if (degrees == 0) return 0;
        else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
        else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
        else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
    } else { // Do mirror (horizontal flip)


        if (degrees == 0) { // FLIP_H and ROT_0


            return HAL_TRANSFORM_FLIP_H;
        } else if (degrees == 90) { // FLIP_H and ROT_90


            return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
        } else if (degrees == 180) { // FLIP_H and ROT_180


            return HAL_TRANSFORM_FLIP_V;
        } else if (degrees == 270) { // FLIP_H and ROT_270


            return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
        }
    }
    LOGE("Invalid setDisplayOrientation degrees=%d", degrees);
    return -1;
}


// ----------------------------------------------------------------------------



static const int kDumpLockRetries = 50;
static const int kDumpLockSleep = 60000;

static bool tryLock(Mutex& mutex)
{
    bool locked = false;
    for (int i = 0; i < kDumpLockRetries; ++i) {
        if (mutex.tryLock() == NO_ERROR) {
            locked = true;
            break;
        }
        usleep(kDumpLockSleep);
    }
    return locked;
}

status_t CameraService::dump(int fd, const Vector<String16>& args) {
    static const char* kDeadlockedString = "CameraService may be deadlocked\n";

    const size_t SIZE = 256;
    char buffer[SIZE];
    String8 result;
    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
        snprintf(buffer, SIZE, "Permission Denial: "
                "can't dump CameraService from pid=%d, uid=%d\n",
                getCallingPid(),
                getCallingUid());
        result.append(buffer);
        write(fd, result.string(), result.size());
    } else {
        bool locked = tryLock(mServiceLock);
        // failed to lock - CameraService is probably deadlocked


        if (!locked) {
            String8 result(kDeadlockedString);
            write(fd, result.string(), result.size());
        }

        bool hasClient = false;
        for (int i = 0; i < mNumberOfCameras; i++) {
            sp<Client> client = mClient[i].promote();
            if (client == 0) continue;
            hasClient = true;
            sprintf(buffer, "Client[%d] (%p) PID: %d\n",
                    i,
                    client->getCameraClient()->asBinder().get(),
                    client->mClientPid);
            result.append(buffer);
            write(fd, result.string(), result.size());
            client->mHardware->dump(fd, args);
        }
        if (!hasClient) {
            result.append("No camera client yet.\n");
            write(fd, result.string(), result.size());
        }

        if (locked) mServiceLock.unlock();

        // change logging level


        int n = args.size();
        for (int i = 0; i + 1 < n; i++) {
            if (args[i] == String16("-v")) {
                String8 levelStr(args[i+1]);
                int level = atoi(levelStr.string());
                sprintf(buffer, "Set Log Level to %d", level);
                result.append(buffer);
                setLogLevel(level);
            }
        }
    }
    return NO_ERROR;
}

}; // namespace android