/*
|
* Copyright (c) 2021 by Allwinnertech Co., Ltd.
|
*
|
* 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 "CameraHALv3_StreamManager"
|
#include "stream_manager.h"
|
|
#include <inttypes.h>
|
#include <fcntl.h>
|
#include <sys/stat.h>
|
#include <sys/types.h>
|
#include <sys/time.h>
|
#include <hardware/camera3.h>
|
#include <linux/videodev2.h>
|
|
#include <cstdlib>
|
#include <memory>
|
#include <utility>
|
|
#include "CameraMetadata.h"
|
|
namespace v4l2_camera_hal {
|
|
std::shared_ptr<StreamManager> StreamManager::NewStreamManager(
|
std::shared_ptr<V4L2Wrapper> device,
|
std::shared_ptr<V4L2Camera> camera) {
|
HAL_LOG_ENTER();
|
std::unique_ptr<V4L2Gralloc> gralloc(V4L2Gralloc::NewV4L2Gralloc());
|
if (!gralloc) {
|
HAL_LOGE("Failed to initialize gralloc helper.");
|
}
|
HAL_LOGD("device.use_count:%ld. camera.use_count:%ld.",
|
device.use_count(),
|
camera.use_count());
|
return std::shared_ptr<StreamManager>(new StreamManager(std::move(device),
|
std::move(gralloc), std::move(camera)));
|
}
|
|
StreamManager::StreamManager(std::shared_ptr<V4L2Wrapper> device,
|
std::unique_ptr<V4L2Gralloc> gralloc,
|
std::shared_ptr<V4L2Camera> camera):
|
device_(std::move(device)),
|
gralloc_(std::move(gralloc)),
|
camera_(std::move(camera)) {
|
HAL_LOG_ENTER();
|
mDrop_main_buffers = 0;
|
mDrop_sub_buffers = 0;
|
merge_stream_flag = 0;
|
HAL_LOGD("device.use_count:%ld. camera.use_count:%ld.",
|
device.use_count(), camera.use_count());
|
}
|
|
StreamManager::~StreamManager() {
|
HAL_LOG_ENTER();
|
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
HAL_LOGV("before reset null mStream[%d].use_count:%ld."
|
"mCameraStream[%d].use_count:%ld.",
|
ss, mStream[ss].use_count(), ss, mCameraStream[ss].use_count());
|
}
|
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
mConnection[ss].reset();
|
}
|
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
mStream[ss].reset();
|
}
|
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
mCameraStream[ss].reset();
|
}
|
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
HAL_LOGV("mStream[%d].use_count:%ld. mCameraStream[%d].use_count:%ld",
|
ss, mStream[ss].use_count(), ss, mCameraStream[ss].use_count());
|
}
|
|
HAL_LOGV("device.use_count:%ld. camera.use_count:%ld.",
|
device_.use_count(), camera_.use_count());
|
}
|
|
CameraStream* StreamManager::createStream(STREAM_SERIAL ss,
|
uint32_t width,
|
uint32_t height,
|
int format,
|
uint32_t usage,
|
int isBlob,
|
bool mergeStreamFlag) {
|
|
HAL_LOG_ENTER();
|
mMapFrameNumRef.clear();
|
if (mConnection[ss +isBlob] != nullptr) {
|
HAL_LOGD("Camera stream %d is already connected.", ss +isBlob);
|
return nullptr;
|
}
|
|
//mConnection[ss +isBlob].reset(new V4L2Wrapper::Connection(device_, ss));
|
if (width * height > 4000*3000) {
|
merge_stream_flag = 1;
|
mConnection[ss + isBlob].reset(new V4L2Wrapper::Connection(device_, ss, merge_stream_flag));
|
} else {
|
mConnection[ss + isBlob].reset(new V4L2Wrapper::Connection(device_, ss, merge_stream_flag));
|
}
|
|
if (mConnection[ss +isBlob]->status()) {
|
HAL_LOGE("Failed to connect to device: %d.",
|
mConnection[ss +isBlob]->status());
|
return nullptr;
|
}
|
|
mStream[ss +isBlob] = device_->getStream(ss);
|
if (mStream[ss +isBlob] == nullptr) {
|
HAL_LOGE("Failed to get Stream, we should connect first.");
|
return nullptr;
|
}
|
|
int isThirdMirrorStream = 0;
|
if (ss >= MAIN_MIRROR_STREAM) {
|
isThirdMirrorStream = 1;
|
}
|
mCameraStream[ss +isBlob].reset(
|
CameraStream::NewCameraStream(mStream[ss +isBlob],
|
isBlob,
|
isThirdMirrorStream));
|
if (mCameraStream[ss +isBlob] == nullptr) {
|
HAL_LOGD("Failed to get mCameraStream ojb %d .", ss +isBlob);
|
mConnection[ss +isBlob].reset();
|
return nullptr;
|
}
|
|
CameraMetadata static_metadata;
|
camera_->initStaticInfo(&static_metadata);
|
mCameraStream[ss +isBlob]->mStaticMetadata.reset(
|
new CameraMetadata(static_metadata));
|
|
int res = mCameraStream[ss +isBlob]->setFormat(width, height, format, usage);
|
if (res) {
|
HAL_LOGW("Failed to setFormat, ojb %d .", ss +isBlob);
|
}
|
|
if (ss < SUB_0_STREAM_BLOB) {
|
if (isBlob) {
|
if (mCameraStream[ss] == nullptr) {
|
if (mCameraStream[ss +isBlob]->initialize(width,
|
height,
|
format,
|
usage,
|
mergeStreamFlag)) {
|
HAL_LOGE("mCameraStream %d initialize failed.", ss);
|
mConnection[ss +isBlob].reset();
|
return nullptr;
|
}
|
} else {
|
HAL_LOGD("mCameraStream %d has link to stream,"
|
"do not need initialize.", ss +isBlob);
|
}
|
} else {
|
if (mCameraStream[ss +1] == nullptr) {
|
if (mCameraStream[ss +isBlob]->initialize(width,
|
height,
|
format,
|
usage,
|
mergeStreamFlag)) {
|
HAL_LOGE("mCameraStream %d initialize failed.", ss);
|
mConnection[ss +isBlob].reset();
|
return nullptr;
|
}
|
} else {
|
HAL_LOGD("mCameraStream %d has link to stream, do not need initialize.",
|
ss +isBlob);
|
}
|
}
|
}
|
|
HAL_LOGD("mCameraStream %d created, blob flag:%d.", ss, isBlob);
|
return mCameraStream[ss +isBlob].get();
|
}
|
|
int StreamManager::configurateManager(STREAM_SERIAL ss) {
|
HAL_LOG_ENTER();
|
int res = 0;
|
|
if (instance == nullptr) {
|
instance = this;
|
}
|
|
if (mCameraStream[ss] != nullptr) {
|
res = mCameraStream[ss]->configurateManager(instance);
|
}
|
return res;
|
}
|
|
int StreamManager::start(STREAM_SERIAL ss) {
|
HAL_LOGV("Stream %d start.", ss);
|
std::lock_guard<std::mutex> guard(frameNumber_lock_);
|
if (mCameraStream[ss] != nullptr) {
|
mCameraStream[ss]->start();
|
switch (ss) {
|
case MAIN_STREAM:
|
case MAIN_STREAM_BLOB:
|
if (msYUVmainEnqueue == nullptr) {
|
// init YUV main stream Enqueue thread
|
msYUVmainEnqueue = new StreamYUVMEQ(this);
|
mYUVMEThreadState = STREAM_STATE_NULL;
|
msYUVmainEnqueue->startThread();
|
HAL_LOGD("msYUVmainEnqueue thread was created.");
|
}
|
|
if (msYUVmainDequeue == nullptr) {
|
// init YUV main stream Dequeue thread
|
msYUVmainDequeue = new StreamYUVMDQ(this);
|
mYUVMDThreadState = STREAM_STATE_NULL;
|
msYUVmainDequeue->startThread();
|
HAL_LOGD("msYUVmainDequeue thread was created.");
|
}
|
{
|
std::unique_lock<std::mutex> lock(msYUVmainDequeueMutex);
|
// singal to start main thread, start dequeue before enqueue buffer.
|
if (mYUVMDThreadState == STREAM_STATE_NULL) {
|
mYUVMDThreadState = STREAM_STATE_STARTED;
|
msYUVmainDequeueCond.notify_one();
|
}
|
}
|
{
|
std::unique_lock<std::mutex> lock(msYUVmainEnqueueMutex);
|
if (mYUVMEThreadState == STREAM_STATE_NULL) {
|
mYUVMEThreadState = STREAM_STATE_STARTED;
|
msYUVmainEnqueueCond.notify_one();
|
}
|
}
|
break;
|
case SUB_0_STREAM:
|
case SUB_0_STREAM_BLOB:
|
// init YUV sub stream Enqueue thread
|
if (msYUVsubEnqueue == nullptr) {
|
msYUVsubEnqueue = new StreamYUVSEQ(this);
|
mYUVSEThreadState = STREAM_STATE_NULL;
|
msYUVsubEnqueue->startThread();
|
HAL_LOGD("msYUVsubEnqueue thread was created.");
|
}
|
|
// init YUV sub stream Dequeue thread
|
if (msYUVsubDequeue == nullptr) {
|
msYUVsubDequeue = new StreamYUVSDQ(this);
|
mYUVSDThreadState = STREAM_STATE_NULL;
|
msYUVsubDequeue->startThread();
|
HAL_LOGD("msYUVsubDequeue thread was created.");
|
}
|
{
|
std::unique_lock<std::mutex> lock(msYUVsubDequeueMutex);
|
// singal to start main thread, start dequeue before enqueue buffer.
|
if (mYUVSDThreadState == STREAM_STATE_NULL) {
|
mYUVSDThreadState = STREAM_STATE_STARTED;
|
msYUVsubDequeueCond.notify_one();
|
}
|
}
|
{
|
std::unique_lock<std::mutex> lock(msYUVsubEnqueueMutex);
|
if (mYUVSEThreadState == STREAM_STATE_NULL) {
|
mYUVSEThreadState = STREAM_STATE_STARTED;
|
msYUVsubEnqueueCond.notify_one();
|
}
|
}
|
break;
|
default:
|
break;
|
}
|
} else {
|
HAL_LOGV("mCameraStream %d has not live.", ss);
|
}
|
|
return 0;
|
}
|
|
int StreamManager::stop(STREAM_SERIAL ss) {
|
HAL_LOG_ENTER();
|
std::lock_guard<std::mutex> guard(frameNumber_lock_);
|
if (mCameraStream[ss] != nullptr) {
|
switch (ss) {
|
case MAIN_STREAM:
|
case MAIN_STREAM_BLOB:
|
// stop main thread
|
if (msYUVmainEnqueue != NULL) {
|
msYUVmainEnqueue->stopThread();
|
mCameraStream[ss]->flush();
|
msYUVmainEnqueue.clear();
|
msYUVmainEnqueue = 0;
|
HAL_LOGD("msYUVmainEnqueue %d stoped.", ss);
|
}
|
if (msYUVmainDequeue != NULL) {
|
msYUVmainDequeue->stopThread();
|
mCameraStream[ss]->flush();
|
msYUVmainDequeue.clear();
|
msYUVmainDequeue = 0;
|
HAL_LOGD("msYUVmainDequeue %d stoped.", ss);
|
}
|
mYUVMDThreadState = STREAM_STATE_NULL;
|
mYUVMEThreadState = STREAM_STATE_NULL;
|
break;
|
case SUB_0_STREAM:
|
case SUB_0_STREAM_BLOB:
|
// singal to stop sub thread
|
if (msYUVsubEnqueue != NULL) {
|
msYUVsubEnqueue->stopThread();
|
mCameraStream[ss]->flush();
|
msYUVsubEnqueue.clear();
|
msYUVsubEnqueue = 0;
|
HAL_LOGD("msYUVsubEnqueue %d stoped.", ss);
|
}
|
if (msYUVsubDequeue != NULL) {
|
msYUVsubDequeue->stopThread();
|
mCameraStream[ss]->flush();
|
msYUVsubDequeue.clear();
|
msYUVsubDequeue = 0;
|
HAL_LOGD("msYUVsubDequeue %d stoped.", ss);
|
}
|
mYUVSDThreadState = STREAM_STATE_NULL;
|
mYUVSEThreadState = STREAM_STATE_NULL;
|
break;
|
default:
|
break;
|
}
|
mCameraStream[ss]->stop();
|
}
|
|
if (mCameraStream[ss] == nullptr) {
|
HAL_LOGD("mCameraStream %d has not live.", ss);
|
}
|
HAL_LOGD("mCameraStream %d stoped.", ss);
|
return 0;
|
}
|
|
int StreamManager::request(uint32_t /*frameNumber*/) {
|
HAL_LOG_ENTER();
|
return 0;
|
}
|
|
int StreamManager::markFrameNumber(uint32_t frameNumber) {
|
HAL_LOG_ENTER();
|
std::lock_guard<std::mutex> guard(frameNumber_lock_);
|
int res = 0;
|
auto map_entry = mMapFrameNumRef.find(frameNumber);
|
if (map_entry == mMapFrameNumRef.end()) {
|
HAL_LOGV("No matching refcnt for frameNumber:%d, initialize!", frameNumber);
|
mMapFrameNumRef.emplace(frameNumber, 1);
|
} else {
|
int refcnt = map_entry->second;
|
if (refcnt < 1) {
|
HAL_LOGE("Refcnt:%d for frameNumber:%d erased!", refcnt, frameNumber);
|
mMapFrameNumRef.erase(frameNumber);
|
return -ENODEV;
|
}
|
mMapFrameNumRef.erase(frameNumber);
|
refcnt++;
|
HAL_LOGD("Refcnt:%d for frameNumber:%d emplaced!", refcnt, frameNumber);
|
mMapFrameNumRef.emplace(frameNumber, refcnt);
|
}
|
return res;
|
}
|
|
int StreamManager::resultCallback(uint32_t frameNumber, struct timeval ts) {
|
HAL_LOG_ENTER();
|
|
std::lock_guard<std::mutex> guard(frameNumber_lock_);
|
int res = 0;
|
auto map_entry = mMapFrameNumRef.find(frameNumber);
|
if (map_entry == mMapFrameNumRef.end()) {
|
HAL_LOGE("No matching refcnt for frameNumber:%d, something wrong!",
|
frameNumber);
|
return -ENOMEM;
|
} else {
|
int refcnt = map_entry->second;
|
refcnt = refcnt -1;
|
HAL_LOGV("Encount call back frameNumber:%d, refcnt:%d!",
|
frameNumber, refcnt);
|
if (refcnt == 0) {
|
HAL_LOGV("Call back frameNumber:%d!", frameNumber);
|
mMapFrameNumRef.erase(frameNumber);
|
camera_->sResultCallback(frameNumber, ts);
|
return res;
|
}
|
mMapFrameNumRef.erase(frameNumber);
|
mMapFrameNumRef.emplace(frameNumber, refcnt);
|
}
|
return res;
|
}
|
|
bool StreamManager::sYUVmainEnqueue() {
|
HAL_LOG_ENTER();
|
{
|
std::unique_lock<std::mutex> lock(msYUVmainEnqueueMutex);
|
while (STREAM_STATE_STARTED != mYUVMEThreadState) {
|
msYUVmainEnqueueCond.wait(lock);
|
}
|
}
|
int res = -1;
|
if (mCameraStream[MAIN_STREAM] != nullptr) {
|
res = mCameraStream[MAIN_STREAM]->enqueueBuffer();
|
if (res) {
|
HAL_LOGE("Device EnqueueBuffer failed.");
|
}
|
}
|
if (mCameraStream[MAIN_STREAM_BLOB] != nullptr) {
|
res = mCameraStream[MAIN_STREAM_BLOB]->enqueueBuffer();
|
if (res) {
|
HAL_LOGE("Device EnqueueBuffer failed.");
|
}
|
}
|
return true;
|
}
|
|
bool StreamManager::sYUVmainDequeue() {
|
HAL_LOG_ENTER();
|
{
|
std::unique_lock<std::mutex> lock(msYUVmainDequeueMutex);
|
while (STREAM_STATE_STARTED != mYUVMDThreadState) {
|
msYUVmainDequeueCond.wait(lock);
|
}
|
}
|
|
int res = -1;
|
void* src_addr = nullptr;
|
struct timeval stream_timestamp;
|
if (mCameraStream[MAIN_STREAM] != nullptr) {
|
res = mCameraStream[MAIN_STREAM]->dequeueBuffer(&src_addr,
|
&stream_timestamp);
|
if (res) {
|
HAL_LOGE("Device main stream dequeueBuffer failed, src_addr:%p.",
|
src_addr);
|
if (src_addr == nullptr) {
|
return true;
|
}
|
}
|
}
|
if (mCameraStream[MAIN_STREAM_BLOB] != nullptr) {
|
res = mCameraStream[MAIN_STREAM_BLOB]->dequeueBuffer(&src_addr,
|
&stream_timestamp);
|
if (res) {
|
HAL_LOGE("Device main blob stream dequeueBuffer failed, src_addr:%p.",
|
src_addr);
|
if (src_addr == nullptr) {
|
return true;
|
}
|
}
|
}
|
|
if (mDrop_main_buffers <= DROP_BUFFERS_NUM) {
|
mDrop_main_buffers++;
|
HAL_LOGD("mDrop_main_buffers:%d, DequeueBuffer %p.",
|
mDrop_main_buffers, src_addr);
|
return true;
|
}
|
|
HAL_LOGV("Device DequeueBuffer %p.", src_addr);
|
if (gtimemain > 0) {
|
int64_t currentTime = systemTime() / 1000000;
|
int64_t deltaTime = currentTime - gtimemain;
|
gtimemain = currentTime;
|
HAL_LOGV("Device deltaTime %" PRId64 ".", deltaTime);
|
} else {
|
gtimemain = systemTime() / 1000000;
|
}
|
|
void * dst_addr = nullptr;
|
buffer_handle_t * buffer = nullptr;
|
uint32_t frameNumber = 0;
|
android_ycbcr dst_addr_ycbcr;
|
|
if (mCameraStream[MAIN_STREAM] != nullptr) {
|
res = mCameraStream[MAIN_STREAM]->getBuffer(&buffer, &frameNumber);
|
if (!res) {
|
gralloc_->lock_handle_ycbcr(buffer, &dst_addr_ycbcr);
|
if (mCameraStream[MAIN_STREAM]->copy_ycbcr_buffer(&dst_addr_ycbcr,
|
src_addr)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device mian stream copybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
if (mCameraStream[MAIN_STREAM_BLOB] != nullptr) {
|
res = mCameraStream[MAIN_STREAM_BLOB]->getBuffer(&buffer, &frameNumber);
|
if (!res) {
|
unsigned long mJpegBufferSizes = 0;
|
gralloc_->lock_handle(buffer, &dst_addr, &mJpegBufferSizes);
|
if (mCameraStream[MAIN_STREAM_BLOB]->encodebuffer(dst_addr,
|
src_addr, mJpegBufferSizes)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device main blob stream copybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
if (mCameraStream[MAIN_MIRROR_STREAM] != nullptr) {
|
res = mCameraStream[MAIN_MIRROR_STREAM]->getBuffer(&buffer, &frameNumber);
|
if (!res) {
|
gralloc_->lock_handle_ycbcr(buffer, &dst_addr_ycbcr);
|
if (mCameraStream[MAIN_MIRROR_STREAM]->copy_ycbcr_buffer(&dst_addr_ycbcr,
|
src_addr)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device main mirror tream opybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
if (mCameraStream[MAIN_MIRROR_STREAM_BLOB] != nullptr) {
|
res = mCameraStream[MAIN_MIRROR_STREAM_BLOB]->getBuffer(&buffer,
|
&frameNumber);
|
if (!res) {
|
unsigned long mJpegBufferSizes = 0;
|
gralloc_->lock_handle(buffer, &dst_addr, &mJpegBufferSizes);
|
if (mCameraStream[MAIN_MIRROR_STREAM_BLOB]->encodebuffer(
|
dst_addr,
|
src_addr,
|
mJpegBufferSizes)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device main mirror blob stream copybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
|
return true;
|
}
|
|
bool StreamManager::sYUVsubEnqueue() {
|
HAL_LOG_ENTER();
|
{
|
std::unique_lock<std::mutex> lock(msYUVsubEnqueueMutex);
|
while (STREAM_STATE_STARTED != mYUVSEThreadState) {
|
msYUVsubEnqueueCond.wait(lock);
|
}
|
}
|
|
int res = -1;
|
if (mCameraStream[SUB_0_STREAM] != nullptr) {
|
res = mCameraStream[SUB_0_STREAM]->enqueueBuffer();
|
if (res) {
|
HAL_LOGE("Device EnqueueBuffer failed.");
|
}
|
}
|
if (mCameraStream[SUB_0_STREAM_BLOB] != nullptr) {
|
res = mCameraStream[SUB_0_STREAM_BLOB]->enqueueBuffer();
|
if (res) {
|
HAL_LOGE("Device EnqueueBuffer failed.");
|
}
|
}
|
return true;
|
}
|
|
bool StreamManager::sYUVsubDequeue() {
|
HAL_LOG_ENTER();
|
{
|
std::unique_lock<std::mutex> lock(msYUVsubDequeueMutex);
|
while (STREAM_STATE_STARTED != mYUVSDThreadState) {
|
msYUVsubDequeueCond.wait(lock);
|
}
|
}
|
|
int res = -1;
|
void* src_addr = nullptr;
|
struct timeval stream_timestamp;
|
if (mCameraStream[SUB_0_STREAM] != nullptr) {
|
res = mCameraStream[SUB_0_STREAM]->dequeueBuffer(&src_addr,
|
&stream_timestamp);
|
if (res) {
|
HAL_LOGE("Device sub stream dequeueBuffer failed, src_addr:%p.",
|
src_addr);
|
if (src_addr == nullptr) {
|
return true;
|
}
|
}
|
}
|
if (mCameraStream[SUB_0_STREAM_BLOB] != nullptr) {
|
res = mCameraStream[SUB_0_STREAM_BLOB]->dequeueBuffer(&src_addr,
|
&stream_timestamp);
|
if (res) {
|
HAL_LOGE("Device sub blob stream dequeueBuffer failed, src_addr:%p.",
|
src_addr);
|
if (src_addr == nullptr) {
|
return true;
|
}
|
}
|
}
|
if (mDrop_sub_buffers <= DROP_BUFFERS_NUM) {
|
mDrop_sub_buffers++;
|
HAL_LOGD("mDrop_sub_buffers:%d, DequeueBuffer %p.",
|
mDrop_sub_buffers, src_addr);
|
return true;
|
}
|
|
HAL_LOGV("Device DequeueBuffer %p.", src_addr);
|
|
if (gtimesub > 0) {
|
int64_t currentTime = systemTime() / 1000000;
|
int64_t deltaTime = currentTime - gtimesub;
|
HAL_LOGV("Device deltaTime %" PRId64 ".", deltaTime);
|
gtimesub = currentTime;
|
} else {
|
gtimesub = systemTime() / 1000000;
|
}
|
|
void* dst_addr = nullptr;
|
buffer_handle_t* buffer = nullptr;
|
uint32_t frameNumber = 0;
|
android_ycbcr dst_addr_ycbcr;
|
if (mCameraStream[SUB_0_STREAM] != nullptr) {
|
res = mCameraStream[SUB_0_STREAM]->getBuffer(&buffer, &frameNumber);
|
if (!res) {
|
gralloc_->lock_handle_ycbcr(buffer, &dst_addr_ycbcr);
|
if (mCameraStream[SUB_0_STREAM]->copy_ycbcr_buffer(&dst_addr_ycbcr,
|
src_addr)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device sub stream copybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
if (mCameraStream[SUB_0_STREAM_BLOB] != nullptr) {
|
if (mCameraStream[SUB_0_STREAM_BLOB] != nullptr)
|
res = mCameraStream[SUB_0_STREAM_BLOB]->getBuffer(&buffer, &frameNumber);
|
if (!res) {
|
unsigned long mJpegBufferSizes = 0;
|
gralloc_->lock_handle(buffer, &dst_addr, &mJpegBufferSizes);
|
if (mCameraStream[SUB_0_STREAM_BLOB]->encodebuffer(dst_addr,
|
src_addr,
|
mJpegBufferSizes)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device copybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
if (mCameraStream[SUB_0_MIRROR_STREAM] != nullptr) {
|
res = mCameraStream[SUB_0_MIRROR_STREAM]->getBuffer(&buffer, &frameNumber);
|
if (!res) {
|
gralloc_->lock_handle_ycbcr(buffer, &dst_addr_ycbcr);
|
if (mCameraStream[SUB_0_MIRROR_STREAM]->copy_ycbcr_buffer(&dst_addr_ycbcr,
|
src_addr)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device sub mirror stream copybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
if (mCameraStream[SUB_0_MIRROR_STREAM_BLOB] != nullptr) {
|
if (mCameraStream[SUB_0_MIRROR_STREAM_BLOB] != nullptr)
|
res = mCameraStream[SUB_0_MIRROR_STREAM_BLOB]->getBuffer(&buffer,
|
&frameNumber);
|
if (!res) {
|
unsigned long mJpegBufferSizes = 0;
|
gralloc_->lock_handle(buffer, &dst_addr, &mJpegBufferSizes);
|
if (mCameraStream[SUB_0_MIRROR_STREAM_BLOB]->encodebuffer(
|
dst_addr,
|
src_addr,
|
mJpegBufferSizes)) {
|
gralloc_->unlock_handle(buffer);
|
HAL_LOGE("Device sub mirror blob stream copybuffer failed.");
|
} else {
|
gralloc_->unlock_handle(buffer);
|
resultCallback(frameNumber, stream_timestamp);
|
}
|
}
|
}
|
return true;
|
}
|
|
}
|
