/*
 * Copyright 2016 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "hal/usb/metadata_handler.h"

#include <algorithm>
#include <cmath>
#include <limits>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

#include <base/no_destructor.h>

#include <chromeos-config/libcros_config/cros_config.h>
#include "cros-camera/common.h"
#include "cros-camera/utils/camera_config.h"
#include "hal/usb/quirks.h"
#include "hal/usb/stream_format.h"
#include "hal/usb/v4l2_camera_device.h"
#include "hal/usb/vendor_tag.h"
#include "mojo/cros_camera_enum.mojom.h"

namespace cros {

namespace {

constexpr int32_t kMinFps = 1;
constexpr float kDefaultAvailableFocalLength = 1.6f;
constexpr float kDefaultMinimumFocusDistance = 0.3f;
constexpr float kDefaultLensFocusDistance = 0.5f;

const cros::AwbModeToTemperatureMap& GetAwbModeTemperatureMap() {
  // https://source.android.com/devices/camera/camera3_3Amodes#auto-wb
  static const base::NoDestructor<cros::AwbModeToTemperatureMap>
      kAwbModeTemperatureMap({
          {ANDROID_CONTROL_AWB_MODE_INCANDESCENT, 2700},
          {ANDROID_CONTROL_AWB_MODE_FLUORESCENT, 5000},
          {ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT, 3000},
          {ANDROID_CONTROL_AWB_MODE_DAYLIGHT, 5500},
          {ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT, 6500},
          {ANDROID_CONTROL_AWB_MODE_TWILIGHT, 15000},
          {ANDROID_CONTROL_AWB_MODE_SHADE, 7500},
      });
  return *kAwbModeTemperatureMap;
}

uint32_t GetAwbTemperatureByMode(
    const cros::ControlRange& range,
    camera_metadata_enum_android_control_awb_mode mode) {
  const cros::AwbModeToTemperatureMap& map = GetAwbModeTemperatureMap();

  if (mode == ANDROID_CONTROL_AWB_MODE_AUTO)
    return 0;

  auto it = map.find(mode);
  if (it == map.end()) {
    LOGF(ERROR) << "Can't find mode " << mode;
    return 0;
  }

  // Get acceptable temperature by minimum and step. in case the step is
  // too large.
  uint32_t temperature =
      range.minimum + range.step * ((it->second - range.minimum) / range.step);

  if (temperature < range.minimum || temperature > range.maximum)
    return 0;

  return temperature;
}

std::vector<float> GetPhysicalSize(float horiz_fov,
                                   float vert_fov,
                                   float focal_length,
                                   float array_aspect,
                                   float still_aspect) {
  float angle_to_rad_ratio = M_PI / 180.f;
  float crop_factor = still_aspect / array_aspect;
  float horiz_crop_factor = std::min(1.f, crop_factor);
  float vert_crop_factor = std::min(1.f, 1.f / crop_factor);
  return {2.f * focal_length * std::tan(horiz_fov * angle_to_rad_ratio / 2.f) /
              horiz_crop_factor,
          2.f * focal_length * std::tan(vert_fov * angle_to_rad_ratio / 2.f) /
              vert_crop_factor};
}

// The unit of ANDROID_LENS_FOCUS_DISTANCE is diopters (1/meter), but the unit
// of V4L2_CID_FOCUS_ABSOLUTE is undefined. We map the V4L2 value to diopters by
// (value - minimum) / normalize_factor where |value| is in [minimum, maximum].
// We calculate a proper |normalize_factor| by assuming the minimum focus
// distance of USB cameras is >= 1cm (tested on real webcams), i.e. max diopter
// is <= 100, and only use power of 10s for readability.
// For example, V4L2 range [0, 250] will map to Android range [0, 25], where the
// minimum focus distance is 1m/25=4cm. This function takes |v4l2_range|
// (== maximum - minimum) and returns |normalize_factor|.
uint32_t GetNormalizeFactorForV4l2FocusRange(float v4l2_range) {
  uint32_t normalize_factor = 1;

  while (v4l2_range / normalize_factor > 100.0)
    normalize_factor *= 10;

  return normalize_factor;
}

class MetadataUpdater {
 public:
  explicit MetadataUpdater(android::CameraMetadata* metadata)
      : metadata_(metadata), ok_(true) {}

  bool ok() { return ok_; }

  template <typename T>
  void operator()(int tag, const std::vector<T>& data) {
    if (!ok_) {
      return;
    }
    if (metadata_->update(tag, data) != 0) {
      ok_ = false;
      LOGF(ERROR) << "Update metadata with tag " << std::hex << std::showbase
                  << tag << " failed" << std::dec;
    }
  }

  template <typename T>
  std::enable_if_t<std::is_enum<T>::value> operator()(int tag, const T& data) {
    static const std::set<int> kInt32EnumTags = {
        ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS,
        ANDROID_SCALER_AVAILABLE_FORMATS,
        ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
        ANDROID_SENSOR_TEST_PATTERN_MODE,
        ANDROID_SYNC_MAX_LATENCY,
    };
    if (kInt32EnumTags.find(tag) != kInt32EnumTags.end()) {
      operator()(tag, std::vector<int32_t>{static_cast<int32_t>(data)});
    } else {
      operator()(tag, std::vector<uint8_t>{base::checked_cast<uint8_t>(data)});
    }
  }

  template <typename T>
  std::enable_if_t<!std::is_enum<T>::value> operator()(int tag, const T& data) {
    operator()(tag, std::vector<T>{data});
  }

 private:
  android::CameraMetadata* metadata_;
  bool ok_;
};

// Checks if a fps range can be filled into aeAvailableTargetFpsRanges given a
// list of supported formats.
// Android metadata only reports min frame duration for each format/resolution.
// CTS assumes a fps range is supported if the min frame duration (1/max_fps)
// covers the range. Thus we need to check if the USB camera actually supports
// some fps in the range.
bool IsFpsRangeSupported(const SupportedFormats& supported_formats,
                         int32_t fps_range_min,
                         int32_t fps_range_max) {
  for (const auto& format : supported_formats) {
    const int32_t max_fps = static_cast<int32_t>(*std::max_element(
        format.frame_rates.begin(), format.frame_rates.end()));
    if (max_fps >= fps_range_max) {
      const bool has_fps_in_range = std::any_of(
          format.frame_rates.begin(), format.frame_rates.end(), [&](float x) {
            const int32_t fps = static_cast<int32_t>(x);
            return fps_range_min <= fps && fps <= fps_range_max;
          });
      if (!has_fps_in_range)
        return false;
    }
  }
  return true;
}

Size GetMaxDimensions(const SupportedFormats& formats) {
  uint32_t max_width = 0;
  uint32_t max_height = 0;
  for (const SupportedFormat& format : formats) {
    max_width = std::max(max_width, format.width);
    max_height = std::max(max_height, format.height);
  }
  return Size(max_width, max_height);
}

}  // namespace

MetadataHandler::MetadataHandler(const camera_metadata_t& static_metadata,
                                 const camera_metadata_t& request_template,
                                 const DeviceInfo& device_info,
                                 V4L2CameraDevice* device,
                                 const SupportedFormats& supported_formats)
    : device_info_(device_info),
      device_(device),
      af_trigger_(false),
      focus_distance_normalize_factor_(0) {
  // MetadataBase::operator= will make a copy of camera_metadata_t.
  static_metadata_ = &static_metadata;
  request_template_ = &request_template;

  max_supported_fps_ = 0;
  for (const auto& format : supported_formats) {
    for (const float& frame_rate : format.frame_rates) {
      // Since the |frame_rate| is a float, we need to round here.
      int fps = std::round(frame_rate);
      if (fps > max_supported_fps_) {
        max_supported_fps_ = fps;
      }
    }
  }

  // camera3_request_template_t starts at 1.
  for (int i = 1; i < CAMERA3_TEMPLATE_COUNT; i++) {
    template_settings_[i] = CreateDefaultRequestSettings(i);
  }

  sensor_handler_ = SensorHandler::Create(device_info, supported_formats);

  is_awb_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info_.device_path, kControlWhiteBalanceTemperature);
  awb_temperature_ = GetAvailableAwbTemperatures(device_info);

  is_brightness_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info.device_path, kControlBrightness);
  is_contrast_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info.device_path, kControlContrast);
  is_pan_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info.device_path, kControlPan);
  is_saturation_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info.device_path, kControlSaturation);
  is_sharpness_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info.device_path, kControlSharpness);
  is_tilt_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info.device_path, kControlTilt);
  is_zoom_control_supported_ = V4L2CameraDevice::IsControlSupported(
      device_info.device_path, kControlZoom);

  if (V4L2CameraDevice::IsFocusDistanceSupported(device_info.device_path,
                                                 &focus_distance_range_)) {
    float full_range =
        focus_distance_range_.maximum - focus_distance_range_.minimum;
    focus_distance_normalize_factor_ =
        GetNormalizeFactorForV4l2FocusRange(full_range);
  }

  thread_checker_.DetachFromThread();
}

MetadataHandler::~MetadataHandler() {}

int MetadataHandler::FillDefaultMetadata(
    android::CameraMetadata* static_metadata,
    android::CameraMetadata* request_metadata) {
  MetadataUpdater update_static(static_metadata);
  MetadataUpdater update_request(request_metadata);

  // android.colorCorrection
  update_static(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
                std::vector<uint8_t>{
                    ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST,
                    ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY});
  update_request(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
                 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST);

  // android.control
  // We don't support AE compensation.
  update_static(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
                std::vector<int32_t>{0, 0});

  update_static(ANDROID_CONTROL_AE_COMPENSATION_STEP,
                camera_metadata_rational_t{0, 1});

  update_static(ANDROID_CONTROL_MAX_REGIONS,
                std::vector<int32_t>{/*AE*/ 0, /*AWB*/ 0, /*AF*/ 0});

  update_static(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
                ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF);
  update_request(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
                 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF);

  update_static(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
                ANDROID_CONTROL_AWB_MODE_AUTO);
  update_request(ANDROID_CONTROL_AWB_MODE, ANDROID_CONTROL_AWB_MODE_AUTO);

  update_static(ANDROID_CONTROL_AE_AVAILABLE_MODES, ANDROID_CONTROL_AE_MODE_ON);
  // ON means auto-exposure is active with no flash control.
  update_request(ANDROID_CONTROL_AE_MODE, ANDROID_CONTROL_AE_MODE_ON);

  update_request(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, int32_t{0});

  update_request(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
                 ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE);

  update_request(ANDROID_CONTROL_AF_TRIGGER, ANDROID_CONTROL_AF_TRIGGER_IDLE);

  update_static(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
                ANDROID_CONTROL_SCENE_MODE_DISABLED);
  update_request(ANDROID_CONTROL_SCENE_MODE,
                 ANDROID_CONTROL_SCENE_MODE_DISABLED);

  update_static(ANDROID_CONTROL_AVAILABLE_EFFECTS,
                ANDROID_CONTROL_EFFECT_MODE_OFF);
  update_request(ANDROID_CONTROL_EFFECT_MODE, ANDROID_CONTROL_EFFECT_MODE_OFF);

  update_static(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
                ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE);

  update_static(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
                ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE);

  update_static(ANDROID_CONTROL_AVAILABLE_MODES,
                std::vector<uint8_t>{ANDROID_CONTROL_MODE_OFF,
                                     ANDROID_CONTROL_MODE_AUTO});

  // android.flash
  update_static(ANDROID_FLASH_INFO_AVAILABLE,
                ANDROID_FLASH_INFO_AVAILABLE_FALSE);
  update_request(ANDROID_FLASH_STATE, ANDROID_FLASH_STATE_UNAVAILABLE);
  update_request(ANDROID_FLASH_MODE, ANDROID_FLASH_MODE_OFF);

  // android.jpeg
  update_static(ANDROID_JPEG_MAX_SIZE, int32_t{13 << 20});
  update_request(ANDROID_JPEG_QUALITY, uint8_t{90});
  update_request(ANDROID_JPEG_THUMBNAIL_QUALITY, uint8_t{90});
  update_request(ANDROID_JPEG_ORIENTATION, int32_t{0});

  // android.lens
  // This should not be needed.
  update_static(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 0.0f);
  update_static(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
                ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF);
  update_request(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
                 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF);

  // android.noiseReduction
  update_static(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
                ANDROID_NOISE_REDUCTION_MODE_OFF);
  update_request(ANDROID_NOISE_REDUCTION_MODE,
                 ANDROID_NOISE_REDUCTION_MODE_OFF);

  // android.request
  update_static(ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
                ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE);
  update_static(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, int32_t{1});

  // This means pipeline latency of X frame intervals. The maximum number is 4.
  update_static(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, uint8_t{4});
  update_request(ANDROID_REQUEST_PIPELINE_DEPTH, uint8_t{4});

  // Three numbers represent the maximum numbers of different types of output
  // streams simultaneously. The types are raw sensor, processed (but not
  // stalling), and processed (but stalling). For usb limited mode, raw sensor
  // is not supported. Stalling stream is JPEG. Non-stalling streams are
  // YUV_420_888, NV21, or YV12.
  update_static(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
                std::vector<int32_t>{0, 2, 1});

  // Limited mode doesn't support reprocessing.
  update_static(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, int32_t{0});

  // android.scaler
  update_static(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, 1.0f);

  update_static(ANDROID_SCALER_CROPPING_TYPE,
                ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY);

  update_static(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
                std::vector<int32_t>{
                    ANDROID_SENSOR_TEST_PATTERN_MODE_OFF,
                    ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY});
  update_request(ANDROID_SENSOR_TEST_PATTERN_MODE,
                 ANDROID_SENSOR_TEST_PATTERN_MODE_OFF);

  uint8_t timestamp_source;
  if (V4L2CameraDevice::GetUvcClock() == CLOCK_BOOTTIME) {
    timestamp_source = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME;
  } else {
    timestamp_source = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
  }
  update_static(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, timestamp_source);

  // android.shading
  update_static(ANDROID_SHADING_AVAILABLE_MODES, ANDROID_SHADING_MODE_FAST);

  // android.statistics
  update_static(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
                ANDROID_STATISTICS_FACE_DETECT_MODE_OFF);
  update_request(ANDROID_STATISTICS_FACE_DETECT_MODE,
                 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF);

  update_static(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, int32_t{0});

  update_static(ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES,
                ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF);
  update_request(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
                 ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF);

  update_static(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
                ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);

  // android.sync
  update_static(ANDROID_SYNC_MAX_LATENCY, ANDROID_SYNC_MAX_LATENCY_UNKNOWN);

  return update_static.ok() && update_request.ok() ? 0 : -EINVAL;
}

