midi_manager_usb.h 3.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef MEDIA_MIDI_MIDI_MANAGER_USB_H_
  5. #define MEDIA_MIDI_MIDI_MANAGER_USB_H_
  6. #include <stddef.h>
  7. #include <stdint.h>
  8. #include <memory>
  9. #include <unordered_map>
  10. #include <utility>
  11. #include <vector>
  12. #include "base/compiler_specific.h"
  13. #include "base/hash/hash.h"
  14. #include "base/synchronization/lock.h"
  15. #include "base/time/time.h"
  16. #include "media/midi/midi_manager.h"
  17. #include "media/midi/usb_midi_device.h"
  18. #include "media/midi/usb_midi_export.h"
  19. #include "media/midi/usb_midi_input_stream.h"
  20. #include "media/midi/usb_midi_jack.h"
  21. #include "media/midi/usb_midi_output_stream.h"
  22. namespace midi {
  23. class MidiService;
  24. // MidiManager for USB-MIDI.
  25. class USB_MIDI_EXPORT MidiManagerUsb : public MidiManager,
  26. public UsbMidiDeviceDelegate,
  27. public UsbMidiInputStream::Delegate {
  28. public:
  29. MidiManagerUsb(MidiService* service,
  30. std::unique_ptr<UsbMidiDevice::Factory> device_factory);
  31. MidiManagerUsb(const MidiManagerUsb&) = delete;
  32. MidiManagerUsb& operator=(const MidiManagerUsb&) = delete;
  33. ~MidiManagerUsb() override;
  34. // MidiManager implementation.
  35. void StartInitialization() override;
  36. void DispatchSendMidiData(MidiManagerClient* client,
  37. uint32_t port_index,
  38. const std::vector<uint8_t>& data,
  39. base::TimeTicks timestamp) override;
  40. // UsbMidiDeviceDelegate implementation.
  41. void ReceiveUsbMidiData(UsbMidiDevice* device,
  42. int endpoint_number,
  43. const uint8_t* data,
  44. size_t size,
  45. base::TimeTicks time) override;
  46. void OnDeviceAttached(std::unique_ptr<UsbMidiDevice> device) override;
  47. void OnDeviceDetached(size_t index) override;
  48. // UsbMidiInputStream::Delegate implementation.
  49. void OnReceivedData(size_t jack_index,
  50. const uint8_t* data,
  51. size_t size,
  52. base::TimeTicks time) override;
  53. const std::vector<std::unique_ptr<UsbMidiOutputStream>>& output_streams()
  54. const {
  55. return output_streams_;
  56. }
  57. const UsbMidiInputStream* input_stream() const { return input_stream_.get(); }
  58. private:
  59. // Initializes this object.
  60. // When the initialization finishes, CompleteInitialization will be called
  61. // with the result on the same thread, but asynchronously.
  62. // When this factory is destroyed during the operation, the operation
  63. // will be canceled silently (i.e. CompleteInitialization will not be called).
  64. void Initialize();
  65. void OnEnumerateDevicesDone(bool result, UsbMidiDevice::Devices* devices);
  66. bool AddPorts(UsbMidiDevice* device, int device_id);
  67. // TODO(toyoshim): Remove |lock_| once dynamic instantiation mode is enabled
  68. // by default. This protects objects allocated on the I/O thread from doubly
  69. // released on the main thread.
  70. base::Lock lock_;
  71. std::unique_ptr<UsbMidiDevice::Factory> device_factory_;
  72. std::vector<std::unique_ptr<UsbMidiDevice>> devices_;
  73. std::vector<std::unique_ptr<UsbMidiOutputStream>> output_streams_;
  74. std::unique_ptr<UsbMidiInputStream> input_stream_;
  75. // A map from <endpoint_number, cable_number> to the index of input jacks.
  76. std::unordered_map<std::pair<int, int>,
  77. size_t,
  78. base::IntPairHash<std::pair<int, int>>>
  79. input_jack_dictionary_;
  80. };
  81. } // namespace midi
  82. #endif // MEDIA_MIDI_MIDI_MANAGER_USB_H_