exile/v1/src/midiio_win32.cpp

   1 /*----------------------------------------------------------------------------
   2     ChucK Concurrent, On-the-fly Audio Programming Language
   3       Compiler and Virtual Machine
   4
   5     Copyright (c) 2004 Ge Wang and Perry R. Cook.  All rights reserved.
   6       http://chuck.cs.princeton.edu/
   7       http://soundlab.cs.princeton.edu/
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22     U.S.A.
  23 -----------------------------------------------------------------------------*/
  24
  25 //-----------------------------------------------------------------------------
  26 // file: midiio_win32.cpp
  27 // desc: midi io
  28 //
  29 // author: Ge Wang (gewang@cs.princeton.edu)
  30 //         Perry R. Cook (prc@cs.princeton.edu)
  31 //-----------------------------------------------------------------------------
  32 #include <stdlib.h>
  33 #include "midiio_win32.h"
  34
  35
  36
  37
  38 //-----------------------------------------------------------------------------
  39 // global variables
  40 //-----------------------------------------------------------------------------
  41 UINT g_midi_device;
  42 #define BUFFER_SIZE 8192
  43
  44
  45
  46
  47 //-----------------------------------------------------------------------------
  48 // name: MidiOut()
  49 // desc: constructor
  50 //-----------------------------------------------------------------------------
  51 MidiOut::MidiOut()
  52 {
  53     m_device_num = 0;
  54     m_midi_out = NULL;
  55 }
  56
  57
  58
  59
  60 //-----------------------------------------------------------------------------
  61 // name: ~MidiOut()
  62 // desc: destructor
  63 //-----------------------------------------------------------------------------
  64 MidiOut::~MidiOut()
  65 {
  66     if( m_midi_out ) this->close();
  67 }
  68
  69
  70
  71
  72 //-----------------------------------------------------------------------------
  73 // name: send()
  74 // desc: send 1 byte midi message
  75 //-----------------------------------------------------------------------------
  76 UINT MidiOut::send( BYTE status )
  77 {
  78     return this->send( status, 0, 0 );
  79 }
  80
  81
  82
  83
  84 //-----------------------------------------------------------------------------
  85 // name: send()
  86 // desc: send 2 byte midi message
  87 //-----------------------------------------------------------------------------
  88 UINT MidiOut::send( BYTE status, BYTE data1 )
  89 {
  90     return this->send( status, data1, 0 );
  91 }
  92
  93
  94
  95
  96 //-----------------------------------------------------------------------------
  97 // name: send()
  98 // desc: send 3 byte midi message
  99 //-----------------------------------------------------------------------------
 100 UINT MidiOut::send( BYTE status, BYTE data1, BYTE data2 )
 101 {
 102     MidiMsg msg;
 103
 104     msg.data[0] = status;
 105     msg.data[1] = data1;
 106     msg.data[2] = data2;
 107     msg.data[3] = 0;
 108
 109     return midiOutShortMsg( m_midi_out, msg.dw );
 110 }
 111
 112
 113
 114
 115 //-----------------------------------------------------------------------------
 116 // name: send()
 117 // desc: send
 118 //-----------------------------------------------------------------------------
 119 UINT MidiOut::send( const MidiMsg * msg )
 120 {
 121     return midiOutShortMsg( m_midi_out, msg->dw );
 122 }
 123
 124
 125
 126
 127 //-----------------------------------------------------------------------------
 128 // name: open
 129 // desc: open midi output
 130 //-----------------------------------------------------------------------------
 131 BOOL MidiOut::open( UINT device_num )
 132 {
 133     // close if already opened
 134     if( m_midi_out )
 135         this->close();
 136
 137     // copy
 138     m_device_num = device_num;
 139
 140     // open the midi out
 141     return midiOutOpen( &m_midi_out, m_device_num,
 142                         (DWORD)cb_midi_output, NULL, CALLBACK_FUNCTION ) == 0;
 143 }
 144
 145
 146
 147
 148 //-----------------------------------------------------------------------------
 149 // name: close( )
 150 // desc: close midi output
 151 //-----------------------------------------------------------------------------
 152 BOOL MidiOut::close( )
 153 {
 154     if( !m_midi_out )
 155         return FALSE;
 156
 157     // turn off everything
 158     midiOutReset( m_midi_out );
 159
 160     // close
 161     midiOutClose( m_midi_out );
 162
 163     // set to NULL
 164     m_midi_out = NULL;
 165
 166     return TRUE;
 167 }
 168
 169
 170
 171
 172 //-----------------------------------------------------------------------------
 173 // name: noteon()
 174 // desc: note on message
 175 //-----------------------------------------------------------------------------
 176 UINT MidiOut::noteon( UINT channel, UINT note, UINT velocity )
 177 { return this->send( (BYTE)(MIDI_NOTEON + channel), note, velocity ); }
 178
 179
 180
 181
 182 //-----------------------------------------------------------------------------
 183 // name: noteoff()
 184 // desc: note off message
 185 //-----------------------------------------------------------------------------
 186 UINT MidiOut::noteoff( UINT channel, UINT note, UINT velocity )
 187 { return this->send( (BYTE)(MIDI_NOTEOFF + channel), note, velocity ); }
 188
 189
 190
 191
 192 //-----------------------------------------------------------------------------
 193 // name: polypress()
 194 // desc: polypress message
 195 //-----------------------------------------------------------------------------
 196 UINT MidiOut::polypress( UINT channel, UINT note, UINT pressure )
 197 { return this->send( (BYTE)(MIDI_POLYPRESS + channel), note, pressure ); }
 198
 199
 200
 201
 202 //-----------------------------------------------------------------------------
 203 // name: ctrlchange()
 204 // desc: ctrl change message
 205 //-----------------------------------------------------------------------------
 206 UINT MidiOut::ctrlchange( UINT channel, UINT ctrl_num, UINT ctrl_val )
 207 { return this->send( (BYTE)(MIDI_CTRLCHANGE + channel), ctrl_num, ctrl_val ); }
 208
 209
 210
 211
 212 //-----------------------------------------------------------------------------
 213 // name: progchange()
 214 // desc: prog change message
 215 //-----------------------------------------------------------------------------
 216 UINT MidiOut::progchange( UINT channel, UINT patch )
 217 { return this->send( (BYTE)(MIDI_PROGCHANGE + channel), patch, 0 ); }
 218
 219
 220
 221
 222 //-----------------------------------------------------------------------------
 223 // name: chanpress()
 224 // desc: chan press
 225 //-----------------------------------------------------------------------------
 226 UINT MidiOut::chanpress( UINT channel, UINT pressure )
 227 { return this->send( (BYTE)(MIDI_CHANPRESS + channel), pressure, 0 ); }
 228
 229
 230
 231
 232 //-----------------------------------------------------------------------------
 233 // name: pitchbend()
 234 // desc: pitch bend
 235 //-----------------------------------------------------------------------------
 236 UINT MidiOut::pitchbend( UINT channel, UINT bend_val )
 237 {
 238     return this->send( (BYTE)(MIDI_PITCHBEND + channel),
 239                        (BYTE)(HIBYTE( bend_val << 1 )),
 240                        (BYTE)(LOBYTE( bend_val & 0x7f )) );
 241 }
 242
 243
 244
 245
 246 //-----------------------------------------------------------------------------
 247 // name: allnotesoff()
 248 // desc: allnotesoff
 249 //-----------------------------------------------------------------------------
 250 UINT MidiOut::allnotesoff( UINT channel )
 251 {
 252     return this->send( (BYTE)(MIDI_CTRLCHANGE + channel),
 253                      (BYTE)(MIDI_ALLNOTESOFF), 0 );
 254 }
 255
 256
 257
 258
 259 //-----------------------------------------------------------------------------
 260 // name: cb_midi_output
 261 // desc: call back
 262 //-----------------------------------------------------------------------------
 263 void CALLBACK MidiOut::cb_midi_output( HMIDIOUT hm_out, UINT msg,
 264                        DWORD instance, DWORD param1, DWORD param2 )
 265 {
 266     MMRESULT result;
 267     MIDIHDR * mhdr = NULL;
 268
 269     switch( msg )
 270     {
 271     case MOM_OPEN:
 272         break;
 273     case MOM_CLOSE:
 274         break;
 275     case MOM_DONE:
 276         mhdr = (MIDIHDR*)param1;
 277
 278         result = midiOutUnprepareHeader( hm_out, mhdr, sizeof(MIDIHDR) );
 279
 280         if( result != 0 )
 281         {
 282             // TODO: handle the error
 283             break;
 284         }
 285
 286         if( mhdr->lpData )
 287             free( mhdr->lpData );
 288
 289         break;
 290     case MOM_POSITIONCB:
 291         mhdr = (MIDIHDR*)param2;
 292         break;
 293     }
 294 }
 295
 296
 297
 298
 299 //-----------------------------------------------------------------------------
 300 // name: MidiIn()
 301 // desc: constructor
 302 //-----------------------------------------------------------------------------
 303 MidiIn::MidiIn()
 304 {
 305     m_midi_in = NULL;
 306     m_device_num = 0;
 307 }
 308
 309
 310
 311
 312 //-----------------------------------------------------------------------------
 313 // name: ~MidiIn()
 314 // desc: destructor
 315 //-----------------------------------------------------------------------------
 316 MidiIn::~MidiIn( )
 317 {
 318     this->close();
 319 }
 320
 321
 322
 323
 324 //-----------------------------------------------------------------------------
 325 // name: open()
 326 // desc: open
 327 //-----------------------------------------------------------------------------
 328 BOOL MidiIn::open( UINT device_num )
 329 {
 330     MMRESULT result;
 331     if( m_midi_in )
 332         this->close();
 333
 334     m_device_num = device_num;
 335
 336     // open the midi
 337     result = midiInOpen( &m_midi_in, m_device_num, (DWORD)cb_midi_input,
 338                          (DWORD)this, CALLBACK_FUNCTION );
 339
 340     // check result
 341     if( result != 0 )
 342         return FALSE;
 343
 344     // allocate the buffer
 345     if( !m_buffer.initialize( BUFFER_SIZE, sizeof(MidiMsg) ) )
 346     {
 347         this->close();
 348         return FALSE;
 349     }
 350
 351     return midiInStart( m_midi_in ) == 0;
 352 }
 353
 354
 355
 356
 357 //-----------------------------------------------------------------------------
 358 // name: close()
 359 // desc: close
 360 //-----------------------------------------------------------------------------
 361 BOOL MidiIn::close()
 362 {
 363     if( !m_midi_in )
 364         return FALSE;
 365
 366     // midi reset
 367     midiInReset( m_midi_in );
 368
 369     // midi close
 370     midiInClose( m_midi_in );
 371
 372     // set to NULL
 373     m_midi_in = NULL;
 374
 375     // deallocate the buffer
 376     m_buffer.cleanup();
 377
 378     return TRUE;
 379 }
 380
 381
 382
 383
 384 //-----------------------------------------------------------------------------
 385 // name: get()
 386 // desc: get message
 387 //-----------------------------------------------------------------------------
 388 UINT MidiIn::recv( MidiMsg * msg )
 389 {
 390     return m_buffer.get( msg, 1 );
 391 }
 392
 393
 394
 395
 396 //-----------------------------------------------------------------------------
 397 // name: cb_midi_input()
 398 // desc: cb
 399 //-----------------------------------------------------------------------------
 400 void CALLBACK MidiIn::cb_midi_input( HMIDIIN hm_in, UINT msg, DWORD instance,
 401                                      DWORD param1, DWORD param2 )
 402 {
 403     MidiMsg m, n;
 404     MidiIn * midi_in = (MidiIn *)instance;
 405
 406     switch( msg )
 407     {
 408     case MIM_OPEN:
 409         break;
 410
 411     case MIM_CLOSE:
 412         break;
 413
 414     case MIM_DATA:
 415         n.dw = param1;
 416         m.data[0] = n.data[2];
 417         m.data[1] = n.data[1];
 418         m.data[2] = n.data[0];
 419         m.data[3] = n.data[3];
 420
 421         // put in the buffer, make sure not active sensing
 422         if( m.data[2] != 0xfe )
 423         {
 424             midi_in->m_buffer.put( &m, 1 );
 425         }
 426         break;
 427
 428     case MIM_ERROR:
 429         break;
 430
 431     case MIM_LONGDATA:
 432         break;
 433
 434     case MIM_LONGERROR:
 435         break;
 436     }
 437 }