int MetadataHandler::FillMetadataFromSupportedFormats(
    const SupportedFormats& supported_formats,
    const DeviceInfo& device_info,
    android::CameraMetadata* static_metadata,
    android::CameraMetadata* request_metadata) {
  bool is_external = device_info.lens_facing == LensFacing::kExternal;
  bool is_builtin = !is_external;
  bool is_v1_builtin = device_info.quirks & kQuirkV1Device;

  if (supported_formats.empty()) {
    return -EINVAL;
  }
  std::vector<int32_t> stream_configurations;
  std::vector<int64_t> min_frame_durations;
  std::vector<int64_t> stall_durations;

  // The min fps <= 15 must be supported in CTS.
  const int64_t kOneSecOfNanoUnit = 1000000000LL;
  int32_t max_fps = std::numeric_limits<int32_t>::min();
  int64_t max_frame_duration = kOneSecOfNanoUnit / kMinFps;
  std::set<int32_t> supported_fps;

  std::vector<int> hal_formats{HAL_PIXEL_FORMAT_BLOB,
                               HAL_PIXEL_FORMAT_YCbCr_420_888,
                               HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED};

  std::unordered_map<int, int> max_hal_width_by_format;
  std::unordered_map<int, int> max_hal_height_by_format;
  std::unique_ptr<CameraConfig> camera_config =
      CameraConfig::Create(constants::kCrosCameraConfigPathString);
  max_hal_width_by_format[HAL_PIXEL_FORMAT_BLOB] = camera_config->GetInteger(
      constants::kCrosMaxBlobWidth, std::numeric_limits<int>::max());
  max_hal_width_by_format[HAL_PIXEL_FORMAT_YCbCr_420_888] =
      camera_config->GetInteger(constants::kCrosMaxYuvWidth,
                                std::numeric_limits<int>::max());
  max_hal_width_by_format[HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED] =
      camera_config->GetInteger(constants::kCrosMaxPrivateWidth,
                                std::numeric_limits<int>::max());

  max_hal_height_by_format[HAL_PIXEL_FORMAT_BLOB] = camera_config->GetInteger(
      constants::kCrosMaxBlobHeight, std::numeric_limits<int>::max());
  max_hal_height_by_format[HAL_PIXEL_FORMAT_YCbCr_420_888] =
      camera_config->GetInteger(constants::kCrosMaxYuvHeight,
                                std::numeric_limits<int>::max());
  max_hal_height_by_format[HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED] =
      camera_config->GetInteger(constants::kCrosMaxPrivateHeight,
                                std::numeric_limits<int>::max());

  for (const auto& supported_format : supported_formats) {
    int64_t min_frame_duration = std::numeric_limits<int64_t>::max();
    int32_t per_format_max_fps = std::numeric_limits<int32_t>::min();
    for (const auto& frame_rate : supported_format.frame_rates) {
      // To prevent floating point precision problem we cast the floating point
      // to double here.
      int64_t frame_duration =
          kOneSecOfNanoUnit / static_cast<double>(frame_rate);
      if (frame_duration < min_frame_duration) {
        min_frame_duration = frame_duration;
      }
      if (frame_duration > max_frame_duration) {
        max_frame_duration = frame_duration;
      }
      if (per_format_max_fps < static_cast<int32_t>(frame_rate)) {
        per_format_max_fps = static_cast<int32_t>(frame_rate);
      }
      supported_fps.insert(frame_rate);
    }
    if (per_format_max_fps > max_fps) {
      max_fps = per_format_max_fps;
    }

    for (const auto& format : hal_formats) {
      if (is_builtin) {
        if (supported_format.width > max_hal_width_by_format[format]) {
          LOGF(INFO) << "Filter Format: 0x" << std::hex << format << std::dec
                     << "-width " << supported_format.width << ". max is "
                     << max_hal_width_by_format[format];
          continue;
        }
        if (supported_format.height > max_hal_height_by_format[format]) {
          LOGF(INFO) << "Filter Format: 0x" << std::hex << format << std::dec
                     << "-height " << supported_format.height << ". max is "
                     << max_hal_height_by_format[format];
          continue;
        }
        if (format != HAL_PIXEL_FORMAT_BLOB && per_format_max_fps < 30) {
          continue;
        }
      }

      stream_configurations.push_back(format);
      stream_configurations.push_back(supported_format.width);
      stream_configurations.push_back(supported_format.height);
      stream_configurations.push_back(
          ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT);

      min_frame_durations.push_back(format);
      min_frame_durations.push_back(supported_format.width);
      min_frame_durations.push_back(supported_format.height);
      min_frame_durations.push_back(min_frame_duration);
    }

    // The stall duration is 0 for non-jpeg formats. For JPEG format, stall
    // duration can be 0 if JPEG is small. 5MP JPEG takes 700ms to decode
    // and encode. Here we choose 1 sec for JPEG.
    for (const auto& format : hal_formats) {
      // For non-jpeg formats, the camera orientation workaround crops,
      // rotates, and scales the frames. Theoretically the stall duration of
      // huge resolution may be bigger than 0. Set it to 0 for now.
      int64_t stall_duration =
          (format == HAL_PIXEL_FORMAT_BLOB) ? 1000000000 : 0;
      stall_durations.push_back(format);
      stall_durations.push_back(supported_format.width);
      stall_durations.push_back(supported_format.height);
      stall_durations.push_back(stall_duration);
    }
  }

  MetadataUpdater update_static(static_metadata);
  MetadataUpdater update_request(request_metadata);

  // The document in aeAvailableTargetFpsRanges section says the min fps should
  // not be larger than 15.
  // We enumerate all possible fps and put (min, fps) as available fps range. If
  // the device support constant frame rate, put (fps, fps) into the list as
  // well.
  // TODO(wtlee): Handle non-integer fps when setting controls.
  bool support_constant_framerate = !device_info.constant_framerate_unsupported;
  std::vector<int32_t> available_fps_ranges;

  // For devices that cannot actually meet the fps ranges they report, only
  // report (min, max) and optional (max, max) if they support constant frame
  // rate.
  if (device_info.quirks & kQuirkReportLeastFpsRanges) {
    available_fps_ranges.push_back(kMinFps);
    available_fps_ranges.push_back(max_fps);

    if (support_constant_framerate) {
      available_fps_ranges.push_back(max_fps);
      available_fps_ranges.push_back(max_fps);
    }
  } else {
    for (auto fps : supported_fps) {
      // The IsFpsRangeSupported() filter should only apply on built-in
      // cameras, otherwise some webcams with fps combinations that cannot be
      // represented in HALv3 API would stop working (b/171845790).
      if (is_external || IsFpsRangeSupported(supported_formats, kMinFps, fps)) {
        available_fps_ranges.push_back(kMinFps);
        available_fps_ranges.push_back(fps);
      }

      if (support_constant_framerate &&
          (is_external || IsFpsRangeSupported(supported_formats, fps, fps))) {
        available_fps_ranges.push_back(fps);
        available_fps_ranges.push_back(fps);
      }
    }
  }
  update_static(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
                available_fps_ranges);
  update_static(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
                stream_configurations);
  update_static(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
                min_frame_durations);
  update_static(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, stall_durations);

  std::vector<int32_t> jpeg_available_thumbnail_sizes =
      GetJpegAvailableThumbnailSizes(supported_formats);
  update_static(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
                jpeg_available_thumbnail_sizes);
  update_request(ANDROID_JPEG_THUMBNAIL_SIZE,
                 std::vector<int32_t>(jpeg_available_thumbnail_sizes.end() - 2,
                                      jpeg_available_thumbnail_sizes.end()));
  update_static(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, max_frame_duration);

  const Size max_dimensions = GetMaxDimensions(supported_formats);
  std::vector<int32_t> active_array_size(4);
  if (device_info.sensor_info_active_array_size.is_valid()) {
    const Rect<int32_t>& rect = device_info.sensor_info_active_array_size;
    if (rect.width() < max_dimensions.width ||
        rect.height() < max_dimensions.height) {
      LOGF(ERROR) << "Sensor active array size (" << rect.width() << "x"
                  << rect.height()
                  << ") is smaller than max supported format dimensions ("
                  << max_dimensions.width << "x" << max_dimensions.height
                  << ")";
      return -EINVAL;
    }
    active_array_size[0] = rect.left;
    active_array_size[1] = rect.top;
    active_array_size[2] = rect.right;
    active_array_size[3] = rect.bottom;
  } else {
    active_array_size[0] = 0;
    active_array_size[1] = 0;
    active_array_size[2] = static_cast<int32_t>(max_dimensions.width);
    active_array_size[3] = static_cast<int32_t>(max_dimensions.height);
  }
  update_static(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,
                active_array_size);
  update_static(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, active_array_size);

  if (is_v1_builtin) {
    if (FillSensorInfo(device_info, static_metadata,
                       static_cast<int32_t>(max_dimensions.width),
                       static_cast<int32_t>(max_dimensions.height)) != 0) {
      LOGF(ERROR) << "Failed to fill sensor info for v1 built-in camera";
      return -EINVAL;
    }
  } else if (is_external) {
    // It's a sensible value for external camera, since it's required on all
    // devices per spec. For built-in camera, this would be filled in
    // FillMetadataFromDeviceInfo() or FillSensorInfo() using the value from the
    // configuration file.
    //
    // The official document for this field:
    // https://developer.android.com/reference/android/hardware/camera2/CameraCharacteristics.html#SENSOR_INFO_PIXEL_ARRAY_SIZE
    update_static(
        ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
        std::vector<int32_t>{static_cast<int32_t>(max_dimensions.width),
                             static_cast<int32_t>(max_dimensions.height)});
  }

  return update_static.ok() && update_request.ok() ? 0 : -EINVAL;
}

