path: root/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp

/*
 * Copyright (C) 2019 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_TAG "EmulatedCameraDevSession"
#define ATRACE_TAG ATRACE_TAG_CAMERA

#include "EmulatedCameraDeviceSessionHWLImpl.h"

#include <android/hardware/graphics/common/1.2/types.h>
#include <hardware/gralloc.h>
#include <inttypes.h>
#include <log/log.h>
#include <utils/Trace.h>

#include <memory>

#include "EmulatedSensor.h"
#include "utils.h"
#include "utils/HWLUtils.h"

namespace android {

using google_camera_hal::utils::GetSensorActiveArraySize;
using google_camera_hal::utils::HasCapability;

using android::hardware::graphics::common::V1_2::Dataspace;
std::unique_ptr<EmulatedCameraZoomRatioMapperHwlImpl>
EmulatedCameraZoomRatioMapperHwlImpl::Create(
    const std::unordered_map<uint32_t, std::pair<Dimension, Dimension>>& dims) {
  auto zoom_ratio_mapper_hwl_impl =
      std::make_unique<EmulatedCameraZoomRatioMapperHwlImpl>(dims);
  return zoom_ratio_mapper_hwl_impl;
}

EmulatedCameraZoomRatioMapperHwlImpl::EmulatedCameraZoomRatioMapperHwlImpl(
    const std::unordered_map<uint32_t, std::pair<Dimension, Dimension>>& dims)
    : camera_ids_to_dimensions_(dims) {
}

bool EmulatedCameraZoomRatioMapperHwlImpl::GetActiveArrayDimensionToBeUsed(
    uint32_t camera_id, const HalCameraMetadata* settings,
    Dimension* active_array_dimension) const {
  auto dim_it = camera_ids_to_dimensions_.find(camera_id);
  if (settings == nullptr || active_array_dimension == nullptr ||
      dim_it == camera_ids_to_dimensions_.end()) {
    // default request / camera id not found
    return false;
  }
  camera_metadata_ro_entry entry = {};
  status_t res = settings->Get(ANDROID_SENSOR_PIXEL_MODE, &entry);
  if (res != OK) {
    // return default res dimension
    *active_array_dimension = dim_it->second.second;
    return true;
  }
  if (entry.data.u8[0] == ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) {
    // return max res mode dimension
    *active_array_dimension = dim_it->second.first;
  } else {
    *active_array_dimension = dim_it->second.second;
  }
  return true;
}

std::unique_ptr<EmulatedCameraDeviceSessionHwlImpl>
EmulatedCameraDeviceSessionHwlImpl::Create(
    uint32_t camera_id, std::unique_ptr<HalCameraMetadata> static_meta,
    PhysicalDeviceMapPtr physical_devices,
    std::shared_ptr<EmulatedTorchState> torch_state) {
  ATRACE_CALL();
  if (static_meta.get() == nullptr) {
    return nullptr;
  }

  auto session = std::unique_ptr<EmulatedCameraDeviceSessionHwlImpl>(
      new EmulatedCameraDeviceSessionHwlImpl(std::move(physical_devices),
                                             torch_state));
  if (session == nullptr) {
    ALOGE("%s: Creating EmulatedCameraDeviceSessionHwlImpl failed",
          __FUNCTION__);
    return nullptr;
  }

  status_t res = session->Initialize(camera_id, std::move(static_meta));
  if (res != OK) {
    ALOGE("%s: Initializing EmulatedCameraDeviceSessionHwlImpl failed: %s(%d)",
          __FUNCTION__, strerror(-res), res);
    return nullptr;
  }

  return session;
}

static std::pair<Dimension, Dimension> GetArrayDimensions(
    uint32_t camera_id, const HalCameraMetadata* metadata) {
  google_camera_hal::Rect active_array_size;
  Dimension active_array_size_dimension;
  Dimension active_array_size_dimension_maximum_resolution;
  status_t ret = GetSensorActiveArraySize(metadata, &active_array_size);
  if (ret != OK) {
    ALOGE("%s: Failed to get sensor active array size for camera id %d",
          __FUNCTION__, (int)camera_id);
    return std::pair<Dimension, Dimension>();
  }
  active_array_size_dimension = {
      active_array_size.right - active_array_size.left + 1,
      active_array_size.bottom - active_array_size.top + 1};

  active_array_size_dimension_maximum_resolution = active_array_size_dimension;
  if (HasCapability(
          metadata,
          ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR)) {
    status_t ret = GetSensorActiveArraySize(metadata, &active_array_size,
                                            /*maximum_resolution=*/true);
    if (ret != OK) {
      ALOGE(
          "%s: Failed to get max resolution sensor active array size for "
          "camera id %d",
          __FUNCTION__, (int)camera_id);
      return std::pair<Dimension, Dimension>();
    }
    active_array_size_dimension_maximum_resolution = {
        active_array_size.right - active_array_size.left + 1,
        active_array_size.bottom - active_array_size.top + 1};
  }
  return std::make_pair(active_array_size_dimension_maximum_resolution,
                        active_array_size_dimension);
}

