| // 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. | |
| #ifndef SRC_MEDIA_CODEC_CODECS_VAAPI_CODEC_RUNNER_APP_H_ | |
| #define SRC_MEDIA_CODEC_CODECS_VAAPI_CODEC_RUNNER_APP_H_ | |
| #include <fuchsia/mediacodec/cpp/fidl.h> | |
| #include <lib/async-loop/cpp/loop.h> | |
| #include <lib/async-loop/default.h> | |
| #include <lib/component/incoming/cpp/protocol.h> | |
| #include <lib/fidl/cpp/interface_request.h> | |
| #include <lib/inspect/cpp/inspector.h> | |
| #include <lib/sys/cpp/component_context.h> | |
| #include <lib/syslog/cpp/log_level.h> | |
| #include <lib/syslog/cpp/log_settings.h> | |
| #include <lib/syslog/cpp/macros.h> | |
| #include <lib/trace-provider/provider.h> | |
| #include <initializer_list> | |
| #include <memory> | |
| #include <string> | |
| #include "local_single_codec_factory.h" | |
| // If a software can only provide an encoder or decoder, the other should be | |
| // assigned NoAdapter in the template arguments, e.g.: | |
| // CodecRunnerApp<CodecAdapterFfmpeg, NoAdapter> | |
| template <typename Decoder, typename Encoder> | |
| class CodecRunnerApp { | |
| public: | |
| CodecRunnerApp() | |
| : codec_admission_control_(std::make_unique<CodecAdmissionControl>(loop_.dispatcher())) {} | |
| void Init() { | |
| static const std::initializer_list<std::string> kLogTags = {"vaapi_codec_runner"}; | |
| #ifdef NDEBUG | |
| fuchsia_logging::LogSettingsBuilder builder; | |
| builder.WithTags(kLogTags).BuildAndInitialize(); | |
| #else | |
| fuchsia_logging::LogSettingsBuilder builder; | |
| builder.WithMinLogSeverity(FUCHSIA_LOG_DEBUG).WithTags(kLogTags).BuildAndInitialize(); | |
| #endif | |
| trace_provider_ = | |
| std::make_unique<trace::TraceProviderWithFdio>(loop_.dispatcher(), "vaapi_codec_runner"); | |
| // This is bit of a misnomer since CodecRunnerApp isn't a driver but instead a component. Since | |
| // we need a new instance for every FIDL connection a driver does not make sense currently. | |
| codec_diagnostics_ = | |
| std::make_unique<CodecDiagnostics>("vaapi_codec_runner", loop_.dispatcher()); | |
| component_context_->outgoing()->AddPublicService( | |
| fidl::InterfaceRequestHandler<fuchsia::mediacodec::CodecFactory>( | |
| [this, codec_admission_control = codec_admission_control_.get()]( | |
| fidl::InterfaceRequest<fuchsia::mediacodec::CodecFactory> request) { | |
| // We RemoveService() near the end of the present lambda, so it | |
| // should be impossible to receive a second CodecFactory request. | |
| FX_DCHECK(!codec_factory_); | |
| auto sysmem_result = component::Connect<fuchsia_sysmem2::Allocator>(); | |
| ZX_ASSERT(sysmem_result.is_ok()); | |
| auto sysmem = std::move(sysmem_result.value()); | |
| codec_factory_ = std::make_unique<LocalSingleCodecFactory<Decoder, Encoder>>( | |
| loop_.dispatcher(), std::move(sysmem), std::move(request), | |
| [this](std::unique_ptr<CodecImpl> created_codec_instance) { | |
| ZX_DEBUG_ASSERT(!codec_instance_); | |
| if (!created_codec_instance) { | |
| // Drop factory and close factory channel on factory | |
| // failure to create instance. | |
| codec_factory_ = nullptr; | |
| // The codec_instance_ channel is the only reason for the | |
| // isolate to exist. | |
| loop_.Quit(); | |
| return; | |
| } | |
| // Own codec implementation and bind it. | |
| codec_instance_ = std::move(created_codec_instance); | |
| codec_instance_->BindAsync([this] { | |
| // Drop codec implementation and close channel on | |
| // error. | |
| codec_instance_ = nullptr; | |
| // The codec_instance_ channel is the only reason for | |
| // the isolate to exist. | |
| loop_.Quit(); | |
| }); | |
| // Drop factory and close factory channel. | |
| codec_factory_ = nullptr; | |
| }, | |
| codec_admission_control, | |
| [this](zx_status_t error) { | |
| // Drop factory and close factory channel on error. | |
| codec_factory_ = nullptr; | |
| // The codec_instance_ channel is the only reason for | |
| // the isolate to exist. If codec_instance_ wasn't | |
| // created via the codec_factory_ before this point, | |
| // it'll never be created via codec_factory_. | |
| if (!codec_instance_) { | |
| loop_.Quit(); | |
| } | |
| }, | |
| codec_diagnostics_.get()); | |
| // This runner only expects a single Local Codec Factory to ever | |
| // be requested. | |
| // | |
| // This call deletes the presently-running lambda, so nothing | |
| // after this call can use the lambda's captures, including the | |
| // "this" pointer implicitly. | |
| component_context_->outgoing() | |
| ->RemovePublicService<fuchsia::mediacodec::CodecFactory>(); | |
| })); | |
| } | |
| void Serve() { component_context_->outgoing()->ServeFromStartupInfo(); } | |
| void Run() { | |
| loop_.Run(); | |
| // Run the loop_.Shutdown() here (before ~CodecRunnerApp), so that any | |
| // pending tasks get deleted sooner rather than later. The only pending | |
| // task we expect to potentially be deleted here is the task queued in | |
| // ~CodecImpl that does ~CodecAdmission and then ~zx::channel (even if the | |
| // task is just deleted and not run). That task needs to run or be | |
| // deleted before ~CodecAdmissionControl. | |
| loop_.Shutdown(); | |
| } | |
| std::unique_ptr<sys::ComponentContext>& component_context() { return component_context_; } | |
| private: | |
| async::Loop loop_{&kAsyncLoopConfigAttachToCurrentThread}; | |
| std::unique_ptr<sys::ComponentContext> component_context_{sys::ComponentContext::Create()}; | |
| std::unique_ptr<CodecAdmissionControl> codec_admission_control_; | |
| std::unique_ptr<LocalSingleCodecFactory<Decoder, Encoder>> codec_factory_; | |
| std::unique_ptr<CodecImpl> codec_instance_; | |
| std::unique_ptr<trace::TraceProviderWithFdio> trace_provider_; | |
| std::unique_ptr<CodecDiagnostics> codec_diagnostics_; | |
| }; | |
| #endif // SRC_MEDIA_CODEC_CODECS_VAAPI_CODEC_RUNNER_APP_H_ |