// static
AwbModeToTemperatureMap MetadataHandler::GetAvailableAwbTemperatures(
    const DeviceInfo& device_info) {
  AwbModeToTemperatureMap available_awb_temperatures;

  available_awb_temperatures[ANDROID_CONTROL_AWB_MODE_AUTO] =
      kColorTemperatureAuto;

  if (!V4L2CameraDevice::IsControlSupported(device_info.device_path,
                                            kControlAutoWhiteBalance))
    return available_awb_temperatures;

  ControlInfo info;
  if (V4L2CameraDevice::QueryControl(
          device_info.device_path, kControlWhiteBalanceTemperature, &info) != 0)
    return available_awb_temperatures;

  for (auto& mode_temperature : GetAwbModeTemperatureMap()) {
    uint32_t temperature =
        GetAwbTemperatureByMode(info.range, mode_temperature.first);
    if (!temperature)
      continue;
    available_awb_temperatures[mode_temperature.first] = temperature;
  }

  return available_awb_temperatures;
}

// static
int MetadataHandler::FillMetadataFromDeviceInfo(
    const DeviceInfo& device_info,
    android::CameraMetadata* static_metadata,
    android::CameraMetadata* request_metadata) {
  MetadataUpdater update_static(static_metadata);
  MetadataUpdater update_request(request_metadata);

  bool is_external = device_info.lens_facing == LensFacing::kExternal;
  bool is_builtin = !is_external;
  bool is_v1_builtin = device_info.quirks & kQuirkV1Device;
  bool is_v3_builtin = is_builtin && !is_v1_builtin;

  std::vector<int32_t> available_request_keys = {
      ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
      ANDROID_CONTROL_AE_ANTIBANDING_MODE,
      ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
      ANDROID_CONTROL_AE_LOCK,
      ANDROID_CONTROL_AE_MODE,
      ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
      ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
      ANDROID_CONTROL_AF_MODE,
      ANDROID_CONTROL_AF_TRIGGER,
      ANDROID_CONTROL_AWB_LOCK,
      ANDROID_CONTROL_AWB_MODE,
      ANDROID_CONTROL_CAPTURE_INTENT,
      ANDROID_CONTROL_EFFECT_MODE,
      ANDROID_CONTROL_MODE,
      ANDROID_CONTROL_SCENE_MODE,
      ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
      ANDROID_FLASH_MODE,
      ANDROID_JPEG_ORIENTATION,
      ANDROID_JPEG_QUALITY,
      ANDROID_JPEG_THUMBNAIL_QUALITY,
      ANDROID_JPEG_THUMBNAIL_SIZE,
      ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
      ANDROID_NOISE_REDUCTION_MODE,
      ANDROID_SCALER_CROP_REGION,
      ANDROID_SENSOR_TEST_PATTERN_MODE,
      ANDROID_STATISTICS_FACE_DETECT_MODE,
      ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
  };
  if (is_builtin) {
    available_request_keys.insert(available_request_keys.end(),
                                  {
                                      ANDROID_LENS_APERTURE,
                                      ANDROID_LENS_FOCAL_LENGTH,
                                      ANDROID_LENS_FOCUS_DISTANCE,
                                  });
  }

  // TODO(shik): All properties listed for capture requests can also be queried
  // on the capture result, to determine the final values used for capture. We
  // shuold build this list from |available_request_keys|.
  // ref:
  // https://developer.android.com/reference/android/hardware/camera2/CaptureResult
  std::vector<int32_t> available_result_keys = {
      ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
      ANDROID_CONTROL_AE_ANTIBANDING_MODE,
      ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
      ANDROID_CONTROL_AE_LOCK,
      ANDROID_CONTROL_AE_MODE,
      ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
      ANDROID_CONTROL_AE_STATE,
      ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
      ANDROID_CONTROL_AF_MODE,
      ANDROID_CONTROL_AF_STATE,
      ANDROID_CONTROL_AF_TRIGGER,
      ANDROID_CONTROL_AWB_LOCK,
      ANDROID_CONTROL_AWB_MODE,
      ANDROID_CONTROL_AWB_STATE,
      ANDROID_CONTROL_CAPTURE_INTENT,
      ANDROID_CONTROL_EFFECT_MODE,
      ANDROID_CONTROL_MODE,
      ANDROID_CONTROL_SCENE_MODE,
      ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
      ANDROID_FLASH_MODE,
      ANDROID_FLASH_STATE,
      ANDROID_JPEG_ORIENTATION,
      ANDROID_JPEG_QUALITY,
      ANDROID_JPEG_THUMBNAIL_QUALITY,
      ANDROID_JPEG_THUMBNAIL_SIZE,
      ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
      ANDROID_LENS_STATE,
      ANDROID_NOISE_REDUCTION_MODE,
      ANDROID_REQUEST_PIPELINE_DEPTH,
      ANDROID_SCALER_CROP_REGION,
      ANDROID_SENSOR_EXPOSURE_TIME,
      ANDROID_SENSOR_ROLLING_SHUTTER_SKEW,
      ANDROID_SENSOR_TEST_PATTERN_MODE,
      ANDROID_SENSOR_TIMESTAMP,
      ANDROID_STATISTICS_FACE_DETECT_MODE,
      ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
      ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
      ANDROID_STATISTICS_SCENE_FLICKER,
  };
  if (is_builtin) {
    available_result_keys.insert(available_result_keys.end(),
                                 {
                                     ANDROID_LENS_APERTURE,
                                     ANDROID_LENS_FOCAL_LENGTH,
                                     ANDROID_LENS_FOCUS_DISTANCE,
                                 });
  }

  // TODO(shik): The HAL must not have any tags in its static info that are not
  // listed either here or in the vendor tag list.  Some request/result metadata
  // entries are also presented in the static info now, and we should fix it.
  // ref:
  // https://android.googlesource.com/platform/system/media/+/a8cff157ff0ed02fa7e29438f4889a9933c37768/camera/docs/docs.html#16298
  std::vector<int32_t> available_characteristics_keys = {
      ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
      ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
      ANDROID_CONTROL_AE_AVAILABLE_MODES,
      ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
      ANDROID_CONTROL_AE_COMPENSATION_RANGE,
      ANDROID_CONTROL_AE_COMPENSATION_STEP,
      ANDROID_CONTROL_AE_LOCK_AVAILABLE,
      ANDROID_CONTROL_AF_AVAILABLE_MODES,
      ANDROID_CONTROL_AVAILABLE_EFFECTS,
      ANDROID_CONTROL_AVAILABLE_MODES,
      ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
      ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
      ANDROID_CONTROL_AWB_AVAILABLE_MODES,
      ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
      ANDROID_CONTROL_MAX_REGIONS,
      ANDROID_FLASH_INFO_AVAILABLE,
      ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
      ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
      ANDROID_JPEG_MAX_SIZE,
      ANDROID_LENS_FACING,
      ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
      ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
      ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
      ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
      ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
      ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
      ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS,
      ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
      ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
      ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
      ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
      ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
      ANDROID_SCALER_CROPPING_TYPE,
      ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
      ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
      ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
      ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
      ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,
      ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
      ANDROID_SENSOR_ORIENTATION,
      ANDROID_SHADING_AVAILABLE_MODES,
      ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
      ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES,
      ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
      ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
      ANDROID_SYNC_MAX_LATENCY,
  };
  if (is_builtin) {
    if (!device_info.lens_info_available_apertures.empty()) {
      // This field is optional. Only list it if it presents in the
      // configuration.
      available_characteristics_keys.insert(
          available_characteristics_keys.end(),
          {
              ANDROID_LENS_INFO_AVAILABLE_APERTURES,
          });
    }
    available_characteristics_keys.insert(
        available_characteristics_keys.end(),
        {
            ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
            ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
        });
  }

  update_static(ANDROID_SENSOR_ORIENTATION, device_info.sensor_orientation);
  update_static(ANDROID_LENS_FACING,
                static_cast<uint8_t>(device_info.lens_facing));

  if (is_v3_builtin) {
    update_static(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
                  ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED);

    update_static(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
                  device_info.lens_info_available_apertures);

    update_request(ANDROID_LENS_APERTURE,
                   device_info.lens_info_available_apertures[0]);

    update_static(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
                  device_info.lens_info_available_focal_lengths);

    update_request(ANDROID_LENS_FOCAL_LENGTH,
                   device_info.lens_info_available_focal_lengths[0]);

    update_static(
        ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
        std::vector<float>{device_info.sensor_info_physical_size_width,
                           device_info.sensor_info_physical_size_height});
    update_static(
        ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
        std::vector<int32_t>{device_info.sensor_info_pixel_array_size_width,
                             device_info.sensor_info_pixel_array_size_height});
  } else if (is_v1_builtin) {
    update_static(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
                  ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL);

    if (device_info.lens_info_available_apertures.size() > 0) {
      update_static(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
                    device_info.lens_info_available_apertures);
      update_request(ANDROID_LENS_APERTURE,
                     device_info.lens_info_available_apertures[0]);
    }

    if (device_info.lens_info_available_focal_lengths.size() > 0) {
      update_static(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
                    device_info.lens_info_available_focal_lengths);
      update_request(ANDROID_LENS_FOCAL_LENGTH,
                     device_info.lens_info_available_focal_lengths[0]);
    } else {
      update_static(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
                    kDefaultAvailableFocalLength);
      update_request(ANDROID_LENS_FOCAL_LENGTH, kDefaultAvailableFocalLength);
    }

    if (device_info.sensor_info_pixel_array_size_width > 0 &&
        device_info.sensor_info_pixel_array_size_height > 0) {
      update_static(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
                    std::vector<int32_t>{
                        device_info.sensor_info_pixel_array_size_width,
                        device_info.sensor_info_pixel_array_size_height});
    }
    // For |sensor_info_physical_size|, fill them later with supported formats
    // information.
  } else {
    update_static(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
                  ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL);
  }

  update_static(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
                ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO);
  update_request(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
                 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO);

  // Set vendor tags for specified boards.
  if (device_info.quirks & kQuirkMonocle) {
    int32_t timestamp_sync =
        static_cast<int32_t>(mojom::CameraSensorSyncTimestamp::NEAREST);
    update_static(kVendorTagTimestampSync, timestamp_sync);
  }

  ControlInfo info;

  if (V4L2CameraDevice::QueryControl(device_info.device_path,
                                     kControlBrightness, &info) == 0) {
    update_static(kVendorTagControlBrightnessRange,
                  std::vector<int32_t>{info.range.minimum, info.range.maximum,
                                       info.range.step});
  }

  if (V4L2CameraDevice::QueryControl(device_info.device_path, kControlContrast,
                                     &info) == 0) {
    update_static(kVendorTagControlContrastRange,
                  std::vector<int32_t>{info.range.minimum, info.range.maximum,
                                       info.range.step});
  }

  if (V4L2CameraDevice::QueryControl(device_info.device_path, kControlPan,
                                     &info) == 0) {
    update_static(kVendorTagControlPanRange,
                  std::vector<int32_t>{info.range.minimum, info.range.maximum,
                                       info.range.step});
  }

  if (V4L2CameraDevice::QueryControl(device_info.device_path,
                                     kControlSaturation, &info) == 0) {
    update_static(kVendorTagControlSaturationRange,
                  std::vector<int32_t>{info.range.minimum, info.range.maximum,
                                       info.range.step});
  }

  if (V4L2CameraDevice::QueryControl(device_info.device_path, kControlSharpness,
                                     &info) == 0) {
    update_static(kVendorTagControlSharpnessRange,
                  std::vector<int32_t>{info.range.minimum, info.range.maximum,
                                       info.range.step});
  }

  if (V4L2CameraDevice::QueryControl(device_info.device_path, kControlTilt,
                                     &info) == 0) {
    update_static(kVendorTagControlTiltRange,
                  std::vector<int32_t>{info.range.minimum, info.range.maximum,
                                       info.range.step});
  }

  if (V4L2CameraDevice::QueryControl(device_info.device_path, kControlZoom,
                                     &info) == 0) {
    update_static(kVendorTagControlZoomRange,
                  std::vector<int32_t>{info.range.minimum, info.range.maximum,
                                       info.range.step});
  }

  std::vector<uint8_t> available_awb_modes;
  for (auto const& it : GetAvailableAwbTemperatures(device_info))
    available_awb_modes.push_back(it.first);

  update_static(ANDROID_CONTROL_AWB_AVAILABLE_MODES, available_awb_modes);

  // Check if device supports manual exposure control.
  ControlRange range;
  if (V4L2CameraDevice::IsManualExposureTimeSupported(device_info.device_path,
                                                      &range)) {
    update_static(ANDROID_CONTROL_AE_AVAILABLE_MODES,
                  std::vector<uint8_t>{ANDROID_CONTROL_AE_MODE_OFF,
                                       ANDROID_CONTROL_AE_MODE_ON});
    // The unit of the range is 100 us.
    update_static(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
                  std::vector<int64_t>{
                      range.minimum * 100 * 1000 /* ns */,
                      range.maximum * 100 * 1000 /* ns */
                  });
    // CtsCameraTestCases needs it. This control is only effective if
    // android.control.aeMode is set to OFF.
    update_request(
        ANDROID_SENSOR_EXPOSURE_TIME,
        static_cast<int64_t>(range.default_value) * 100 * 1000 /* ns */);
    available_characteristics_keys.push_back(
        ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE);
    available_request_keys.push_back(ANDROID_SENSOR_EXPOSURE_TIME);
  }

  // The unit of V4L2 focus distance is undefined, so set it to uncalibrated.
  update_static(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
                ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED);
  if (V4L2CameraDevice::IsControlSupported(device_info.device_path,
                                           kControlFocusAuto)) {
    update_static(ANDROID_CONTROL_AF_AVAILABLE_MODES,
                  std::vector<uint8_t>{ANDROID_CONTROL_AF_MODE_OFF,
                                       ANDROID_CONTROL_AF_MODE_AUTO});
    update_request(ANDROID_CONTROL_AF_MODE, ANDROID_CONTROL_AF_MODE_AUTO);
    update_request(ANDROID_LENS_FOCUS_DISTANCE, 0.0f);
    if (V4L2CameraDevice::IsFocusDistanceSupported(device_info.device_path,
                                                   &range)) {
      float full_range = range.maximum - range.minimum;
      uint32_t factor = GetNormalizeFactorForV4l2FocusRange(full_range);
      update_static(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
                    full_range / factor);
    } else {
      if (device_info.lens_info_minimum_focus_distance > 0) {
        update_static(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
                      1.0f / device_info.lens_info_minimum_focus_distance);
      } else {
        update_static(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
                      1.0f / kDefaultMinimumFocusDistance);
      }
    }
  } else {
    update_static(ANDROID_CONTROL_AF_AVAILABLE_MODES,
                  ANDROID_CONTROL_AF_MODE_OFF);
    update_request(ANDROID_CONTROL_AF_MODE, ANDROID_CONTROL_AF_MODE_OFF);
    update_static(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0.0f);
  }

  update_static(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
                available_characteristics_keys);
  update_static(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, available_request_keys);
  update_static(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, available_result_keys);
  return update_static.ok() && update_request.ok() ? 0 : -EINVAL;
}

