| // Copyright 2016 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #ifdef UNSAFE_BUFFERS_BUILD | |
| // TODO(crbug.com/40285824): Remove this and convert code to safer constructs. | |
| #pragma allow_unsafe_buffers | |
| #endif | |
| #include "media/midi/midi_manager_winrt.h" | |
| #include "base/memory/raw_ptr.h" | |
| #pragma warning(disable : 4467) | |
| #define INITGUID | |
| #include <objbase.h> | |
| #include <initguid.h> | |
| #include <windows.h> | |
| #include <cfgmgr32.h> | |
| #include <comdef.h> | |
| #include <devpkey.h> | |
| #include <robuffer.h> | |
| #include <windows.devices.enumeration.h> | |
| #include <windows.devices.midi.h> | |
| #include <wrl/client.h> | |
| #include <wrl/event.h> | |
| #include <iomanip> | |
| #include <memory> | |
| #include "base/containers/heap_array.h" | |
| #include "base/functional/bind.h" | |
| #include "base/scoped_generic.h" | |
| #include "base/strings/string_util.h" | |
| #include "base/strings/utf_string_conversions.h" | |
| #include "base/timer/timer.h" | |
| #include "base/win/core_winrt_util.h" | |
| #include "base/win/scoped_hstring.h" | |
| #include "base/win/winrt_storage_util.h" | |
| #include "media/midi/midi_service.h" | |
| #include "media/midi/task_service.h" | |
| #include "third_party/abseil-cpp/absl/container/flat_hash_map.h" | |
| #include "third_party/abseil-cpp/absl/container/flat_hash_set.h" | |
| namespace midi { | |
| namespace { | |
| namespace WRL = Microsoft::WRL; | |
| namespace Win = ABI::Windows; | |
| using base::win::GetActivationFactory; | |
| using base::win::ScopedHString; | |
| using mojom::PortState; | |
| using mojom::Result; | |
| using Win::Devices::Enumeration::DeviceInformationUpdate; | |
| using Win::Devices::Enumeration::DeviceWatcher; | |
| using Win::Devices::Enumeration::IDeviceInformation; | |
| using Win::Devices::Enumeration::IDeviceInformationUpdate; | |
| using Win::Devices::Enumeration::IDeviceWatcher; | |
| using Win::Foundation::IAsyncOperation; | |
| using Win::Foundation::ITypedEventHandler; | |
| // Alias for printing HRESULT. | |
| const auto PrintHr = logging::SystemErrorCodeToString; | |
| enum { | |
| kDefaultTaskRunner = TaskService::kDefaultRunnerId, | |
| kComTaskRunner | |
| }; | |
| template <typename T> | |
| std::string GetIdString(T* obj) { | |
| HSTRING result; | |
| HRESULT hr = obj->get_Id(&result); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "get_Id failed: " << PrintHr(hr); | |
| return std::string(); | |
| } | |
| return ScopedHString(result).GetAsUTF8(); | |
| } | |
| template <typename T> | |
| std::string GetDeviceIdString(T* obj) { | |
| HSTRING result; | |
| HRESULT hr = obj->get_DeviceId(&result); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "get_DeviceId failed: " << PrintHr(hr); | |
| return std::string(); | |
| } | |
| return ScopedHString(result).GetAsUTF8(); | |
| } | |
| std::string GetNameString(IDeviceInformation* info) { | |
| HSTRING result; | |
| HRESULT hr = info->get_Name(&result); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "get_Name failed: " << PrintHr(hr); | |
| return std::string(); | |
| } | |
| return ScopedHString(result).GetAsUTF8(); | |
| } | |
| // Checks if given DeviceInformation represent a Microsoft GS Wavetable Synth | |
| // instance. | |
| bool IsMicrosoftSynthesizer(IDeviceInformation* info) { | |
| WRL::ComPtr<Win::Devices::Midi::IMidiSynthesizerStatics> | |
| midi_synthesizer_statics; | |
| HRESULT hr = | |
| GetActivationFactory<Win::Devices::Midi::IMidiSynthesizerStatics, | |
| RuntimeClass_Windows_Devices_Midi_MidiSynthesizer>( | |
| &midi_synthesizer_statics); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "IMidiSynthesizerStatics factory failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| boolean result = FALSE; | |
| hr = midi_synthesizer_statics->IsSynthesizer(info, &result); | |
| VLOG_IF(1, FAILED(hr)) << "IsSynthesizer failed: " << PrintHr(hr); | |
| return result != FALSE; | |
| } | |
| void GetDevPropString(DEVINST handle, | |
| const DEVPROPKEY* devprop_key, | |
| std::string* out) { | |
| DEVPROPTYPE devprop_type; | |
| unsigned long buffer_size = 0; | |
| // Retrieve |buffer_size| and allocate buffer later for receiving data. | |
| CONFIGRET cr = CM_Get_DevNode_Property(handle, devprop_key, &devprop_type, | |
| nullptr, &buffer_size, 0); | |
| if (cr != CR_BUFFER_SMALL) { | |
| // Here we print error codes in hex instead of using PrintHr() with | |
| // HRESULT_FROM_WIN32() and CM_MapCrToWin32Err(), since only a minor set of | |
| // CONFIGRET values are mapped to Win32 errors. Same for following VLOG()s. | |
| VLOG(1) << "CM_Get_DevNode_Property failed: CONFIGRET 0x" << std::hex << cr; | |
| return; | |
| } | |
| if (devprop_type != DEVPROP_TYPE_STRING) { | |
| VLOG(1) << "CM_Get_DevNode_Property returns wrong data type, " | |
| << "expected DEVPROP_TYPE_STRING"; | |
| return; | |
| } | |
| auto buffer = base::HeapArray<uint8_t>::Uninit(buffer_size); | |
| // Receive property data. | |
| cr = CM_Get_DevNode_Property(handle, devprop_key, &devprop_type, | |
| buffer.data(), &buffer_size, 0); | |
| if (cr != CR_SUCCESS) | |
| VLOG(1) << "CM_Get_DevNode_Property failed: CONFIGRET 0x" << std::hex << cr; | |
| else | |
| *out = base::WideToUTF8(reinterpret_cast<wchar_t*>(buffer.data())); | |
| } | |
| // Retrieves manufacturer (provider) and version information of underlying | |
| // device driver through PnP Configuration Manager, given device (interface) ID | |
| // provided by WinRT. |out_manufacturer| and |out_driver_version| won't be | |
| // modified if retrieval fails. | |
| // | |
| // Device instance ID is extracted from device (interface) ID provided by WinRT | |
| // APIs, for example from the following interface ID: | |
| // \\?\SWD#MMDEVAPI#MIDII_60F39FCA.P_0002#{504be32c-ccf6-4d2c-b73f-6f8b3747e22b} | |
| // we extract the device instance ID: SWD\MMDEVAPI\MIDII_60F39FCA.P_0002 | |
| // | |
| // However the extracted device instance ID represent a "software device" | |
| // provided by Microsoft, which is an interface on top of the hardware for each | |
| // input/output port. Therefore we further locate its parent device, which is | |
| // the actual hardware device, for driver information. | |
| void GetDriverInfoFromDeviceId(const std::string& dev_id, | |
| std::string* out_manufacturer, | |
| std::string* out_driver_version) { | |
| std::wstring dev_instance_id = | |
| base::UTF8ToWide(dev_id.substr(4, dev_id.size() - 43)); | |
| base::ReplaceChars(dev_instance_id, L"#", L"\\", &dev_instance_id); | |
| DEVINST dev_instance_handle; | |
| CONFIGRET cr = CM_Locate_DevNode(&dev_instance_handle, &dev_instance_id[0], | |
| CM_LOCATE_DEVNODE_NORMAL); | |
| if (cr != CR_SUCCESS) { | |
| VLOG(1) << "CM_Locate_DevNode failed: CONFIGRET 0x" << std::hex << cr; | |
| return; | |
| } | |
| DEVINST parent_handle; | |
| cr = CM_Get_Parent(&parent_handle, dev_instance_handle, 0); | |
| if (cr != CR_SUCCESS) { | |
| VLOG(1) << "CM_Get_Parent failed: CONFIGRET 0x" << std::hex << cr; | |
| return; | |
| } | |
| GetDevPropString(parent_handle, &DEVPKEY_Device_DriverProvider, | |
| out_manufacturer); | |
| GetDevPropString(parent_handle, &DEVPKEY_Device_DriverVersion, | |
| out_driver_version); | |
| } | |
| // Tokens with value = 0 are considered invalid (as in <wrl/event.h>). | |
| const int64_t kInvalidTokenValue = 0; | |
| template <typename InterfaceType> | |
| struct MidiPort { | |
| MidiPort() = default; | |
| MidiPort(const MidiPort&) = delete; | |
| MidiPort& operator=(const MidiPort&) = delete; | |
| uint32_t index; | |
| WRL::ComPtr<InterfaceType> handle; | |
| EventRegistrationToken token_MessageReceived; | |
| }; | |
| } // namespace | |
| template <typename InterfaceType, | |
| typename RuntimeType, | |
| typename StaticsInterfaceType, | |
| wchar_t const* runtime_class_id> | |
| class MidiManagerWinrt::MidiPortManager { | |
| public: | |
| // MidiPortManager instances should be constructed on the kComTaskRunner. | |
| MidiPortManager(MidiManagerWinrt* midi_manager) | |
| : midi_service_(midi_manager->service()), midi_manager_(midi_manager) {} | |
| virtual ~MidiPortManager() { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| } | |
| bool StartWatcher() { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| HRESULT hr = GetActivationFactory<StaticsInterfaceType, runtime_class_id>( | |
| &midi_port_statics_); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "StaticsInterfaceType factory failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| HSTRING device_selector = nullptr; | |
| hr = midi_port_statics_->GetDeviceSelector(&device_selector); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "GetDeviceSelector failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| WRL::ComPtr<Win::Devices::Enumeration::IDeviceInformationStatics> | |
| dev_info_statics; | |
| hr = GetActivationFactory< | |
| Win::Devices::Enumeration::IDeviceInformationStatics, | |
| RuntimeClass_Windows_Devices_Enumeration_DeviceInformation>( | |
| &dev_info_statics); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "IDeviceInformationStatics failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| hr = dev_info_statics->CreateWatcherAqsFilter(device_selector, &watcher_); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "CreateWatcherAqsFilter failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| // Register callbacks to WinRT that post state-modifying tasks back to | |
| // kComTaskRunner. All posted tasks run only during the MidiPortManager | |
| // instance is alive. This is ensured by MidiManagerWinrt by calling | |
| // UnbindInstance() before destructing any MidiPortManager instance. Thus | |
| // we can handle raw pointers safely in the following blocks. | |
| MidiPortManager* port_manager = this; | |
| TaskService* task_service = midi_service_->task_service(); | |
| hr = watcher_->add_Added( | |
| WRL::Callback<ITypedEventHandler< | |
| DeviceWatcher*, Win::Devices::Enumeration::DeviceInformation*>>( | |
| [port_manager, task_service](IDeviceWatcher* watcher, | |
| IDeviceInformation* info) { | |
| if (!info) { | |
| VLOG(1) << "DeviceWatcher.Added callback provides null " | |
| "pointer, ignoring"; | |
| return S_OK; | |
| } | |
| // Disable Microsoft GS Wavetable Synth due to security reasons. | |
| // http://crbug.com/499279 | |
| if (IsMicrosoftSynthesizer(info)) | |
| return S_OK; | |
| std::string dev_id = GetIdString(info), | |
| dev_name = GetNameString(info); | |
| task_service->PostBoundTask( | |
| kComTaskRunner, base::BindOnce(&MidiPortManager::OnAdded, | |
| base::Unretained(port_manager), | |
| dev_id, dev_name)); | |
| return S_OK; | |
| }) | |
| .Get(), | |
| &token_Added_); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "add_Added failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| hr = watcher_->add_EnumerationCompleted( | |
| WRL::Callback<ITypedEventHandler<DeviceWatcher*, IInspectable*>>( | |
| [port_manager, task_service](IDeviceWatcher* watcher, | |
| IInspectable* insp) { | |
| task_service->PostBoundTask( | |
| kComTaskRunner, | |
| base::BindOnce(&MidiPortManager::OnEnumerationCompleted, | |
| base::Unretained(port_manager))); | |
| return S_OK; | |
| }) | |
| .Get(), | |
| &token_EnumerationCompleted_); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "add_EnumerationCompleted failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| hr = watcher_->add_Removed( | |
| WRL::Callback< | |
| ITypedEventHandler<DeviceWatcher*, DeviceInformationUpdate*>>( | |
| [port_manager, task_service](IDeviceWatcher* watcher, | |
| IDeviceInformationUpdate* update) { | |
| if (!update) { | |
| VLOG(1) << "DeviceWatcher.Removed callback provides null " | |
| "pointer, ignoring"; | |
| return S_OK; | |
| } | |
| std::string dev_id = GetIdString(update); | |
| task_service->PostBoundTask( | |
| kComTaskRunner, | |
| base::BindOnce(&MidiPortManager::OnRemoved, | |
| base::Unretained(port_manager), dev_id)); | |
| return S_OK; | |
| }) | |
| .Get(), | |
| &token_Removed_); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "add_Removed failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| hr = watcher_->add_Stopped( | |
| WRL::Callback<ITypedEventHandler<DeviceWatcher*, IInspectable*>>( | |
| [](IDeviceWatcher* watcher, IInspectable* insp) { | |
| // Placeholder, does nothing for now. | |
| return S_OK; | |
| }) | |
| .Get(), | |
| &token_Stopped_); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "add_Stopped failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| hr = watcher_->add_Updated( | |
| WRL::Callback< | |
| ITypedEventHandler<DeviceWatcher*, DeviceInformationUpdate*>>( | |
| [](IDeviceWatcher* watcher, IDeviceInformationUpdate* update) { | |
| // TODO(shaochuan): Check for fields to be updated here. | |
| return S_OK; | |
| }) | |
| .Get(), | |
| &token_Updated_); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "add_Updated failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| hr = watcher_->Start(); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "Start failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| is_initialized_ = true; | |
| return true; | |
| } | |
| void StopWatcher() { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| HRESULT hr; | |
| for (const auto& entry : ports_) | |
| RemovePortEventHandlers(entry.second.get()); | |
| if (token_Added_.value != kInvalidTokenValue) { | |
| hr = watcher_->remove_Added(token_Added_); | |
| VLOG_IF(1, FAILED(hr)) << "remove_Added failed: " << PrintHr(hr); | |
| token_Added_.value = kInvalidTokenValue; | |
| } | |
| if (token_EnumerationCompleted_.value != kInvalidTokenValue) { | |
| hr = watcher_->remove_EnumerationCompleted(token_EnumerationCompleted_); | |
| VLOG_IF(1, FAILED(hr)) << "remove_EnumerationCompleted failed: " | |
| << PrintHr(hr); | |
| token_EnumerationCompleted_.value = kInvalidTokenValue; | |
| } | |
| if (token_Removed_.value != kInvalidTokenValue) { | |
| hr = watcher_->remove_Removed(token_Removed_); | |
| VLOG_IF(1, FAILED(hr)) << "remove_Removed failed: " << PrintHr(hr); | |
| token_Removed_.value = kInvalidTokenValue; | |
| } | |
| if (token_Stopped_.value != kInvalidTokenValue) { | |
| hr = watcher_->remove_Stopped(token_Stopped_); | |
| VLOG_IF(1, FAILED(hr)) << "remove_Stopped failed: " << PrintHr(hr); | |
| token_Stopped_.value = kInvalidTokenValue; | |
| } | |
| if (token_Updated_.value != kInvalidTokenValue) { | |
| hr = watcher_->remove_Updated(token_Updated_); | |
| VLOG_IF(1, FAILED(hr)) << "remove_Updated failed: " << PrintHr(hr); | |
| token_Updated_.value = kInvalidTokenValue; | |
| } | |
| if (is_initialized_) { | |
| hr = watcher_->Stop(); | |
| VLOG_IF(1, FAILED(hr)) << "Stop failed: " << PrintHr(hr); | |
| is_initialized_ = false; | |
| } | |
| } | |
| MidiPort<InterfaceType>* GetPortByDeviceId(std::string dev_id) { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| CHECK(is_initialized_); | |
| auto it = ports_.find(dev_id); | |
| if (it == ports_.end()) | |
| return nullptr; | |
| return it->second.get(); | |
| } | |
| MidiPort<InterfaceType>* GetPortByIndex(uint32_t port_index) { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| CHECK(is_initialized_); | |
| return GetPortByDeviceId(port_ids_[port_index]); | |
| } | |
| protected: | |
| // Points to the MidiService instance, which is expected to outlive the | |
| // MidiPortManager instance. | |
| raw_ptr<MidiService> midi_service_; | |
| // Points to the MidiManagerWinrt instance, which is safe to be accessed | |
| // from tasks that are invoked by TaskService. | |
| raw_ptr<MidiManagerWinrt> midi_manager_; | |
| private: | |
| // DeviceWatcher callbacks: | |
| void OnAdded(std::string dev_id, std::string dev_name) { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| CHECK(is_initialized_); | |
| port_names_[dev_id] = dev_name; | |
| ScopedHString dev_id_hstring = ScopedHString::Create(dev_id); | |
| if (!dev_id_hstring.is_valid()) | |
| return; | |
| IAsyncOperation<RuntimeType*>* async_op; | |
| HRESULT hr = | |
| midi_port_statics_->FromIdAsync(dev_id_hstring.get(), &async_op); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "FromIdAsync failed: " << PrintHr(hr); | |
| return; | |
| } | |
| MidiPortManager* port_manager = this; | |
| TaskService* task_service = midi_service_->task_service(); | |
| hr = async_op->put_Completed( | |
| WRL::Callback< | |
| Win::Foundation::IAsyncOperationCompletedHandler<RuntimeType*>>( | |
| [port_manager, task_service]( | |
| IAsyncOperation<RuntimeType*>* async_op, AsyncStatus status) { | |
| // A reference to |async_op| is kept in |async_ops_|, safe to pass | |
| // outside. | |
| task_service->PostBoundTask( | |
| kComTaskRunner, | |
| base::BindOnce( | |
| &MidiPortManager::OnCompletedGetPortFromIdAsync, | |
| base::Unretained(port_manager), | |
| base::Unretained(async_op))); | |
| return S_OK; | |
| }) | |
| .Get()); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "put_Completed failed: " << PrintHr(hr); | |
| return; | |
| } | |
| // Keep a reference to incompleted |async_op| for releasing later. | |
| async_ops_.insert(async_op); | |
| } | |
| void OnEnumerationCompleted() { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| CHECK(is_initialized_); | |
| if (async_ops_.empty()) | |
| midi_manager_->OnPortManagerReady(); | |
| else | |
| enumeration_completed_not_ready_ = true; | |
| } | |
| void OnRemoved(std::string dev_id) { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| CHECK(is_initialized_); | |
| // Note: in case Microsoft GS Wavetable Synth triggers this event for some | |
| // reason, it will be ignored here with log emitted. | |
| MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id); | |
| if (!port) { | |
| VLOG(1) << "Removing non-existent port " << dev_id; | |
| return; | |
| } | |
| SetPortState(port->index, PortState::DISCONNECTED); | |
| RemovePortEventHandlers(port); | |
| port->handle = nullptr; | |
| } | |
| void OnCompletedGetPortFromIdAsync(IAsyncOperation<RuntimeType*>* async_op) { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| CHECK(is_initialized_); | |
| InterfaceType* handle = nullptr; | |
| HRESULT hr = async_op->GetResults(&handle); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "GetResults failed: " << PrintHr(hr); | |
| return; | |
| } | |
| // Manually release COM interface to completed |async_op|. | |
| auto it = async_ops_.find(async_op); | |
| CHECK(it != async_ops_.end()); | |
| (*it)->Release(); | |
| async_ops_.erase(it); | |
| if (!handle) { | |
| VLOG(1) << "Midi{In,Out}Port.FromIdAsync callback provides null pointer, " | |
| "ignoring"; | |
| return; | |
| } | |
| EventRegistrationToken token = {kInvalidTokenValue}; | |
| if (!RegisterOnMessageReceived(handle, &token)) | |
| return; | |
| std::string dev_id = GetDeviceIdString(handle); | |
| MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id); | |
| if (port == nullptr) { | |
| std::string manufacturer = "Unknown", driver_version = "Unknown"; | |
| GetDriverInfoFromDeviceId(dev_id, &manufacturer, &driver_version); | |
| AddPort(mojom::PortInfo(dev_id, manufacturer, port_names_[dev_id], | |
| driver_version, PortState::OPENED)); | |
| port = new MidiPort<InterfaceType>; | |
| port->index = static_cast<uint32_t>(port_ids_.size()); | |
| ports_[dev_id].reset(port); | |
| port_ids_.push_back(dev_id); | |
| } else { | |
| SetPortState(port->index, PortState::CONNECTED); | |
| } | |
| port->handle = handle; | |
| port->token_MessageReceived = token; | |
| if (enumeration_completed_not_ready_ && async_ops_.empty()) { | |
| midi_manager_->OnPortManagerReady(); | |
| enumeration_completed_not_ready_ = false; | |
| } | |
| } | |
| // Overridden by MidiInPortManager to listen to input ports. | |
| virtual bool RegisterOnMessageReceived(InterfaceType* handle, | |
| EventRegistrationToken* p_token) { | |
| return true; | |
| } | |
| // Overridden by MidiInPortManager to remove MessageReceived event handler. | |
| virtual void RemovePortEventHandlers(MidiPort<InterfaceType>* port) {} | |
| // Calls midi_manager_->Add{Input,Output}Port. | |
| virtual void AddPort(mojom::PortInfo info) = 0; | |
| // Calls midi_manager_->Set{Input,Output}PortState. | |
| virtual void SetPortState(uint32_t port_index, PortState state) = 0; | |
| // Midi{In,Out}PortStatics instance. | |
| WRL::ComPtr<StaticsInterfaceType> midi_port_statics_; | |
| // DeviceWatcher instance and event registration tokens for unsubscribing | |
| // events in destructor. | |
| WRL::ComPtr<IDeviceWatcher> watcher_; | |
| EventRegistrationToken token_Added_ = {kInvalidTokenValue}, | |
| token_EnumerationCompleted_ = {kInvalidTokenValue}, | |
| token_Removed_ = {kInvalidTokenValue}, | |
| token_Stopped_ = {kInvalidTokenValue}, | |
| token_Updated_ = {kInvalidTokenValue}; | |
| // All manipulations to these fields should be done on kComTaskRunner. | |
| absl::flat_hash_map<std::string, std::unique_ptr<MidiPort<InterfaceType>>> | |
| ports_; | |
| std::vector<std::string> port_ids_; | |
| absl::flat_hash_map<std::string, std::string> port_names_; | |
| // Keeps AsyncOperation references before the operation completes. Note that | |
| // raw pointers are used here and the COM interfaces should be released | |
| // manually. | |
| absl::flat_hash_set<IAsyncOperation<RuntimeType*>*> async_ops_; | |
| // Set when device enumeration is completed but OnPortManagerReady() is not | |
| // called since some ports are not yet ready (i.e. |async_ops_| is not empty). | |
| // In such cases, OnPortManagerReady() will be called in | |
| // OnCompletedGetPortFromIdAsync() when the last pending port is ready. | |
| bool enumeration_completed_not_ready_ = false; | |
| // Set if the instance is initialized without error. Should be checked in all | |
| // methods on kComTaskRunner except StartWatcher(). | |
| bool is_initialized_ = false; | |
| }; | |
| class MidiManagerWinrt::MidiInPortManager final | |
| : public MidiPortManager<Win::Devices::Midi::IMidiInPort, | |
| Win::Devices::Midi::MidiInPort, | |
| Win::Devices::Midi::IMidiInPortStatics, | |
| RuntimeClass_Windows_Devices_Midi_MidiInPort> { | |
| public: | |
| MidiInPortManager(MidiManagerWinrt* midi_manager) | |
| : MidiPortManager(midi_manager) {} | |
| MidiInPortManager(const MidiInPortManager&) = delete; | |
| MidiInPortManager& operator=(const MidiInPortManager&) = delete; | |
| private: | |
| // MidiPortManager overrides: | |
| bool RegisterOnMessageReceived(Win::Devices::Midi::IMidiInPort* handle, | |
| EventRegistrationToken* p_token) override { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| MidiInPortManager* port_manager = this; | |
| TaskService* task_service = midi_service_->task_service(); | |
| HRESULT hr = handle->add_MessageReceived( | |
| WRL::Callback<ITypedEventHandler< | |
| Win::Devices::Midi::MidiInPort*, | |
| Win::Devices::Midi::MidiMessageReceivedEventArgs*>>( | |
| [port_manager, task_service]( | |
| Win::Devices::Midi::IMidiInPort* handle, | |
| Win::Devices::Midi::IMidiMessageReceivedEventArgs* args) { | |
| const base::TimeTicks now = base::TimeTicks::Now(); | |
| std::string dev_id = GetDeviceIdString(handle); | |
| WRL::ComPtr<Win::Devices::Midi::IMidiMessage> message; | |
| HRESULT hr = args->get_Message(&message); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "get_Message failed: " << PrintHr(hr); | |
| return hr; | |
| } | |
| WRL::ComPtr<Win::Storage::Streams::IBuffer> buffer; | |
| hr = message->get_RawData(&buffer); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "get_RawData failed: " << PrintHr(hr); | |
| return hr; | |
| } | |
| uint8_t* p_buffer_data = nullptr; | |
| uint32_t data_length = 0; | |
| hr = base::win::GetPointerToBufferData( | |
| buffer.Get(), &p_buffer_data, &data_length); | |
| if (FAILED(hr)) | |
| return hr; | |
| std::vector<uint8_t> data(p_buffer_data, | |
| p_buffer_data + data_length); | |
| task_service->PostBoundTask( | |
| kComTaskRunner, | |
| base::BindOnce(&MidiInPortManager::OnMessageReceived, | |
| base::Unretained(port_manager), dev_id, data, | |
| now)); | |
| return S_OK; | |
| }) | |
| .Get(), | |
| p_token); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "add_MessageReceived failed: " << PrintHr(hr); | |
| return false; | |
| } | |
| return true; | |
| } | |
| void RemovePortEventHandlers( | |
| MidiPort<Win::Devices::Midi::IMidiInPort>* port) override { | |
| if (!(port->handle && | |
| port->token_MessageReceived.value != kInvalidTokenValue)) | |
| return; | |
| HRESULT hr = | |
| port->handle->remove_MessageReceived(port->token_MessageReceived); | |
| VLOG_IF(1, FAILED(hr)) << "remove_MessageReceived failed: " << PrintHr(hr); | |
| port->token_MessageReceived.value = kInvalidTokenValue; | |
| } | |
| void AddPort(mojom::PortInfo info) final { | |
| midi_manager_->AddInputPort(info); | |
| } | |
| void SetPortState(uint32_t port_index, PortState state) final { | |
| midi_manager_->SetInputPortState(port_index, state); | |
| } | |
| // Callback on receiving MIDI input message. | |
| void OnMessageReceived(std::string dev_id, | |
| std::vector<uint8_t> data, | |
| base::TimeTicks time) { | |
| DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| MidiPort<Win::Devices::Midi::IMidiInPort>* port = GetPortByDeviceId(dev_id); | |
| CHECK(port); | |
| midi_manager_->ReceiveMidiData(port->index, data, time); | |
| } | |
| }; | |
| class MidiManagerWinrt::MidiOutPortManager final | |
| : public MidiPortManager<Win::Devices::Midi::IMidiOutPort, | |
| Win::Devices::Midi::IMidiOutPort, | |
| Win::Devices::Midi::IMidiOutPortStatics, | |
| RuntimeClass_Windows_Devices_Midi_MidiOutPort> { | |
| public: | |
| MidiOutPortManager(MidiManagerWinrt* midi_manager) | |
| : MidiPortManager(midi_manager) {} | |
| MidiOutPortManager(const MidiOutPortManager&) = delete; | |
| MidiOutPortManager& operator=(const MidiOutPortManager&) = delete; | |
| private: | |
| // MidiPortManager overrides: | |
| void AddPort(mojom::PortInfo info) final { | |
| midi_manager_->AddOutputPort(info); | |
| } | |
| void SetPortState(uint32_t port_index, PortState state) final { | |
| midi_manager_->SetOutputPortState(port_index, state); | |
| } | |
| }; | |
| namespace { | |
| // FinalizeOnComRunner() run on kComTaskRunner even after the MidiManager | |
| // instance destruction. | |
| void FinalizeOnComRunner( | |
| std::unique_ptr<MidiManagerWinrt::MidiInPortManager> port_manager_in, | |
| std::unique_ptr<MidiManagerWinrt::MidiOutPortManager> port_manager_out) { | |
| if (port_manager_in) | |
| port_manager_in->StopWatcher(); | |
| if (port_manager_out) | |
| port_manager_out->StopWatcher(); | |
| } | |
| } // namespace | |
| MidiManagerWinrt::MidiManagerWinrt(MidiService* service) | |
| : MidiManager(service) {} | |
| MidiManagerWinrt::~MidiManagerWinrt() { | |
| // Unbind and take a lock to ensure that InitializeOnComRunner should not run | |
| // after here. | |
| if (!service()->task_service()->UnbindInstance()) | |
| return; | |
| base::AutoLock auto_lock(lazy_init_member_lock_); | |
| service()->task_service()->PostStaticTask( | |
| kComTaskRunner, | |
| base::BindOnce(&FinalizeOnComRunner, std::move(port_manager_in_), | |
| std::move(port_manager_out_))); | |
| } | |
| void MidiManagerWinrt::StartInitialization() { | |
| if (!service()->task_service()->BindInstance()) | |
| return CompleteInitialization(Result::INITIALIZATION_ERROR); | |
| service()->task_service()->PostBoundTask( | |
| kComTaskRunner, base::BindOnce(&MidiManagerWinrt::InitializeOnComRunner, | |
| base::Unretained(this))); | |
| } | |
| void MidiManagerWinrt::DispatchSendMidiData(MidiManagerClient* client, | |
| uint32_t port_index, | |
| const std::vector<uint8_t>& data, | |
| base::TimeTicks timestamp) { | |
| base::TimeDelta delay = MidiService::TimestampToTimeDeltaDelay(timestamp); | |
| service()->task_service()->PostBoundDelayedTask( | |
| kComTaskRunner, | |
| base::BindOnce(&MidiManagerWinrt::SendOnComRunner, base::Unretained(this), | |
| port_index, data), | |
| delay); | |
| service()->task_service()->PostBoundDelayedTask( | |
| kComTaskRunner, | |
| base::BindOnce(&MidiManagerWinrt::AccumulateMidiBytesSent, | |
| base::Unretained(this), client, data.size()), | |
| delay); | |
| } | |
| void MidiManagerWinrt::InitializeOnComRunner() { | |
| base::AutoLock auto_lock(lazy_init_member_lock_); | |
| DCHECK(service()->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| port_manager_in_ = std::make_unique<MidiInPortManager>(this); | |
| port_manager_out_ = std::make_unique<MidiOutPortManager>(this); | |
| if (!(port_manager_in_->StartWatcher() && | |
| port_manager_out_->StartWatcher())) { | |
| port_manager_in_->StopWatcher(); | |
| port_manager_out_->StopWatcher(); | |
| service()->task_service()->PostBoundTask( | |
| kDefaultTaskRunner, | |
| base::BindOnce(&MidiManagerWinrt::CompleteInitialization, | |
| base::Unretained(this), Result::INITIALIZATION_ERROR)); | |
| } | |
| } | |
| void MidiManagerWinrt::SendOnComRunner(uint32_t port_index, | |
| const std::vector<uint8_t>& data) { | |
| DCHECK(service()->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| base::AutoLock auto_lock(lazy_init_member_lock_); | |
| MidiPort<Win::Devices::Midi::IMidiOutPort>* port = | |
| port_manager_out_->GetPortByIndex(port_index); | |
| if (!(port && port->handle)) { | |
| VLOG(1) << "Port not available: " << port_index; | |
| return; | |
| } | |
| WRL::ComPtr<Win::Storage::Streams::IBuffer> buffer; | |
| HRESULT hr = base::win::CreateIBufferFromData( | |
| data.data(), static_cast<UINT32>(data.size()), &buffer); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "CreateIBufferFromData failed: " << PrintHr(hr); | |
| return; | |
| } | |
| hr = port->handle->SendBuffer(buffer.Get()); | |
| if (FAILED(hr)) { | |
| VLOG(1) << "SendBuffer failed: " << PrintHr(hr); | |
| return; | |
| } | |
| } | |
| void MidiManagerWinrt::OnPortManagerReady() { | |
| DCHECK(service()->task_service()->IsOnTaskRunner(kComTaskRunner)); | |
| DCHECK(port_manager_ready_count_ < 2); | |
| if (++port_manager_ready_count_ == 2) { | |
| service()->task_service()->PostBoundTask( | |
| kDefaultTaskRunner, | |
| base::BindOnce(&MidiManagerWinrt::CompleteInitialization, | |
| base::Unretained(this), Result::OK)); | |
| } | |
| } | |
| } // namespace midi |