| /* |
| * Copyright (C) 2011 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. |
| */ |
| |
| /* |
| * Contains implementation of an abstract class EmulatedCameraDevice that defines |
| * functionality expected from an emulated physical camera device: |
| * - Obtaining and setting camera parameters |
| * - Capturing frames |
| * - Streaming video |
| * - etc. |
| */ |
| |
| #define LOG_NDEBUG 0 |
| #define LOG_TAG "EmulatedCamera_Device" |
| #include <log/log.h> |
| #include <sys/select.h> |
| #include <cmath> |
| #include "Alignment.h" |
| #include "EmulatedCamera.h" |
| #include "EmulatedCameraDevice.h" |
| |
| #undef min |
| #undef max |
| #include <algorithm> |
| |
| namespace android { |
| |
| const float GAMMA_CORRECTION = 2.2f; |
| EmulatedCameraDevice::EmulatedCameraDevice(EmulatedCamera* camera_hal) |
| : mObjectLock(), |
| mCameraHAL(camera_hal), |
| mExposureCompensation(1.0f), |
| mWhiteBalanceScale(NULL), |
| mSupportedWhiteBalanceScale(), |
| mState(ECDS_CONSTRUCTED), |
| mTriggerAutoFocus(false) |
| { |
| } |
| |
| EmulatedCameraDevice::~EmulatedCameraDevice() |
| { |
| ALOGV("EmulatedCameraDevice destructor"); |
| for (size_t i = 0; i < mSupportedWhiteBalanceScale.size(); ++i) { |
| if (mSupportedWhiteBalanceScale.valueAt(i) != NULL) { |
| delete[] mSupportedWhiteBalanceScale.valueAt(i); |
| } |
| } |
| } |
| |
| /**************************************************************************** |
| * Emulated camera device public API |
| ***************************************************************************/ |
| |
| status_t EmulatedCameraDevice::Initialize() |
| { |
| if (isInitialized()) { |
| ALOGW("%s: Emulated camera device is already initialized: mState = %d", |
| __FUNCTION__, mState); |
| return NO_ERROR; |
| } |
| |
| mState = ECDS_INITIALIZED; |
| |
| return NO_ERROR; |
| } |
| |
| status_t EmulatedCameraDevice::startDeliveringFrames(bool one_burst) |
| { |
| ALOGV("%s", __FUNCTION__); |
| |
| if (!isStarted()) { |
| ALOGE("%s: Device is not started", __FUNCTION__); |
| return EINVAL; |
| } |
| |
| /* Frames will be delivered from the thread routine. */ |
| const status_t res = startWorkerThread(one_burst); |
| ALOGE_IF(res != NO_ERROR, "%s: startWorkerThread failed", __FUNCTION__); |
| return res; |
| } |
| |
| status_t EmulatedCameraDevice::stopDeliveringFrames() |
| { |
| ALOGV("%s", __FUNCTION__); |
| |
| if (!isStarted()) { |
| ALOGW("%s: Device is not started", __FUNCTION__); |
| return NO_ERROR; |
| } |
| |
| const status_t res = stopWorkerThread(); |
| ALOGE_IF(res != NO_ERROR, "%s: stopWorkerThread failed", __FUNCTION__); |
| return res; |
| } |
| |
| status_t EmulatedCameraDevice::setPreviewFrameRate(int framesPerSecond) { |
| if (framesPerSecond <= 0) { |
| return EINVAL; |
| } |
| mFramesPerSecond = framesPerSecond; |
| return NO_ERROR; |
| } |
| |
| void EmulatedCameraDevice::setExposureCompensation(const float ev) { |
| ALOGV("%s", __FUNCTION__); |
| |
| if (!isStarted()) { |
| ALOGW("%s: Fake camera device is not started.", __FUNCTION__); |
| } |
| |
| mExposureCompensation = std::pow(2.0f, ev / GAMMA_CORRECTION); |
| ALOGV("New exposure compensation is %f", mExposureCompensation); |
| } |
| |
| void EmulatedCameraDevice::initializeWhiteBalanceModes(const char* mode, |
| const float r_scale, |
| const float b_scale) { |
| ALOGV("%s with %s, %f, %f", __FUNCTION__, mode, r_scale, b_scale); |
| float* value = new float[3]; |
| value[0] = r_scale; value[1] = 1.0f; value[2] = b_scale; |
| mSupportedWhiteBalanceScale.add(String8(mode), value); |
| } |
| |
| void EmulatedCameraDevice::setWhiteBalanceMode(const char* mode) { |
| ALOGV("%s with white balance %s", __FUNCTION__, mode); |
| mWhiteBalanceScale = |
| mSupportedWhiteBalanceScale.valueFor(String8(mode)); |
| } |
| |
| /* Computes the pixel value after adjusting the white balance to the current |
| * one. The input the y, u, v channel of the pixel and the adjusted value will |
| * be stored in place. The adjustment is done in RGB space. |
| */ |
| void EmulatedCameraDevice::changeWhiteBalance(uint8_t& y, |
| uint8_t& u, |
| uint8_t& v) const { |
| float r_scale = mWhiteBalanceScale[0]; |
| float b_scale = mWhiteBalanceScale[2]; |
| int r = static_cast<float>(YUV2R(y, u, v)) / r_scale; |
| int g = YUV2G(y, u, v); |
| int b = static_cast<float>(YUV2B(y, u, v)) / b_scale; |
| |
| y = RGB2Y(r, g, b); |
| u = RGB2U(r, g, b); |
| v = RGB2V(r, g, b); |
| } |
| |
| void EmulatedCameraDevice::checkAutoFocusTrigger() { |
| // The expected value is a reference so we need it to be a variable |
| bool expectedTrigger = true; |
| if (mTriggerAutoFocus.compare_exchange_strong(expectedTrigger, false)) { |
| // If the compare exchange returns true then the value was the expected |
| // 'true' and was successfully set to 'false'. So that means it's time |
| // to trigger an auto-focus event and that we have disabled that trigger |
| // so it won't happen until another request is received. |
| mCameraHAL->autoFocusComplete(); |
| } |
| } |
| |
| status_t EmulatedCameraDevice::getCurrentFrameImpl(const uint8_t* source, |
| uint8_t* dest, |
| uint32_t pixelFormat) const { |
| if (pixelFormat == mPixelFormat) { |
| memcpy(dest, source, mFrameBufferSize); |
| return NO_ERROR; |
| } else if (pixelFormat == V4L2_PIX_FMT_YUV420 && |
| mPixelFormat == V4L2_PIX_FMT_YVU420) { |
| // Convert from YV12 to YUV420 without alignment |
| const int ySize = mYStride * mFrameHeight; |
| const int uvSize = mUVStride * (mFrameHeight / 2); |
| if (mYStride == mFrameWidth) { |
| // Copy Y straight up |
| memcpy(dest, source, ySize); |
| } else { |
| // Strip alignment |
| for (int y = 0; y < mFrameHeight; ++y) { |
| memcpy(dest + y * mFrameWidth, |
| source + y * mYStride, |
| mFrameWidth); |
| } |
| } |
| |
| if (mUVStride == mFrameWidth / 2) { |
| // Swap U and V |
| memcpy(dest + ySize, source + ySize + uvSize, uvSize); |
| memcpy(dest + ySize + uvSize, source + ySize, uvSize); |
| } else { |
| // Strip alignment |
| uint8_t* uvDest = dest + mFrameWidth * mFrameHeight; |
| const uint8_t* uvSource = source + ySize + uvSize; |
| |
| for (int i = 0; i < 2; ++i) { |
| for (int y = 0; y < mFrameHeight / 2; ++y) { |
| memcpy(uvDest + y * (mFrameWidth / 2), |
| uvSource + y * mUVStride, |
| mFrameWidth / 2); |
| } |
| uvDest += (mFrameHeight / 2) * (mFrameWidth / 2); |
| uvSource -= uvSize; |
| } |
| } |
| return NO_ERROR; |
| } |
| ALOGE("%s: Invalid pixel format conversion [%.4s to %.4s] requested", |
| __FUNCTION__, reinterpret_cast<const char*>(&mPixelFormat), |
| reinterpret_cast<const char*>(&pixelFormat)); |
| return EINVAL; |
| } |
| |
| status_t EmulatedCameraDevice::getCurrentFrame(void* buffer, |
| uint32_t pixelFormat, |
| int64_t* timestamp) |
| { |
| if (!isStarted()) { |
| ALOGE("%s: Device is not started", __FUNCTION__); |
| return EINVAL; |
| } |
| if (buffer == nullptr) { |
| ALOGE("%s: Invalid buffer provided", __FUNCTION__); |
| return EINVAL; |
| } |
| |
| FrameLock lock(*this); |
| const void* source = mCameraThread->getPrimaryBuffer(); |
| if (source == nullptr) { |
| ALOGE("%s: No framebuffer", __FUNCTION__); |
| return EINVAL; |
| } |
| |
| if (timestamp != nullptr) { |
| *timestamp = mCameraThread->getPrimaryTimestamp(); |
| } |
| |
| return getCurrentFrameImpl(reinterpret_cast<const uint8_t*>(source), |
| reinterpret_cast<uint8_t*>(buffer), |
| pixelFormat); |
| } |
| |
| status_t EmulatedCameraDevice::getCurrentPreviewFrame(void* buffer, |
| int64_t* timestamp) |
| { |
| if (!isStarted()) { |
| ALOGE("%s: Device is not started", __FUNCTION__); |
| return EINVAL; |
| } |
| if (buffer == nullptr) { |
| ALOGE("%s: Invalid buffer provided", __FUNCTION__); |
| return EINVAL; |
| } |
| |
| FrameLock lock(*this); |
| const void* currentFrame = mCameraThread->getPrimaryBuffer(); |
| if (currentFrame == nullptr) { |
| ALOGE("%s: No framebuffer", __FUNCTION__); |
| return EINVAL; |
| } |
| |
| if (timestamp != nullptr) { |
| *timestamp = mCameraThread->getPrimaryTimestamp(); |
| } |
| |
| /* In emulation the framebuffer is never RGB. */ |
| switch (mPixelFormat) { |
| case V4L2_PIX_FMT_YVU420: |
| YV12ToRGB32(currentFrame, buffer, mFrameWidth, mFrameHeight); |
| return NO_ERROR; |
| case V4L2_PIX_FMT_YUV420: |
| YU12ToRGB32(currentFrame, buffer, mFrameWidth, mFrameHeight); |
| return NO_ERROR; |
| case V4L2_PIX_FMT_NV21: |
| NV21ToRGB32(currentFrame, buffer, mFrameWidth, mFrameHeight); |
| return NO_ERROR; |
| case V4L2_PIX_FMT_NV12: |
| NV12ToRGB32(currentFrame, buffer, mFrameWidth, mFrameHeight); |
| return NO_ERROR; |
| |
| default: |
| ALOGE("%s: Unknown pixel format %.4s", |
| __FUNCTION__, reinterpret_cast<const char*>(&mPixelFormat)); |
| return EINVAL; |
| } |
| } |
| |
| const void* EmulatedCameraDevice::getCurrentFrame() { |
| if (mCameraThread.get()) { |
| return mCameraThread->getPrimaryBuffer(); |
| } |
| return nullptr; |
| } |
| |
| EmulatedCameraDevice::FrameLock::FrameLock(EmulatedCameraDevice& cameraDevice) |
| : mCameraDevice(cameraDevice) { |
| mCameraDevice.lockCurrentFrame(); |
| } |
| |
| EmulatedCameraDevice::FrameLock::~FrameLock() { |
| mCameraDevice.unlockCurrentFrame(); |
| } |
| |
| status_t EmulatedCameraDevice::setAutoFocus() { |
| mTriggerAutoFocus = true; |
| return NO_ERROR; |
| } |
| |
| status_t EmulatedCameraDevice::cancelAutoFocus() { |
| mTriggerAutoFocus = false; |
| return NO_ERROR; |
| } |
| |
| bool EmulatedCameraDevice::requestRestart(int width, int height, |
| uint32_t pixelFormat, |
| bool takingPicture, bool oneBurst) { |
| if (mCameraThread.get() == nullptr) { |
| ALOGE("%s: No thread alive to perform the restart, is preview on?", |
| __FUNCTION__); |
| return false; |
| } |
| mCameraThread->requestRestart(width, height, pixelFormat, |
| takingPicture, oneBurst); |
| return true; |
| } |
| |
| /**************************************************************************** |
| * Emulated camera device private API |
| ***************************************************************************/ |
| |
| status_t EmulatedCameraDevice::commonStartDevice(int width, |
| int height, |
| uint32_t pix_fmt) |
| { |
| /* Validate pixel format, and calculate framebuffer size at the same time. */ |
| switch (pix_fmt) { |
| case V4L2_PIX_FMT_YVU420: |
| case V4L2_PIX_FMT_YUV420: |
| // For these pixel formats the strides have to be aligned to 16 byte |
| // boundaries as per the format specification |
| // https://developer.android.com/reference/android/graphics/ImageFormat.html#YV12 |
| mYStride = align(width, 16); |
| mUVStride = align(mYStride / 2, 16); |
| // The second term should use half the height but since there are |
| // two planes the multiplication with two cancels that out |
| mFrameBufferSize = mYStride * height + mUVStride * height; |
| break; |
| case V4L2_PIX_FMT_NV21: |
| case V4L2_PIX_FMT_NV12: |
| mYStride = width; |
| // Because of interleaving the UV stride is the same as the Y stride |
| // since it covers two pixels, one U and one V. |
| mUVStride = mYStride; |
| // Since the U/V stride covers both U and V we don't multiply by two |
| mFrameBufferSize = mYStride * height + mUVStride * (height / 2); |
| break; |
| default: |
| ALOGE("%s: Unknown pixel format %.4s", |
| __FUNCTION__, reinterpret_cast<const char*>(&pix_fmt)); |
| return EINVAL; |
| } |
| |
| /* Cache framebuffer info. */ |
| mFrameWidth = width; |
| mFrameHeight = height; |
| mPixelFormat = pix_fmt; |
| mTotalPixels = width * height; |
| |
| /* Allocate framebuffer. */ |
| mFrameBuffers[0].resize(mFrameBufferSize); |
| mFrameBuffers[1].resize(mFrameBufferSize); |
| ALOGV("%s: Allocated %zu bytes for %d pixels in %.4s[%dx%d] frame", |
| __FUNCTION__, mFrameBufferSize, mTotalPixels, |
| reinterpret_cast<const char*>(&mPixelFormat), mFrameWidth, mFrameHeight); |
| return NO_ERROR; |
| } |
| |
| void EmulatedCameraDevice::commonStopDevice() |
| { |
| mFrameWidth = mFrameHeight = mTotalPixels = 0; |
| mPixelFormat = 0; |
| |
| mFrameBuffers[0].clear(); |
| mFrameBuffers[1].clear(); |
| // No need to keep all that memory allocated if the camera isn't running |
| mFrameBuffers[0].shrink_to_fit(); |
| mFrameBuffers[1].shrink_to_fit(); |
| } |
| |
| /**************************************************************************** |
| * Worker thread management. |
| ***************************************************************************/ |
| |
| status_t EmulatedCameraDevice::startWorkerThread(bool one_burst) |
| { |
| ALOGV("%s", __FUNCTION__); |
| |
| if (!isInitialized()) { |
| ALOGE("%s: Emulated camera device is not initialized", __FUNCTION__); |
| return EINVAL; |
| } |
| |
| mCameraThread = new CameraThread(this, staticProduceFrame, this); |
| if (mCameraThread == NULL) { |
| ALOGE("%s: Unable to instantiate CameraThread object", __FUNCTION__); |
| return ENOMEM; |
| } |
| status_t res = mCameraThread->startThread(one_burst); |
| if (res != NO_ERROR) { |
| ALOGE("%s: Unable to start CameraThread: %s", |
| __FUNCTION__, strerror(res)); |
| return res; |
| } |
| |
| return res; |
| } |
| |
| status_t EmulatedCameraDevice::stopWorkerThread() |
| { |
| ALOGV("%s", __FUNCTION__); |
| |
| if (!isInitialized()) { |
| ALOGE("%s: Emulated camera device is not initialized", __FUNCTION__); |
| return EINVAL; |
| } |
| |
| status_t res = mCameraThread->stopThread(); |
| if (res != NO_ERROR) { |
| ALOGE("%s: Unable to stop CameraThread", __FUNCTION__); |
| return res; |
| } |
| res = mCameraThread->joinThread(); |
| if (res != NO_ERROR) { |
| ALOGE("%s: Unable to join CameraThread", __FUNCTION__); |
| return res; |
| } |
| |
| // Destroy the thread as well |
| mCameraThread.clear(); |
| return res; |
| } |
| |
| EmulatedCameraDevice::CameraThread::CameraThread(EmulatedCameraDevice* dev, |
| ProduceFrameFunc producer, |
| void* producerOpaque) |
| : WorkerThread("Camera_CameraThread", dev, dev->mCameraHAL), |
| mCurFrameTimestamp(0), |
| mProducerFunc(producer), |
| mProducerOpaque(producerOpaque), |
| mRestartWidth(0), |
| mRestartHeight(0), |
| mRestartPixelFormat(0), |
| mRestartOneBurst(false), |
| mRestartTakingPicture(false), |
| mRestartRequested(false) { |
| |
| } |
| |
| const void* EmulatedCameraDevice::CameraThread::getPrimaryBuffer() const { |
| if (mFrameProducer.get()) { |
| return mFrameProducer->getPrimaryBuffer(); |
| } |
| return nullptr; |
| } |
| |
| int64_t EmulatedCameraDevice::CameraThread::getPrimaryTimestamp() const { |
| if (mFrameProducer.get()) { |
| return mFrameProducer->getPrimaryTimestamp(); |
| } |
| return 0L; |
| } |
| |
| void EmulatedCameraDevice::CameraThread::lockPrimaryBuffer() { |
| mFrameProducer->lockPrimaryBuffer(); |
| } |
| |
| void EmulatedCameraDevice::CameraThread::unlockPrimaryBuffer() { |
| mFrameProducer->unlockPrimaryBuffer(); |
| } |
| |
| bool |
| EmulatedCameraDevice::CameraThread::waitForFrameOrTimeout(nsecs_t timeout) { |
| // Keep waiting until the frame producer indicates that a frame is available |
| // This does introduce some unnecessary latency to the first frame delivery |
| // but avoids a lot of thread synchronization. |
| do { |
| // We don't have any specific fd we want to select so we pass in -1 |
| // timeout is in nanoseconds but Select expects microseconds |
| Mutex::Autolock lock(mRunningMutex); |
| mRunningCondition.waitRelative(mRunningMutex, timeout); |
| if (!mRunning) { |
| ALOGV("%s: CameraThread has been terminated.", __FUNCTION__); |
| return false; |
| } |
| // Set a short timeout in case there is no frame available and we are |
| // going to loop. This way we ensure a sleep but keep a decent latency |
| timeout = milliseconds(5); |
| } while (!mFrameProducer->hasFrame()); |
| |
| return true; |
| } |
| |
| bool EmulatedCameraDevice::CameraThread::inWorkerThread() { |
| /* Wait till FPS timeout expires, or thread exit message is received. */ |
| nsecs_t wakeAt = |
| mCurFrameTimestamp + 1000000000.0 / mCameraDevice->mFramesPerSecond; |
| nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); |
| nsecs_t timeout = std::max<nsecs_t>(0, wakeAt - now); |
| |
| if (!waitForFrameOrTimeout(timeout)) { |
| return false; |
| } |
| |
| /* Check if a restart and potentially apply the requested changes */ |
| if (!checkRestartRequest()) { |
| return false; |
| } |
| |
| /* Check if an auto-focus event needs to be triggered */ |
| mCameraDevice->checkAutoFocusTrigger(); |
| |
| mCurFrameTimestamp = systemTime(SYSTEM_TIME_MONOTONIC); |
| mCameraHAL->onNextFrameAvailable(mCurFrameTimestamp, mCameraDevice); |
| |
| return true; |
| } |
| |
| status_t EmulatedCameraDevice::CameraThread::onThreadStart() { |
| void* primaryBuffer = mCameraDevice->getPrimaryBuffer(); |
| void* secondaryBuffer = mCameraDevice->getSecondaryBuffer(); |
| mFrameProducer = new FrameProducer(mCameraDevice, |
| mProducerFunc, mProducerOpaque, |
| primaryBuffer, secondaryBuffer); |
| if (mFrameProducer.get() == nullptr) { |
| ALOGE("%s: Could not instantiate FrameProducer object", __FUNCTION__); |
| return ENOMEM; |
| } |
| return mFrameProducer->startThread(mOneBurst); |
| } |
| |
| void EmulatedCameraDevice::CameraThread::onThreadExit() { |
| if (mFrameProducer.get()) { |
| if (mFrameProducer->stopThread() == NO_ERROR) { |
| mFrameProducer->joinThread(); |
| mFrameProducer.clear(); |
| } |
| } |
| } |
| |
| EmulatedCameraDevice::CameraThread::FrameProducer::FrameProducer( |
| EmulatedCameraDevice* dev, |
| ProduceFrameFunc producer, |
| void* opaque, |
| void* primaryBuffer, |
| void* secondaryBuffer) |
| : WorkerThread("Camera_FrameProducer", dev, dev->mCameraHAL), |
| mProducer(producer), |
| mOpaque(opaque), |
| mPrimaryBuffer(primaryBuffer), |
| mSecondaryBuffer(secondaryBuffer), |
| mPrimaryTimestamp(0L), |
| mSecondaryTimestamp(0L), |
| mLastFrame(0), |
| mHasFrame(false) { |
| |
| } |
| |
| const void* |
| EmulatedCameraDevice::CameraThread::FrameProducer::getPrimaryBuffer() const { |
| return mPrimaryBuffer; |
| } |
| |
| int64_t |
| EmulatedCameraDevice::CameraThread::FrameProducer::getPrimaryTimestamp() const { |
| return mPrimaryTimestamp; |
| } |
| |
| void EmulatedCameraDevice::CameraThread::FrameProducer::lockPrimaryBuffer() { |
| mBufferMutex.lock(); |
| } |
| void EmulatedCameraDevice::CameraThread::FrameProducer::unlockPrimaryBuffer() { |
| mBufferMutex.unlock(); |
| } |
| |
| void EmulatedCameraDevice::CameraThread::requestRestart(int width, |
| int height, |
| uint32_t pixelFormat, |
| bool takingPicture, |
| bool oneBurst) { |
| Mutex::Autolock lock(mRequestMutex); |
| mRestartWidth = width; |
| mRestartHeight = height; |
| mRestartPixelFormat = pixelFormat; |
| mRestartTakingPicture = takingPicture; |
| mRestartOneBurst = oneBurst; |
| mRestartRequested = true; |
| } |
| |
| bool EmulatedCameraDevice::CameraThread::FrameProducer::hasFrame() const { |
| return mHasFrame; |
| } |
| |
| bool EmulatedCameraDevice::CameraThread::checkRestartRequest() { |
| Mutex::Autolock lock(mRequestMutex); |
| if (mRestartRequested) { |
| mRestartRequested = false; |
| status_t res = mFrameProducer->stopThread(); |
| if (res != NO_ERROR) { |
| ALOGE("%s: Could not stop frame producer thread", __FUNCTION__); |
| mCameraHAL->onCameraDeviceError(CAMERA_ERROR_SERVER_DIED); |
| return false; |
| } |
| res = mFrameProducer->joinThread(); |
| if (res != NO_ERROR) { |
| ALOGE("%s: Could not join frame producer thread", __FUNCTION__); |
| mCameraHAL->onCameraDeviceError(CAMERA_ERROR_SERVER_DIED); |
| return false; |
| } |
| mFrameProducer.clear(); |
| res = mCameraDevice->stopDevice(); |
| if (res != NO_ERROR) { |
| ALOGE("%s: Could not stop device", __FUNCTION__); |
| mCameraHAL->onCameraDeviceError(CAMERA_ERROR_SERVER_DIED); |
| return false; |
| } |
| res = mCameraDevice->startDevice(mRestartWidth, |
| mRestartHeight, |
| mRestartPixelFormat); |
| if (res != NO_ERROR) { |
| ALOGE("%s: Could not start device", __FUNCTION__); |
| mCameraHAL->onCameraDeviceError(CAMERA_ERROR_SERVER_DIED); |
| return false; |
| } |
| if (mRestartTakingPicture) { |
| mCameraHAL->setTakingPicture(true); |
| } |
| mOneBurst = mRestartOneBurst; |
| |
| // Pretend like this a thread start, performs the remaining setup |
| if (onThreadStart() != NO_ERROR) { |
| mCameraDevice->stopDevice(); |
| mCameraHAL->onCameraDeviceError(CAMERA_ERROR_SERVER_DIED); |
| return false; |
| } |
| |
| // Now wait for the frame producer to start producing before we proceed |
| return waitForFrameOrTimeout(0); |
| } |
| return true; |
| } |
| |
| bool EmulatedCameraDevice::CameraThread::FrameProducer::inWorkerThread() { |
| nsecs_t nextFrame = |
| mLastFrame + 1000000000 / mCameraDevice->mFramesPerSecond; |
| nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); |
| nsecs_t timeout = std::max<nsecs_t>(0, nextFrame - now); |
| |
| { |
| Mutex::Autolock lock(mRunningMutex); |
| mRunningCondition.waitRelative(mRunningMutex, timeout); |
| if (!mRunning) { |
| ALOGV("%s: FrameProducer has been terminated.", __FUNCTION__); |
| return false; |
| } |
| } |
| |
| // Produce one frame and place it in the secondary buffer |
| mLastFrame = systemTime(SYSTEM_TIME_MONOTONIC); |
| if (!mProducer(mOpaque, mSecondaryBuffer, &mSecondaryTimestamp)) { |
| ALOGE("FrameProducer could not produce frame, exiting thread"); |
| mCameraHAL->onCameraDeviceError(CAMERA_ERROR_SERVER_DIED); |
| return false; |
| } |
| |
| { |
| // Switch buffers now that the secondary buffer is ready |
| Mutex::Autolock lock(mBufferMutex); |
| std::swap(mPrimaryBuffer, mSecondaryBuffer); |
| std::swap(mPrimaryTimestamp, mSecondaryTimestamp); |
| } |
| mHasFrame = true; |
| return true; |
| } |
| |
| void EmulatedCameraDevice::lockCurrentFrame() { |
| mCameraThread->lockPrimaryBuffer(); |
| } |
| |
| void EmulatedCameraDevice::unlockCurrentFrame() { |
| mCameraThread->unlockPrimaryBuffer(); |
| } |
| |
| }; /* namespace android */ |