int MetadataHandler::FillSensorInfo(const DeviceInfo& device_info,
                                    android::CameraMetadata* metadata,
                                    int32_t array_width,
                                    int32_t array_height) {
  MetadataUpdater update_static(metadata);

  if (device_info.sensor_info_pixel_array_size_width <= 0 ||
      device_info.sensor_info_pixel_array_size_height <= 0) {
    update_static(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
                  std::vector<int32_t>{array_width, array_height});
  }

  float focal_length = device_info.lens_info_available_focal_lengths.size() > 0
                           ? device_info.lens_info_available_focal_lengths[0]
                           : kDefaultAvailableFocalLength;

  float aspect_ratio = 1.f * array_width / array_height;
  bool is_closer_to_16_9 = std::fabs(aspect_ratio - 16.f / 9.f) <
                           std::fabs(aspect_ratio - 4.f / 3.f);
  bool has_fov_info_16_9 = device_info.horizontal_view_angle_16_9 > 0.f &&
                           device_info.vertical_view_angle_16_9 > 0.f;
  bool has_fov_info_4_3 = device_info.horizontal_view_angle_4_3 > 0.f &&
                          device_info.vertical_view_angle_4_3 > 0.f;

  // Use the FOV information (16:9 or 4:3) whose aspect ratio is closer to the
  // ratio of sensor array size to calculate the sensor physical size.
  if (has_fov_info_16_9 && (is_closer_to_16_9 || !has_fov_info_4_3)) {
    update_static(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
                  GetPhysicalSize(device_info.horizontal_view_angle_16_9,
                                  device_info.vertical_view_angle_16_9,
                                  focal_length, aspect_ratio, 16.f / 9.f));
  } else if (has_fov_info_4_3) {
    update_static(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
                  GetPhysicalSize(device_info.horizontal_view_angle_4_3,
                                  device_info.vertical_view_angle_4_3,
                                  focal_length, aspect_ratio, 4.f / 3.f));
  } else if (device_info.sensor_info_physical_size_width > 0.f &&
             device_info.sensor_info_physical_size_height > 0.f) {
    // Since the sensor physical size might be incorrect, only use these values
    // when there are no view angle information.
    update_static(
        ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
        std::vector<float>{device_info.sensor_info_physical_size_width,
                           device_info.sensor_info_physical_size_height});
  } else {
    LOGF(ERROR)
        << "Neither sensor physical size nor view angle information is found";
    return -EINVAL;
  }
  return update_static.ok() ? 0 : -EINVAL;
}

