camera/3_4/static_properties.cpp

/*
 * 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.
 */

#include "static_properties.h"

// #define LOG_NDEBUG 0
#define LOG_TAG "StaticProperties"
#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 %d is null", __func__, i);
      return false;
    } else if (!IsInputType(stream->stream_type) &&
               !IsOutputType(stream->stream_type)) {
      ALOGE("%s: Stream %d 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).
  size_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.
  size_t num_raw = 0;
  size_t num_stalling = 0;
  size_t num_non_stalling = 0;
  for (int 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 %d).",
        __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