| // 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 "manager_stream_provider.h" |
| |
| #include <lib/fzl/vmo-mapper.h> |
| |
| #include <fbl/unique_fd.h> |
| #include <src/lib/syslog/cpp/logger.h> |
| |
| static constexpr uint32_t kDevicesPopulated = ZX_USER_SIGNAL_0; |
| static constexpr uint32_t kStreamCreated = ZX_USER_SIGNAL_1; |
| static constexpr uint32_t kBuffersAllocated = ZX_USER_SIGNAL_2; |
| |
| ManagerStreamProvider::~ManagerStreamProvider() { |
| if (buffer_collection_) { |
| zx_status_t status = buffer_collection_->Close(); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| } |
| } |
| } |
| |
| std::unique_ptr<StreamProvider> ManagerStreamProvider::Create() { |
| auto provider = std::make_unique<ManagerStreamProvider>(); |
| auto context = sys::ComponentContext::Create(); |
| |
| // Connect to sysmem. |
| zx_status_t status = context->svc()->Connect(provider->allocator_.NewRequest()); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to connect to sysmem allocator service"; |
| return nullptr; |
| } |
| |
| // Connect to manager. |
| status = context->svc()->Connect(provider->manager_.NewRequest(provider->loop_.dispatcher())); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to connect to manager service"; |
| return nullptr; |
| } |
| provider->manager_.set_error_handler([provider = provider.get()](zx_status_t status) { |
| FX_PLOGS(ERROR, status) << "Manager disconnected"; |
| }); |
| |
| // Bind event handlers. |
| provider->manager_.events().OnDeviceAvailable = |
| fit::bind_member(provider.get(), &ManagerStreamProvider::OnDeviceAvailable); |
| provider->manager_.events().OnDeviceUnavailable = |
| fit::bind_member(provider.get(), &ManagerStreamProvider::OnDeviceUnavailable); |
| provider->manager_.events().OnDeviceMuteChanged = |
| fit::bind_member(provider.get(), &ManagerStreamProvider::OnDeviceMuteChanged); |
| |
| // Create an event to track async events. |
| status = zx::event::create(0, &provider->async_events_); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return nullptr; |
| } |
| |
| // Start a thread to process manager and sysmem events. |
| status = provider->loop_.StartThread(); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return nullptr; |
| } |
| |
| // Wait for the devices-populated signal. |
| constexpr uint32_t kWaitTimeForPopulateMsec = 500; |
| status = provider->async_events_.wait_one( |
| kDevicesPopulated, zx::deadline_after(zx::msec(kWaitTimeForPopulateMsec)), nullptr); |
| if (status == ZX_ERR_TIMED_OUT) { |
| FX_PLOGS(ERROR, status) << "Manager failed to populate known devices within " |
| << kWaitTimeForPopulateMsec << "ms"; |
| // TODO(39922): remove camera manager workarounds |
| FX_LOGS(WARNING) << "Not yet implemented by camera manger - continuing anyway with device id 0"; |
| // return nullptr; |
| } else if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return nullptr; |
| } |
| |
| FX_LOGS(INFO) << provider->devices_.size() << " devices reported:"; |
| for (const auto& device : provider->devices_) { |
| FX_LOGS(INFO) << " " << device.first << ": " << device.second.vendor_name() << " | " |
| << device.second.product_name(); |
| } |
| |
| return std::move(provider); |
| } |
| |
| // Offer a stream as served through the tester interface. |
| fit::result< |
| std::tuple<fuchsia::sysmem::ImageFormat_2, fuchsia::sysmem::BufferCollectionInfo_2, bool>, |
| zx_status_t> |
| ManagerStreamProvider::ConnectToStream(fidl::InterfaceRequest<fuchsia::camera2::Stream> request, |
| uint32_t index) { |
| if (index > 0) { |
| return fit::error(ZX_ERR_OUT_OF_RANGE); |
| } |
| |
| constexpr uint32_t kDeviceId = 0; |
| fuchsia::sysmem::BufferCollectionTokenSyncPtr token; |
| zx_status_t status = allocator_->AllocateSharedCollection(token.NewRequest()); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return fit::error(status); |
| } |
| |
| fidl::InterfaceHandle<fuchsia::sysmem::BufferCollectionToken> manager_token; |
| status = token->Duplicate(ZX_RIGHT_SAME_RIGHTS, manager_token.NewRequest()); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return fit::error(status); |
| } |
| |
| fuchsia::sysmem::BufferCollectionPtr collection; |
| status = |
| allocator_->BindSharedCollection(std::move(token), collection.NewRequest(loop_.dispatcher())); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return fit::error(status); |
| } |
| |
| constexpr uint32_t kCampingBufferCount = 2; |
| constexpr uint32_t kFormatIndex = 1; |
| fuchsia::sysmem::BufferCollectionConstraints sysmem_constraints; |
| sysmem_constraints.min_buffer_count_for_camping = kCampingBufferCount; |
| sysmem_constraints.image_format_constraints_count = 0; |
| sysmem_constraints.usage.cpu = fuchsia::sysmem::cpuUsageRead | fuchsia::sysmem::cpuUsageWrite; |
| collection->SetConstraints(true, std::move(sysmem_constraints)); |
| |
| fuchsia::camera2::StreamProperties stream_properties; |
| stream_properties.set_stream_type(fuchsia::camera2::CameraStreamType::MONITORING); |
| fuchsia::camera2::StreamConstraints stream_constraints; |
| stream_constraints.set_properties(std::move(stream_properties)); |
| stream_constraints.set_format_index(kFormatIndex); |
| fuchsia::sysmem::ImageFormat_2 format_ret; |
| manager_->ConnectToStream(kDeviceId, std::move(stream_constraints), std::move(manager_token), |
| std::move(request), |
| [this, &format_ret](fuchsia::sysmem::ImageFormat_2 format) { |
| format_ret = std::move(format); |
| async_events_.signal(0, kStreamCreated); |
| }); |
| |
| fuchsia::sysmem::BufferCollectionInfo_2 buffers_ret; |
| collection->WaitForBuffersAllocated( |
| [this, &buffers_ret, &collection](zx_status_t status, |
| fuchsia::sysmem::BufferCollectionInfo_2 buffers) { |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return; |
| } |
| buffers_ret = std::move(buffers); |
| collection->Close(); |
| async_events_.signal(0, kBuffersAllocated); |
| }); |
| |
| constexpr uint32_t kWaitTimeForFormatMsec = 20000; |
| status = async_events_.wait_one(kStreamCreated, |
| zx::deadline_after(zx::msec(kWaitTimeForFormatMsec)), nullptr); |
| if (status == ZX_ERR_TIMED_OUT) { |
| FX_PLOGS(ERROR, status) << "Manager failed to create the stream within " |
| << kWaitTimeForFormatMsec << "ms"; |
| return fit::error(status); |
| } else if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return fit::error(status); |
| } |
| |
| constexpr uint32_t kWaitTimeForSysmemMsec = 20000; |
| status = async_events_.wait_one(kBuffersAllocated, |
| zx::deadline_after(zx::msec(kWaitTimeForSysmemMsec)), nullptr); |
| if (status == ZX_ERR_TIMED_OUT) { |
| FX_PLOGS(ERROR, status) << "Sysmem failed to allocate buffers within " << kWaitTimeForSysmemMsec |
| << "ms"; |
| return fit::error(status); |
| } else if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return fit::error(status); |
| } |
| |
| // The stream from controller is currently unrotated. |
| // TODO: once GDC is hooked up to do the rotation within the controller, set this to 'false' |
| return fit::ok(std::make_tuple(std::move(format_ret), std::move(buffers_ret), true)); |
| } |
| |
| void ManagerStreamProvider::OnDeviceAvailable(int device_id, |
| fuchsia::camera2::DeviceInfo description, |
| bool last_known_camera) { |
| auto it = devices_.find(device_id); |
| if (it != devices_.end()) { |
| FX_LOGS(ERROR) << "device id " << device_id << " already reported to us!"; |
| return; |
| } |
| devices_.emplace(std::make_pair(device_id, std::move(description))); |
| |
| if (last_known_camera) { |
| zx_status_t status = async_events_.signal(0, kDevicesPopulated); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status); |
| return; |
| } |
| } |
| |
| manager_->AcknowledgeDeviceEvent(); |
| } |
| |
| void ManagerStreamProvider::OnDeviceUnavailable(int device_id) { |
| // TODO(msandy): devices_ needs a lock once manager starts sending its own events |
| auto it = devices_.find(device_id); |
| if (it == devices_.end()) { |
| FX_LOGS(ERROR) << "device id " << device_id << " was never reported to us!"; |
| return; |
| } |
| devices_.erase(it); |
| manager_->AcknowledgeDeviceEvent(); |
| } |
| |
| void ManagerStreamProvider::OnDeviceMuteChanged(int device_id, bool currently_muted) { |
| manager_->AcknowledgeDeviceEvent(); |
| } |