const camera_metadata_t* MetadataHandler::GetDefaultRequestSettings(
    int template_type) {
  if (!IsValidTemplateType(template_type)) {
    LOGF(ERROR) << "Invalid template request type: " << template_type;
    return nullptr;
  }
  return template_settings_[template_type].get();
}

bool MetadataHandler::ShouldEnableConstantFrameRate(
    const android::CameraMetadata* metadata) const {
  if (device_info_.constant_framerate_unsupported) {
    return false;
  }

  // TODO(shik): Add a helper function to do the exists() and find() combo, so
  // it's less likely to have typos in the tag name.

  if (metadata->exists(ANDROID_CONTROL_AE_TARGET_FPS_RANGE)) {
    camera_metadata_ro_entry entry =
        metadata->find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE);
    if (entry.data.i32[0] == entry.data.i32[1]) {
      return true;
    }
  }

  if (metadata->exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
    camera_metadata_ro_entry entry =
        metadata->find(ANDROID_CONTROL_CAPTURE_INTENT);
    switch (entry.data.u8[0]) {
      case ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD:
      case ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT:
        return true;
    }
  }

  return false;
}

int MetadataHandler::PreHandleRequest(int frame_number,
                                      const Size& resolution,
                                      android::CameraMetadata* metadata) {
  DCHECK(thread_checker_.CalledOnValidThread());
  MetadataUpdater update_request(metadata);

  if (!device_info_.constant_framerate_unsupported) {
    bool enable = ShouldEnableConstantFrameRate(metadata);
    if (device_->SetControlValue(kControlExposureAutoPriority,
                                 enable ? 0 : 1) != 0) {
      LOGF(WARNING) << "Failed to set constant frame rate to " << std::boolalpha
                    << enable;
    }
  }

  if (metadata->exists(ANDROID_CONTROL_AF_TRIGGER)) {
    camera_metadata_entry entry = metadata->find(ANDROID_CONTROL_AF_TRIGGER);
    if (entry.data.u8[0] == ANDROID_CONTROL_AF_TRIGGER_START) {
      af_trigger_ = true;
    } else if (entry.data.u8[0] == ANDROID_CONTROL_AF_TRIGGER_CANCEL) {
      af_trigger_ = false;
    }
  }

  if (metadata->exists(ANDROID_CONTROL_AF_MODE)) {
    camera_metadata_entry entry = metadata->find(ANDROID_CONTROL_AF_MODE);
    if (entry.data.u8[0] == ANDROID_CONTROL_AF_MODE_OFF) {
      if (metadata->exists(ANDROID_LENS_FOCUS_DISTANCE) &&
          focus_distance_normalize_factor_ > 0) {
        entry = metadata->find(ANDROID_LENS_FOCUS_DISTANCE);
        int32_t distance =
            static_cast<int32_t>(entry.data.f[0] *
                                 focus_distance_normalize_factor_) +
            focus_distance_range_.minimum;
        distance = std::min(distance, focus_distance_range_.maximum);
        device_->SetAutoFocus(false);
        device_->SetFocusDistance(distance);
        int32_t focus_distance;
        device_->GetControlValue(kControlFocusDistance, &focus_distance);
        float simulate_diopters =
            static_cast<float>(focus_distance - focus_distance_range_.minimum) /
            focus_distance_normalize_factor_;
        update_request(ANDROID_LENS_FOCUS_DISTANCE, simulate_diopters);
      } else {
        device_->SetAutoFocus(false);
      }
    } else if (entry.data.u8[0] == ANDROID_CONTROL_AF_MODE_AUTO) {
      device_->SetAutoFocus(true);
      float diopters;
      if (device_info_.lens_info_optimal_focus_distance > 0) {
        diopters = 1.0 / device_info_.lens_info_optimal_focus_distance;
      } else {
        diopters = 1.0 / kDefaultLensFocusDistance;
      }
      update_request(ANDROID_LENS_FOCUS_DISTANCE, diopters);
    }
  }

  if (is_awb_control_supported_ && metadata->exists(ANDROID_CONTROL_AWB_MODE)) {
    camera_metadata_entry entry = metadata->find(ANDROID_CONTROL_AWB_MODE);
    auto mode = static_cast<camera_metadata_enum_android_control_awb_mode>(
        entry.data.u8[0]);
    if (awb_temperature_.count(mode))
      device_->SetColorTemperature(awb_temperature_[mode]);
    else
      LOGF(WARNING) << "Unsupported AWB mode:" << mode;
  }

  const int64_t rolling_shutter_skew =
      sensor_handler_->GetRollingShutterSkew(resolution);
  update_request(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, rolling_shutter_skew);

  if (metadata->exists(kVendorTagControlBrightness)) {
    camera_metadata_entry entry = metadata->find(kVendorTagControlBrightness);
    device_->SetControlValue(kControlBrightness, entry.data.i32[0]);
  }

  if (metadata->exists(kVendorTagControlContrast)) {
    camera_metadata_entry entry = metadata->find(kVendorTagControlContrast);
    device_->SetControlValue(kControlContrast, entry.data.i32[0]);
  }

  if (metadata->exists(kVendorTagControlPan)) {
    camera_metadata_entry entry = metadata->find(kVendorTagControlPan);
    device_->SetControlValue(kControlPan, entry.data.i32[0]);
  }

  if (metadata->exists(kVendorTagControlSaturation)) {
    camera_metadata_entry entry = metadata->find(kVendorTagControlSaturation);
    device_->SetControlValue(kControlSaturation, entry.data.i32[0]);
  }

  if (metadata->exists(kVendorTagControlSharpness)) {
    camera_metadata_entry entry = metadata->find(kVendorTagControlSharpness);
    device_->SetControlValue(kControlSharpness, entry.data.i32[0]);
  }

  if (metadata->exists(kVendorTagControlTilt)) {
    camera_metadata_entry entry = metadata->find(kVendorTagControlTilt);
    device_->SetControlValue(kControlTilt, entry.data.i32[0]);
  }

  if (metadata->exists(kVendorTagControlZoom)) {
    camera_metadata_entry entry = metadata->find(kVendorTagControlZoom);
    device_->SetControlValue(kControlZoom, entry.data.i32[0]);
  }

  if (metadata->exists(ANDROID_CONTROL_AE_MODE)) {
    camera_metadata_entry entry = metadata->find(ANDROID_CONTROL_AE_MODE);
    int32_t exposure_time;
    switch (entry.data.u8[0]) {
      case ANDROID_CONTROL_AE_MODE_ON:
        device_->SetExposureTimeHundredUs(kExposureTimeAuto);
        update_request(ANDROID_SENSOR_EXPOSURE_TIME,
                       sensor_handler_->GetExposureTime(resolution));
        break;

      case ANDROID_CONTROL_AE_MODE_OFF:
        if (metadata->exists(ANDROID_SENSOR_EXPOSURE_TIME)) {
          entry = metadata->find(ANDROID_SENSOR_EXPOSURE_TIME);
          exposure_time =
              static_cast<int32_t>(entry.data.i64[0] / (100 * 1000));  // ns
          device_->SetExposureTimeHundredUs(exposure_time);
          device_->GetControlValue(kControlExposureTime, &exposure_time);
          update_request(
              ANDROID_SENSOR_EXPOSURE_TIME,
              base::strict_cast<int64_t>(exposure_time) * 100 * 1000);  // ns
        } else {
          LOGF(WARNING) << "There is no ANDROID_SENSOR_EXPOSURE_TIME metadata";
        }
        break;

      default:
        LOGF(WARNING) << "Unsupport AE mode " << entry.data.u8[0];
        break;
    }
  }

  current_frame_number_ = frame_number;
  return 0;
}

