64e7f2013b
Test: add `USE_CAMERA_V4L2_HAL := true` to
hardware/libhardware/modules/camera/3_4/Android.mk and build
mmm hardware/libhardware/modules/camera/3_4
Change-Id: I47ee9e39c3bfee7927f4e57dfec459714c959e14
Signed-off-by: Sergii Piatakov <sergii.piatakov@globallogic.com>
495 lines
17 KiB
C++
495 lines
17 KiB
C++
/*
|
|
* Copyright (C) 2016 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_NDEBUG 0
|
|
#define LOG_TAG "StaticProperties"
|
|
|
|
#include "static_properties.h"
|
|
|
|
#include <cutils/log.h>
|
|
#include <hardware/camera3.h>
|
|
#include <system/camera.h>
|
|
|
|
#include "metadata/metadata_reader.h"
|
|
|
|
namespace default_camera_hal {
|
|
|
|
// Build stream capabilities from configs + stall durations.
|
|
static bool ConstructStreamCapabilities(
|
|
const std::vector<StreamConfiguration>& configs,
|
|
const std::vector<StreamStallDuration>& stalls,
|
|
StaticProperties::CapabilitiesMap* capabilities) {
|
|
// Extract directional capabilities from the configs.
|
|
for (const auto& config : configs) {
|
|
switch (config.direction) {
|
|
case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT:
|
|
(*capabilities)[config.spec].output_supported = true;
|
|
break;
|
|
case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT:
|
|
(*capabilities)[config.spec].input_supported = true;
|
|
break;
|
|
default:
|
|
// Should never happen when using the MetadataReader;
|
|
// it should validate directions.
|
|
ALOGE("%s: Unrecognized stream config direction %d.",
|
|
__func__,
|
|
config.direction);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Extract stall durations from the stalls.
|
|
for (const auto& stall : stalls) {
|
|
(*capabilities)[stall.spec].stall_duration = stall.duration;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Check that each output config has a valid corresponding stall duration
|
|
// (extra durations not matching any output config are ignored).
|
|
static bool ValidateStreamCapabilities(
|
|
StaticProperties::CapabilitiesMap capabilities) {
|
|
for (const auto& spec_capabilities : capabilities) {
|
|
// Only non-negative stall durations are valid. This should only happen
|
|
// due to output streams without an associated stall duration, as
|
|
// MetadataReader validates the metadata stall durations.
|
|
if (spec_capabilities.second.output_supported &&
|
|
spec_capabilities.second.stall_duration < 0) {
|
|
ALOGE(
|
|
"%s: Static metadata does not have a stall duration for "
|
|
"each output configuration. ",
|
|
__func__);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Validate that the input/output formats map matches up with
|
|
// the capabilities listed for all formats.
|
|
bool ValidateReprocessFormats(
|
|
const StaticProperties::CapabilitiesMap& capabilities,
|
|
const ReprocessFormatMap& reprocess_map) {
|
|
// Get input formats.
|
|
std::set<int32_t> all_input_formats;
|
|
std::set<int32_t> all_output_formats;
|
|
for (const auto& spec_capabilities : capabilities) {
|
|
if (spec_capabilities.second.input_supported) {
|
|
all_input_formats.insert(spec_capabilities.first.format);
|
|
}
|
|
if (spec_capabilities.second.output_supported) {
|
|
all_output_formats.insert(spec_capabilities.first.format);
|
|
}
|
|
}
|
|
|
|
// Must be at least one input format.
|
|
if (all_input_formats.size() < 1) {
|
|
ALOGE("%s: No input formats, reprocessing can't be supported.", __func__);
|
|
return false;
|
|
}
|
|
|
|
// Check that the reprocess map input formats are exactly all available
|
|
// input formats (check size here, then checking for actual value
|
|
// matches will happen as part of the loop below).
|
|
if (all_input_formats.size() != reprocess_map.size()) {
|
|
ALOGE(
|
|
"%s: Stream configuration input formats do not match "
|
|
"input/output format map input formats.",
|
|
__func__);
|
|
return false;
|
|
}
|
|
|
|
// Check that each input format has at least one matching output format.
|
|
for (const auto& input_format : all_input_formats) {
|
|
const auto input_outputs_iterator = reprocess_map.find(input_format);
|
|
if (input_outputs_iterator == reprocess_map.end()) {
|
|
ALOGE(
|
|
"%s: No output formats for input format %d.", __func__, input_format);
|
|
return false;
|
|
}
|
|
// No need to check that the output formats vector is non-empty;
|
|
// MetadataReader validates this. Instead just check that
|
|
// all outputs are actually output formats.
|
|
for (const auto& output_format : input_outputs_iterator->second) {
|
|
if (all_output_formats.count(output_format) < 1) {
|
|
ALOGE(
|
|
"%s: Output format %d for input format %d "
|
|
"is not a supported output format.",
|
|
__func__,
|
|
input_format,
|
|
output_format);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
StaticProperties* StaticProperties::NewStaticProperties(
|
|
std::unique_ptr<const MetadataReader> metadata_reader) {
|
|
int facing = 0;
|
|
int orientation = 0;
|
|
int32_t max_input_streams = 0;
|
|
int32_t max_raw_output_streams = 0;
|
|
int32_t max_non_stalling_output_streams = 0;
|
|
int32_t max_stalling_output_streams = 0;
|
|
std::set<uint8_t> request_capabilities;
|
|
std::vector<StreamConfiguration> configs;
|
|
std::vector<StreamStallDuration> stalls;
|
|
CapabilitiesMap stream_capabilities;
|
|
ReprocessFormatMap reprocess_map;
|
|
|
|
// If reading any data returns an error, something is wrong.
|
|
if (metadata_reader->Facing(&facing) ||
|
|
metadata_reader->Orientation(&orientation) ||
|
|
metadata_reader->MaxInputStreams(&max_input_streams) ||
|
|
metadata_reader->MaxOutputStreams(&max_raw_output_streams,
|
|
&max_non_stalling_output_streams,
|
|
&max_stalling_output_streams) ||
|
|
metadata_reader->RequestCapabilities(&request_capabilities) ||
|
|
metadata_reader->StreamConfigurations(&configs) ||
|
|
metadata_reader->StreamStallDurations(&stalls) ||
|
|
!ConstructStreamCapabilities(configs, stalls, &stream_capabilities) ||
|
|
// MetadataReader validates configs and stall seperately,
|
|
// but not that they match.
|
|
!ValidateStreamCapabilities(stream_capabilities) ||
|
|
// Reprocessing metadata only necessary if input streams are allowed.
|
|
(max_input_streams > 0 &&
|
|
(metadata_reader->ReprocessFormats(&reprocess_map) ||
|
|
// MetadataReader validates configs and the reprocess map seperately,
|
|
// but not that they match.
|
|
!ValidateReprocessFormats(stream_capabilities, reprocess_map)))) {
|
|
return nullptr;
|
|
}
|
|
|
|
return new StaticProperties(std::move(metadata_reader),
|
|
facing,
|
|
orientation,
|
|
max_input_streams,
|
|
max_raw_output_streams,
|
|
max_non_stalling_output_streams,
|
|
max_stalling_output_streams,
|
|
std::move(request_capabilities),
|
|
std::move(stream_capabilities),
|
|
std::move(reprocess_map));
|
|
}
|
|
|
|
StaticProperties::StaticProperties(
|
|
std::unique_ptr<const MetadataReader> metadata_reader,
|
|
int facing,
|
|
int orientation,
|
|
int32_t max_input_streams,
|
|
int32_t max_raw_output_streams,
|
|
int32_t max_non_stalling_output_streams,
|
|
int32_t max_stalling_output_streams,
|
|
std::set<uint8_t> request_capabilities,
|
|
CapabilitiesMap stream_capabilities,
|
|
ReprocessFormatMap supported_reprocess_outputs)
|
|
: metadata_reader_(std::move(metadata_reader)),
|
|
facing_(facing),
|
|
orientation_(orientation),
|
|
max_input_streams_(max_input_streams),
|
|
max_raw_output_streams_(max_raw_output_streams),
|
|
max_non_stalling_output_streams_(max_non_stalling_output_streams),
|
|
max_stalling_output_streams_(max_stalling_output_streams),
|
|
request_capabilities_(std::move(request_capabilities)),
|
|
stream_capabilities_(std::move(stream_capabilities)),
|
|
supported_reprocess_outputs_(std::move(supported_reprocess_outputs)) {}
|
|
|
|
bool StaticProperties::TemplateSupported(int type) {
|
|
uint8_t required_capability = 0;
|
|
switch (type) {
|
|
case CAMERA3_TEMPLATE_PREVIEW:
|
|
// Preview is always supported.
|
|
return true;
|
|
case CAMERA3_TEMPLATE_MANUAL:
|
|
required_capability =
|
|
ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR;
|
|
break;
|
|
case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
|
|
required_capability =
|
|
ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING;
|
|
break;
|
|
default:
|
|
required_capability =
|
|
ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE;
|
|
return true;
|
|
}
|
|
|
|
return request_capabilities_.count(required_capability) > 0;
|
|
}
|
|
|
|
// Helper functions for checking stream properties when verifying support.
|
|
static bool IsInputType(int stream_type) {
|
|
return stream_type == CAMERA3_STREAM_INPUT ||
|
|
stream_type == CAMERA3_STREAM_BIDIRECTIONAL;
|
|
}
|
|
|
|
static bool IsOutputType(int stream_type) {
|
|
return stream_type == CAMERA3_STREAM_OUTPUT ||
|
|
stream_type == CAMERA3_STREAM_BIDIRECTIONAL;
|
|
}
|
|
|
|
static bool IsRawFormat(int format) {
|
|
return format == HAL_PIXEL_FORMAT_RAW10 || format == HAL_PIXEL_FORMAT_RAW12 ||
|
|
format == HAL_PIXEL_FORMAT_RAW16 ||
|
|
format == HAL_PIXEL_FORMAT_RAW_OPAQUE;
|
|
}
|
|
|
|
bool StaticProperties::StreamConfigurationSupported(
|
|
const camera3_stream_configuration_t* stream_config) {
|
|
return SanityCheckStreamConfiguration(stream_config) &&
|
|
InputStreamsSupported(stream_config) &&
|
|
OutputStreamsSupported(stream_config) &&
|
|
OperationModeSupported(stream_config);
|
|
}
|
|
|
|
bool StaticProperties::SanityCheckStreamConfiguration(
|
|
const camera3_stream_configuration_t* stream_config) {
|
|
// Check for null/empty values.
|
|
if (stream_config == nullptr) {
|
|
ALOGE("%s: NULL stream configuration array", __func__);
|
|
return false;
|
|
} else if (stream_config->num_streams == 0) {
|
|
ALOGE("%s: Empty stream configuration array", __func__);
|
|
return false;
|
|
} else if (stream_config->streams == nullptr) {
|
|
ALOGE("%s: NULL stream configuration streams", __func__);
|
|
return false;
|
|
}
|
|
|
|
// Check that all streams are either inputs or outputs (or both).
|
|
for (size_t i = 0; i < stream_config->num_streams; ++i) {
|
|
const camera3_stream_t* stream = stream_config->streams[i];
|
|
if (stream == nullptr) {
|
|
ALOGE("%s: Stream %zu is null", __func__, i);
|
|
return false;
|
|
} else if (!IsInputType(stream->stream_type) &&
|
|
!IsOutputType(stream->stream_type)) {
|
|
ALOGE("%s: Stream %zu type %d is neither an input nor an output type",
|
|
__func__,
|
|
i,
|
|
stream->stream_type);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool StaticProperties::InputStreamsSupported(
|
|
const camera3_stream_configuration_t* stream_config) {
|
|
// Find the input stream(s).
|
|
int32_t num_input_streams = 0;
|
|
int input_format = -1;
|
|
for (size_t i = 0; i < stream_config->num_streams; ++i) {
|
|
const camera3_stream_t* stream = stream_config->streams[i];
|
|
if (IsInputType(stream->stream_type)) {
|
|
// Check that this stream is valid as an input.
|
|
const auto capabilities_iterator = stream_capabilities_.find(stream);
|
|
if (capabilities_iterator == stream_capabilities_.end() ||
|
|
!capabilities_iterator->second.input_supported) {
|
|
ALOGE("%s: %d x %d stream of format %d is not a supported input setup.",
|
|
__func__,
|
|
stream->width,
|
|
stream->height,
|
|
stream->format);
|
|
return false;
|
|
}
|
|
|
|
// Valid input stream; count it.
|
|
++num_input_streams;
|
|
input_format = stream->format;
|
|
}
|
|
}
|
|
|
|
// Check the count.
|
|
if (num_input_streams > max_input_streams_) {
|
|
ALOGE(
|
|
"%s: Requested number of input streams %d is greater than "
|
|
"the maximum number supported by the device (%d).",
|
|
__func__,
|
|
num_input_streams,
|
|
max_input_streams_);
|
|
return false;
|
|
}
|
|
if (num_input_streams > 1) {
|
|
ALOGE("%s: Camera HAL 3.4 only supports 1 input stream max.", __func__);
|
|
return false;
|
|
}
|
|
|
|
// If there's an input stream, the configuration must have at least one
|
|
// supported output format for reprocessing that input.
|
|
if (num_input_streams > 0) {
|
|
const auto input_output_formats_iterator =
|
|
supported_reprocess_outputs_.find(input_format);
|
|
if (input_output_formats_iterator == supported_reprocess_outputs_.end()) {
|
|
// Should never happen; factory should verify that all valid inputs
|
|
// have one or more valid outputs.
|
|
ALOGE("%s: No valid output formats for input format %d.",
|
|
__func__,
|
|
input_format);
|
|
return false;
|
|
}
|
|
bool match_found = false;
|
|
// Go through outputs looking for a supported one.
|
|
for (size_t i = 0; i < stream_config->num_streams; ++i) {
|
|
const camera3_stream_t* stream = stream_config->streams[i];
|
|
if (IsOutputType(stream->stream_type)) {
|
|
if (input_output_formats_iterator->second.count(stream->format) > 0) {
|
|
match_found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!match_found) {
|
|
ALOGE("%s: No supported output format provided for input format %d.",
|
|
__func__,
|
|
input_format);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool StaticProperties::OutputStreamsSupported(
|
|
const camera3_stream_configuration_t* stream_config) {
|
|
// Find and count output streams.
|
|
int32_t num_raw = 0;
|
|
int32_t num_stalling = 0;
|
|
int32_t num_non_stalling = 0;
|
|
for (size_t i = 0; i < stream_config->num_streams; ++i) {
|
|
const camera3_stream_t* stream = stream_config->streams[i];
|
|
if (IsOutputType(stream->stream_type)) {
|
|
// Check that this stream is valid as an output.
|
|
const auto capabilities_iterator = stream_capabilities_.find(stream);
|
|
if (capabilities_iterator == stream_capabilities_.end() ||
|
|
!capabilities_iterator->second.output_supported) {
|
|
ALOGE(
|
|
"%s: %d x %d stream of format %d "
|
|
"is not a supported output setup.",
|
|
__func__,
|
|
stream->width,
|
|
stream->height,
|
|
stream->format);
|
|
return false;
|
|
}
|
|
|
|
// Valid output; count it.
|
|
if (IsRawFormat(stream->format)) {
|
|
++num_raw;
|
|
} else if (capabilities_iterator->second.stall_duration > 0) {
|
|
++num_stalling;
|
|
} else {
|
|
++num_non_stalling;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check that the counts are within bounds.
|
|
if (num_raw > max_raw_output_streams_) {
|
|
ALOGE(
|
|
"%s: Requested stream configuration exceeds maximum supported "
|
|
"raw output streams %d (requested %d).",
|
|
__func__,
|
|
max_raw_output_streams_,
|
|
num_raw);
|
|
return false;
|
|
} else if (num_stalling > max_stalling_output_streams_) {
|
|
ALOGE(
|
|
"%s: Requested stream configuration exceeds maximum supported "
|
|
"stalling output streams %d (requested %u).",
|
|
__func__,
|
|
max_stalling_output_streams_,
|
|
num_stalling);
|
|
return false;
|
|
} else if (num_non_stalling > max_non_stalling_output_streams_) {
|
|
ALOGE(
|
|
"%s: Requested stream configuration exceeds maximum supported "
|
|
"non-stalling output streams %d (requested %d).",
|
|
__func__,
|
|
max_non_stalling_output_streams_,
|
|
num_non_stalling);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool StaticProperties::OperationModeSupported(
|
|
const camera3_stream_configuration_t* stream_config) {
|
|
switch (stream_config->operation_mode) {
|
|
case CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE:
|
|
return true;
|
|
case CAMERA3_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE:
|
|
// TODO(b/31370792): Check metadata for high speed support,
|
|
// check that requested streams have support for high speed.
|
|
ALOGE("%s: Support for CONSTRAINED_HIGH_SPEED not implemented", __func__);
|
|
return false;
|
|
default:
|
|
ALOGE("%s: Unrecognized stream configuration mode: %d",
|
|
__func__,
|
|
stream_config->operation_mode);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool StaticProperties::ReprocessingSupported(
|
|
const camera3_stream_t* input_stream,
|
|
const std::set<const camera3_stream_t*>& output_streams) {
|
|
// There must be an input.
|
|
if (!input_stream) {
|
|
ALOGE("%s: No input stream.", __func__);
|
|
return false;
|
|
}
|
|
// There must be an output.
|
|
if (output_streams.size() < 1) {
|
|
ALOGE("%s: No output stream.", __func__);
|
|
return false;
|
|
}
|
|
|
|
const auto input_output_formats =
|
|
supported_reprocess_outputs_.find(input_stream->format);
|
|
if (input_output_formats == supported_reprocess_outputs_.end()) {
|
|
// Should never happen for a valid input stream.
|
|
ALOGE("%s: Input format %d does not support any output formats.",
|
|
__func__,
|
|
input_stream->format);
|
|
return false;
|
|
}
|
|
|
|
// Check that all output streams can be outputs for the input stream.
|
|
const std::set<int32_t>& supported_output_formats =
|
|
input_output_formats->second;
|
|
for (const auto output_stream : output_streams) {
|
|
if (supported_output_formats.count(output_stream->format) < 1) {
|
|
ALOGE(
|
|
"%s: Output format %d is not a supported output "
|
|
"for request input format %d.",
|
|
__func__,
|
|
output_stream->format,
|
|
input_stream->format);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace default_camera_hal
|