v2/skiniio_skini.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: skiniio_skini.cpp
  27 // desc: skini 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 <vector>
  34 #include "skiniio_skini.h"
  35 #include "chuck_errmsg.h"
  36
  37
  38
  39
  40 //-----------------------------------------------------------------------------
  41 // global variables
  42 //-----------------------------------------------------------------------------
  43 //#define BUFFER_SIZE 8192
  44
  45 //std::vector<RtMidiIn *> MidiInManager::the_mins;
  46 //std::vector<CBuffer *> MidiInManager::the_bufs;
  47 //std::vector<RtMidiOut *> MidiOutManager::the_mouts;
  48
  49
  50
  51 //-----------------------------------------------------------------------------
  52 // name: SkiniOut()
  53 // desc: constructor
  54 //-----------------------------------------------------------------------------
  55 SkiniOut::SkiniOut()
  56 {
  57         skout = new Skini;
  58     m_filename = NULL;
  59         m_valid = FALSE;
  60 }
  61
  62
  63
  64
  65 //-----------------------------------------------------------------------------
  66 // name: ~SkiniOut()
  67 // desc: destructor
  68 //-----------------------------------------------------------------------------
  69 SkiniOut::~SkiniOut()
  70 {
  71     if( skout ) this->close();
  72         SAFE_DELETE( skout );
  73 }
  74
  75
  76
  77
  78 //-----------------------------------------------------------------------------
  79 // name: send()
  80 // desc: send skini message
  81 //-----------------------------------------------------------------------------
  82 t_CKUINT SkiniOut::send( const SkiniMsg * msg )
  83 {
  84         if( !m_valid ) return 0;
  85
  86         // write message in file
  87         skout->write_message( msg->type, msg->time, msg->channel, msg->data1, msg->data2 );
  88
  89         return 3;
  90 }
  91
  92
  93
  94
  95 //-----------------------------------------------------------------------------
  96 // name: open
  97 // desc: open skini output
  98 //-----------------------------------------------------------------------------
  99 t_CKBOOL SkiniOut::open( const char * filename )
 100 {
 101     // close if already opened
 102     if( m_valid )
 103         this->close();
 104
 105         m_valid = skout->setFile( filename );
 106         //if( m_valid ) strcpy( m_filename, filename );
 107
 108         return m_valid;
 109 }
 110
 111
 112
 113
 114 //-----------------------------------------------------------------------------
 115 // name: close( )
 116 // desc: close skini output
 117 //-----------------------------------------------------------------------------
 118 t_CKBOOL SkiniOut::close( )
 119 {
 120     if( !m_valid )
 121         return FALSE;
 122
 123     // close
 124         //MidiOutManager::close( this );
 125
 126         m_valid = FALSE;
 127         m_filename = NULL;
 128
 129         skout->close_file();
 130
 131     return TRUE;
 132 }
 133
 134
 135
 136 /*
 137 //-----------------------------------------------------------------------------
 138 // name: noteon()
 139 // desc: note on message
 140 //-----------------------------------------------------------------------------
 141 t_CKUINT MidiOut::noteon( t_CKUINT channel, t_CKUINT note, t_CKUINT velocity )
 142 { return this->send( (t_CKBYTE)(MIDI_NOTEON + channel), note, velocity ); }
 143
 144
 145
 146
 147 //-----------------------------------------------------------------------------
 148 // name: noteoff()
 149 // desc: note off message
 150 //-----------------------------------------------------------------------------
 151 t_CKUINT MidiOut::noteoff( t_CKUINT channel, t_CKUINT note, t_CKUINT velocity )
 152 { return this->send( (t_CKBYTE)(MIDI_NOTEOFF + channel), note, velocity ); }
 153
 154
 155
 156
 157 //-----------------------------------------------------------------------------
 158 // name: polypress()
 159 // desc: polypress message
 160 //-----------------------------------------------------------------------------
 161 t_CKUINT MidiOut::polypress( t_CKUINT channel, t_CKUINT note, t_CKUINT pressure )
 162 { return this->send( (t_CKBYTE)(MIDI_POLYPRESS + channel), note, pressure ); }
 163
 164
 165
 166
 167 //-----------------------------------------------------------------------------
 168 // name: ctrlchange()
 169 // desc: ctrl change message
 170 //-----------------------------------------------------------------------------
 171 t_CKUINT MidiOut::ctrlchange( t_CKUINT channel, t_CKUINT ctrl_num, t_CKUINT ctrl_val )
 172 { return this->send( (t_CKBYTE)(MIDI_CTRLCHANGE + channel), ctrl_num, ctrl_val ); }
 173
 174
 175
 176
 177 //-----------------------------------------------------------------------------
 178 // name: progchange()
 179 // desc: prog change message
 180 //-----------------------------------------------------------------------------
 181 t_CKUINT MidiOut::progchange( t_CKUINT channel, t_CKUINT patch )
 182 { return this->send( (t_CKBYTE)(MIDI_PROGCHANGE + channel), patch, 0 ); }
 183
 184
 185
 186
 187 //-----------------------------------------------------------------------------
 188 // name: chanpress()
 189 // desc: chan press
 190 //-----------------------------------------------------------------------------
 191 t_CKUINT MidiOut::chanpress( t_CKUINT channel, t_CKUINT pressure )
 192 { return this->send( (t_CKBYTE)(MIDI_CHANPRESS + channel), pressure, 0 ); }
 193
 194
 195
 196
 197 //-----------------------------------------------------------------------------
 198 // name: pitchbend()
 199 // desc: pitch bend
 200 //-----------------------------------------------------------------------------
 201 t_CKUINT MidiOut::pitchbend( t_CKUINT channel, t_CKUINT bend_val )
 202 {
 203         assert( FALSE );
 204         return 0;
 205 //    return this->send( (t_CKBYTE)(MIDI_PITCHBEND + channel),
 206 //                       (t_CKBYTE)(HIBYTE( bend_val << 1 )),
 207 //                       (t_CKBYTE)(LOBYTE( bend_val & 0x7f )) );
 208 }
 209
 210
 211
 212
 213 //-----------------------------------------------------------------------------
 214 // name: allnotesoff()
 215 // desc: allnotesoff
 216 //-----------------------------------------------------------------------------
 217 t_CKUINT MidiOut::allnotesoff( t_CKUINT channel )
 218 {
 219     return this->send( (t_CKBYTE)(MIDI_CTRLCHANGE + channel),
 220                        (t_CKBYTE)(MIDI_ALLNOTESOFF), 0 );
 221 }
 222 */
 223
 224
 225
 226 //-----------------------------------------------------------------------------
 227 // name: MidiIn()
 228 // desc: constructor
 229 //-----------------------------------------------------------------------------
 230 SkiniIn::SkiniIn()
 231 {
 232         m_filename = NULL;
 233         m_valid = FALSE;
 234         //m_read_index = 0;
 235         //m_buffer = NULL;
 236         //SELF = NULL;
 237 }
 238
 239
 240
 241
 242 //-----------------------------------------------------------------------------
 243 // name: ~SkiniIn()
 244 // desc: destructor
 245 //-----------------------------------------------------------------------------
 246 SkiniIn::~SkiniIn( )
 247 {
 248     this->close();
 249         // SAFE_DELETE( min );
 250 }
 251
 252
 253
 254
 255 //-----------------------------------------------------------------------------
 256 // name: open()
 257 // desc: open
 258 //-----------------------------------------------------------------------------
 259 t_CKBOOL SkiniIn::open( const char * filename )
 260 {
 261     // close if already opened
 262     if( m_valid )
 263         this->close();
 264
 265         // open
 266         m_valid = skin->setFile( filename );
 267         //if( m_valid ) strcpy( m_filename, filename );
 268         return m_valid;
 269 }
 270
 271
 272
 273 /*
 274 MidiInManager::MidiInManager()
 275 {
 276         the_mins.resize( 1024 );
 277         the_bufs.resize( 1024 );
 278 }
 279
 280
 281 MidiInManager::~MidiInManager()
 282 {
 283         // yeah right
 284 }
 285
 286
 287 t_CKBOOL MidiInManager::open( MidiIn * min, t_CKINT device_num )
 288 {
 289     // see if port not already open
 290         if( device_num >= the_mins.capacity() || !the_mins[device_num] )
 291         {
 292
 293                 // allocate the buffer
 294                 CBuffer * cbuf = new CBuffer;
 295                 if( !cbuf->initialize( BUFFER_SIZE, sizeof(MidiMsg) ) )
 296                 {
 297                         EM_error2( 0, "MidiIn: couldn't allocate CBuffer for port %i...", device_num );
 298                         delete cbuf;
 299                         return FALSE;
 300                 }
 301
 302                 // allocate
 303                 RtMidiIn * rtmin = new RtMidiIn;
 304                 try {
 305                         rtmin->openPort( device_num );
 306                         rtmin->setCallback( cb_midi_input, cbuf );
 307                 } catch( RtError & err ) {
 308                         // print it
 309                         EM_error2( 0, "MidiIn: couldn't open MIDI port %i...", device_num );
 310                         EM_error2( 0, "...(%s)", err.getMessage().c_str() );
 311                         delete cbuf;
 312                         return FALSE;
 313                 }
 314
 315                 // resize?
 316                 if( device_num >= the_mins.capacity() )
 317                 {
 318                         t_CKINT size = the_mins.capacity() * 2;
 319                         if( device_num >= size ) size = device_num + 1;
 320                         the_mins.resize( size );
 321                         the_bufs.resize( size );
 322                 }
 323
 324                 // put cbuf and rtmin in vector for future generations
 325         the_mins[device_num] = rtmin;
 326                 the_bufs[device_num] = cbuf;
 327         }
 328
 329         // found
 330         min->m_buffer = the_bufs[device_num];
 331         // get an index into your (you are min here) own buffer,
 332         // and a free ticket to your own workshop
 333         min->m_read_index = min->m_buffer->join( (Chuck_Event *)min->SELF );
 334     min->m_device_num = (t_CKUINT)device_num;
 335
 336         // done
 337         return TRUE;
 338 }
 339 */
 340
 341
 342 //-----------------------------------------------------------------------------
 343 // name: close()
 344 // desc: close
 345 //-----------------------------------------------------------------------------
 346 t_CKBOOL SkiniIn::close()
 347 {
 348     if( !m_valid )
 349         return FALSE;
 350
 351         // close
 352         // MidiInManager::close( this );
 353
 354         m_valid = FALSE;
 355         m_filename = NULL;
 356         skin->close_file();
 357
 358     return TRUE;
 359 }
 360
 361
 362 //-----------------------------------------------------------------------------
 363 // name: get()
 364 // desc: get message
 365 //-----------------------------------------------------------------------------
 366 t_CKUINT SkiniIn::recv( SkiniMsg * msg )
 367 {
 368         if( !m_valid ) return FALSE;
 369     //return m_buffer->get( msg, 1, m_read_index );
 370
 371         Skini::Message mess;
 372         msg->type = skin->nextMessage( mess ); // what????
 373         msg->time = mess.time;
 374         msg->channel = mess.channel;
 375         if( mess.floatValues.size() > 0 )
 376                 msg->data1 = mess.floatValues[0];
 377         if( mess.floatValues.size() > 1 )
 378                 msg->data2 = mess.floatValues[1];
 379
 380         return 0;
 381 }