| /* | |
| * Copyright (C) 2022 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 "ExtCamOfflnSsn" | |
| #include <android/log.h> | |
| #include "ExternalCameraOfflineSession.h" | |
| #include <aidl/android/hardware/camera/device/BufferStatus.h> | |
| #include <aidl/android/hardware/camera/device/ErrorMsg.h> | |
| #include <aidl/android/hardware/camera/device/ShutterMsg.h> | |
| #include <aidl/android/hardware/camera/device/StreamBuffer.h> | |
| #include <aidlcommonsupport/NativeHandle.h> | |
| #include <convert.h> | |
| #include <linux/videodev2.h> | |
| #include <sync/sync.h> | |
| #include <utils/Trace.h> | |
| #define HAVE_JPEG // required for libyuv.h to export MJPEG decode APIs | |
| #include <libyuv.h> | |
| namespace { | |
| // Size of request/result metadata fast message queue. Change to 0 to always use hwbinder buffer. | |
| constexpr size_t kMetadataMsgQueueSize = 1 << 18 /* 256kB */; | |
| } // anonymous namespace | |
| namespace android { | |
| namespace hardware { | |
| namespace camera { | |
| namespace device { | |
| namespace implementation { | |
| using ::aidl::android::hardware::camera::device::BufferStatus; | |
| using ::aidl::android::hardware::camera::device::ErrorMsg; | |
| using ::aidl::android::hardware::camera::device::ShutterMsg; | |
| using ::aidl::android::hardware::camera::device::StreamBuffer; | |
| // Static instance | |
| HandleImporter ExternalCameraOfflineSession::sHandleImporter; | |
| ExternalCameraOfflineSession::ExternalCameraOfflineSession( | |
| const CroppingType& croppingType, const common::V1_0::helper::CameraMetadata& chars, | |
| const std::string& cameraId, const std::string& exifMake, const std::string& exifModel, | |
| uint32_t blobBufferSize, bool afTrigger, const std::vector<Stream>& offlineStreams, | |
| std::deque<std::shared_ptr<HalRequest>>& offlineReqs, | |
| const std::map<int, CirculatingBuffers>& circulatingBuffers) | |
| : mCroppingType(croppingType), | |
| mChars(chars), | |
| mCameraId(cameraId), | |
| mExifMake(exifMake), | |
| mExifModel(exifModel), | |
| mBlobBufferSize(blobBufferSize), | |
| mAfTrigger(afTrigger), | |
| mOfflineStreams(offlineStreams), | |
| mOfflineReqs(offlineReqs), | |
| mCirculatingBuffers(circulatingBuffers) {} | |
| ExternalCameraOfflineSession::~ExternalCameraOfflineSession() { | |
| close(); | |
| } | |
| bool ExternalCameraOfflineSession::initialize() { | |
| mResultMetadataQueue = | |
| std::make_shared<ResultMetadataQueue>(kMetadataMsgQueueSize, false /* non blocking */); | |
| if (!mResultMetadataQueue->isValid()) { | |
| ALOGE("%s: invalid result fmq", __FUNCTION__); | |
| return true; | |
| } | |
| return false; | |
| } | |
| Status ExternalCameraOfflineSession::importBuffer(int32_t streamId, uint64_t bufId, | |
| buffer_handle_t buf, | |
| buffer_handle_t** outBufPtr) { | |
| Mutex::Autolock _l(mCbsLock); | |
| return importBufferImpl(mCirculatingBuffers, sHandleImporter, streamId, bufId, buf, outBufPtr); | |
| } | |
| Status ExternalCameraOfflineSession::processCaptureResult(std::shared_ptr<HalRequest>& req) { | |
| ATRACE_CALL(); | |
| // Fill output buffers | |
| std::vector<CaptureResult> results; | |
| results.resize(1); | |
| CaptureResult& result = results[0]; | |
| result.frameNumber = req->frameNumber; | |
| result.partialResult = 1; | |
| result.inputBuffer.streamId = -1; | |
| result.outputBuffers.resize(req->buffers.size()); | |
| for (size_t i = 0; i < req->buffers.size(); i++) { | |
| StreamBuffer& outputBuffer = result.outputBuffers[i]; | |
| outputBuffer.streamId = req->buffers[i].streamId; | |
| outputBuffer.bufferId = req->buffers[i].bufferId; | |
| if (req->buffers[i].fenceTimeout) { | |
| outputBuffer.status = BufferStatus::ERROR; | |
| if (req->buffers[i].acquireFence >= 0) { | |
| native_handle_t* handle = native_handle_create(/*numFds*/ 1, /*numInts*/ 0); | |
| handle->data[0] = req->buffers[i].acquireFence; | |
| result.outputBuffers[i].releaseFence = android::dupToAidl(handle); | |
| native_handle_delete(handle); | |
| } | |
| notifyError(req->frameNumber, req->buffers[i].streamId, ErrorCode::ERROR_BUFFER); | |
| } else { | |
| result.outputBuffers[i].status = BufferStatus::OK; | |
| // TODO: refactor | |
| if (req->buffers[i].acquireFence >= 0) { | |
| native_handle_t* handle = native_handle_create(/*numFds*/ 1, /*numInts*/ 0); | |
| handle->data[0] = req->buffers[i].acquireFence; | |
| outputBuffer.releaseFence = android::dupToAidl(handle); | |
| native_handle_delete(handle); | |
| } | |
| } | |
| } | |
| // Fill capture result metadata | |
| fillCaptureResult(req->setting, req->shutterTs); | |
| const camera_metadata_t* rawResult = req->setting.getAndLock(); | |
| convertToAidl(rawResult, &result.result); | |
| req->setting.unlock(rawResult); | |
| // Callback into framework | |
| invokeProcessCaptureResultCallback(results, /* tryWriteFmq */ true); | |
| freeReleaseFences(results); | |
| return Status::OK; | |
| } | |
| #define UPDATE(md, tag, data, size) \ | |
| do { \ | |
| if ((md).update((tag), (data), (size))) { \ | |
| ALOGE("Update " #tag " failed!"); \ | |
| return BAD_VALUE; \ | |
| } \ | |
| } while (0) | |
| status_t ExternalCameraOfflineSession::fillCaptureResult(common::V1_0::helper::CameraMetadata md, | |
| nsecs_t timestamp) { | |
| bool afTrigger = false; | |
| { | |
| std::lock_guard<std::mutex> lk(mAfTriggerLock); | |
| afTrigger = mAfTrigger; | |
| if (md.exists(ANDROID_CONTROL_AF_TRIGGER)) { | |
| camera_metadata_entry entry = md.find(ANDROID_CONTROL_AF_TRIGGER); | |
| if (entry.data.u8[0] == ANDROID_CONTROL_AF_TRIGGER_START) { | |
| mAfTrigger = afTrigger = true; | |
| } else if (entry.data.u8[0] == ANDROID_CONTROL_AF_TRIGGER_CANCEL) { | |
| mAfTrigger = afTrigger = false; | |
| } | |
| } | |
| } | |
| // For USB camera, the USB camera handles everything and we don't have control | |
| // over AF. We only simply fake the AF metadata based on the request | |
| // received here. | |
| uint8_t afState; | |
| if (afTrigger) { | |
| afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; | |
| } else { | |
| afState = ANDROID_CONTROL_AF_STATE_INACTIVE; | |
| } | |
| UPDATE(md, ANDROID_CONTROL_AF_STATE, &afState, 1); | |
| camera_metadata_ro_entry activeArraySize = mChars.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE); | |
| return fillCaptureResultCommon(md, timestamp, activeArraySize); | |
| } | |
| void ExternalCameraOfflineSession::invokeProcessCaptureResultCallback( | |
| std::vector<CaptureResult>& results, bool tryWriteFmq) { | |
| if (mProcessCaptureResultLock.tryLock() != OK) { | |
| const nsecs_t NS_TO_SECOND = 1E9; | |
| ALOGV("%s: previous call is not finished! waiting 1s...", __FUNCTION__); | |
| if (mProcessCaptureResultLock.timedLock(/* 1s */ NS_TO_SECOND) != OK) { | |
| ALOGE("%s: cannot acquire lock in 1s, cannot proceed", __FUNCTION__); | |
| return; | |
| } | |
| } | |
| if (tryWriteFmq && mResultMetadataQueue->availableToWrite() > 0) { | |
| for (CaptureResult& result : results) { | |
| if (!result.result.metadata.empty()) { | |
| if (mResultMetadataQueue->write( | |
| reinterpret_cast<int8_t*>(result.result.metadata.data()), | |
| result.result.metadata.size())) { | |
| result.fmqResultSize = result.result.metadata.size(); | |
| result.result.metadata.clear(); | |
| } else { | |
| ALOGW("%s: couldn't utilize fmq, fall back to hwbinder", __FUNCTION__); | |
| result.fmqResultSize = 0; | |
| } | |
| } else { | |
| result.fmqResultSize = 0; | |
| } | |
| } | |
| } | |
| auto status = mCallback->processCaptureResult(results); | |
| if (!status.isOk()) { | |
| ALOGE("%s: processCaptureResult ERROR : %d:%d", __FUNCTION__, status.getExceptionCode(), | |
| status.getServiceSpecificError()); | |
| } | |
| mProcessCaptureResultLock.unlock(); | |
| } | |
| Status ExternalCameraOfflineSession::processCaptureRequestError( | |
| const std::shared_ptr<HalRequest>& req, std::vector<NotifyMsg>* outMsgs, | |
| std::vector<CaptureResult>* outResults) { | |
| ATRACE_CALL(); | |
| if (outMsgs == nullptr) { | |
| notifyError(/*frameNum*/ req->frameNumber, /*stream*/ -1, ErrorCode::ERROR_REQUEST); | |
| } else { | |
| NotifyMsg shutter; | |
| shutter.set<NotifyMsg::Tag::shutter>(ShutterMsg{ | |
| .frameNumber = req->frameNumber, | |
| .timestamp = req->shutterTs, | |
| }); | |
| NotifyMsg error; | |
| error.set<NotifyMsg::Tag::error>(ErrorMsg{.frameNumber = req->frameNumber, | |
| .errorStreamId = -1, | |
| .errorCode = ErrorCode::ERROR_REQUEST}); | |
| outMsgs->push_back(shutter); | |
| outMsgs->push_back(error); | |
| } | |
| // Fill output buffers | |
| CaptureResult result; | |
| result.frameNumber = req->frameNumber; | |
| result.partialResult = 1; | |
| result.inputBuffer.streamId = -1; | |
| result.outputBuffers.resize(req->buffers.size()); | |
| for (size_t i = 0; i < req->buffers.size(); i++) { | |
| StreamBuffer& outputBuffer = result.outputBuffers[i]; | |
| outputBuffer.streamId = req->buffers[i].streamId; | |
| outputBuffer.bufferId = req->buffers[i].bufferId; | |
| outputBuffer.status = BufferStatus::ERROR; | |
| if (req->buffers[i].acquireFence >= 0) { | |
| native_handle_t* handle = native_handle_create(/*numFds*/ 1, /*numInts*/ 0); | |
| handle->data[0] = req->buffers[i].acquireFence; | |
| outputBuffer.releaseFence = dupToAidl(handle); | |
| native_handle_delete(handle); | |
| } | |
| } | |
| if (outResults == nullptr) { | |
| // Callback into framework | |
| std::vector<CaptureResult> results(1); | |
| results[0] = std::move(result); | |
| invokeProcessCaptureResultCallback(results, /* tryWriteFmq */ true); | |
| freeReleaseFences(results); | |
| } else { | |
| outResults->push_back(std::move(result)); | |
| } | |
| return Status::OK; | |
| } | |
| ssize_t ExternalCameraOfflineSession::getJpegBufferSize(int32_t, int32_t) const { | |
| // Empty implementation here as the jpeg buffer size is passed in by ctor | |
| return 0; | |
| } | |
| void ExternalCameraOfflineSession::notifyError(int32_t frameNumber, int32_t streamId, | |
| ErrorCode ec) { | |
| NotifyMsg msg; | |
| msg.set<NotifyMsg::Tag::error>( | |
| ErrorMsg{.frameNumber = frameNumber, .errorStreamId = streamId, .errorCode = ec}); | |
| mCallback->notify({msg}); | |
| } | |
| ScopedAStatus ExternalCameraOfflineSession::setCallback( | |
| const std::shared_ptr<ICameraDeviceCallback>& in_cb) { | |
| Mutex::Autolock _il(mInterfaceLock); | |
| if (mCallback != nullptr && in_cb != nullptr) { | |
| ALOGE("%s: callback must not be set twice!", __FUNCTION__); | |
| return fromStatus(Status::OK); | |
| } | |
| mCallback = in_cb; | |
| initOutputThread(); | |
| if (mOutputThread == nullptr) { | |
| ALOGE("%s: init OutputThread failed!", __FUNCTION__); | |
| } | |
| return fromStatus(Status::OK); | |
| } | |
| void ExternalCameraOfflineSession::initOutputThread() { | |
| if (mOutputThread != nullptr) { | |
| ALOGE("%s: OutputThread already exist!", __FUNCTION__); | |
| return; | |
| } | |
| // Grab a shared_ptr to 'this' from ndk::SharedRefBase::ref() | |
| std::shared_ptr<ExternalCameraOfflineSession> thiz = ref<ExternalCameraOfflineSession>(); | |
| mBufferRequestThread = std::make_shared<ExternalCameraDeviceSession::BufferRequestThread>( | |
| /*parent=*/thiz, mCallback); | |
| mBufferRequestThread->run(); | |
| mOutputThread = std::make_shared<OutputThread>(/*parent=*/thiz, mCroppingType, mChars, | |
| mBufferRequestThread, mOfflineReqs); | |
| mOutputThread->setExifMakeModel(mExifMake, mExifModel); | |
| Size inputSize = {mOfflineReqs[0]->frameIn->mWidth, mOfflineReqs[0]->frameIn->mHeight}; | |
| Size maxThumbSize = getMaxThumbnailResolution(mChars); | |
| mOutputThread->allocateIntermediateBuffers(inputSize, maxThumbSize, mOfflineStreams, | |
| mBlobBufferSize); | |
| mOutputThread->run(); | |
| } | |
| ScopedAStatus ExternalCameraOfflineSession::getCaptureResultMetadataQueue( | |
| MQDescriptor<int8_t, SynchronizedReadWrite>* _aidl_return) { | |
| Mutex::Autolock _il(mInterfaceLock); | |
| *_aidl_return = mResultMetadataQueue->dupeDesc(); | |
| return fromStatus(Status::OK); | |
| } | |
| ScopedAStatus ExternalCameraOfflineSession::close() { | |
| Mutex::Autolock _il(mInterfaceLock); | |
| { | |
| Mutex::Autolock _l(mLock); | |
| if (mClosed) { | |
| ALOGW("%s: offline session already closed!", __FUNCTION__); | |
| return fromStatus(Status::OK); | |
| } | |
| } | |
| if (mBufferRequestThread != nullptr) { | |
| mBufferRequestThread->requestExitAndWait(); | |
| mBufferRequestThread.reset(); | |
| } | |
| if (mOutputThread) { | |
| mOutputThread->flush(); | |
| mOutputThread->requestExitAndWait(); | |
| mOutputThread.reset(); | |
| } | |
| Mutex::Autolock _l(mLock); | |
| // free all buffers | |
| { | |
| Mutex::Autolock _cbl(mCbsLock); | |
| for (auto& stream : mOfflineStreams) { | |
| cleanupBuffersLocked(stream.id); | |
| } | |
| } | |
| mCallback.reset(); | |
| mClosed = true; | |
| return fromStatus(Status::OK); | |
| } | |
| void ExternalCameraOfflineSession::cleanupBuffersLocked(int32_t id) { | |
| for (auto& pair : mCirculatingBuffers.at(id)) { | |
| sHandleImporter.freeBuffer(pair.second); | |
| } | |
| mCirculatingBuffers[id].clear(); | |
| mCirculatingBuffers.erase(id); | |
| } | |
| bool ExternalCameraOfflineSession::OutputThread::threadLoop() { | |
| auto parent = mParent.lock(); | |
| if (parent == nullptr) { | |
| ALOGE("%s: session has been disconnected!", __FUNCTION__); | |
| return false; | |
| } | |
| if (mOfflineReqs.empty()) { | |
| ALOGI("%s: all offline requests are processed. Stopping.", __FUNCTION__); | |
| return false; | |
| } | |
| std::shared_ptr<HalRequest> req = mOfflineReqs.front(); | |
| mOfflineReqs.pop_front(); | |
| auto onDeviceError = [&](auto... args) { | |
| ALOGE(args...); | |
| parent->notifyError(req->frameNumber, /*stream*/ -1, ErrorCode::ERROR_DEVICE); | |
| signalRequestDone(); | |
| return false; | |
| }; | |
| if (req->frameIn->mFourcc != V4L2_PIX_FMT_MJPEG && req->frameIn->mFourcc != V4L2_PIX_FMT_Z16) { | |
| return onDeviceError("%s: do not support V4L2 format %c%c%c%c", __FUNCTION__, | |
| req->frameIn->mFourcc & 0xFF, (req->frameIn->mFourcc >> 8) & 0xFF, | |
| (req->frameIn->mFourcc >> 16) & 0xFF, | |
| (req->frameIn->mFourcc >> 24) & 0xFF); | |
| } | |
| int res = requestBufferStart(req->buffers); | |
| if (res != 0) { | |
| ALOGE("%s: send BufferRequest failed! res %d", __FUNCTION__, res); | |
| return onDeviceError("%s: failed to send buffer request!", __FUNCTION__); | |
| } | |
| std::unique_lock<std::mutex> lk(mBufferLock); | |
| // Convert input V4L2 frame to YU12 of the same size | |
| // TODO: see if we can save some computation by converting to YV12 here | |
| uint8_t* inData; | |
| size_t inDataSize; | |
| if (req->frameIn->getData(&inData, &inDataSize) != 0) { | |
| lk.unlock(); | |
| return onDeviceError("%s: V4L2 buffer map failed", __FUNCTION__); | |
| } | |
| // TODO: in some special case maybe we can decode jpg directly to gralloc output? | |
| if (req->frameIn->mFourcc == V4L2_PIX_FMT_MJPEG) { | |
| ATRACE_BEGIN("MJPGtoI420"); | |
| int convRes = libyuv::MJPGToI420( | |
| inData, inDataSize, static_cast<uint8_t*>(mYu12FrameLayout.y), | |
| mYu12FrameLayout.yStride, static_cast<uint8_t*>(mYu12FrameLayout.cb), | |
| mYu12FrameLayout.cStride, static_cast<uint8_t*>(mYu12FrameLayout.cr), | |
| mYu12FrameLayout.cStride, mYu12Frame->mWidth, mYu12Frame->mHeight, | |
| mYu12Frame->mWidth, mYu12Frame->mHeight); | |
| ATRACE_END(); | |
| if (convRes != 0) { | |
| // For some webcam, the first few V4L2 frames might be malformed... | |
| ALOGE("%s: Convert V4L2 frame to YU12 failed! res %d", __FUNCTION__, convRes); | |
| lk.unlock(); | |
| Status st = parent->processCaptureRequestError(req); | |
| if (st != Status::OK) { | |
| return onDeviceError("%s: failed to process capture request error!", __FUNCTION__); | |
| } | |
| signalRequestDone(); | |
| return true; | |
| } | |
| } | |
| ATRACE_BEGIN("Wait for BufferRequest done"); | |
| res = waitForBufferRequestDone(&req->buffers); | |
| ATRACE_END(); | |
| if (res != 0) { | |
| ALOGE("%s: wait for BufferRequest done failed! res %d", __FUNCTION__, res); | |
| lk.unlock(); | |
| return onDeviceError("%s: failed to process buffer request error!", __FUNCTION__); | |
| } | |
| ALOGV("%s processing new request", __FUNCTION__); | |
| const int kSyncWaitTimeoutMs = 500; | |
| for (auto& halBuf : req->buffers) { | |
| if (*(halBuf.bufPtr) == nullptr) { | |
| ALOGW("%s: buffer for stream %d missing", __FUNCTION__, halBuf.streamId); | |
| halBuf.fenceTimeout = true; | |
| } else if (halBuf.acquireFence >= 0) { | |
| int ret = sync_wait(halBuf.acquireFence, kSyncWaitTimeoutMs); | |
| if (ret) { | |
| halBuf.fenceTimeout = true; | |
| } else { | |
| ::close(halBuf.acquireFence); | |
| halBuf.acquireFence = -1; | |
| } | |
| } | |
| if (halBuf.fenceTimeout) { | |
| continue; | |
| } | |
| // Gralloc lockYCbCr the buffer | |
| switch (halBuf.format) { | |
| case PixelFormat::BLOB: { | |
| int ret = createJpegLocked(halBuf, req->setting); | |
| if (ret != 0) { | |
| lk.unlock(); | |
| return onDeviceError("%s: createJpegLocked failed with %d", __FUNCTION__, ret); | |
| } | |
| } break; | |
| case PixelFormat::Y16: { | |
| void* outLayout = sHandleImporter.lock( | |
| *(halBuf.bufPtr), static_cast<uint64_t>(halBuf.usage), inDataSize); | |
| std::memcpy(outLayout, inData, inDataSize); | |
| int relFence = sHandleImporter.unlock(*(halBuf.bufPtr)); | |
| if (relFence >= 0) { | |
| halBuf.acquireFence = relFence; | |
| } | |
| } break; | |
| case PixelFormat::YCBCR_420_888: | |
| case PixelFormat::YV12: { | |
| android::Rect outRect{0, 0, static_cast<int32_t>(halBuf.width), | |
| static_cast<int32_t>(halBuf.height)}; | |
| android_ycbcr result = sHandleImporter.lockYCbCr( | |
| *(halBuf.bufPtr), static_cast<uint64_t>(halBuf.usage), outRect); | |
| ALOGV("%s: outLayout y %p cb %p cr %p y_str %zu c_str %zu c_step %zu", __FUNCTION__, | |
| result.y, result.cb, result.cr, result.ystride, result.cstride, | |
| result.chroma_step); | |
| if (result.ystride > UINT32_MAX || result.cstride > UINT32_MAX || | |
| result.chroma_step > UINT32_MAX) { | |
| return onDeviceError("%s: lockYCbCr failed. Unexpected values!", __FUNCTION__); | |
| } | |
| YCbCrLayout outLayout = {.y = result.y, | |
| .cb = result.cb, | |
| .cr = result.cr, | |
| .yStride = static_cast<uint32_t>(result.ystride), | |
| .cStride = static_cast<uint32_t>(result.cstride), | |
| .chromaStep = static_cast<uint32_t>(result.chroma_step)}; | |
| // Convert to output buffer size/format | |
| uint32_t outputFourcc = getFourCcFromLayout(outLayout); | |
| ALOGV("%s: converting to format %c%c%c%c", __FUNCTION__, outputFourcc & 0xFF, | |
| (outputFourcc >> 8) & 0xFF, (outputFourcc >> 16) & 0xFF, | |
| (outputFourcc >> 24) & 0xFF); | |
| YCbCrLayout cropAndScaled; | |
| ATRACE_BEGIN("cropAndScaleLocked"); | |
| int ret = cropAndScaleLocked(mYu12Frame, Size{halBuf.width, halBuf.height}, | |
| &cropAndScaled); | |
| ATRACE_END(); | |
| if (ret != 0) { | |
| lk.unlock(); | |
| return onDeviceError("%s: crop and scale failed!", __FUNCTION__); | |
| } | |
| Size sz{halBuf.width, halBuf.height}; | |
| ATRACE_BEGIN("formatConvert"); | |
| ret = formatConvert(cropAndScaled, outLayout, sz, outputFourcc); | |
| ATRACE_END(); | |
| if (ret != 0) { | |
| lk.unlock(); | |
| return onDeviceError("%s: format coversion failed!", __FUNCTION__); | |
| } | |
| int relFence = sHandleImporter.unlock(*(halBuf.bufPtr)); | |
| if (relFence >= 0) { | |
| halBuf.acquireFence = relFence; | |
| } | |
| } break; | |
| default: | |
| lk.unlock(); | |
| return onDeviceError("%s: unknown output format %x", __FUNCTION__, halBuf.format); | |
| } | |
| } // for each buffer | |
| mScaledYu12Frames.clear(); | |
| // Don't hold the lock while calling back to parent | |
| lk.unlock(); | |
| Status st = parent->processCaptureResult(req); | |
| if (st != Status::OK) { | |
| return onDeviceError("%s: failed to process capture result!", __FUNCTION__); | |
| } | |
| signalRequestDone(); | |
| return true; | |
| } | |
| } // namespace implementation | |
| } // namespace device | |
| } // namespace camera | |
| } // namespace hardware | |
| } // namespace android |