/*
|
* 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_V4L2Camera"
|
#include "v4l2_camera.h"
|
|
#include <fcntl.h>
|
#include <hardware/camera3.h>
|
#include <linux/videodev2.h>
|
#include <sys/stat.h>
|
#include <sys/time.h>
|
#include <sys/types.h>
|
|
#include <algorithm>
|
#include <cstdlib>
|
#include <memory>
|
#include <utility>
|
#include <vector>
|
|
#include "CameraMetadata.h"
|
#include "camera_config.h"
|
#include "function_thread.h"
|
#include "metadata/metadata_common.h"
|
#include "stream_format.h"
|
#include "v4l2_metadata_factory.h"
|
|
namespace v4l2_camera_hal {
|
|
using ::android::hardware::camera::common::V1_0::helper::CameraMetadata;
|
|
// Helper function for managing metadata.
|
static std::vector<int32_t> UNUSED_FUNCTION(getMetadataKeys)(
|
const camera_metadata_t* metadata) {
|
std::vector<int32_t> keys;
|
size_t num_entries = get_camera_metadata_entry_count(metadata);
|
for (size_t i = 0; i < num_entries; ++i) {
|
camera_metadata_ro_entry_t entry;
|
get_camera_metadata_ro_entry(metadata, i, &entry);
|
keys.push_back(entry.tag);
|
}
|
return keys;
|
}
|
|
V4L2Camera* V4L2Camera::NewV4L2Camera(
|
int id,
|
std::shared_ptr<CCameraConfig> pCameraCfg,
|
bool mergeStreamStatus) {
|
HAL_LOG_ENTER();
|
// Select one stream for fill metadata.
|
// The path has been pick the stream for query format.
|
std::shared_ptr<V4L2Wrapper> v4l2_wrapper(V4L2Wrapper::NewV4L2Wrapper(
|
id, pCameraCfg));
|
if (!v4l2_wrapper) {
|
HAL_LOGE("Failed to initialize V4L2 wrapper.");
|
return nullptr;
|
}
|
HAL_LOGD("v4l2_wrapper.count %ld", v4l2_wrapper.use_count());
|
|
std::unique_ptr<Metadata> metadata;
|
int res = GetV4L2Metadata(v4l2_wrapper, &metadata, pCameraCfg);
|
if (res) {
|
HAL_LOGE("Failed to initialize V4L2 metadata: %d", res);
|
return nullptr;
|
}
|
|
HAL_LOGD("v4l2_wrapper.count %ld", v4l2_wrapper.use_count());
|
return new V4L2Camera(id,
|
std::move(v4l2_wrapper),
|
std::move(metadata),
|
std::move(pCameraCfg),
|
mergeStreamStatus);
|
}
|
|
V4L2Camera::V4L2Camera(int id,
|
std::shared_ptr<V4L2Wrapper> v4l2_wrapper,
|
std::unique_ptr<Metadata> metadata,
|
std::shared_ptr<CCameraConfig> pCameraCfg,
|
bool mergeStreamStatus)
|
: default_camera_hal::Camera(id),
|
mCameraConfig(std::move(pCameraCfg)),
|
device_(std::move(v4l2_wrapper)),
|
device_id_(id),
|
mgSituationMode(INIT),
|
metadata_(std::move(metadata)),
|
camera_fd(-1),
|
in_flight_buffer_count(0),
|
buffers_in_flight_flag_(false),
|
max_input_streams_(0),
|
max_output_streams_({{0, 0, 0}}),
|
FlashStatusFlag(0),
|
MarkFrameNum(0),
|
curFlashStateE(CAM_FLASH_STATE_MAX),
|
curFlashModeE(CAM_FLASH_MODE_MAX),
|
merge_stream_status_(mergeStreamStatus),
|
is_merge_stream_flag(false){
|
|
HAL_LOG_ENTER();
|
instance = std::shared_ptr<V4L2Camera>(this);
|
|
HAL_LOGD("v4l2_wrapper.count %ld", v4l2_wrapper.use_count());
|
|
memset(&mBeffer_status, 0, sizeof(mBeffer_status));
|
memset(&mStream_status, 0, sizeof(mStream_status));
|
for (int i = 0; i < MAX_STREAM; i++) {
|
mCameraStream[i] = nullptr;
|
}
|
|
camFocusImpl.focus_frame_num = -1;
|
camFocusImpl.focused_times = -1;
|
camFocusImpl.update_status = -1;
|
camFocusImpl.status_flag = -1;
|
camFocusImpl.focus_status = -1;
|
camFocusImpl.update_status_times = -1;
|
camFocusImpl.camera_focus_mode = CAM_FOCUS_MODE_MAX;
|
camFocusImpl.camera_focus_trigger = CAM_FOCUS_TRIGGER_MAX;
|
memset(&camAreaRoi, 0, sizeof(cam_area_t));
|
memset(&camCropRect, 0, sizeof(cam_crop_rect_t));
|
mStream_status.pstream = OPEN_STREAM;
|
}
|
|
V4L2Camera::~V4L2Camera() {
|
HAL_LOG_ENTER();
|
}
|
|
int V4L2Camera::connect() {
|
HAL_LOG_ENTER();
|
return 0;
|
}
|
|
void V4L2Camera::disconnect() {
|
HAL_LOG_ENTER();
|
HAL_LOGD("before disconnect.");
|
// stop stream.
|
if (mStreamManager_ != nullptr) {
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
mStreamManager_->stop((STREAM_SERIAL)ss);
|
}
|
}
|
HAL_LOGD("after disconnect.");
|
in_flight_buffer_count = 0;
|
mStreamManager_.reset();
|
flushRequests(-ENODEV);
|
mBeffer_status.pbuffers = INIT_BUFFER;
|
mBeffer_status.vbuffers = INIT_BUFFER;
|
if (mCameraConfig->supportFlashMode()) {
|
std::lock_guard<std::mutex> guard(camera_fd_lock_);
|
if (camera_fd != -1) {
|
int ret_close = 0;
|
ret_close = ::close(camera_fd);
|
HAL_LOGD("mCameraFd:%d, ret_close: %d, errno:%s",
|
camera_fd, ret_close, strerror(errno));
|
camera_fd = -1;
|
}
|
}
|
// TODO(b/29158098): Inform service of any flashes that are available again
|
// because this camera is no longer in use.
|
}
|
|
int V4L2Camera::flushBuffers() {
|
HAL_LOG_ENTER();
|
int res = 0;
|
return res;
|
}
|
|
int V4L2Camera::flushRequests(int err) {
|
HAL_LOG_ENTER();
|
// Calvin: encount wrong in picture mode.
|
// This is not strictly necessary, but prevents a buildup of aborted
|
// requests in the in_flight_ map. These should be cleared
|
// whenever the stream is turned off.
|
HAL_LOGV("We hold %zu request(s) in Camera HAL,"
|
" let us send them to frameworks.",
|
in_flight_.size());
|
for (int i = (MAX_BUFFER_NUM -1); i >= 0; i--) {
|
auto brequest = in_flight_.find(i);
|
if (brequest != in_flight_.end()) {
|
HAL_LOGD("Send No.%d request to frameworks request queue.", i);
|
completeRequest(brequest->second, err);
|
in_flight_.erase(i);
|
} else {
|
HAL_LOGD("No.%d request request had been called back.", i);
|
in_flight_.erase(i);
|
}
|
}
|
HAL_LOG_EXIT();
|
return 0;
|
}
|
|
int V4L2Camera::flushRequestsForCTS(int err) {
|
HAL_LOG_ENTER();
|
uint32_t mFrameNum = 0;
|
std::shared_ptr<default_camera_hal::CaptureRequest> mFrameNumRequest;
|
// This is not strictly necessary, but prevents a buildup of aborted
|
// requests in the in_flight_ map. These should be cleared
|
// whenever the stream is turned off.
|
{
|
std::lock_guard<std::mutex> guard(request_queue_stream_lock_);
|
while (!request_queue_pstream_.empty()) {
|
request_queue_pstream_.pop();
|
}
|
while (!request_queue_tstream_.empty()) {
|
request_queue_tstream_.pop();
|
}
|
while (!request_queue_vstream_.empty()) {
|
request_queue_vstream_.pop();
|
}
|
}
|
|
HAL_LOGD("We hold %zu request(s) in Camera HAL,"
|
"let us send them to frameworks.", in_flight_.size());
|
{
|
std::lock_guard<std::mutex> guard(in_flight_lock_);
|
for (int i = (MAX_BUFFER_NUM -1); i >= 0; i--) {
|
auto brequest = in_flight_.find(i);
|
if (brequest != in_flight_.end()) {
|
HAL_LOGD("Send No.%d request to frameworks request queue,"
|
" frame_number:%d.", i, brequest->second->frame_number);
|
if ((brequest->second->frame_number < mFrameNum) &&
|
(0 != mFrameNum)) {
|
completeRequest(brequest->second, err);
|
completeRequest(mFrameNumRequest, err);
|
} else if ((brequest->second->frame_number > mFrameNum) &&
|
(0 != mFrameNum)) {
|
completeRequest(mFrameNumRequest, err);
|
completeRequest(brequest->second, err);
|
}
|
mFrameNum = brequest->second->frame_number;
|
mFrameNumRequest = brequest->second;
|
// Erase the buffer in the lock of in_flight_lock_.
|
in_flight_.erase(i);
|
} else {
|
// Erase the buffer in the lock of in_flight_lock_.
|
// There are leave buffer in csi driver that
|
// will lead the request delay the buffer.
|
in_flight_.erase(i);
|
HAL_LOGD("No.%d request request had been called back.", i);
|
}
|
}
|
}
|
HAL_LOG_EXIT();
|
return 0;
|
}
|
|
int V4L2Camera::initStaticInfo(CameraMetadata* out) {
|
HAL_LOG_ENTER();
|
|
int focus_supported = 0;
|
int crop_regions_supported = 0;
|
if (mCameraConfig->supportFocusMode()) {
|
focus_supported = 1;
|
}
|
if (mCameraConfig->supportZoom()) {
|
crop_regions_supported = 1;
|
}
|
int res = metadata_->FillStaticMetadata(out,
|
device_id_,
|
focus_supported,
|
crop_regions_supported);
|
if (res) {
|
HAL_LOGE("Failed to get static metadata.");
|
return res;
|
}
|
|
if (mCameraConfig->supportFlashMode() && device_id_ == 0) {
|
HAL_LOGV("initStaticInfo");
|
std::vector<uint8_t> avail_ae_modes;
|
avail_ae_modes.push_back(ANDROID_CONTROL_AE_MODE_ON);
|
avail_ae_modes.push_back(ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH);
|
avail_ae_modes.push_back(ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH);
|
out->update(ANDROID_CONTROL_AE_AVAILABLE_MODES,
|
avail_ae_modes.data(),
|
avail_ae_modes.size());
|
}
|
|
if (mCameraConfig->supportFocusMode()) {
|
std::vector<uint8_t> avail_af_modes;
|
HAL_LOGV("initStaticInfo avail_af_modes");
|
avail_af_modes.push_back(ANDROID_CONTROL_AF_MODE_OFF);
|
avail_af_modes.push_back(ANDROID_CONTROL_AF_MODE_AUTO);
|
out->update(ANDROID_CONTROL_AF_AVAILABLE_MODES,
|
avail_af_modes.data(),
|
avail_af_modes.size());
|
}
|
|
// Extract max streams for use in verifying stream configs.
|
res = SingleTagValue(
|
*out, ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, &max_input_streams_);
|
if (res) {
|
HAL_LOGE("Failed to get max num input streams from static metadata.");
|
return res;
|
}
|
res = SingleTagValue(
|
*out, ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, &max_output_streams_);
|
if (res) {
|
HAL_LOGE("Failed to get max num output streams from static metadata.");
|
return res;
|
}
|
|
return 0;
|
}
|
|
int V4L2Camera::initTemplate(int type, CameraMetadata* out) {
|
HAL_LOG_ENTER();
|
return metadata_->GetRequestTemplate(type, out);
|
}
|
|
void V4L2Camera::initDeviceInfo(camera_info_t* info) {
|
HAL_LOG_ENTER();
|
|
// TODO(b/31044975): move this into device interface.
|
// For now, just constants.
|
info->resource_cost = 100;
|
info->conflicting_devices = nullptr;
|
info->conflicting_devices_length = 0;
|
}
|
|
int V4L2Camera::initDevice() {
|
HAL_LOG_ENTER();
|
return 0;
|
}
|
|
int V4L2Camera::closeFlashTorch() {
|
std::lock_guard<std::mutex> guard(camera_fd_lock_);
|
if (camera_fd != -1) {
|
int ret_close = 0;
|
ret_close = ::close(camera_fd);
|
HAL_LOGE("mCameraFd:%d, ret_close: %d, errno:%s",
|
camera_fd, ret_close, strerror(errno));
|
camera_fd = -1;
|
return 1;
|
} else {
|
return 0;
|
}
|
}
|
|
int V4L2Camera::setFlashTorchMode(bool enabled) {
|
int retVal = 0;
|
struct v4l2_input inp;
|
struct v4l2_control ctrl;
|
|
if (camera_fd == -1) {
|
camera_fd = open("/dev/video0", O_RDWR | O_NONBLOCK, 0);
|
if (camera_fd == -1) {
|
HAL_LOGE("ERROR opening /dev/video0: %s", strerror(errno));
|
return -1;
|
}
|
HAL_LOGD("cameraFd : %d opened", camera_fd);
|
inp.index = 0;
|
if (-1 == ioctl(camera_fd, VIDIOC_S_INPUT, &inp)) {
|
HAL_LOGE("VIDIOC_S_INPUT error!");
|
::close(camera_fd);
|
return -1;
|
}
|
}
|
|
if (enabled) {
|
ctrl.id = V4L2_CID_FLASH_LED_MODE;
|
ctrl.value = V4L2_FLASH_LED_MODE_TORCH;
|
retVal = ioctl(camera_fd, VIDIOC_S_CTRL, &ctrl);
|
if (retVal < 0) {
|
HAL_LOGE("setFlashMode failed, %s", strerror(errno));
|
} else {
|
HAL_LOGE("setFlashMode ok V4L2_FLASH_LED_MODE_TORCH");
|
}
|
} else {
|
ctrl.id = V4L2_CID_FLASH_LED_MODE;
|
ctrl.value = V4L2_FLASH_LED_MODE_NONE;
|
retVal = ioctl(camera_fd, VIDIOC_S_CTRL, &ctrl);
|
if (retVal < 0) {
|
HAL_LOGE("setFlashMode failed, %s", strerror(errno));
|
} else {
|
HAL_LOGE("setFlashMode ok V4L2_FLASH_LED_MODE_NONE");
|
}
|
}
|
return retVal;
|
}
|
|
int V4L2Camera::updateStatus(SituationMode mSituationMode) {
|
mgSituationMode = mSituationMode;
|
switch (mSituationMode) {
|
case BEFORE_PREVIEW:
|
break;
|
case BEFORE_VIDEO:
|
break;
|
case BEFORE_PICTURE:
|
mStream_status.pstream = CLOSE_STREAM;
|
mStream_status.tstream = OPEN_STREAM;
|
mBeffer_status.tbuffers = INIT_BUFFER;
|
break;
|
case AFTER_PICTURE:
|
mStream_status.pstream = OPEN_STREAM;
|
mBeffer_status.pbuffers = INIT_BUFFER;
|
mBeffer_status.tbuffers = INIT_BUFFER;
|
break;
|
default:
|
break;
|
}
|
return -1;
|
}
|
|
V4L2Camera::SituationMode V4L2Camera::getStatus() {
|
return mgSituationMode;
|
}
|
|
V4L2Camera::RequestMode V4L2Camera::analysisRequest(
|
std::shared_ptr<default_camera_hal::CaptureRequest> request) {
|
if (request == nullptr) {
|
if ((mVideoflag || isVideoByTemplate) &&
|
mBeffer_status.vbuffers == PREPARE_BUFFER) {
|
return RUN_VIDEO_MODE;
|
} else if (mBeffer_status.pbuffers == PREPARE_BUFFER) {
|
return RUN_PREVIEW_MODE;
|
}
|
} else {
|
// If the request include the tstream, return immediatly.
|
for (uint32_t i = 0; i <request->output_buffers.size(); i++) {
|
if ((analysisStreamModes(request->output_buffers[i].stream) == TSTREAM) &&
|
(request->tbuffer_has_been_used == false)) {
|
return PICTURE_MODE;
|
}
|
}
|
|
// If the request include the vstream and in video mode, return immediatly.
|
for (uint32_t i = 0; i <request->output_buffers.size(); i++) {
|
if ((analysisStreamModes(request->output_buffers[i].stream) == VSTREAM) &&
|
(mVideoflag || isVideoByTemplate)) {
|
return VIDEO_MODE;
|
}
|
}
|
|
// Deal the preview stream in the final.
|
for (uint32_t i = 0; i <request->output_buffers.size(); i++) {
|
if ((analysisStreamModes(request->output_buffers[i].stream) == PSTREAM)) {
|
return PREVIEW_MODE;
|
}
|
}
|
}
|
return ERROR_MODE;
|
}
|
|
int V4L2Camera::analysisStreamNum(
|
std::shared_ptr<default_camera_hal::CaptureRequest> request,
|
RequestMode mRequestMode) {
|
int revalue = -1;
|
for (uint32_t i = 0; i <request->output_buffers.size(); i++) {
|
HAL_LOGD("Get format %d!", request->output_buffers[i].stream->format);
|
if (request->output_buffers[i].stream->format == HAL_PIXEL_FORMAT_BLOB) {
|
if (mRequestMode == VIDEO_SNAP_SHOT_MODE) {
|
revalue = i;
|
}
|
}
|
|
if (request->output_buffers[i].stream->format ==
|
HAL_PIXEL_FORMAT_YCBCR_420_888) {
|
if (mRequestMode == PICTURE_MODE) {
|
revalue = i;
|
}
|
}
|
|
if (request->output_buffers[i].stream->format ==
|
HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
|
if ((mRequestMode == PREVIEW_MODE) &&
|
(analysisStreamModes(request->output_buffers[i].stream) == PSTREAM)) {
|
revalue = i;
|
}
|
if ((mRequestMode == VIDEO_MODE) &&
|
(analysisStreamModes(request->output_buffers[i].stream) == VSTREAM)) {
|
revalue = i;
|
}
|
}
|
}
|
HAL_LOGD("No.%d is picked.", revalue);
|
return revalue;
|
}
|
|
V4L2Camera::StreamIedex V4L2Camera::analysisStreamModes(
|
camera3_stream_t* stream) {
|
HAL_LOGD("Get usage %d(%s), format %d(%s)!",
|
stream->usage,
|
getGrallocUsageString(stream->usage).c_str(),
|
stream->format,
|
getHalPixelFormatString(stream->format).c_str());
|
StreamIedex mStreamIedex = ESTREAM;
|
|
switch (stream->format) {
|
case HAL_PIXEL_FORMAT_YCBCR_420_888: {
|
HAL_LOGD("Detected the picture stream.");
|
mStreamIedex = TSTREAM;
|
break;
|
}
|
case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: {
|
if ((stream->usage & GRALLOC_USAGE_HW_TEXTURE) ||
|
(stream->usage &
|
(GRALLOC_USAGE_HW_COMPOSER|GRALLOC_USAGE_HW_TEXTURE))) {
|
mStreamIedex = PSTREAM;
|
} else if ((stream->usage &
|
(GRALLOC_USAGE_HW_VIDEO_ENCODER|GRALLOC_USAGE_HW_2D))) {
|
mStreamIedex = VSTREAM;
|
}
|
break;
|
}
|
// Be compatible with Camera api 1.
|
case HAL_PIXEL_FORMAT_BLOB: {
|
if ((stream->usage & GRALLOC_USAGE_SW_READ_OFTEN) &&
|
(isVideoByTemplate)) {
|
mStreamIedex = VSTREAM;
|
}
|
if ((stream->usage & GRALLOC_USAGE_SW_READ_OFTEN) &&
|
(stream->usage & GRALLOC_USAGE_SW_WRITE_OFTEN)) {
|
mStreamIedex = VHSTREAM;
|
HAL_LOGD("Set stream isVideoSnap flag to ture!");
|
}
|
break;
|
}
|
default: {
|
HAL_LOGE("Do not find any stream!");
|
break;
|
}
|
}
|
return mStreamIedex;
|
}
|
|
|
int V4L2Camera::max(std::vector<uint32_t>vec) {
|
auto result = std::minmax_element(vec.begin(), vec.end());
|
return result.second - vec.begin();
|
}
|
|
int V4L2Camera::min(std::vector<uint32_t>vec) {
|
auto result = std::minmax_element(vec.begin(), vec.end());
|
return result.first - vec.begin();
|
}
|
|
int V4L2Camera::maxWidth(camera3_stream_t** streams, int num) {
|
int ret = -1;
|
if (num == 0) {
|
HAL_LOGE("Prepare num err!");
|
} else if (num == 1) {
|
ret = 0;
|
} else if (num == 2) {
|
if (streams[0]->width > streams[1]->width) {
|
ret = 0;
|
} else if (streams[0]->width == streams[1]->width) {
|
ret = 0;
|
} else {
|
ret = 1;
|
}
|
} else if (num == 3) {
|
std::vector<uint32_t>streamWidths{
|
streams[0]->width,
|
streams[1]->width,
|
streams[2]->width
|
};
|
ret = max(streamWidths);
|
}
|
return ret;
|
}
|
|
int V4L2Camera::maxHeight(camera3_stream_t** streams, int num) {
|
int ret = -1;
|
if (num == 0) {
|
HAL_LOGE("Prepare num err!");
|
} else if (num == 1) {
|
ret = 0;
|
} else if (num == 2) {
|
if (streams[0]->height > streams[1]->height) {
|
ret = 0;
|
} else if (streams[0]->height == streams[1]->height) {
|
ret = 0;
|
} else {
|
ret = 1;
|
}
|
} else if (num == 3) {
|
std::vector<uint32_t>streamHeight{
|
streams[0]->height,
|
streams[1]->height,
|
streams[2]->height
|
};
|
ret = max(streamHeight);
|
}
|
return ret;
|
}
|
|
int V4L2Camera::fillStreamInfo(camera3_stream_t * stream) {
|
int res = 0;
|
// Doesn't matter what was requested, we always use dataspace V0_JFIF.
|
// Note: according to camera3.h, this isn't allowed, but the camera
|
// framework team claims it's underdocumented; the implementation lets the
|
// HAL overwrite it. If this is changed, change the validation above.
|
stream->data_space = HAL_DATASPACE_V0_JFIF;
|
// Usage: currently using sw graphics.
|
switch (stream->stream_type) {
|
case CAMERA3_STREAM_INPUT:
|
stream->usage |= GRALLOC_USAGE_SW_READ_OFTEN;
|
break;
|
case CAMERA3_STREAM_OUTPUT:
|
// Set the usage to GRALLOC_USAGE_SW_WRITE_OFTEN for buffers
|
// with cache alloc by gralloc.
|
stream->usage |= GRALLOC_USAGE_SW_WRITE_OFTEN;
|
break;
|
case CAMERA3_STREAM_BIDIRECTIONAL:
|
stream->usage |=
|
(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
|
break;
|
default:
|
// nothing to do.
|
break;
|
}
|
// Add camera usage.
|
stream->usage |= GRALLOC_USAGE_HW_CAMERA_WRITE;
|
|
switch (stream->format) {
|
case HAL_PIXEL_FORMAT_BLOB: {
|
stream->max_buffers = PICTURE_BUFFER_NUM;
|
break;
|
}
|
case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: {
|
stream->max_buffers = MAX_BUFFER_NUM;
|
break;
|
}
|
case HAL_PIXEL_FORMAT_YCBCR_420_888: {
|
stream->max_buffers = PICTURE_BUFFER_NUM;
|
break;
|
}
|
default: {
|
HAL_LOGE("Do not find any format!");
|
break;
|
}
|
}
|
return res;
|
}
|
|
int V4L2Camera::findStreamModes(STREAM_SERIAL stream_serial,
|
camera3_stream_configuration_t* stream_config, int* isBlob) {
|
int mStreamIndex = -1;
|
camera3_stream_t** streams = stream_config->streams;
|
switch (stream_serial) {
|
case MAIN_STREAM: {
|
if (stream_config->num_streams == 1) {
|
mStreamIndex = 0;
|
} else if (stream_config->num_streams == 2) {
|
std::vector<uint32_t> streamLists {
|
streams[0]->width * streams[0]->height,
|
streams[1]->width * streams[1]->height,
|
};
|
mStreamIndex = max(streamLists);
|
} else if (stream_config->num_streams == 3) {
|
std::vector<uint32_t> streamLists {
|
streams[0]->width * streams[0]->height,
|
streams[1]->width * streams[1]->height,
|
streams[2]->width * streams[2]->height,
|
};
|
mStreamIndex = max(streamLists);
|
} else {
|
HAL_LOGE("Get stream_config->num_streams:%d failed!",
|
stream_config->num_streams);
|
break;
|
}
|
if (stream_config->streams[mStreamIndex]->format ==
|
HAL_PIXEL_FORMAT_BLOB) {
|
*isBlob = 1;
|
} else {
|
*isBlob = 0;
|
}
|
break;
|
}
|
case SUB_0_STREAM: {
|
if (stream_config->num_streams <= 1) {
|
HAL_LOGE("Get stream_config->num_streams:%d failed!",
|
stream_config->num_streams);
|
} else if (stream_config->num_streams == 2) {
|
int maintmp = findStreamModes(MAIN_STREAM, stream_config, isBlob);
|
if (maintmp == 1) {
|
mStreamIndex = 0;
|
} else {
|
mStreamIndex = 1;
|
}
|
} else if (stream_config->num_streams == 3) {
|
std::vector<uint32_t> streamLists{
|
streams[0]->width * streams[0]->height,
|
streams[1]->width * streams[1]->height,
|
streams[2]->width * streams[2]->height,
|
};
|
|
uint32_t maxtmp = max(streamLists);
|
uint32_t mintmp = min(streamLists);
|
|
for (uint32_t i = 0; i < stream_config->num_streams; i++) {
|
if ((i != maxtmp) && (i != mintmp)) {
|
mStreamIndex = i;
|
}
|
}
|
} else {
|
HAL_LOGE("Get stream_config->num_streams:%d failed!",
|
stream_config->num_streams);
|
break;
|
}
|
if (stream_config->streams[mStreamIndex]->format ==
|
HAL_PIXEL_FORMAT_BLOB) {
|
*isBlob = 1;
|
} else {
|
*isBlob = 0;
|
}
|
break;
|
}
|
default: {
|
HAL_LOGE("Do not find any stream!");
|
break;
|
}
|
}
|
return mStreamIndex;
|
}
|
|
int V4L2Camera::ProbeFlashMode(CameraFlashModeE* camera_flash_mode,
|
CameraMetadata* camera_meta_data,
|
int* set_flash_flag,
|
int frame_number) {
|
int result = 0;
|
uint8_t fwk_aeMode = 0;
|
uint8_t capture_intent = 0;
|
uint8_t fwk_flashMode = 0;
|
if (camera_meta_data->exists(ANDROID_CONTROL_AE_MODE)) {
|
fwk_aeMode =
|
mMetadata->find(ANDROID_CONTROL_AE_MODE).data.u8[0];
|
}
|
if (camera_meta_data->exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
|
capture_intent =
|
mMetadata->find(ANDROID_CONTROL_CAPTURE_INTENT).data.u8[0];
|
}
|
if (camera_meta_data->exists(ANDROID_FLASH_MODE)) {
|
fwk_flashMode =
|
mMetadata->find(ANDROID_FLASH_MODE).data.u8[0];
|
}
|
|
std::lock_guard<std::mutex> guard(flash_status_lock_);
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH) {
|
if (!FlashStatusFlag) {
|
MarkFrameNum = frame_number;
|
FlashStatusFlag = 1;
|
*camera_flash_mode = CAM_FLASH_MODE_ON;
|
*set_flash_flag = 1;
|
}
|
}
|
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH) {
|
if (!FlashStatusFlag) {
|
MarkFrameNum = frame_number;
|
FlashStatusFlag = 1;
|
*camera_flash_mode = CAM_FLASH_MODE_AUTO;
|
*set_flash_flag = 1;
|
}
|
}
|
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON &&
|
fwk_flashMode == ANDROID_FLASH_MODE_TORCH) {
|
if (curFlashModeE != CAM_FLASH_MODE_TORCH) {
|
MarkFrameNum = 0;
|
curFlashModeE = CAM_FLASH_MODE_TORCH;
|
*camera_flash_mode = CAM_FLASH_MODE_TORCH;
|
*set_flash_flag = 1;
|
}
|
}
|
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD &&
|
fwk_flashMode == ANDROID_FLASH_MODE_TORCH) {
|
HAL_LOGV("CAM_FLASH_MODE_TORCH");
|
MarkFrameNum = 0;
|
*camera_flash_mode = CAM_FLASH_MODE_TORCH;
|
*set_flash_flag = 1;
|
}
|
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD &&
|
fwk_flashMode == ANDROID_FLASH_MODE_OFF && frame_number > 10) {
|
HAL_LOGV("CAM_FLASH_MODE_VIDEO_OFF");
|
MarkFrameNum = 0;
|
*camera_flash_mode = CAM_FLASH_MODE_VIDEO_OFF;
|
*set_flash_flag = 1;
|
}
|
|
if (MarkFrameNum != 0 && frame_number - MarkFrameNum == 20) {
|
*camera_flash_mode = CAM_FLASH_MODE_OFF;
|
*set_flash_flag = 1;
|
}
|
if (MarkFrameNum != 0 && frame_number - MarkFrameNum > 33) {
|
FlashStatusFlag = 0;
|
MarkFrameNum = 0;
|
}
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH &&
|
fwk_flashMode == ANDROID_FLASH_MODE_OFF) {
|
HAL_LOGV("ON_ALWAYS_FLASH MODE_OFF frame_number:%d", frame_number);
|
curFlashStateE = CAM_FLASH_STATE_READY;
|
}
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH &&
|
fwk_flashMode == ANDROID_FLASH_MODE_OFF) {
|
HAL_LOGV("ON_AUTO_FLASH MODE_OFF frame_number:%d", frame_number);
|
curFlashStateE = CAM_FLASH_STATE_READY;
|
curFlashModeE = CAM_FLASH_MODE_AUTO;
|
}
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON &&
|
fwk_flashMode == ANDROID_FLASH_MODE_OFF) {
|
HAL_LOGV("AE_MODE_ON FLASH_MODE_OFF frame_number:%d", frame_number);
|
if (curFlashModeE == CAM_FLASH_MODE_TORCH) {
|
*camera_flash_mode = CAM_FLASH_MODE_VIDEO_OFF;
|
*set_flash_flag = 1;
|
}
|
curFlashStateE = CAM_FLASH_STATE_READY;
|
}
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE &&
|
fwk_flashMode == ANDROID_FLASH_MODE_OFF) {
|
HAL_LOGV("REDEYE MODE_OFF frame_number:%d", frame_number);
|
curFlashStateE = CAM_FLASH_STATE_READY;
|
}
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON &&
|
fwk_flashMode == ANDROID_FLASH_MODE_SINGLE) {
|
HAL_LOGV("FIRED FLASH_MODE_SINGLE frame_number:%d", frame_number);
|
curFlashStateE = CAM_FLASH_STATE_FIRED;
|
}
|
if (capture_intent == ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW &&
|
fwk_flashMode == ANDROID_FLASH_MODE_TORCH &&
|
fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON) {
|
HAL_LOGV("TORCH AE_MODE_ON frame_number:%d", frame_number);
|
MarkFrameNum = 0;
|
*camera_flash_mode = CAM_FLASH_MODE_TORCH;
|
*set_flash_flag = 1;
|
curFlashModeE = CAM_FLASH_MODE_TORCH;
|
curFlashStateE = CAM_FLASH_STATE_FIRED;
|
}
|
|
return result;
|
}
|
|
void V4L2Camera::convertFromRegions(cam_area_t* roi,
|
const CameraMetadata &frame_settings,
|
uint32_t tag) {
|
const int32_t* i32_data = frame_settings.find(tag).data.i32;
|
int32_t x_min = i32_data[0];
|
int32_t y_min = i32_data[1];
|
int32_t x_max = i32_data[2];
|
int32_t y_max = i32_data[3];
|
|
roi->weight = i32_data[4];
|
roi->rect.x_min = x_min;
|
roi->rect.y_min = y_min;
|
roi->rect.x_max = x_max;
|
roi->rect.y_max = y_max;
|
}
|
|
void V4L2Camera::updateActiveArray(CameraMetadata* camera_meta_data,
|
uint32_t tag) {
|
int32_t* i32_data = camera_meta_data->find(tag).data.i32;
|
int32_t x_min = i32_data[0];
|
int32_t y_min = i32_data[1];
|
int32_t x_max = i32_data[2];
|
int32_t y_max = i32_data[3];
|
int32_t weight = i32_data[4];
|
|
x_min = std::max(camCropRect.left, x_min);
|
y_min = std::max(camCropRect.top, y_min);
|
x_max = x_min + std::min(x_max-x_min, camCropRect.width);
|
y_max = y_min + std::min(y_max-y_min, camCropRect.height);
|
|
int32_t ActiveRegions[5] = {x_min, y_min, x_max, y_max, weight};
|
camera_meta_data->update(tag, ActiveRegions, 5);
|
}
|
|
int V4L2Camera::ProcessFocusMode(CameraMetadata* camera_meta_data,
|
int frame_number) {
|
int result = 0;
|
uint8_t fwk_afMode = 0;
|
uint8_t fwk_afTrigger = 0;
|
CameraStream* focusStream;
|
uint32_t i = 0;
|
|
std::lock_guard<std::mutex> guard(auto_focus_lock_);
|
if (camera_meta_data->exists(ANDROID_CONTROL_AF_MODE)) {
|
for (i = 0; i < MAX_STREAM; i++) {
|
if (mCameraStream[i] != nullptr) {
|
focusStream = mCameraStream[i];
|
break;
|
}
|
}
|
if (i >= MAX_STREAM) {
|
HAL_LOGE("can not find camera stream!");
|
return -1;
|
}
|
camFocusImpl.focus_frame_num = frame_number;
|
fwk_afMode =
|
camera_meta_data->find(ANDROID_CONTROL_AF_MODE).data.u8[0];
|
if (fwk_afMode == ANDROID_CONTROL_AF_MODE_OFF) {
|
HAL_LOGV("ANDROID_CONTROL_AF_MODE_OFF frameNumber:%d", frame_number);
|
camFocusImpl.camera_focus_mode = CAM_FOCUS_MODE_OFF;
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_AUTO) {
|
HAL_LOGV("ANDROID_CONTROL_AF_MODE_AUTO frameNumber:%d", frame_number);
|
camFocusImpl.camera_focus_mode = CAM_FOCUS_MODE_AUTO;
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_MACRO) {
|
HAL_LOGV("ANDROID_CONTROL_AF_MODE_MACRO frameNumber:%d", frame_number);
|
camFocusImpl.camera_focus_mode = CAM_FOCUS_MODE_MACRO;
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO) {
|
HAL_LOGV("ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO frameNumber:%d",
|
frame_number);
|
camFocusImpl.camera_focus_mode = CAM_FOCUS_MODE_CONTINUOUS_VIDEO;
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE) {
|
HAL_LOGV("ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE frameNumber:%d",
|
frame_number);
|
camFocusImpl.camera_focus_mode = CAM_FOCUS_MODE_CONTINUOUS_PICTURE;
|
} else {
|
HAL_LOGE("error ANDROID_CONTROL_AF_MODE frameNumber:%d", frame_number);
|
}
|
}
|
|
if (camera_meta_data->exists(ANDROID_CONTROL_AF_TRIGGER)) {
|
fwk_afTrigger =
|
camera_meta_data->find(ANDROID_CONTROL_AF_TRIGGER).data.u8[0];
|
if (fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_IDLE) {
|
HAL_LOGV("ANDROID_CONTROL_AF_TRIGGER_IDLE frameNumber:%d", frame_number);
|
camFocusImpl.camera_focus_trigger = CAM_FOCUS_TRIGGER_IDLE;
|
} else if (fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_START) {
|
HAL_LOGV("ANDROID_CONTROL_AF_TRIGGER_START frameNumber:%d", frame_number);
|
camFocusImpl.camera_focus_trigger = CAM_FOCUS_TRIGGER_START;
|
} else if (fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_CANCEL) {
|
HAL_LOGV("ANDROID_CONTROL_AF_TRIGGER_CANCEL frameNumber:%d",
|
frame_number);
|
camFocusImpl.camera_focus_trigger = CAM_FOCUS_TRIGGER_CANCLE;
|
} else {
|
HAL_LOGE("error ANDROID_CONTROL_AF_TRIGGER frameNumber:%d", frame_number);
|
}
|
}
|
if (camera_meta_data->exists(ANDROID_SCALER_CROP_REGION)) {
|
updateActiveArray(camera_meta_data, ANDROID_CONTROL_AF_REGIONS);
|
}
|
if (camera_meta_data->exists(ANDROID_CONTROL_AF_REGIONS)) {
|
cam_area_t roi;
|
memset(&roi, 0, sizeof(cam_area_t));
|
int32_t* i32_data =
|
camera_meta_data->find(ANDROID_CONTROL_AF_REGIONS).data.i32;
|
roi.rect.x_min = i32_data[0];
|
roi.rect.y_min = i32_data[1];
|
roi.rect.x_max = i32_data[2];
|
roi.rect.y_max = i32_data[3];
|
roi.weight = i32_data[4];
|
|
HAL_LOGV("roi.weight:%d,roi.rect.x_min:%d roi.rect.y_min:%d"
|
"roi.rect.x_max:%d roi.rect.y_max:%d",
|
roi.weight,
|
roi.rect.x_min,
|
roi.rect.y_min,
|
roi.rect.x_max,
|
roi.rect.y_max);
|
|
if (roi.weight != 0) {
|
cam_rect_t cam_regions;
|
cam_regions.x_min = roi.rect.x_min;
|
cam_regions.y_min = roi.rect.y_min;
|
cam_regions.x_max = roi.rect.x_max;
|
cam_regions.y_max = roi.rect.y_max;
|
camAreaRoi.rect.x_min = roi.rect.x_min;
|
camAreaRoi.rect.y_min = roi.rect.y_min;
|
camAreaRoi.rect.x_max = roi.rect.x_max;
|
camAreaRoi.rect.y_max = roi.rect.y_max;
|
camAreaRoi.weight = roi.weight;
|
focusStream->setIspFocusRegions(cam_regions);
|
}
|
}
|
|
if (fwk_afMode == ANDROID_CONTROL_AF_MODE_AUTO &&
|
fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_IDLE) {
|
camFocusImpl.update_status = 1;
|
}
|
|
if (fwk_afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE &&
|
frame_number == 0) {
|
focusStream->setIspFocus(CAM_FOCUS_MODE_START_UP);
|
camFocusImpl.focus_status = CAM_FOCUS_MODE_START_UP;
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE &&
|
frame_number != 0 &&
|
camFocusImpl.focus_status != CAM_FOCUS_MODE_CONTINUOUS_PICTURE) {
|
focusStream->setIspFocus(CAM_FOCUS_MODE_CONTINUOUS_PICTURE);
|
camFocusImpl.focus_status = CAM_FOCUS_MODE_CONTINUOUS_PICTURE;
|
} else if ((fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_CANCEL &&
|
camAreaRoi.weight != 0) ||
|
(fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_CANCEL &&
|
frame_number < 2)) {
|
focusStream->setIspFocus(CAM_FOCUS_MODE_STOP);
|
camFocusImpl.focus_status = CAM_FOCUS_MODE_STOP;
|
camFocusImpl.camera_focus_trigger = CAM_FOCUS_TRIGGER_CANCLE;
|
} else if (fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_START &&
|
fwk_afMode != ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE &&
|
camFocusImpl.focus_status != CAM_FOCUS_MODE_START) {
|
focusStream->setIspFocus(CAM_FOCUS_MODE_START);
|
camFocusImpl.focus_status = CAM_FOCUS_MODE_START;
|
camFocusImpl.focused_times = -1;
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_AUTO &&
|
fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_IDLE &&
|
camFocusImpl.focus_status == CAM_FOCUS_MODE_STOP) {
|
focusStream->setIspFocus(CAM_FOCUS_MODE_START);
|
camFocusImpl.focus_status = CAM_FOCUS_MODE_START;
|
camFocusImpl.focused_times = -1;
|
}
|
|
return result;
|
}
|
|
int V4L2Camera::ProcessCropRegion(CameraMetadata* camera_meta_data,
|
CameraStream* camera_stream) {
|
std::unique_lock<std::mutex> lock(frameNumber_request_lock_);
|
int result = 0;
|
|
if (camera_meta_data->exists(ANDROID_SCALER_CROP_REGION)) {
|
cam_crop_rect_t CameraCropRect;
|
memset(&CameraCropRect, 0, sizeof(cam_crop_rect_t));
|
int32_t* i32_data =
|
camera_meta_data->find(ANDROID_SCALER_CROP_REGION).data.i32;
|
camCropRect.left = i32_data[0];
|
camCropRect.top = i32_data[1];
|
camCropRect.width = i32_data[2];
|
camCropRect.height = i32_data[3];
|
HAL_LOGV("ANDROID_SCALER_CROP_REGION left:%d top:%d width:%d height:%d",
|
camCropRect.left,
|
camCropRect.top,
|
camCropRect.width,
|
camCropRect.height);
|
CameraCropRect.left = camCropRect.left;
|
CameraCropRect.top = camCropRect.top;
|
CameraCropRect.width = camCropRect.width;
|
CameraCropRect.height = camCropRect.height;
|
|
result = camera_stream->setIspCrop(CameraCropRect);
|
if (result) {
|
HAL_LOGE("Fail to setIspCrop on mCameraStream!");
|
return result;
|
}
|
}
|
|
return result;
|
}
|
|
int V4L2Camera::enqueueRequest(
|
std::shared_ptr<default_camera_hal::CaptureRequest> request) {
|
HAL_LOG_ENTER();
|
int res;
|
|
// Be compatible with Camera api 1.
|
mRunStreamNum = request->output_buffers.size();
|
uint32_t frameNumber;
|
{
|
std::unique_lock<std::mutex> lock(frameNumber_request_lock_);
|
in_flight_buffer_count++;
|
if (in_flight_buffer_count > MAX_BUFFER_NUM) {
|
HAL_LOGW("in_flight_buffer_count:%d > %d,wait!",
|
in_flight_buffer_count, MAX_BUFFER_NUM);
|
tbuffers_in_flight_.wait(lock);
|
}
|
frameNumber = request->frame_number;
|
mMapFrameNumRequest.emplace(frameNumber, request);
|
rfequest_queue_stream_.push(request);
|
mMetadata = &request->settings;
|
}
|
|
int setFlashFlag = 0;
|
CameraFlashModeE CameraFlashMode = CAM_FLASH_MODE_MAX;
|
if (mCameraConfig->supportFlashMode()) {
|
ProbeFlashMode(&CameraFlashMode, mMetadata, &setFlashFlag, frameNumber);
|
}
|
for (uint32_t i = 0; i <request->output_buffers.size(); i++) {
|
res = mStreamManager_.get()->markFrameNumber(frameNumber);
|
if (res) {
|
HAL_LOGE("mark FrameNumber failed.%d", i);
|
return -ENODEV;
|
}
|
}
|
for (uint32_t i = 0; i <request->output_buffers.size(); i++) {
|
std::lock_guard<std::mutex> guard(request_queue_stream_lock_);
|
const camera3_stream_buffer_t& output = request->output_buffers[i];
|
mCameraStream[i] = reinterpret_cast<CameraStream *>(output.stream->priv);
|
HAL_LOGV("i:%d request %d x %d, format:%d. frameNumber:%d", i,
|
output.stream->width, output.stream->height, output.stream->format,
|
frameNumber);
|
res = mCameraStream[i]->request(output.buffer, frameNumber, mMetadata);
|
if (res) {
|
HAL_LOGE("Fail to request on mCameraStream");
|
}
|
|
if (mCameraConfig->supportZoom()) {
|
ProcessCropRegion(mMetadata, mCameraStream[i]);
|
}
|
|
if (setFlashFlag) {
|
HAL_LOGV("setIspFlash(CameraFlashMode:%d)", CameraFlashMode);
|
res = mCameraStream[i]->setIspFlash(CameraFlashMode);
|
if (res) {
|
HAL_LOGE("Fail to setIspFlash on mCameraStream");
|
}
|
}
|
}
|
|
if (mCameraConfig->supportFocusMode()) {
|
ProcessFocusMode(mMetadata, frameNumber);
|
}
|
|
{
|
std::unique_lock<std::mutex> lock(frameNumber_request_lock_);
|
res = metadata_->SetRequestSettings(*mMetadata);
|
if (res) {
|
HAL_LOGE("Failed to set settings.");
|
}
|
|
res = metadata_->FillResultMetadata(mMetadata);
|
if (res) {
|
HAL_LOGE("Failed to fill result metadata.");
|
}
|
}
|
|
return 0;
|
}
|
|
std::shared_ptr<default_camera_hal::CaptureRequest>
|
V4L2Camera::dequeueRequest() {
|
HAL_LOG_ENTER();
|
|
// Wait.
|
// 1. No request in stream.
|
// 2. And exchange to record, record exchange to preview.
|
// a.exchange to record: In preview mode,
|
// so pbuffers must be PREPARE_BUFFER, until timeout that mean
|
// in_flight_.size() less than 2 buffers.
|
// b.exchange to preview: In record mode,
|
// so vbuffers must be PREPARE_BUFFER, until timeout that mean
|
// in_flight_.size() less than 2 buffers.
|
// Jump out while wait.
|
// 1. There are request in stream.
|
// 2. Or exchange to record, record exchange to preview.
|
// a.exchange to record: In preview mode,
|
// so pbuffers must be PREPARE_BUFFER, until timeout that mean
|
// in_flight_.size() less than 2 buffers.
|
// b.exchange to preview: In record mode,
|
// so vbuffers must be PREPARE_BUFFER, until timeout that mean
|
// in_flight_.size() less than 2 buffers.
|
HAL_LOGD("The request queue will be pop,there are leave %zu in prequest,"
|
"%zu in trequest, %zu in vrequest, %zu in vhrequest now!",
|
request_queue_pstream_.size(),
|
request_queue_tstream_.size(),
|
request_queue_vstream_.size(),
|
request_queue_vhstream_.size());
|
|
std::shared_ptr<default_camera_hal::CaptureRequest> request = nullptr;
|
while (1) {
|
std::unique_lock<std::mutex> lock(request_queue_stream_lock_);
|
// Only pick one stream.
|
if (!request_queue_tstream_.empty()) {
|
request = request_queue_tstream_.front();
|
request_queue_tstream_.pop();
|
break;
|
} else if (!request_queue_vstream_.empty() && mVideoflag) {
|
request = request_queue_vstream_.front();
|
request_queue_vstream_.pop();
|
break;
|
} else if (!request_queue_pstream_.empty() &&
|
((mVideoflag == false) || mRunStreamNum == 1)) {
|
// Think about the stream has only one cache for using,
|
// add detect stream number for preview in video mode.
|
request = request_queue_pstream_.front();
|
request_queue_pstream_.pop();
|
break;
|
}
|
HAL_LOGD("Wait the requests_available_stream_ lock,"
|
" in_flight_ buffer(s) size:%zu.",
|
in_flight_.size());
|
requests_available_stream_.wait(lock);
|
HAL_LOGD("The lock has been notified.");
|
}
|
|
HAL_LOGD("Stream queue has been pop,there are leave %zu in prequest,"
|
"%zu in trequest, %zu in vrequest,%zu in vhrequest now!",
|
request_queue_pstream_.size(),
|
request_queue_tstream_.size(),
|
request_queue_vstream_.size(),
|
request_queue_vhstream_.size());
|
return request;
|
}
|
|
void V4L2Camera::ReadyForBuffer() {
|
// Wait until something is available before looping again.
|
std::unique_lock<std::mutex> lock(in_flight_lock_);
|
while (!(((mBeffer_status.pbuffers == PREPARE_BUFFER) ||
|
(mBeffer_status.vbuffers == PREPARE_BUFFER)) &&
|
(in_flight_.size() > 0))) {
|
HAL_LOGV("Wait the buffers_in_flight_ lock, "
|
"in_flight_ buffer(s) size:%zu.",
|
in_flight_.size());
|
buffers_in_flight_.wait(lock);
|
HAL_LOGV("The lock has been notified.");
|
}
|
}
|
|
bool V4L2Camera::validateDataspacesAndRotations(
|
const camera3_stream_configuration_t* stream_config) {
|
HAL_LOG_ENTER();
|
for (uint32_t i = 0; i < stream_config->num_streams; ++i) {
|
if (stream_config->streams[i]->rotation != CAMERA3_STREAM_ROTATION_0) {
|
HAL_LOGV("Rotation %d for stream %d not supported",
|
stream_config->streams[i]->rotation,
|
i);
|
return false;
|
}
|
// Accept all dataspaces, as it will just be overwritten below anyways.
|
}
|
return true;
|
}
|
|
int V4L2Camera::sResultCallback(uint32_t frameNumber, struct timeval ts) {
|
std::unique_lock<std::mutex> lock(frameNumber_request_lock_);
|
int res = 0;
|
int ret = 0;
|
std::shared_ptr<default_camera_hal::CaptureRequest> request =
|
rfequest_queue_stream_.front();
|
int focus_status = -1;
|
CameraStream* focus_camera_stream = nullptr;
|
if (mCameraConfig->supportFocusMode()) {
|
for (int i = 0; i < MAX_STREAM; i++) {
|
if (mCameraStream[i] != nullptr) {
|
focus_camera_stream = mCameraStream[i];
|
break;
|
}
|
}
|
}
|
|
auto map_entry = mMapFrameNumRequest.find(frameNumber);
|
if (map_entry == mMapFrameNumRequest.end()) {
|
HAL_LOGE("No matching request for frameNumber:%d, something wrong!",
|
frameNumber);
|
return -ENOMEM;
|
} else {
|
if (request->frame_number != frameNumber) {
|
HAL_LOGE("No the successfully front request frameNumber:%d"
|
"for result frameNumber:%d, something wrong!",
|
request->frame_number, frameNumber);
|
wfequest_queue_stream_.push(map_entry->second);
|
} else {
|
// Fix cts case:
|
// android.hardware.camera2.cts.StillCaptureTest#testJpegExif
|
// We update the mThumbnailSize and sort for avoid framework sort the
|
// metadata so mThumbnailSize changed.
|
std::array<int32_t, 2> mThumbnailSize = {-1, -1};
|
ret = SingleTagValue(&map_entry->second->settings,
|
ANDROID_JPEG_THUMBNAIL_SIZE,
|
&mThumbnailSize);
|
(&map_entry->second->settings)->sort();
|
if ((mThumbnailSize[0] == 0) && (mThumbnailSize[1] == 0)) {
|
int mThumbnailSizet[2] = {0, 0};
|
ret = (&map_entry->second->settings)->update(
|
ANDROID_JPEG_THUMBNAIL_SIZE,
|
mThumbnailSizet,
|
2);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_JPEG_THUMBNAIL_SIZE);
|
}
|
}
|
|
if(!is_merge_stream_flag)
|
{
|
int64_t timestamp = 0;
|
timestamp = ts.tv_sec * 1000000000ULL + ts.tv_usec*1000;
|
ret = (&map_entry->second->settings)->update(ANDROID_SENSOR_TIMESTAMP, ×tamp, 1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x", ANDROID_SENSOR_TIMESTAMP);
|
}
|
res = 404;
|
}
|
|
if (mCameraConfig->supportFlashMode()) {
|
uint8_t fwk_flashState;
|
uint8_t fwk_aeMode;
|
if (curFlashStateE == CAM_FLASH_STATE_READY && device_id_ != 1) {
|
fwk_flashState = ANDROID_FLASH_STATE_READY;
|
ret = (&map_entry->second->settings)->update(ANDROID_FLASH_STATE,
|
&fwk_flashState, 1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x", ANDROID_FLASH_STATE);
|
}
|
} else if (curFlashStateE == CAM_FLASH_STATE_FIRED && device_id_ != 1) {
|
fwk_flashState = ANDROID_FLASH_STATE_FIRED;
|
ret = (&map_entry->second->settings)->update(ANDROID_FLASH_STATE,
|
&fwk_flashState,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x", ANDROID_FLASH_STATE);
|
}
|
}
|
if (curFlashModeE == CAM_FLASH_MODE_AUTO && device_id_ != 1) {
|
HAL_LOGV("frameNumber:%d", frameNumber);
|
fwk_aeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH;
|
ret = (&map_entry->second->settings)->update(ANDROID_CONTROL_AE_MODE,
|
&fwk_aeMode,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_CONTROL_AE_MODE);
|
}
|
}
|
}
|
|
if (mCameraConfig->supportFocusMode()) {
|
uint8_t fwk_afStatus;
|
uint8_t fwk_afTrigger;
|
uint8_t fwk_afMode;
|
|
focus_status = focus_camera_stream->getFocusStatus();
|
HAL_LOGD("focus_status:%d frameNumber:%d", focus_status, frameNumber);
|
if (focus_status == 2 && camFocusImpl.focused_times < 2) {
|
HAL_LOGV("ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED focused_times:%d",
|
camFocusImpl.focused_times);
|
fwk_afStatus = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
|
ret = (&map_entry->second->settings)->update(ANDROID_CONTROL_AF_STATE,
|
&fwk_afStatus,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_CONTROL_AF_STATE);
|
}
|
camFocusImpl.focused_times++;
|
}
|
|
if ((&map_entry->second->settings)->exists(
|
ANDROID_CONTROL_AF_TRIGGER)) {
|
fwk_afTrigger = (&map_entry->second->settings)->find(
|
ANDROID_CONTROL_AF_TRIGGER).data.u8[0];
|
if (fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_IDLE) {
|
HAL_LOGV("sResultCallback ANDROID_CONTROL_AF_TRIGGER_IDLE"
|
" frameNumber:%d", frameNumber);
|
} else if (fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_START) {
|
HAL_LOGV("sResultCallback ANDROID_CONTROL_AF_TRIGGER_START"
|
" frameNumber:%d", frameNumber);
|
} else if (fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_CANCEL) {
|
HAL_LOGV("sResultCallback ANDROID_CONTROL_AF_TRIGGER_CANCEL"
|
" frameNumber:%d", frameNumber);
|
} else {
|
HAL_LOGE("sResultCallback error ANDROID_CONTROL_AF_TRIGGER"
|
" frameNumber:%d", frameNumber);
|
}
|
}
|
if ((&map_entry->second->settings)->exists(ANDROID_CONTROL_AF_MODE)) {
|
fwk_afMode =
|
(&map_entry->second->settings)->find(
|
ANDROID_CONTROL_AF_MODE).data.u8[0];
|
if (fwk_afMode == ANDROID_CONTROL_AF_MODE_OFF) {
|
HAL_LOGV("sResultCallback ANDROID_CONTROL_AF_MODE_OFF "
|
"frameNumber:%d", frameNumber);
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_AUTO) {
|
HAL_LOGV("sResultCallback ANDROID_CONTROL_AF_MODE_AUTO "
|
"frameNumber:%d", frameNumber);
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_MACRO) {
|
HAL_LOGV("sResultCallback ANDROID_CONTROL_AF_MODE_MACRO "
|
"frameNumber:%d", frameNumber);
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO) {
|
HAL_LOGV("sResultCallback ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO "
|
"frameNumber:%d", frameNumber);
|
} else if (fwk_afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE) {
|
HAL_LOGV("sResultCallback "
|
"ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE "
|
"frameNumber:%d", frameNumber);
|
} else {
|
HAL_LOGE("sResultCallback error ANDROID_CONTROL_AF_MODE "
|
"frameNumber:%d", frameNumber);
|
}
|
}
|
if ((&map_entry->second->settings)->exists(
|
ANDROID_CONTROL_AF_REGIONS)) {
|
cam_area_t camRoi;
|
camRoi.rect.x_min = (&map_entry->second->settings)->find(
|
ANDROID_CONTROL_AF_REGIONS).data.i32[0];
|
camRoi.rect.y_min = (&map_entry->second->settings)->find(
|
ANDROID_CONTROL_AF_REGIONS).data.i32[1];
|
camRoi.rect.x_max = (&map_entry->second->settings)->find(
|
ANDROID_CONTROL_AF_REGIONS).data.i32[2];
|
camRoi.rect.y_max = (&map_entry->second->settings)->find(
|
ANDROID_CONTROL_AF_REGIONS).data.i32[3];
|
camRoi.weight = (&map_entry->second->settings)->find(
|
ANDROID_CONTROL_AF_REGIONS).data.i32[4];
|
HAL_LOGV("sResultCallback roi.weight:%d,roi.rect.x_min:%d "
|
"roi.rect.y_min:%d roi.rect.x_max:%d roi.rect.y_max:%d",
|
camAreaRoi.weight,
|
camAreaRoi.rect.x_min,
|
camAreaRoi.rect.y_min,
|
camAreaRoi.rect.x_max,
|
camAreaRoi.rect.y_max);
|
HAL_LOGV("sResultCallback camRoi.weight:%d,camRoi.rect.x_min:%d "
|
"camRoi.rect.y_min:%d camRoi.rect.x_max:%d camRoi.rect.y_max:%d",
|
camRoi.weight,
|
camRoi.rect.x_min,
|
camRoi.rect.y_min,
|
camRoi.rect.x_max,
|
camRoi.rect.y_max);
|
}
|
if (focus_status == 2 &&
|
fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_START &&
|
fwk_afMode == ANDROID_CONTROL_AF_MODE_AUTO) {
|
HAL_LOGV("update_status ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED "
|
"focused_times:%d",
|
camFocusImpl.focused_times);
|
fwk_afStatus = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
|
ret = (&map_entry->second->settings)->update(ANDROID_CONTROL_AF_STATE,
|
&fwk_afStatus,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_CONTROL_AF_STATE);
|
}
|
camFocusImpl.status_flag = 1;
|
}
|
if (focus_status == 4 &&
|
fwk_afTrigger == ANDROID_CONTROL_AF_TRIGGER_START &&
|
fwk_afMode == ANDROID_CONTROL_AF_MODE_AUTO) {
|
HAL_LOGV("update_status ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED "
|
"focused_times:%d",
|
camFocusImpl.focused_times);
|
fwk_afStatus = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
|
ret = (&map_entry->second->settings)->update(ANDROID_CONTROL_AF_STATE,
|
&fwk_afStatus,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_CONTROL_AF_STATE);
|
}
|
camFocusImpl.status_flag = 1;
|
}
|
if (focus_status == 2 &&
|
camFocusImpl.update_status == 1 &&
|
camFocusImpl.status_flag == 1) {
|
HAL_LOGV("update_status no CANCEL "
|
"ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED focused_times:%d",
|
camFocusImpl.focused_times);
|
fwk_afStatus = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
|
ret = (&map_entry->second->settings)->update(ANDROID_CONTROL_AF_STATE,
|
&fwk_afStatus,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_CONTROL_AF_STATE);
|
}
|
camFocusImpl.update_status_times++;
|
}
|
if (focus_status == 4 &&
|
camFocusImpl.update_status == 1 &&
|
camFocusImpl.status_flag == 1) {
|
HAL_LOGV("update_status no CANCEL "
|
"ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED focused_times:%d",
|
camFocusImpl.focused_times);
|
fwk_afStatus = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
|
ret = (&map_entry->second->settings)->update(ANDROID_CONTROL_AF_STATE,
|
&fwk_afStatus,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_CONTROL_AF_STATE);
|
}
|
camFocusImpl.update_status_times++;
|
}
|
if (focus_status == 1) {
|
HAL_LOGV("ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN frameNumber:%d",
|
frameNumber);
|
fwk_afStatus = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN;
|
ret = (&map_entry->second->settings)->update(
|
ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN,
|
&fwk_afStatus,
|
1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_CONTROL_AF_STATE);
|
}
|
}
|
|
if (device_id_ != 1) {
|
int32_t afRegions[5] = {
|
camAreaRoi.rect.x_min,
|
camAreaRoi.rect.y_min,
|
camAreaRoi.rect.x_max,
|
camAreaRoi.rect.y_max,
|
camAreaRoi.weight};
|
(&map_entry->second->settings)->update(ANDROID_CONTROL_AF_REGIONS,
|
afRegions,
|
5);
|
}
|
}
|
|
if (mCameraConfig->supportZoom()) {
|
if ((&map_entry->second->settings)->exists(
|
ANDROID_SCALER_CROP_REGION)) {
|
int32_t* i32_data = (&map_entry->second->settings)->find(
|
ANDROID_SCALER_CROP_REGION).data.i32;
|
int left = i32_data[0];
|
int top = i32_data[1];
|
int width = i32_data[2];
|
int height = i32_data[3];
|
|
HAL_LOGV("sResultCallback ANDROID_SCALER_CROP_REGION left:%d "
|
"top:%d width:%d height:%d frameNumber:%d",
|
left,
|
top,
|
width,
|
height,
|
frameNumber);
|
HAL_LOGV("sResultCallback ANDROID_SCALER_CROP_REGION left:%d "
|
"top:%d width:%d height:%d frameNumber:%d",
|
camCropRect.left,
|
camCropRect.top,
|
camCropRect.width,
|
camCropRect.height,
|
frameNumber);
|
|
int32_t cropRegions[4];
|
cropRegions[0] = camCropRect.left;
|
cropRegions[1] = camCropRect.top;
|
cropRegions[2] = camCropRect.width;
|
cropRegions[3] = camCropRect.height;
|
(&map_entry->second->settings)->update(ANDROID_SCALER_CROP_REGION,
|
cropRegions,
|
4);
|
}
|
}
|
|
completeRequest(map_entry->second, res);
|
rfequest_queue_stream_.pop();
|
in_flight_buffer_count--;
|
tbuffers_in_flight_.notify_one();
|
|
while (!wfequest_queue_stream_.empty()) {
|
if (rfequest_queue_stream_.front()->frame_number ==
|
wfequest_queue_stream_.front()->frame_number) {
|
|
if (!is_merge_stream_flag) {
|
int64_t timestamp_w = 0;
|
timestamp_w = ts.tv_sec * 1000000000ULL + ts.tv_usec*1000;
|
ret = (&map_entry->second->settings)->update(
|
ANDROID_SENSOR_TIMESTAMP, ×tamp_w, 1);
|
if (ret) {
|
HAL_LOGE("Failed to update metadata tag 0x%x",
|
ANDROID_SENSOR_TIMESTAMP);
|
}
|
res = 404;
|
}
|
|
completeRequest(wfequest_queue_stream_.front(), res);
|
wfequest_queue_stream_.pop();
|
rfequest_queue_stream_.pop();
|
in_flight_buffer_count--;
|
tbuffers_in_flight_.notify_one();
|
} else {
|
HAL_LOGE("the front frameNumber in rfequest_queue(%d) "
|
"!= the wfequest_queue(%d), so keep",
|
rfequest_queue_stream_.front()->frame_number,
|
wfequest_queue_stream_.front()->frame_number);
|
break;
|
}
|
}
|
}
|
mMapFrameNumRequest.erase(frameNumber);
|
}
|
return res;
|
}
|
|
int V4L2Camera::setupStreams(camera3_stream_configuration_t* stream_config) {
|
HAL_LOG_ENTER();
|
int res = 0;
|
// stream_config should have been validated; assume at least 1 stream.
|
if (stream_config->num_streams < 1) {
|
HAL_LOGE("Validate the stream numbers, at least 1 stream.");
|
return -EINVAL;
|
}
|
// stream_config should have been validated; do not over MAX_STREAM_NUM.
|
if (stream_config->num_streams > MAX_STREAM_NUM) {
|
HAL_LOGE("Validate the stream numbers, "
|
"over the max stream number %d we support.", MAX_STREAM_NUM);
|
return -EINVAL;
|
}
|
|
// stop stream.
|
if (mStreamManager_ != nullptr) {
|
HAL_LOGD("Stop stream.");
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
mStreamManager_->stop((STREAM_SERIAL)ss);
|
}
|
}
|
|
while (!wfequest_queue_stream_.empty()) {
|
wfequest_queue_stream_.pop();
|
}
|
while (!rfequest_queue_stream_.empty()) {
|
rfequest_queue_stream_.pop();
|
}
|
mMapFrameNumRequest.clear();
|
mStreamManager_.reset();
|
mStreamManager_ = StreamManager::NewStreamManager(device_, instance);
|
|
if (mCameraConfig->supportFlashMode()) {
|
std::lock_guard<std::mutex> guard(camera_fd_lock_);
|
if (camera_fd != -1) {
|
int ret_close = 0;
|
ret_close = ::close(camera_fd);
|
HAL_LOGD("mCameraFd:%d, ret_close: %d, errno:%s",
|
camera_fd, ret_close, strerror(errno));
|
camera_fd = -1;
|
}
|
}
|
|
uint32_t numStreamsSet = 0;
|
int retIndex = -1;
|
int mainIndex = -1;
|
int subIndex = -1;
|
int thirdIndex = -1;
|
|
for (int j = 0; j <MAX_STREAM; j++) {
|
mStreamTracker[j] = false;
|
}
|
for (int j = 0; j <MAX_STREAM; j++) {
|
mSourceStreamTracker[j] = false;
|
}
|
|
// Analysis and create stream.
|
for (uint32_t i = 0; i < stream_config->num_streams; ++i) {
|
int isBlob = 0;
|
retIndex = findStreamModes(MAIN_STREAM, stream_config, &isBlob);
|
if ((retIndex >= 0) && (!mStreamTracker[MAIN_STREAM +isBlob])) {
|
HAL_LOGD("Detect the main stream %d is format %d(%s), "
|
"width %d, height %d, usage %d(%s), stream_type %d, "
|
"data_space %d, num_streams:%d. isBlob %d",
|
retIndex,
|
stream_config->streams[retIndex]->format,
|
getHalPixelFormatString(
|
stream_config->streams[retIndex]->format).c_str(),
|
stream_config->streams[retIndex]->width,
|
stream_config->streams[retIndex]->height,
|
stream_config->streams[retIndex]->usage,
|
getGrallocUsageString(
|
stream_config->streams[retIndex]->usage).c_str(),
|
stream_config->streams[retIndex]->stream_type,
|
stream_config->streams[retIndex]->data_space,
|
stream_config->num_streams, isBlob);
|
mainIndex = retIndex;
|
|
stream_config->streams[retIndex]->priv =
|
reinterpret_cast<void *> (mStreamManager_->createStream(
|
MAIN_STREAM,
|
stream_config->streams[retIndex]->width,
|
stream_config->streams[retIndex]->height,
|
stream_config->streams[retIndex]->format,
|
stream_config->streams[retIndex]->usage,
|
isBlob,
|
merge_stream_status_));
|
if (nullptr == stream_config->streams[retIndex]->priv) {
|
HAL_LOGE("Failed create main stream!");
|
return -EINVAL;
|
}
|
mSourceStreamTracker[retIndex] = true;
|
mStreamTracker[MAIN_STREAM +isBlob] = true;
|
numStreamsSet++;
|
continue;
|
}
|
isBlob = 0;
|
retIndex = findStreamModes(SUB_0_STREAM, stream_config, &isBlob);
|
if ((retIndex >= 0) && (!mStreamTracker[SUB_0_STREAM +isBlob])) {
|
HAL_LOGV("Detect the sub stream %d is format %d(%s), "
|
"width %d, height %d, usage %d(%s), stream_type %d, "
|
"data_space %d, num_streams:%d. isBlob %d",
|
retIndex,
|
stream_config->streams[retIndex]->format,
|
getHalPixelFormatString(
|
stream_config->streams[retIndex]->format).c_str(),
|
stream_config->streams[retIndex]->width,
|
stream_config->streams[retIndex]->height,
|
stream_config->streams[retIndex]->usage,
|
getGrallocUsageString(
|
stream_config->streams[retIndex]->usage).c_str(),
|
stream_config->streams[retIndex]->stream_type,
|
stream_config->streams[retIndex]->data_space,
|
stream_config->num_streams, isBlob);
|
|
subIndex = retIndex;
|
|
stream_config->streams[retIndex]->priv =
|
reinterpret_cast<void *> (mStreamManager_->createStream(
|
SUB_0_STREAM,
|
stream_config->streams[retIndex]->width,
|
stream_config->streams[retIndex]->height,
|
stream_config->streams[retIndex]->format,
|
stream_config->streams[retIndex]->usage,
|
isBlob,
|
merge_stream_status_));
|
if (nullptr == stream_config->streams[retIndex]->priv) {
|
HAL_LOGE("Failed create sub stream!");
|
return -EINVAL;
|
}
|
mSourceStreamTracker[retIndex] = true;
|
mStreamTracker[SUB_0_STREAM +isBlob] = true;
|
numStreamsSet++;
|
continue;
|
}
|
|
// For third stream
|
isBlob = 0;
|
// detect source stream
|
for (uint32_t k = 0; k < stream_config->num_streams; k++) {
|
if (mSourceStreamTracker[k] == false) {
|
thirdIndex = k;
|
if (stream_config->streams[k]->format == HAL_PIXEL_FORMAT_BLOB) {
|
isBlob = 1;
|
}
|
}
|
}
|
|
camera3_stream_t* subIndexStream = stream_config->streams[subIndex];
|
camera3_stream_t* thirdIndexStream = stream_config->streams[thirdIndex];
|
|
// We can not deal the blob stream when input
|
// source/output source large than 5.
|
|
if ((numStreamsSet != stream_config->num_streams) &&
|
(((subIndexStream->width/thirdIndexStream->width) < 5) &&
|
((subIndexStream->height/thirdIndexStream->height) < 5))) {
|
// For third blob stream
|
for (int j = SUB_0_STREAM_BLOB; j >0;) {
|
HAL_LOGD("In j:%d circle!", j);
|
if ((!mStreamTracker[j]) && isBlob) {
|
HAL_LOGD("Find j+isBlob:%d false!", j);
|
HAL_LOGD("Detect the third blob stream %d link to %d "
|
"stream is format %d(%s), width %d, height %d, num_streams:%d.",
|
thirdIndex,
|
j,
|
stream_config->streams[thirdIndex]->format,
|
getHalPixelFormatString(
|
stream_config->streams[retIndex]->format).c_str(),
|
stream_config->streams[thirdIndex]->width,
|
stream_config->streams[thirdIndex]->height,
|
stream_config->num_streams);
|
|
stream_config->streams[thirdIndex]->priv =
|
reinterpret_cast<void *> (mStreamManager_->createStream(
|
(STREAM_SERIAL)(j -1),
|
stream_config->streams[thirdIndex]->width,
|
stream_config->streams[thirdIndex]->height,
|
stream_config->streams[thirdIndex]->format,
|
stream_config->streams[thirdIndex]->usage,
|
isBlob,
|
merge_stream_status_));
|
|
if (nullptr == stream_config->streams[thirdIndex]->priv) {
|
HAL_LOGE("Failed create third stream!");
|
return -EINVAL;
|
}
|
mSourceStreamTracker[thirdIndex] = true;
|
mStreamTracker[j] = true;
|
numStreamsSet++;
|
break;
|
}
|
|
if (numStreamsSet == stream_config->num_streams) {
|
break;
|
}
|
j = j -2;
|
}
|
}
|
|
// find mirror stream
|
if (numStreamsSet != stream_config->num_streams) {
|
if (!mStreamTracker[SUB_0_MIRROR_STREAM]) {
|
HAL_LOGD("Find SUB_0_MIRROR_STREAM:%d!", SUB_0_MIRROR_STREAM+isBlob);
|
HAL_LOGD("Detect the third mirror stream %d link to %d "
|
"stream is format %d(%s), width %d, height %d, num_streams:%d.",
|
thirdIndex,
|
SUB_0_MIRROR_STREAM +isBlob,
|
stream_config->streams[thirdIndex]->format,
|
getHalPixelFormatString(
|
stream_config->streams[retIndex]->format).c_str(),
|
stream_config->streams[thirdIndex]->width,
|
stream_config->streams[thirdIndex]->height,
|
stream_config->num_streams);
|
|
stream_config->streams[thirdIndex]->priv =
|
reinterpret_cast<void *> (mStreamManager_->createStream((
|
STREAM_SERIAL)SUB_0_MIRROR_STREAM,
|
stream_config->streams[thirdIndex]->width,
|
stream_config->streams[thirdIndex]->height,
|
stream_config->streams[thirdIndex]->format,
|
stream_config->streams[thirdIndex]->usage,
|
isBlob,
|
merge_stream_status_));
|
|
camera3_stream_t* subIndexStream = stream_config->streams[subIndex];
|
camera3_stream_t* thirdIndexStream = stream_config->streams[thirdIndex];
|
if (subIndexStream->width != thirdIndexStream->width ||
|
subIndexStream->height != thirdIndexStream->height) {
|
res = (reinterpret_cast<CameraSubMirrorStream *>
|
(thirdIndexStream->priv))->setScaleFlag();
|
if (res) {
|
HAL_LOGE("Failed setScaleFlag!");
|
}
|
}
|
if (nullptr == stream_config->streams[thirdIndex]->priv) {
|
HAL_LOGE("Failed create third stream!");
|
return -EINVAL;
|
}
|
mSourceStreamTracker[thirdIndex] = true;
|
mStreamTracker[SUB_0_MIRROR_STREAM +isBlob] = true;
|
numStreamsSet++;
|
}
|
}
|
}
|
|
HAL_LOGD("Configurate stream Manager.");
|
if (mStreamManager_ != nullptr) {
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
res = mStreamManager_->configurateManager((STREAM_SERIAL) ss);
|
if (res) {
|
HAL_LOGE("Configurate stream Manager failed.");
|
}
|
}
|
}
|
|
camFocusImpl.focus_frame_num = -1;
|
camFocusImpl.focused_times = -1;
|
camFocusImpl.update_status = -1;
|
camFocusImpl.status_flag = -1;
|
camFocusImpl.focus_status = -1;
|
camFocusImpl.update_status_times = -1;
|
camFocusImpl.camera_focus_mode = CAM_FOCUS_MODE_MAX;
|
camFocusImpl.camera_focus_trigger = CAM_FOCUS_TRIGGER_MAX;
|
memset(&camAreaRoi, 0, sizeof(cam_area_t));
|
memset(&camCropRect, 0, sizeof(cam_crop_rect_t));
|
|
HAL_LOGD("Start stream.");
|
// start stream.
|
if (mStreamManager_ != nullptr) {
|
for (int ss = 0; ss < MAX_STREAM; ss++) {
|
mStreamManager_->start((STREAM_SERIAL)ss);
|
}
|
}
|
|
// Fill some stream info:
|
// stream->usage, stream->max_buffers, stream->data_space.
|
for (uint32_t i = 0; i < stream_config->num_streams; ++i) {
|
fillStreamInfo(stream_config->streams[i]);
|
}
|
is_merge_stream_flag = false;
|
for (uint32_t i = 0; i < stream_config->num_streams; ++i) {
|
HAL_LOGD("stream %d is format %d(%s), width %d, height %d, "
|
"usage %d(%s), stream_type %d, data_space %d, num_streams:%d.",
|
i,
|
stream_config->streams[i]->format,
|
getHalPixelFormatString(stream_config->streams[i]->format).c_str(),
|
stream_config->streams[i]->width,
|
stream_config->streams[i]->height,
|
stream_config->streams[i]->usage,
|
getGrallocUsageString(stream_config->streams[retIndex]->usage).c_str(),
|
stream_config->streams[i]->stream_type,
|
stream_config->streams[i]->data_space,
|
stream_config->num_streams);
|
if(stream_config->streams[i]->width * stream_config->streams[i]->height >
|
4000*3000) {
|
is_merge_stream_flag = true;
|
}
|
}
|
|
HAL_LOGI("setupStreams finished");
|
return 0;
|
}
|
|
bool V4L2Camera::isValidRequestSettings(const CameraMetadata& settings) {
|
if (!metadata_->IsValidRequest(settings)) {
|
HAL_LOGE("Invalid request settings.");
|
return false;
|
}
|
return true;
|
}
|
|
} // namespace v4l2_camera_hal
|