status_t EmulatedCameraDeviceSessionHwlImpl::Initialize(
    uint32_t camera_id, std::unique_ptr<HalCameraMetadata> static_meta) {
  camera_id_ = camera_id;
  static_metadata_ = std::move(static_meta);
  stream_configuration_map_ =
      std::make_unique<StreamConfigurationMap>(*static_metadata_);
  stream_configuration_map_max_resolution_ =
      std::make_unique<StreamConfigurationMap>(*static_metadata_, true);
  camera_metadata_ro_entry_t entry;
  auto ret = static_metadata_->Get(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &entry);
  if (ret != OK) {
    ALOGE("%s: Unable to extract ANDROID_REQUEST_PIPELINE_MAX_DEPTH, %s (%d)",
          __FUNCTION__, strerror(-ret), ret);
    return ret;
  }

  max_pipeline_depth_ = entry.data.u8[0];

  std::unordered_map<uint32_t, std::pair<Dimension, Dimension>>
      camera_ids_to_dimensions;
  camera_ids_to_dimensions[camera_id] =
      GetArrayDimensions(camera_id, static_metadata_.get());

  ret = GetSensorCharacteristics(static_metadata_.get(), &sensor_chars_);
  if (ret != OK) {
    ALOGE("%s: Unable to extract sensor characteristics %s (%d)", __FUNCTION__,
          strerror(-ret), ret);
    return ret;
  }

  ret = SupportsSessionHalBufManager(static_metadata_.get(),
                                     &supports_session_hal_buf_manager_);
  if (ret != OK) {
    ALOGE("%s: Unable to get sensor hal buffer manager support %s (%d)",
          __FUNCTION__, strerror(-ret), ret);
    return ret;
  }

  logical_chars_.emplace(camera_id_, sensor_chars_);
  for (const auto& it : *physical_device_map_) {
    SensorCharacteristics physical_chars;
    auto stat = GetSensorCharacteristics(it.second.second.get(), &physical_chars);
    if (stat == OK) {
      logical_chars_.emplace(it.first, physical_chars);
    } else {
      ALOGE("%s: Unable to extract physical device: %u characteristics %s (%d)",
            __FUNCTION__, it.first, strerror(-ret), ret);
      return ret;
    }
    camera_ids_to_dimensions[it.first] =
        GetArrayDimensions(it.first, it.second.second.get());
    physical_stream_configuration_map_.emplace(
        it.first,
        std::make_unique<StreamConfigurationMap>(*it.second.second.get()));
    physical_stream_configuration_map_max_resolution_.emplace(
        it.first, std::make_unique<StreamConfigurationMap>(
                      *it.second.second.get(), true));
  }

  zoom_ratio_mapper_hwl_impl_ = std::move(
      EmulatedCameraZoomRatioMapperHwlImpl::Create(camera_ids_to_dimensions));
  return InitializeRequestProcessor();
}