int MetadataHandler::PostHandleRequest(int frame_number,
                                       int64_t timestamp,
                                       android::CameraMetadata* metadata) {
  DCHECK(thread_checker_.CalledOnValidThread());
  if (current_frame_number_ != frame_number) {
    LOGF(ERROR)
        << "Frame number mismatch in PreHandleRequest and PostHandleRequest";
    return -EINVAL;
  }

  MetadataUpdater update_request(metadata);
  // android.control
  // For USB camera, we don't know the AE state. Set the state to converged to
  // indicate the frame should be good to use. Then apps don't have to wait the
  // AE state.
  update_request(ANDROID_CONTROL_AE_STATE, ANDROID_CONTROL_AE_STATE_CONVERGED);
  update_request(ANDROID_CONTROL_AE_LOCK, ANDROID_CONTROL_AE_LOCK_OFF);

  // For USB camera, the USB camera handles everything and we don't have control
  // over AF. We only simply fake the AF metadata based on the request
  // received here.
  uint8_t af_state;
  if (af_trigger_) {
    af_state = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
  } else {
    af_state = ANDROID_CONTROL_AF_STATE_INACTIVE;
  }
  update_request(ANDROID_CONTROL_AF_STATE, af_state);

  // Set AWB state to converged to indicate the frame should be good to use.
  update_request(ANDROID_CONTROL_AWB_STATE,
                 ANDROID_CONTROL_AWB_STATE_CONVERGED);

  update_request(ANDROID_CONTROL_AWB_LOCK, ANDROID_CONTROL_AWB_LOCK_OFF);

  camera_metadata_entry active_array_size =
      static_metadata_.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);

  if (active_array_size.count == 0) {
    LOGF(ERROR) << "Active array size is not found.";
    return -EINVAL;
  }

  // android.lens
  // Since android.lens.focalLength, android.lens.focusDistance and
  // android.lens.aperture are all fixed. And we don't support
  // android.lens.filterDensity so we can set the state to stationary.
  update_request(ANDROID_LENS_STATE, ANDROID_LENS_STATE_STATIONARY);

  // android.scaler
  update_request(ANDROID_SCALER_CROP_REGION, std::vector<int32_t>{
                                                 active_array_size.data.i32[0],
                                                 active_array_size.data.i32[1],
                                                 active_array_size.data.i32[2],
                                                 active_array_size.data.i32[3],
                                             });

  // android.sensor
  update_request(ANDROID_SENSOR_TIMESTAMP, timestamp);

  // android.statistics
  update_request(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
                 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);

  update_request(ANDROID_STATISTICS_SCENE_FLICKER,
                 ANDROID_STATISTICS_SCENE_FLICKER_NONE);

  int32_t value;
  if (is_brightness_control_supported_ &&
      device_->GetControlValue(kControlBrightness, &value) == 0)
    update_request(kVendorTagControlBrightness, value);

  if (is_contrast_control_supported_ &&
      device_->GetControlValue(kControlContrast, &value) == 0)
    update_request(kVendorTagControlContrast, value);

  if (is_pan_control_supported_ &&
      device_->GetControlValue(kControlPan, &value) == 0)
    update_request(kVendorTagControlPan, value);

  if (is_saturation_control_supported_ &&
      device_->GetControlValue(kControlSaturation, &value) == 0)
    update_request(kVendorTagControlSaturation, value);

  if (is_sharpness_control_supported_ &&
      device_->GetControlValue(kControlSharpness, &value) == 0)
    update_request(kVendorTagControlSharpness, value);

  if (is_tilt_control_supported_ &&
      device_->GetControlValue(kControlTilt, &value) == 0)
    update_request(kVendorTagControlTilt, value);

  if (is_zoom_control_supported_ &&
      device_->GetControlValue(kControlZoom, &value) == 0)
    update_request(kVendorTagControlZoom, value);

  if (metadata->exists(ANDROID_CONTROL_AWB_MODE)) {
    update_request(ANDROID_CONTROL_AWB_MODE, ANDROID_CONTROL_AWB_MODE_AUTO);
    if (is_awb_control_supported_ &&
        device_->GetControlValue(kControlAutoWhiteBalance, &value) == 0) {
      if (!value &&  // Not auto white balance.
          device_->GetControlValue(kControlWhiteBalanceTemperature, &value) ==
              0) {
        for (auto& mode_temperature : awb_temperature_) {
          if (value == mode_temperature.second) {
            update_request(ANDROID_CONTROL_AWB_MODE, mode_temperature.first);
            break;
          }
        }
      }
    }
  }

  return 0;
}

