blob: 8ac079685382a953b1b878ea3af294ae63b0fb73 [file] [log] [blame]
// Copyright 2019 The Fuchsia 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 "src/camera/drivers/controller/gdc_node.h"
#include <lib/fit/defer.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/trace/event.h>
#include <zircon/errors.h>
#include <zircon/types.h>
#include <safemath/safe_conversions.h>
#include "src/camera/drivers/controller/stream_pipeline_info.h"
#include "src/camera/lib/format_conversion/format_conversion.h"
#include "src/devices/lib/sysmem/sysmem.h"
namespace camera {
constexpr auto kTag = "camera_controller_gdc_node";
static fpromise::result<gdc_config_info, zx_status_t> LoadGdcConfiguration(
const LoadFirmwareCallback& load_firmware, ProductConfig& product_config,
const camera::GdcConfig& config_type) {
if (config_type == GdcConfig::INVALID) {
FX_LOGST(DEBUG, kTag) << "Invalid GDC configuration type";
return fpromise::error(ZX_ERR_INVALID_ARGS);
}
auto result = load_firmware(product_config.GetGdcConfigFile(config_type));
if (result.is_error() || result.value().second == 0) {
FX_PLOGST(ERROR, kTag, result.error()) << "Failed to load the GDC firmware";
return fpromise::error(result.error());
}
auto [vmo, size] = result.take_value();
return fpromise::ok(
gdc_config_info{.config_vmo = vmo.release(), .size = safemath::checked_cast<uint32_t>(size)});
}
GdcNode::GdcNode(async_dispatcher_t* dispatcher, BufferAttachments attachments,
FrameCallback frame_callback, const ddk::GdcProtocolClient& gdc)
: ProcessNode(dispatcher, NodeType::kGe2d, attachments, std::move(frame_callback)), gdc_(gdc) {}
fpromise::result<std::unique_ptr<ProcessNode>, zx_status_t> GdcNode::Create(
async_dispatcher_t* dispatcher, BufferAttachments attachments, FrameCallback frame_callback,
const LoadFirmwareCallback& load_firmware, const ddk::GdcProtocolClient& gdc,
const InternalConfigNode& internal_gdc_node, const StreamCreationData& info) {
TRACE_DURATION("camera", "GdcNode::Create");
// Create GDC Node
auto node =
std::make_unique<camera::GdcNode>(dispatcher, attachments, std::move(frame_callback), gdc);
const fuchsia::sysmem::BufferCollectionInfo_2& output_buffer_collection = node->OutputBuffers();
const fuchsia::sysmem::BufferCollectionInfo_2& input_buffer_collection = node->InputBuffers();
ZX_ASSERT(output_buffer_collection.settings.has_image_format_constraints);
fuchsia_sysmem::wire::ImageFormatConstraints output_buffer_constraints =
ConvertToWireType(output_buffer_collection.settings.image_format_constraints);
ZX_ASSERT(input_buffer_collection.settings.has_image_format_constraints);
fuchsia_sysmem::wire::ImageFormatConstraints input_buffer_constraints =
ConvertToWireType(input_buffer_collection.settings.image_format_constraints);
std::vector<image_format_2_t> output_image_formats_wire;
output_image_formats_wire.reserve(internal_gdc_node.image_formats.size());
for (const auto& format : internal_gdc_node.image_formats) {
output_image_formats_wire.push_back(sysmem::fidl_to_banjo(GetImageFormatFromConstraints(
output_buffer_constraints, format.coded_width, format.coded_height)));
}
// GDC only supports one input format and multiple output format at the
// moment. So we take the first format from the previous node.
// All existing usecases we support have only 1 format going into GDC.
fuchsia_sysmem::wire::ImageFormat2 input_image_formats_wire =
GetImageFormatFromConstraints(input_buffer_constraints, node->InputFormats()[0].coded_width,
node->InputFormats()[0].coded_height);
// Image format index refers to the final output format list of the pipeline. If this GDC node
// only has one output format, then the image format index must not be meant for this node. If
// this assumption is false the GdcTask will fail to init. Without this filter then streams which
// have a multiple output resolution node, but only a single output resolution GDC node will fail
// to init.
//
// Note: this is highly specific to sherlock use case. It would be good to revisit how nodes
// receive their output format index when this assumption doesn't hold on another platform.
uint32_t output_format_index =
internal_gdc_node.image_formats.size() > 1 ? info.image_format_index : 0;
// Get the GDC configurations loaded
auto product_config = ProductConfig::Create();
std::vector<gdc_config_info> config_vmos_info;
for (const auto& config : internal_gdc_node.gdc_info.config_type) {
auto gdc_config = LoadGdcConfiguration(load_firmware, *product_config, config);
if (gdc_config.is_error()) {
FX_LOGST(ERROR, kTag) << "Failed to load GDC configuration";
return fpromise::error(gdc_config.error());
}
config_vmos_info.push_back(gdc_config.value());
}
auto cleanup = fit::defer([config_vmos_info]() {
for (auto info : config_vmos_info) {
ZX_ASSERT_MSG(ZX_OK == zx_handle_close(info.config_vmo), "Failed to free up Config VMOs");
}
});
// Initialize the GDC to get a unique task index
buffer_collection_info_2 temp_input_collection = sysmem::fidl_to_banjo(input_buffer_collection);
buffer_collection_info_2 temp_output_collection = sysmem::fidl_to_banjo(output_buffer_collection);
image_format_2_t temp_image_format = sysmem::fidl_to_banjo(input_image_formats_wire);
auto status =
gdc.InitTask(&temp_input_collection, &temp_output_collection, &temp_image_format,
output_image_formats_wire.data(), output_image_formats_wire.size(),
output_format_index, config_vmos_info.data(), config_vmos_info.size(),
node->GetHwFrameReadyCallback(), node->GetHwFrameResolutionChangeCallback(),
node->GetHwTaskRemovedCallback(), &node->task_index_);
if (status != ZX_OK) {
FX_PLOGST(ERROR, kTag, status) << "Failed to initialize GDC";
return fpromise::error(status);
}
return fpromise::ok(std::move(node));
}
void GdcNode::ProcessFrame(FrameToken token, frame_metadata_t metadata) {
TRACE_DURATION("camera", "GdcNode::ProcessFrame", "buffer_index", *token);
if (shutdown_callback_) {
// ~token
return;
}
input_frame_queue_.push(token);
ZX_ASSERT(gdc_.ProcessFrame(task_index_, *token, metadata.capture_timestamp) == ZX_OK);
}
void GdcNode::SetOutputFormat(uint32_t output_format_index, fit::closure callback) {
TRACE_DURATION("camera", "GdcNode::SetOutputFormat", "format_index", output_format_index);
format_callback_ = std::move(callback);
gdc_.SetOutputResolution(task_index_, output_format_index);
}
void GdcNode::ShutdownImpl(fit::closure callback) {
TRACE_DURATION("camera", "GdcNode::ShutdownImpl");
ZX_ASSERT(!shutdown_callback_);
shutdown_callback_ = std::move(callback);
// Request GDC to shutdown.
gdc_.RemoveTask(task_index_);
}
void GdcNode::HwFrameReady(frame_available_info_t info) {
TRACE_DURATION("camera", "GdcNode::HwFrameReady", "status", info.frame_status, "buffer_index",
info.buffer_id);
auto token = std::move(input_frame_queue_.front());
input_frame_queue_.pop();
// Don't do anything further with error frames.
if (info.frame_status != FRAME_STATUS_OK) {
FX_LOGST(ERROR, kTag) << "failed gdc frame: " << static_cast<uint32_t>(info.frame_status);
return;
}
// Send the frame onward.
SendFrame(info.buffer_id, info.metadata, [this, buffer_index = info.buffer_id] {
gdc_.ReleaseFrame(task_index_, buffer_index);
});
}
void GdcNode::HwFrameResolutionChanged(frame_available_info_t info) {
TRACE_DURATION("camera", "GdcNode::HwFrameResolutionChanged");
format_callback_();
format_callback_ = nullptr;
}
void GdcNode::HwTaskRemoved(task_remove_status_t status) {
TRACE_DURATION("camera", "GdcNode::HwTaskRemoved");
ZX_ASSERT(status == TASK_REMOVE_STATUS_OK);
ZX_ASSERT(shutdown_callback_);
if (!input_frame_queue_.empty()) {
FX_LOGS(WARNING) << "GDC driver completed task removal but did not complete processing for all "
"frames it was sent. These will be manually released.";
while (!input_frame_queue_.empty()) {
input_frame_queue_.pop();
}
}
shutdown_callback_();
}
} // namespace camera