status_t EmulatedCameraDeviceSessionHwlImpl::InitializeRequestProcessor() {
  sp<EmulatedSensor> emulated_sensor = new EmulatedSensor();
  auto logical_chars = std::make_unique<LogicalCharacteristics>(logical_chars_);
  auto ret = emulated_sensor->StartUp(camera_id_, std::move(logical_chars));
  if (ret != OK) {
    ALOGE("%s: Failed on sensor start up %s (%d)", __FUNCTION__, strerror(-ret),
          ret);
    return ret;
  }

  request_processor_ = std::make_shared<EmulatedRequestProcessor>(
      camera_id_, emulated_sensor, session_callback_);

  request_processor_->InitializeSensorQueue(request_processor_);

  return request_processor_->Initialize(
      HalCameraMetadata::Clone(static_metadata_.get()),
      ClonePhysicalDeviceMap(physical_device_map_));
}

EmulatedCameraDeviceSessionHwlImpl::~EmulatedCameraDeviceSessionHwlImpl() {
  if (torch_state_.get() != nullptr) {
    torch_state_->ReleaseFlashHw();
  }
}

status_t EmulatedCameraDeviceSessionHwlImpl::ConstructDefaultRequestSettings(
    RequestTemplate type, std::unique_ptr<HalCameraMetadata>* default_settings) {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);

  return request_processor_->GetDefaultRequest(type, default_settings);
}

status_t EmulatedCameraDeviceSessionHwlImpl::ConfigurePipeline(
    uint32_t physical_camera_id, HwlPipelineCallback hwl_pipeline_callback,
    const StreamConfiguration& request_config,
    const StreamConfiguration& /*overall_config*/, uint32_t* pipeline_id) {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);
  if (pipeline_id == nullptr) {
    ALOGE("%s pipeline_id is nullptr", __FUNCTION__);
    return BAD_VALUE;
  }

  if (pipelines_built_) {
    ALOGE("%s Cannot configure pipelines after calling BuildPipelines()",
          __FUNCTION__);
    return ALREADY_EXISTS;
  }

  if (!EmulatedSensor::IsStreamCombinationSupported(
          physical_camera_id, request_config, *stream_configuration_map_,
          *stream_configuration_map_max_resolution_,
          physical_stream_configuration_map_,
          physical_stream_configuration_map_max_resolution_, logical_chars_)) {
    ALOGE("%s: Stream combination not supported!", __FUNCTION__);
    return BAD_VALUE;
  }

  if ((physical_camera_id != camera_id_) &&
      (physical_device_map_.get() != nullptr)) {
    if (physical_device_map_->find(physical_camera_id) ==
        physical_device_map_->end()) {
      ALOGE("%s: Camera: %d doesn't include physical device with id: %u",
            __FUNCTION__, camera_id_, physical_camera_id);
      return BAD_VALUE;
    }
  }

  *pipeline_id = pipelines_.size();
  EmulatedPipeline emulated_pipeline{.cb = hwl_pipeline_callback,
                                     .physical_camera_id = physical_camera_id,
                                     .pipeline_id = *pipeline_id,};

  emulated_pipeline.streams.reserve(request_config.streams.size());
  for (const auto& stream : request_config.streams) {
    bool is_input = stream.stream_type == google_camera_hal::StreamType::kInput;
    emulated_pipeline.streams.emplace(
        stream.id,
        EmulatedStream(
            {{.id = stream.id,
              .override_format =
                  is_input ? stream.format
                           : EmulatedSensor::OverrideFormat(
                                 stream.format, stream.dynamic_profile),
              .producer_usage = is_input ? 0
                                         : GRALLOC_USAGE_SW_WRITE_OFTEN |
                                               GRALLOC_USAGE_HW_CAMERA_WRITE |
                                               GRALLOC_USAGE_HW_CAMERA_READ,
              .consumer_usage = 0,
              .max_buffers = max_pipeline_depth_,
              .override_data_space =
                  (stream.dynamic_profile ==
                   ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10) &&
                          (stream.format ==
                           HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED)
                      ? static_cast<android_dataspace_t>(
                            Dataspace::BT2020_ITU_HLG)
                      : stream.data_space,
              .is_physical_camera_stream = stream.is_physical_camera_stream,
              .physical_camera_id = stream.physical_camera_id},
             .width = stream.width,
             .height = stream.height,
             .buffer_size = stream.buffer_size,
             .is_input = is_input,
             .group_id = stream.group_id,
             .use_case = stream.use_case,
             .color_space = stream.color_space}));

    if (stream.group_id != -1 && stream.is_physical_camera_stream) {
      // TODO: For quad bayer camera, the logical camera id should be used if
      // this is not a physical camera.
      dynamic_stream_id_map_[stream.physical_camera_id][stream.group_id] =
          stream.id;
    }
    if (!stream.is_physical_camera_stream &&
        (stream.format == HAL_PIXEL_FORMAT_RAW16)) {
      has_raw_stream_ = true;
    }
  }

  pipelines_.push_back(emulated_pipeline);

  return OK;
}