bool MetadataHandler::IsValidTemplateType(int template_type) {
  return template_type > 0 && template_type < CAMERA3_TEMPLATE_COUNT;
}

ScopedCameraMetadata MetadataHandler::CreateDefaultRequestSettings(
    int template_type) {
  android::CameraMetadata data(request_template_);

  int ret;
  switch (template_type) {
    case CAMERA3_TEMPLATE_PREVIEW:
      ret = FillDefaultPreviewSettings(&data);
      break;
    case CAMERA3_TEMPLATE_STILL_CAPTURE:
      ret = FillDefaultStillCaptureSettings(&data);
      break;
    case CAMERA3_TEMPLATE_VIDEO_RECORD:
      ret = FillDefaultVideoRecordSettings(&data);
      break;
    case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
      ret = FillDefaultVideoSnapshotSettings(&data);
      break;
    case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
      ret = FillDefaultZeroShutterLagSettings(&data);
      break;
    case CAMERA3_TEMPLATE_MANUAL:
      ret = FillDefaultManualSettings(&data);
      break;
    default:
      LOGF(ERROR) << "Invalid template request type: " << template_type;
      return NULL;
  }

  if (ret) {
    return ScopedCameraMetadata();
  }
  return ScopedCameraMetadata(data.release());
}

int MetadataHandler::FillDefaultPreviewSettings(
    android::CameraMetadata* metadata) {
  MetadataUpdater update_request(metadata);

  // android.control
  update_request(ANDROID_CONTROL_CAPTURE_INTENT,
                 ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW);
  update_request(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
                 std::vector<int32_t>{kMinFps, max_supported_fps_});
  update_request(ANDROID_CONTROL_MODE, ANDROID_CONTROL_MODE_AUTO);

  // android.jpeg
  update_request(ANDROID_JPEG_THUMBNAIL_SIZE, std::vector<int32_t>{0, 0});
  return 0;
}

