| // Copyright 2018 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 "codec_factory_app.h" |
| |
| #include "codec_factory_impl.h" |
| |
| #include <fuchsia/mediacodec/cpp/fidl.h> |
| #include <lib/fsl/io/device_watcher.h> |
| #include <lib/svc/cpp/services.h> |
| #include <trace-provider/provider.h> |
| #include <zircon/device/media-codec.h> |
| #include <zircon/status.h> |
| |
| #include <fcntl.h> |
| |
| namespace codec_factory { |
| |
| namespace { |
| |
| constexpr char kDeviceClass[] = "/dev/class/media-codec"; |
| |
| } // namespace |
| |
| CodecFactoryApp::CodecFactoryApp(async::Loop* loop) : loop_(loop) { |
| // TODO(dustingreen): Determine if this is useful and if we're holding it |
| // right. |
| trace::TraceProvider trace_provider(loop_->dispatcher()); |
| |
| // We pump |loop| in here, so it's important that |
| // component::StartupContext::CreateFromStartupInfo() happen after |
| // DiscoverMediaCodecDrivers(), else the pumping of the loop will drop the |
| // incoming request for CodecFactory before AddServiceForName() below has had |
| // a chance to register for it. |
| DiscoverMediaCodecDriversAndListenForMoreAsync(); |
| |
| // We _rely_ on the driver to either fail the channel or send OnCodecList(). |
| // We don't set a timeout here because under different conditions this could |
| // take different duration. |
| zx_status_t run_result; |
| do { |
| run_result = loop_->Run(zx::time::infinite(), true); |
| } while (run_result == ZX_OK && !existing_devices_discovered_); |
| if (run_result != ZX_OK) { |
| // ignore/skip the driver that failed the channel already |
| // The ~codec_factory takes care of un-binding. |
| FXL_LOG(ERROR) << "loop failed: " << zx_status_get_string(run_result); |
| return; |
| } |
| FXL_LOG(INFO) |
| << "discovery of all pre-existing devices done - serving CodecFactory"; |
| |
| // We delay doing this until we're completely ready to add services, because |
| // CreateFromStartupInfo() binds to |loop| implicitly, so we don't want any |
| // pumping of |loop| up to this point to drop service connection requests. |
| // |
| // It's fine that AddServiceForName() happens after CreateFromStartupInfo() |
| // only because |loop| doesn't have a separate thread, and the current thread |
| // won't pump |loop| until after AddServiceForName() is also done. |
| startup_context_ = component::StartupContext::CreateFromStartupInfo(); |
| startup_context_->outgoing().deprecated_services()->AddServiceForName( |
| [this](zx::channel request) { |
| // The CodecFactoryImpl is self-owned and will self-delete when the |
| // channel closes or an error occurs. |
| CodecFactoryImpl::CreateSelfOwned(this, startup_context_.get(), |
| std::move(request)); |
| }, |
| fuchsia::mediacodec::CodecFactory::Name_); |
| } |
| |
| const fuchsia::mediacodec::CodecFactoryPtr* CodecFactoryApp::FindHwDecoder( |
| fit::function<bool(const fuchsia::mediacodec::CodecDescription&)> |
| is_match) { |
| auto iter = std::find_if( |
| hw_codecs_.begin(), hw_codecs_.end(), |
| [&is_match](const std::unique_ptr<CodecListEntry>& entry) -> bool { |
| return is_match(entry->description); |
| }); |
| if (iter == hw_codecs_.end()) { |
| return nullptr; |
| } |
| return (*iter)->factory.get(); |
| } |
| |
| void CodecFactoryApp::DiscoverMediaCodecDriversAndListenForMoreAsync() { |
| // We use fsl::DeviceWatcher::CreateWithIdleCallback() instead of |
| // fsl::DeviceWatcher::Create() because the CodecFactory service is started on |
| // demand, and we don't want to start serving CodecFactory until we've |
| // discovered and processed all existing media-codec devices. That way, the |
| // first time a client requests a HW-backed codec, we robustly consider all |
| // codecs provided by pre-existing devices. The request for a HW-backed Codec |
| // will have a much higher probability of succeeding vs. if we just discovered |
| // pre-existing devices async. This doesn't prevent the possiblity that the |
| // device might not exist at the moment the CodecFactory is started, but as |
| // long as the device does exist by then, this will ensure the device's codecs |
| // are considered, including for the first client request. |
| device_watcher_ = fsl::DeviceWatcher::CreateWithIdleCallback( |
| kDeviceClass, |
| [this](int dir_fd, std::string filename) { |
| FXL_LOG(INFO) << "DeviceWatcher callback got filename: " << filename; |
| |
| std::string device_path = std::string(kDeviceClass) + "/" + filename; |
| |
| int fd = ::openat(dir_fd, filename.c_str(), O_RDONLY); |
| if (fd < 0) { |
| // This is ok (locally here) if the device (filename) really did go |
| // away in the meantime. |
| int snap_errno = errno; |
| FXL_LOG(INFO) << "Failed to open device by filename - resulting fd: " |
| << fd << " errno: " << snap_errno |
| << " device_path: " << device_path; |
| return; |
| } |
| |
| zx::channel client_factory_channel; |
| ssize_t res = ioctl_media_codec_get_codec_factory_channel( |
| fd, client_factory_channel.reset_and_get_address()); |
| ::close(fd); |
| |
| if (res != sizeof(client_factory_channel)) { |
| // This could be ok (locally here) if the device's devhost exited |
| // already or similar. |
| FXL_LOG(INFO) << "Failed to obtain channel - res: " << res |
| << " device_path: " << device_path; |
| // ignore/skip the driver that failed the ioctl |
| return; |
| } |
| |
| // From here on in the current lambda, we're doing stuff that can't fail |
| // here locally (at least, not without exiting the whole process). The |
| // error handler will handle channel error async. |
| |
| auto discovery_entry = std::make_unique<DeviceDiscoveryEntry>(); |
| discovery_entry->device_path = device_path; |
| |
| discovery_entry->codec_factory = |
| std::make_shared<fuchsia::mediacodec::CodecFactoryPtr>(); |
| discovery_entry->codec_factory->set_error_handler( |
| [this, device_path, factory = discovery_entry->codec_factory.get()]( |
| zx_status_t status) { |
| FXL_LOG(INFO) << "Device's CodecFactoryPtr error handler - " |
| "cancelling discovery or de-registering: " |
| << device_path; |
| // Any given factory won't be in both lists, but will be in one or |
| // the other by the time this error handler runs. |
| device_discovery_queue_.remove_if( |
| [factory]( |
| const std::unique_ptr<DeviceDiscoveryEntry>& entry) { |
| return factory == entry->codec_factory.get(); |
| }); |
| // Perhaps the removed discovery item was the first item in the |
| // list; maybe now the new first item in the list can be |
| // processed. |
| PostDiscoveryQueueProcessing(); |
| |
| hw_codecs_.remove_if( |
| [factory](const std::unique_ptr<CodecListEntry>& entry) { |
| return factory == entry->factory.get(); |
| }); |
| }); |
| |
| discovery_entry->codec_factory->events().OnCodecList = |
| [this, discovery_entry = discovery_entry.get()]( |
| std::vector<fuchsia::mediacodec::CodecDescription> |
| codec_list) { |
| discovery_entry->driver_codec_list = fidl::VectorPtr(codec_list); |
| // In case discovery_entry is the first item which is now ready to |
| // process, process the discovery queue. |
| PostDiscoveryQueueProcessing(); |
| |
| // We're no longer interested in OnCodecList events from the |
| // driver's CodecFactory, should the driver send any more. Sending |
| // more is not legal, but disconnect this event just in case, |
| // since we don't want the old lambda that touches |
| // driver_codec_list (this lambda). |
| discovery_entry->codec_factory->events().OnCodecList = nullptr; |
| }; |
| |
| discovery_entry->codec_factory->Bind(std::move(client_factory_channel), |
| loop_->dispatcher()); |
| |
| device_discovery_queue_.emplace_back(std::move(discovery_entry)); |
| }, |
| [this] { |
| FXL_LOG(INFO) << "DeviceWatcher idle_callback"; |
| // The idle_callback indicates that all pre-existing devices have been |
| // seen, and by the time this item reaches the front of the discovery |
| // queue, all pre-existing devices have all been processed. |
| device_discovery_queue_.emplace_back( |
| std::make_unique<DeviceDiscoveryEntry>()); |
| PostDiscoveryQueueProcessing(); |
| }); |
| |
| FXL_LOG(INFO) |
| << "CodecFactory::DiscoverMediaCodecDriversAndListenForMoreAsync() ran."; |
| } |
| |
| void CodecFactoryApp::PostDiscoveryQueueProcessing() { |
| async::PostTask( |
| loop_->dispatcher(), |
| fit::bind_member(this, &CodecFactoryApp::ProcessDiscoveryQueue)); |
| } |
| |
| void CodecFactoryApp::ProcessDiscoveryQueue() { |
| // Both startup and steady-state use this processing loop. |
| // |
| // In startup, we care about ordering of the discovery queue because we want |
| // to allow serving of CodecFactory as soon as all pre-existing devices are |
| // done processing. We care that pre-existing devices are before |
| // newly-discovered devices in the queue. As far as startup is concerned, |
| // there are other ways we could track this without using a queue, but a queue |
| // works, and using the queue allows startup to share code with steady-state. |
| // |
| // In steady-state, we care (a little) about ordering of the discovery queue |
| // because we want (to a limited degree, for now) to prefer a |
| // more-recently-discovered device over a less-recently-discovered device (for |
| // now at least), so to make that robust, we preserve the device discovery |
| // order through the codec discovery sequence, to account for the possibility |
| // that an previously discovered device may have only just recently sent |
| // OnCodecList before failing; without the device_discovery_queue_ that |
| // previously-discovered device's OnCodecList could re-order vs. the |
| // replacement device's OnCodecList. |
| // |
| // The device_discovery_queue_ marginally increases the odds of a client |
| // request picking up a replacement devhost instead of an old devhost that |
| // failed quickly and which we haven't yet noticed is gone. This devhost |
| // replacement case is the main motivation for caring about the device |
| // discovery order in the first place (at least for now), since it should be |
| // robustly the case that discovery of the old devhost happens before |
| // discovery of the replacement devhost. |
| // |
| // The ordering of the hw_codec_ list is the main way in which |
| // more-recently-discovered codecs are prefered over less-recently-discovered |
| // codecs. The device_discovery_queue_ just makes the hw_codec_ ordering |
| // exactly correspond to the device discovery order (reversed) even when |
| // devices are discovered near each other in time. |
| // |
| // None of this changes the fact that a replacement devhost's arrival can race |
| // with a client's request, so if a devhost fails and is replaced, it's quite |
| // possible the client will see the Codec interface just fail. Even if this |
| // were mitigated, it wouldn't change the fact that a devhost failure later |
| // would result in Codec interface failure at that time, so failures near the |
| // start aren't really much different than async failures later. It can make |
| // sense for a client to retry a low number of times (if the client wants to |
| // work despite a devhost not always fully working), even if the Codec failure |
| // happens quite early. |
| while (!device_discovery_queue_.empty()) { |
| std::unique_ptr<DeviceDiscoveryEntry>& front = |
| device_discovery_queue_.front(); |
| if (!front->codec_factory) { |
| // All pre-existing devices have been processed. |
| // |
| // Now the CodecFactory can begin serving (shortly). |
| existing_devices_discovered_ = true; |
| // The marker has done its job, so remove the marker. |
| device_discovery_queue_.pop_front(); |
| return; |
| } |
| |
| if (!front->driver_codec_list) { |
| // The first item is not yet ready. The current method will get re-posted |
| // when the first item is potentially ready. |
| return; |
| } |
| FXL_DCHECK(front->driver_codec_list); |
| |
| for (auto& codec_description : front->driver_codec_list.get()) { |
| FXL_LOG(INFO) << "registering - codec_type: " |
| << fidl::ToUnderlying(codec_description.codec_type) |
| << " mime_type: " << codec_description.mime_type |
| << " device_path: " << front->device_path; |
| hw_codecs_.emplace_front(std::make_unique<CodecListEntry>(CodecListEntry{ |
| .description = std::move(codec_description), |
| // shared_ptr<> |
| .factory = front->codec_factory, |
| })); |
| } |
| |
| device_discovery_queue_.pop_front(); |
| } |
| } |
| |
| } // namespace codec_factory |