status_t EmulatedCameraDeviceSessionHwlImpl::GetConfiguredHalStream(
    uint32_t pipeline_id, std::vector<HalStream>* hal_streams) const {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);
  if (hal_streams == nullptr) {
    ALOGE("%s hal_streams is nullptr", __FUNCTION__);
    return BAD_VALUE;
  }

  if (!pipelines_built_) {
    ALOGE("%s No pipeline was built.", __FUNCTION__);
    return NO_INIT;
  }

  if (pipeline_id >= pipelines_.size()) {
    ALOGE("%s: Unknown pipeline ID: %u", __FUNCTION__, pipeline_id);
    return NAME_NOT_FOUND;
  }

  const auto& streams = pipelines_[pipeline_id].streams;
  hal_streams->reserve(streams.size());
  for (const auto& it : streams) {
    hal_streams->push_back(it.second);
  }

  return OK;
}

status_t EmulatedCameraDeviceSessionHwlImpl::BuildPipelines() {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);
  if (pipelines_built_) {
    ALOGE("%s Pipelines have already been built!", __FUNCTION__);
    return ALREADY_EXISTS;
  } else if (pipelines_.size() == 0) {
    ALOGE("%s No pipelines have been configured yet!", __FUNCTION__);
    return NO_INIT;
  }

  status_t ret = OK;
  if (request_processor_ == nullptr) {
    ret = InitializeRequestProcessor();
  }

  if (ret == OK) {
    pipelines_built_ = true;
  }

  return OK;
}

status_t EmulatedCameraDeviceSessionHwlImpl::ShouldUseHalBufferManager(
    bool* result) {
  if (result == nullptr) {
    ALOGE("%s result is nullptr", __FUNCTION__);
    return BAD_VALUE;
  }
  *result = false;
  if (!pipelines_built_) {
    ALOGE("%s: Pipelines haven't been built yet", __FUNCTION__);
    return INVALID_OPERATION;
  }
  if (!supports_session_hal_buf_manager_) {
    return OK;
  }
  // Heuristic which doesn't necessarily correspond to real scenarios
  if (pipelines_.size() >= 1 && pipelines_[0].streams.size() >= 2) {
    *result = true;
  }
  return OK;
}

void EmulatedCameraDeviceSessionHwlImpl::DestroyPipelines() {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);
  if (!pipelines_built_) {
    // Not an error - nothing to destroy
    ALOGV("%s nothing to destroy", __FUNCTION__);
    return;
  }

  pipelines_built_ = false;
  has_raw_stream_ = false;
  pipelines_.clear();
  request_processor_ = nullptr;
}

status_t EmulatedCameraDeviceSessionHwlImpl::CheckOutputFormatsForInput(
    const HwlPipelineRequest& request,
    const std::unordered_map<uint32_t, EmulatedStream>& streams,
    const std::unique_ptr<StreamConfigurationMap>& stream_configuration_map,
    android_pixel_format_t input_format) {
  auto output_formats =
      stream_configuration_map->GetValidOutputFormatsForInput(input_format);
  for (const auto& output_buffer : request.output_buffers) {
    auto output_stream = streams.at(output_buffer.stream_id);
    if (output_formats.find(output_stream.override_format) ==
        output_formats.end()) {
      ALOGE(
          "%s: Reprocess request with input format: 0x%x to output "
          "format: 0x%x"
          " not supported!",
          __FUNCTION__, input_format, output_stream.override_format);
      return BAD_VALUE;
    }
  }
  return OK;
}