int MetadataHandler::FillDefaultStillCaptureSettings(
    android::CameraMetadata* metadata) {
  MetadataUpdater update_request(metadata);

  // android.colorCorrection
  update_request(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
                 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY);

  // android.control
  update_request(ANDROID_CONTROL_CAPTURE_INTENT,
                 ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE);
  update_request(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
                 std::vector<int32_t>{kMinFps, max_supported_fps_});

  update_request(ANDROID_CONTROL_MODE, ANDROID_CONTROL_MODE_AUTO);
  return 0;
}

int MetadataHandler::FillDefaultVideoRecordSettings(
    android::CameraMetadata* metadata) {
  MetadataUpdater update_request(metadata);

  // android.control
  update_request(ANDROID_CONTROL_CAPTURE_INTENT,
                 ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD);
  if (device_info_.constant_framerate_unsupported) {
    update_request(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
                   std::vector<int32_t>{kMinFps, max_supported_fps_});
  } else {
    update_request(
        ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
        std::vector<int32_t>{max_supported_fps_, max_supported_fps_});
  }

  update_request(ANDROID_CONTROL_MODE, ANDROID_CONTROL_MODE_AUTO);
  return 0;
}

int MetadataHandler::FillDefaultVideoSnapshotSettings(
    android::CameraMetadata* metadata) {
  MetadataUpdater update_request(metadata);

  // android.control
  update_request(ANDROID_CONTROL_CAPTURE_INTENT,
                 ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT);
  if (device_info_.constant_framerate_unsupported) {
    update_request(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
                   std::vector<int32_t>{kMinFps, max_supported_fps_});
  } else {
    update_request(
        ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
        std::vector<int32_t>{max_supported_fps_, max_supported_fps_});
  }

  update_request(ANDROID_CONTROL_MODE, ANDROID_CONTROL_MODE_AUTO);
  return 0;
}

int MetadataHandler::FillDefaultZeroShutterLagSettings(
    android::CameraMetadata* /*metadata*/) {
  // Do not support ZSL template.
  return -EINVAL;
}

int MetadataHandler::FillDefaultManualSettings(
    android::CameraMetadata* /*metadata*/) {
  // Do not support manual template.
  return -EINVAL;
}

}  // namespace cros