Home | History | Annotate | Download | only in midi
      1 // Copyright (c) 2013 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 
      5 #ifndef MEDIA_MIDI_MIDI_MANAGER_H_
      6 #define MEDIA_MIDI_MIDI_MANAGER_H_
      7 
      8 #include <set>
      9 #include <vector>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/synchronization/lock.h"
     13 #include "media/base/media_export.h"
     14 #include "media/midi/midi_port_info.h"
     15 
     16 namespace media {
     17 
     18 // A MIDIManagerClient registers with the MIDIManager to receive MIDI data.
     19 // See MIDIManager::RequestAccess() and MIDIManager::ReleaseAccess()
     20 // for details.
     21 class MEDIA_EXPORT MIDIManagerClient {
     22  public:
     23    virtual ~MIDIManagerClient() {}
     24 
     25   // ReceiveMIDIData() is called when MIDI data has been received from the
     26   // MIDI system.
     27   // |port_index| represents the specific input port from input_ports().
     28   // |data| represents a series of bytes encoding one or more MIDI messages.
     29   // |length| is the number of bytes in |data|.
     30   // |timestamp| is the time the data was received, in seconds.
     31   virtual void ReceiveMIDIData(uint32 port_index,
     32                                const uint8* data,
     33                                size_t length,
     34                                double timestamp) = 0;
     35 
     36   // AccumulateMIDIBytesSent() is called to acknowledge when bytes have
     37   // successfully been sent to the hardware.
     38   // This happens as a result of the client having previously called
     39   // MIDIManager::DispatchSendMIDIData().
     40   virtual void AccumulateMIDIBytesSent(size_t n) = 0;
     41 };
     42 
     43 // Manages access to all MIDI hardware.
     44 class MEDIA_EXPORT MIDIManager {
     45  public:
     46   static MIDIManager* Create();
     47 
     48   MIDIManager();
     49   virtual ~MIDIManager();
     50 
     51   // A client calls StartSession() to receive and send MIDI data.
     52   // If the session is ready to start, the MIDI system is lazily initialized
     53   // and the client is registered to receive MIDI data.
     54   // Returns |true| if the session succeeds to start.
     55   bool StartSession(MIDIManagerClient* client);
     56 
     57   // A client calls ReleaseSession() to stop receiving MIDI data.
     58   void EndSession(MIDIManagerClient* client);
     59 
     60   // DispatchSendMIDIData() is called when MIDI data should be sent to the MIDI
     61   // system.
     62   // This method is supposed to return immediately and should not block.
     63   // |port_index| represents the specific output port from output_ports().
     64   // |data| represents a series of bytes encoding one or more MIDI messages.
     65   // |length| is the number of bytes in |data|.
     66   // |timestamp| is the time to send the data, in seconds. A value of 0
     67   // means send "now" or as soon as possible.
     68   virtual void DispatchSendMIDIData(MIDIManagerClient* client,
     69                                     uint32 port_index,
     70                                     const std::vector<uint8>& data,
     71                                     double timestamp) = 0;
     72 
     73   // input_ports() is a list of MIDI ports for receiving MIDI data.
     74   // Each individual port in this list can be identified by its
     75   // integer index into this list.
     76   const MIDIPortInfoList& input_ports() { return input_ports_; }
     77 
     78   // output_ports() is a list of MIDI ports for sending MIDI data.
     79   // Each individual port in this list can be identified by its
     80   // integer index into this list.
     81   const MIDIPortInfoList& output_ports() { return output_ports_; }
     82 
     83  protected:
     84   // Initializes the MIDI system, returning |true| on success.
     85   virtual bool Initialize() = 0;
     86 
     87   void AddInputPort(const MIDIPortInfo& info);
     88   void AddOutputPort(const MIDIPortInfo& info);
     89 
     90   // Dispatches to all clients.
     91   void ReceiveMIDIData(uint32 port_index,
     92                        const uint8* data,
     93                        size_t length,
     94                        double timestamp);
     95 
     96   bool initialized_;
     97 
     98   // Keeps track of all clients who wish to receive MIDI data.
     99   typedef std::set<MIDIManagerClient*> ClientList;
    100   ClientList clients_;
    101 
    102   // Protects access to our clients.
    103   base::Lock clients_lock_;
    104 
    105   MIDIPortInfoList input_ports_;
    106   MIDIPortInfoList output_ports_;
    107 
    108   DISALLOW_COPY_AND_ASSIGN(MIDIManager);
    109 };
    110 
    111 }  // namespace media
    112 
    113 #endif  // MEDIA_MIDI_MIDI_MANAGER_H_
    114