status_t EmulatedCameraDeviceSessionHwlImpl::SubmitRequests(
    uint32_t frame_number, std::vector<HwlPipelineRequest>& requests) {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);

  // Check whether reprocess request has valid/supported outputs.
  for (const auto& request : requests) {
    if (!request.input_buffers.empty()) {
      for (const auto& input_buffer : request.input_buffers) {
        const auto& streams = pipelines_[request.pipeline_id].streams;
        auto input_stream = streams.at(input_buffer.stream_id);
        if ((CheckOutputFormatsForInput(request, streams,
                                        stream_configuration_map_,
                                        input_stream.override_format) != OK) &&
            (CheckOutputFormatsForInput(
                 request, streams, stream_configuration_map_max_resolution_,
                 input_stream.override_format) != OK)) {
          return BAD_VALUE;
        }
      }
    }
  }

  if (error_state_) {
    ALOGE("%s session is in error state and cannot process further requests",
          __FUNCTION__);
    return INVALID_OPERATION;
  }

  return request_processor_->ProcessPipelineRequests(
      frame_number, requests, pipelines_, dynamic_stream_id_map_,
      has_raw_stream_);
}

status_t EmulatedCameraDeviceSessionHwlImpl::Flush() {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);
  return request_processor_->Flush();
}

uint32_t EmulatedCameraDeviceSessionHwlImpl::GetCameraId() const {
  return camera_id_;
}

std::vector<uint32_t> EmulatedCameraDeviceSessionHwlImpl::GetPhysicalCameraIds()
    const {
  if ((physical_device_map_.get() == nullptr) ||
      (physical_device_map_->empty())) {
    return std::vector<uint32_t>{};
  }

  std::vector<uint32_t> ret;
  ret.reserve(physical_device_map_->size());
  for (const auto& it : *physical_device_map_) {
    ret.push_back(it.first);
  }

  return ret;
}

status_t EmulatedCameraDeviceSessionHwlImpl::GetCameraCharacteristics(
    std::unique_ptr<HalCameraMetadata>* characteristics) const {
  ATRACE_CALL();
  if (characteristics == nullptr) {
    return BAD_VALUE;
  }

  (*characteristics) = HalCameraMetadata::Clone(static_metadata_.get());

  if (*characteristics == nullptr) {
    ALOGE("%s metadata clone failed", __FUNCTION__);
    return NO_MEMORY;
  }

  return OK;
}

status_t EmulatedCameraDeviceSessionHwlImpl::GetPhysicalCameraCharacteristics(
    uint32_t physical_camera_id,
    std::unique_ptr<HalCameraMetadata>* characteristics) const {
  ATRACE_CALL();
  if (characteristics == nullptr) {
    return BAD_VALUE;
  }

  if (physical_device_map_.get() == nullptr) {
    ALOGE("%s: Camera: %d doesn't have physical device support!", __FUNCTION__,
          camera_id_);
    return BAD_VALUE;
  }

  if (physical_device_map_->find(physical_camera_id) ==
      physical_device_map_->end()) {
    ALOGE("%s: Camera: %d doesn't include physical device with id: %u",
          __FUNCTION__, camera_id_, physical_camera_id);
    return BAD_VALUE;
  }

  (*characteristics) = HalCameraMetadata::Clone(
      physical_device_map_->at(physical_camera_id).second.get());

  return OK;
}

void EmulatedCameraDeviceSessionHwlImpl::SetSessionCallback(
    const HwlSessionCallback& hwl_session_callback) {
  ATRACE_CALL();
  std::lock_guard<std::mutex> lock(api_mutex_);
  session_callback_ = hwl_session_callback;
  if (request_processor_ != nullptr) {
    request_processor_->SetSessionCallback(hwl_session_callback);
  }
}

}  // namespace android