comparison data/midi/rtmidi/RtMidi.cpp @ 843:e802e550a1f2

Drop std:: from cout, cerr, endl -- pull these in through Debug.h

 // RtMidi: Version 1.0.8
 
 #include "RtMidi.h"
 #include <sstream>
 
+using std::cerr;
+using std::endl;
+
 //*********************************************************************//
 //  Common RtMidi Definitions
 //*********************************************************************//
 
 RtMidi :: RtMidi()

 }
 
 void RtMidi :: error( RtError::Type type )
 {
   if (type == RtError::WARNING) {
-    std::cerr << '\n' << errorString_ << "\n\n";
+    cerr << '\n' << errorString_ << "\n\n";
   }
   else if (type == RtError::DEBUG_WARNING) {
 #if defined(__RTMIDI_DEBUG__)
-    std::cerr << '\n' << errorString_ << "\n\n";
+    cerr << '\n' << errorString_ << "\n\n";
 #endif
   }
   else {
-    std::cerr << '\n' << errorString_ << "\n\n";
+    cerr << '\n' << errorString_ << "\n\n";
     throw RtError( errorString_, type );
   }
 }
 
 //*********************************************************************//

         else {
           // As long as we haven't reached our queue size limit, push the message.
           if ( data->queueLimit > data->queue.size() )
             data->queue.push( message );
           else
-            std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
+            cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
         }
         message.bytes.clear();
       }
     }
     else {

             else {
               // As long as we haven't reached our queue size limit, push the message.
               if ( data->queueLimit > data->queue.size() )
                 data->queue.push( message );
               else
-                std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
+                cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
             }
             message.bytes.clear();
           }
           iByte += size;
         }

   int result;
   apiData->bufferSize = 32;
   result = snd_midi_event_new( 0, &apiData->coder );
   if ( result < 0 ) {
     data->doInput = false;
-    std::cerr << "\nRtMidiIn::alsaMidiHandler: error initializing MIDI event parser!\n\n";
+    cerr << "\nRtMidiIn::alsaMidiHandler: error initializing MIDI event parser!\n\n";
     return 0;
   }
   unsigned char *buffer = (unsigned char *) malloc( apiData->bufferSize );
   if ( buffer == NULL ) {
     data->doInput = false;
-    std::cerr << "\nRtMidiIn::alsaMidiHandler: error initializing buffer memory!\n\n";
+    cerr << "\nRtMidiIn::alsaMidiHandler: error initializing buffer memory!\n\n";
     return 0;
   }
   snd_midi_event_init( apiData->coder );
   snd_midi_event_no_status( apiData->coder, 1 ); // suppress running status messages
 

     }
 
     // If here, there should be data.
     result = snd_seq_event_input( apiData->seq, &ev );
     if ( result == -ENOSPC ) {
-      std::cerr << "\nRtMidiIn::alsaMidiHandler: MIDI input buffer overrun!\n\n";
+      cerr << "\nRtMidiIn::alsaMidiHandler: MIDI input buffer overrun!\n\n";
       continue;
     }
     else if ( result <= 0 ) {
-      std::cerr << "RtMidiIn::alsaMidiHandler: unknown MIDI input error!\n";
+      cerr << "RtMidiIn::alsaMidiHandler: unknown MIDI input error!\n";
       continue;
     }
 
     // This is a bit weird, but we now have to decode an ALSA MIDI
     // event (back) into MIDI bytes.  We'll ignore non-MIDI types.

 
     switch ( ev->type ) {
 
 		case SND_SEQ_EVENT_PORT_SUBSCRIBED:
 #if defined(__RTMIDI_DEBUG__)
-      std::cout << "RtMidiIn::alsaMidiHandler: port connection made!\n";
+      cout << "RtMidiIn::alsaMidiHandler: port connection made!\n";
 #endif
       break;
 
 		case SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
 #if defined(__RTMIDI_DEBUG__)
       SVDEBUG << "RtMidiIn::alsaMidiHandler: port connection has closed!\n";
       // FIXME: this is called for all unsubscribe events, even ones
       //not related to this particular connection.  As it stands, I
       //see no data provided in the "source" and "dest" fields so
       //there is nothing we can do about this at this time.
-      // std::cout << "sender = " << ev->source.client << ", dest = " << ev->dest.port << endl;
+      // cout << "sender = " << ev->source.client << ", dest = " << ev->dest.port << endl;
 #endif
       //data->doInput = false;
       break;
 
     case SND_SEQ_EVENT_QFRAME: // MIDI time code

         apiData->bufferSize = ev->data.ext.len;
         free( buffer );
         buffer = (unsigned char *) malloc( apiData->bufferSize );
         if ( buffer == NULL ) {
           data->doInput = false;
-          std::cerr << "\nRtMidiIn::alsaMidiHandler: error resizing buffer memory!\n\n";
+          cerr << "\nRtMidiIn::alsaMidiHandler: error resizing buffer memory!\n\n";
           break;
         }
       }
 
     default:
       nBytes = snd_midi_event_decode( apiData->coder, buffer, apiData->bufferSize, ev );
       if ( nBytes <= 0 ) {
 #if defined(__RTMIDI_DEBUG__)
-        std::cerr << "\nRtMidiIn::alsaMidiHandler: event parsing error or not a MIDI event!\n\n";
+        cerr << "\nRtMidiIn::alsaMidiHandler: event parsing error or not a MIDI event!\n\n";
 #endif
         break;
       }
 
       // The ALSA sequencer has a maximum buffer size for MIDI sysex

     else {
       // As long as we haven't reached our queue size limit, push the message.
       if ( data->queueLimit > data->queue.size() )
         data->queue.push( message );
       else
-        std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
+        cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
     }
   }
 
   if ( buffer ) free( buffer );
   snd_midi_event_free( apiData->coder );

   unsigned short size;
   MDevent event;
   int fd = mdGetFd( apiData->port );
   if ( fd < 0 ) {
     data->doInput = false;
-    std::cerr << "\nRtMidiIn::irixMidiHandler: error getting port descriptor!\n\n";
+    cerr << "\nRtMidiIn::irixMidiHandler: error getting port descriptor!\n\n";
     return 0;
   }
 
   fd_set mask, rmask;
   FD_ZERO( &mask );

     }
 
     // If here, there should be data.
     result = mdReceive( apiData->port, &event, 1);
     if ( result <= 0 ) {
-      std::cerr << "\nRtMidiIn::irixMidiHandler: MIDI input read error!\n\n";
+      cerr << "\nRtMidiIn::irixMidiHandler: MIDI input read error!\n\n";
       continue;
     }
 
     message.timeStamp = event.stamp * 0.000000001;
 

             else {
               // As long as we haven't reached our queue size limit, push the message.
               if ( data->queueLimit > data->queue.size() )
                 data->queue.push( message );
               else
-                std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
+                cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
             }
             message.bytes.clear();
           }
         }
       }

       else {
         // As long as we haven't reached our queue size limit, push the message.
         if ( data->queueLimit > data->queue.size() )
           data->queue.push( message );
         else
-          std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
+          cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
       }
       message.bytes.clear();
     }
   }
 

     // one or two minutes.
     if ( apiData->sysexBuffer->dwBytesRecorded > 0 ) {
       //if ( sysex->dwBytesRecorded > 0 ) {
       MMRESULT result = midiInAddBuffer( apiData->inHandle, apiData->sysexBuffer, sizeof(MIDIHDR) );
       if ( result != MMSYSERR_NOERROR )
-        std::cerr << "\nRtMidiIn::midiInputCallback: error sending sysex to Midi device!!\n\n";
+        cerr << "\nRtMidiIn::midiInputCallback: error sending sysex to Midi device!!\n\n";
 
       if ( data->ignoreFlags & 0x01 ) return;
     }
     else return;
   }

   else {
     // As long as we haven't reached our queue size limit, push the message.
     if ( data->queueLimit > data->queue.size() )
       data->queue.push( apiData->message );
     else
-      std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
+      cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
   }
 
   // Clear the vector for the next input message.
   apiData->message.bytes.clear();
 }