exile/v1/src/digiio_rtaudio.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: digiio_rtaudio.cpp
  27 // desc: digitalio over rtaudio (from Gary Scavone)
  28 //
  29 // author: Ge Wang (gewang@cs.princeton.edu)
  30 //         Perry R. Cook (prc@cs.princeton.edu)
  31 //-----------------------------------------------------------------------------
  32 #include "digiio_rtaudio.h"
  33 #include "chuck_vm.h"
  34 #include "chuck_errmsg.h"
  35 #include "rtaudio.h"
  36 #if defined(__WINDOWS_DS__) && !defined(__WINDOWS_PTHREAD__)
  37 #include <windows.h>
  38 #else
  39 #include <unistd.h>
  40 #endif
  41
  42
  43
  44
  45 // static
  46 BOOL__ Digitalio::m_init = FALSE;
  47 DWORD__ Digitalio::m_start = 0;
  48 DWORD__ Digitalio::m_tick_count = 0;
  49 DWORD__ Digitalio::m_num_channels_out = NUM_CHANNELS_DEFAULT;
  50 DWORD__ Digitalio::m_num_channels_in = NUM_CHANNELS_DEFAULT;
  51 DWORD__ Digitalio::m_sampling_rate = SAMPLING_RATE_DEFAULT;
  52 DWORD__ Digitalio::m_bps = BITS_PER_SAMPLE_DEFAULT;
  53 DWORD__ Digitalio::m_buffer_size = BUFFER_SIZE_DEFAULT;
  54 DWORD__ Digitalio::m_num_buffers = NUM_BUFFERS_DEFAULT;
  55 RtAudio * Digitalio::m_rtaudio = NULL;
  56 SAMPLE * Digitalio::m_buffer_out = NULL;
  57 SAMPLE * Digitalio::m_buffer_in = NULL;
  58 SAMPLE ** Digitalio::m_write_ptr = NULL;
  59 SAMPLE ** Digitalio::m_read_ptr = NULL;
  60 SAMPLE * Digitalio::m_extern_in = NULL;
  61 SAMPLE * Digitalio::m_extern_out = NULL;
  62 BOOL__ Digitalio::m_out_ready = FALSE;
  63 BOOL__ Digitalio::m_in_ready = FALSE;
  64 BOOL__ Digitalio::m_use_cb = USE_CB_DEFAULT;
  65 DWORD__ Digitalio::m_go = 0;
  66 DWORD__ Digitalio::m_dac_n = 0;
  67 DWORD__ Digitalio::m_adc_n = 0;
  68 DWORD__ Digitalio::m_end = 0;
  69
  70
  71
  72
  73 //-----------------------------------------------------------------------------
  74 // name: initialize()
  75 // desc: ...
  76 //-----------------------------------------------------------------------------
  77 BOOL__ Digitalio::initialize( DWORD__ num_channels, DWORD__ sampling_rate,
  78                               DWORD__ bps, DWORD__ buffer_size,
  79                               DWORD__ num_buffers )
  80 {
  81     if( m_init )
  82         return FALSE;
  83
  84     m_num_channels_out = num_channels;
  85     m_num_channels_in = num_channels;
  86     m_sampling_rate = sampling_rate;
  87     m_bps = bps;
  88     m_buffer_size = buffer_size;
  89     m_num_buffers = num_buffers;
  90     m_start = 0;
  91     m_tick_count = 0;
  92     m_go = 0;
  93     m_end = 0;
  94
  95     // allocate RtAudio
  96     try { m_rtaudio = new RtAudio( ); }
  97     catch( RtError err )
  98     {
  99         // problem finding audio devices, most likely
 100         EM_error2( 0, "%s", err.getMessageString() );
 101         return m_init = FALSE;
 102     }
 103
 104     // open device
 105     try {
 106         m_rtaudio->openStream(
 107             m_dac_n, m_num_channels_out, m_adc_n, m_num_channels_in,
 108             RTAUDIO_FLOAT32, sampling_rate,
 109             (int *)&m_buffer_size, num_buffers );
 110         if( m_use_cb )
 111             m_rtaudio->setStreamCallback( &cb, NULL );
 112     } catch( RtError err ) {
 113         try {
 114             m_buffer_size = buffer_size;
 115             // try output only
 116             m_rtaudio->openStream(
 117                 m_dac_n, m_num_channels_out, 0, 0,
 118                 RTAUDIO_FLOAT32, sampling_rate,
 119                 (int *)&m_buffer_size, num_buffers );
 120             if( m_use_cb )
 121                 m_rtaudio->setStreamCallback( &cb, NULL );
 122         } catch( RtError err ) {
 123             EM_error2( 0, "%s", err.getMessageString() );
 124             SAFE_DELETE( m_rtaudio );
 125             return m_init = FALSE;
 126         }
 127     }
 128
 129     if( m_use_cb )
 130     {
 131         m_buffer_in = new SAMPLE[m_buffer_size * num_channels];
 132         m_buffer_out = new SAMPLE[m_buffer_size * num_channels];
 133         memset( m_buffer_in, 0, m_buffer_size * sizeof(SAMPLE) * num_channels );
 134         memset( m_buffer_out, 0, m_buffer_size * sizeof(SAMPLE) * num_channels );
 135         m_read_ptr = NULL;
 136         m_write_ptr = NULL;
 137     }
 138
 139     m_in_ready = FALSE;
 140     m_out_ready = FALSE;
 141
 142     return m_init = TRUE;
 143 }
 144
 145
 146
 147
 148 //-----------------------------------------------------------------------------
 149 // name: cb()
 150 // desc: ...
 151 //-----------------------------------------------------------------------------
 152 int Digitalio::cb( char * buffer, int buffer_size, void * user_data )
 153 {
 154     DWORD__ len = buffer_size * sizeof(SAMPLE) * m_num_channels_out;
 155     DWORD__ n = 6;
 156     DWORD__ start = 50;
 157
 158     // copy input to local buffer
 159     if( m_num_channels_in )
 160     {
 161         memcpy( m_buffer_in, buffer, len );
 162         // copy to extern
 163         if( m_extern_in ) memcpy( m_extern_in, buffer, len );
 164     }
 165     // flag ready
 166     m_in_ready = TRUE;
 167     // out is ready early
 168     if( m_go < start && m_go > 1 && m_out_ready ) m_go = start;
 169     // copy output into local buffer
 170     if( m_go >= start )
 171     {
 172         while( !m_out_ready && n-- ) usleep( 250 );
 173         // copy local buffer to be rendered
 174         if( m_out_ready && !m_end ) memcpy( buffer, m_buffer_out, len );
 175         // set all elements of local buffer to silence
 176         else memset( buffer, 0, len);
 177     }
 178     else  // initial condition
 179     {
 180 //#ifndef __WINDOWS_DS__
 181         if( !m_go && Chuck_VM::our_priority != 0x7fffffff )
 182             Chuck_VM::set_priority( Chuck_VM::our_priority, NULL );
 183 //#endif
 184         memset( buffer, 0, len );
 185         m_go++;
 186         return 0;
 187     }
 188
 189     // 2nd buffer
 190     if( m_go == start )
 191     {
 192         n = 8; while( !m_out_ready && n-- ) usleep( 250 );
 193         len /= sizeof(SAMPLE); DWORD__ i = 0;
 194         SAMPLE * s = (SAMPLE *)buffer;
 195         while( i < len ) *s++ *= (SAMPLE)i++/len;
 196         m_go++;
 197     }
 198
 199     // copy to extern
 200     if( m_extern_out ) memcpy( m_extern_out, buffer, len );
 201
 202     // set pointer to the beginning - if not ready, then too late anyway
 203     //*m_write_ptr = (SAMPLE *)m_buffer_out;
 204     //*m_read_ptr = (SAMPLE *)m_buffer_in;
 205     m_out_ready = FALSE;
 206
 207     return 0;
 208 }
 209
 210
 211
 212
 213 //-----------------------------------------------------------------------------
 214 // name: start()
 215 // desc: ...
 216 //-----------------------------------------------------------------------------
 217 BOOL__ Digitalio::start( )
 218 {
 219     try{ if( !m_start )
 220               m_rtaudio->startStream();
 221          m_start = TRUE;
 222     } catch( RtError err ){ return FALSE; }
 223
 224     return m_start;
 225 }
 226
 227
 228
 229
 230 //-----------------------------------------------------------------------------
 231 // name: stop()
 232 // desc: ...
 233 //-----------------------------------------------------------------------------
 234 BOOL__ Digitalio::stop( )
 235 {
 236     try{ if( m_start )
 237              m_rtaudio->stopStream();
 238          m_start = FALSE;
 239     } catch( RtError err ){ return FALSE; }
 240
 241     return !m_start;
 242 }
 243
 244
 245
 246
 247 //-----------------------------------------------------------------------------
 248 // name: tick()
 249 // desc: ...
 250 //-----------------------------------------------------------------------------
 251 BOOL__ Digitalio::tick( )
 252 {
 253     try
 254     {
 255         if( ++m_tick_count >= m_start )
 256         {
 257             m_rtaudio->tickStream();
 258             m_tick_count = 0;
 259             m_out_ready = TRUE;
 260             m_in_ready = TRUE;
 261         }
 262
 263         return TRUE;
 264     } catch( RtError err ){ return FALSE; }
 265 }
 266
 267
 268
 269
 270 //-----------------------------------------------------------------------------
 271 // name: shutdown()
 272 // desc: ...
 273 //-----------------------------------------------------------------------------
 274 void Digitalio::shutdown()
 275 {
 276     if( !m_init ) return;
 277     if( m_start ) m_rtaudio->stopStream();
 278
 279     m_rtaudio->closeStream();
 280     SAFE_DELETE( m_rtaudio );
 281     m_init = FALSE;
 282     m_start = FALSE;
 283 }
 284
 285
 286
 287
 288 //-----------------------------------------------------------------------------
 289 // name: DigitalOut()
 290 // desc: ...
 291 //-----------------------------------------------------------------------------
 292 DigitalOut::DigitalOut()
 293 {
 294     m_data_ptr_out = NULL;
 295     m_data_max_out = NULL;
 296 }
 297
 298
 299
 300
 301 //-----------------------------------------------------------------------------
 302 // name: ~DigitalOut()
 303 // desc: ...
 304 //-----------------------------------------------------------------------------
 305 DigitalOut::~DigitalOut()
 306 {
 307     this->cleanup();
 308 }
 309
 310
 311
 312
 313 //-----------------------------------------------------------------------------
 314 // name: initialize()
 315 // desc: initialize audio out
 316 //-----------------------------------------------------------------------------
 317 BOOL__ DigitalOut::initialize( )
 318 {
 319     // set pointer to beginning of local buffer
 320     m_data_ptr_out = Digitalio::m_use_cb ? Digitalio::m_buffer_out
 321         : (SAMPLE *)Digitalio::audio()->getStreamBuffer();
 322     // calculate the end of the buffer
 323     m_data_max_out = m_data_ptr_out +
 324         Digitalio::buffer_size() * Digitalio::num_channels_out();
 325     // set the writer pointer to our write pointer
 326     Digitalio::m_write_ptr = &m_data_ptr_out;
 327
 328     return TRUE;
 329 }
 330
 331
 332
 333
 334 //-----------------------------------------------------------------------------
 335 // name: start()
 336 // desc: render
 337 //-----------------------------------------------------------------------------
 338 BOOL__ DigitalOut::start()
 339 {
 340     // start stream
 341     return ( Digitalio::start() != 0 );
 342 }
 343
 344
 345
 346
 347 //-----------------------------------------------------------------------------
 348 // name: stop()
 349 // desc: render
 350 //-----------------------------------------------------------------------------
 351 BOOL__ DigitalOut::stop()
 352 {
 353     // well
 354     Digitalio::stop();
 355
 356     return TRUE;
 357 }
 358
 359
 360
 361
 362 //-----------------------------------------------------------------------------
 363 // name: cleanup()
 364 // desc: ...
 365 //-----------------------------------------------------------------------------
 366 void DigitalOut::cleanup()
 367 {
 368 }
 369
 370
 371
 372
 373 //-----------------------------------------------------------------------------
 374 // name: tick_out()
 375 // desc: 1 channel
 376 //-----------------------------------------------------------------------------
 377 BOOL__ DigitalOut::tick_out( SAMPLE sample )
 378 {
 379     if( !prepare_tick_out() )
 380         return FALSE;
 381
 382     *m_data_ptr_out++ = sample;
 383
 384     return TRUE;
 385 }
 386
 387
 388
 389
 390 //-----------------------------------------------------------------------------
 391 // name: tick_out()
 392 // desc: 2 channel
 393 //-----------------------------------------------------------------------------
 394 BOOL__ DigitalOut::tick_out( SAMPLE sample_l, SAMPLE sample_r )
 395 {
 396     if( !prepare_tick_out() )
 397         return FALSE;
 398
 399     *m_data_ptr_out++ = sample_l;
 400     *m_data_ptr_out++ = sample_r;
 401
 402     return TRUE;
 403 }
 404
 405
 406
 407
 408 //-----------------------------------------------------------------------------
 409 // name: tick_out()
 410 // desc: all channels
 411 //-----------------------------------------------------------------------------
 412 BOOL__ DigitalOut::tick_out( const SAMPLE * samples, DWORD__ n )
 413 {
 414     if( !prepare_tick_out() )
 415         return FALSE;
 416
 417     if( !n ) n = Digitalio::m_num_channels_out;
 418     while( n-- )
 419         *m_data_ptr_out++ = *samples++;
 420
 421     return TRUE;
 422 }
 423
 424
 425
 426
 427 //-----------------------------------------------------------------------------
 428 // name: prepare_tick_out()
 429 // desc: data ptr ok
 430 //-----------------------------------------------------------------------------
 431 inline BOOL__ DigitalOut::prepare_tick_out()
 432 {
 433     if( m_data_ptr_out >= m_data_max_out )
 434     {
 435         this->render();
 436     }
 437
 438     return TRUE;
 439 }
 440
 441
 442
 443
 444 //-----------------------------------------------------------------------------
 445 // name: render()
 446 // desc: the render
 447 //-----------------------------------------------------------------------------
 448 DWORD__ DigitalOut::render()
 449 {
 450     //if( !Digitalio::m_use_cb && !Digitalio::tick() ) return FALSE;
 451
 452     // synchronize
 453     Digitalio::m_out_ready = TRUE;
 454     // synchronize
 455     while( Digitalio::m_out_ready )
 456         usleep( 250 );
 457     // set pointer to the beginning - if not ready, then too late anyway
 458     *Digitalio::m_write_ptr = (SAMPLE *)Digitalio::m_buffer_out;
 459
 460     return TRUE;
 461 }
 462
 463
 464
 465
 466 //-----------------------------------------------------------------------------
 467 // name: DigitalIn()
 468 // desc: ...
 469 //-----------------------------------------------------------------------------
 470 DigitalIn::DigitalIn()
 471 {
 472     m_data_ptr_in = NULL;
 473     m_data_max_in = NULL;
 474 }
 475
 476
 477
 478
 479 //-----------------------------------------------------------------------------
 480 // name: ~DigitalIn()
 481 // desc: ...
 482 //-----------------------------------------------------------------------------
 483 DigitalIn::~DigitalIn()
 484 {
 485     this->cleanup();
 486 }
 487
 488
 489
 490
 491 //-----------------------------------------------------------------------------
 492 // name: initialize()
 493 // desc: initialize audio in
 494 //-----------------------------------------------------------------------------
 495 BOOL__ DigitalIn::initialize( )
 496 {
 497     m_data = new SAMPLE[Digitalio::buffer_size() * Digitalio::num_channels_in()];
 498     // set the buffer to the beginning of the local buffer
 499     m_data_ptr_in = Digitalio::m_use_cb ? m_data
 500         : (SAMPLE *)Digitalio::audio()->getStreamBuffer();
 501     // calculate past buffer
 502     m_data_max_in = m_data_ptr_in +
 503         Digitalio::buffer_size() * Digitalio::num_channels_in();
 504     // set the read pointer to the local pointer
 505     Digitalio::m_read_ptr = &m_data_ptr_in;
 506
 507     return TRUE;
 508 }
 509
 510
 511
 512
 513 //-----------------------------------------------------------------------------
 514 // name: start()
 515 // desc: ...
 516 //-----------------------------------------------------------------------------
 517 BOOL__ DigitalIn::start()
 518 {
 519     return ( Digitalio::start() != 0 );
 520 }
 521
 522
 523
 524
 525 //-----------------------------------------------------------------------------
 526 // name: capture_stop()
 527 // desc: ...
 528 //-----------------------------------------------------------------------------
 529 BOOL__ DigitalIn::stop()
 530 {
 531     Digitalio::stop();
 532     return TRUE;
 533 }
 534
 535
 536
 537
 538 //-----------------------------------------------------------------------------
 539 // name: cleanup()
 540 // desc: ...
 541 //-----------------------------------------------------------------------------
 542 void DigitalIn::cleanup()
 543 {
 544 }
 545
 546
 547
 548
 549 //-----------------------------------------------------------------------------
 550 // name: tick_in()
 551 // desc: ...
 552 //-----------------------------------------------------------------------------
 553 BOOL__ DigitalIn::tick_in( SAMPLE * s )
 554 {
 555     if( !prepare_tick_in() )
 556         return 0;
 557
 558     *s = *m_data_ptr_in++;
 559
 560     return TRUE;
 561 }
 562
 563
 564
 565
 566 //-----------------------------------------------------------------------------
 567 // name: tick_in()
 568 // desc: ...
 569 //-----------------------------------------------------------------------------
 570 BOOL__ DigitalIn::tick_in( SAMPLE * l, SAMPLE * r )
 571 {
 572     if( !prepare_tick_in() )
 573         return FALSE;
 574
 575     *l = *m_data_ptr_in++;
 576     *r = *m_data_ptr_in++;
 577
 578     return TRUE;
 579 }
 580
 581
 582
 583
 584 //-----------------------------------------------------------------------------
 585 // name: tick_in()
 586 // desc: ...
 587 //-----------------------------------------------------------------------------
 588 BOOL__ DigitalIn::tick_in( SAMPLE * sample, DWORD__ n )
 589 {
 590     if( !prepare_tick_in() )
 591         return FALSE;
 592
 593     if( !n ) n = Digitalio::m_num_channels_in;
 594     while( n-- )
 595         *sample++ = *m_data_ptr_in++;
 596
 597     return TRUE;
 598 }
 599
 600
 601
 602
 603 //-----------------------------------------------------------------------------
 604 // name: prepare_tick_in()
 605 // desc: data ptr ok
 606 //-----------------------------------------------------------------------------
 607 inline BOOL__ DigitalIn::prepare_tick_in()
 608 {
 609     if( m_data_ptr_in >= m_data_max_in )
 610     {
 611         this->capture();
 612     }
 613
 614     return TRUE;
 615 }
 616
 617
 618
 619
 620 //-----------------------------------------------------------------------------
 621 // name: cb_capture()
 622 // desc: ...
 623 //-----------------------------------------------------------------------------
 624 DWORD__ DigitalIn::capture( )
 625 {
 626     // if( !Digitalio::m_use_cb && !Digitalio::tick() ) return FALSE;
 627
 628     t_CKUINT n = 4;
 629     while( !Digitalio::m_in_ready && n-- )
 630         usleep( 250 );
 631
 632     // copy data
 633     memcpy( m_data, Digitalio::m_buffer_in, Digitalio::buffer_size() *
 634             Digitalio::num_channels_in() * sizeof(SAMPLE) );
 635     Digitalio::m_in_ready = FALSE;
 636     // set pointer to the beginning - if not ready, then too late anyway
 637     *Digitalio::m_read_ptr = (SAMPLE *)m_data;
 638
 639     return TRUE;
 640 }
 641
 642
 643
 644
 645 //-----------------------------------------------------------------------------
 646 // name: AudioBufferX()
 647 // desc: ...
 648 //-----------------------------------------------------------------------------
 649 AudioBufferX::AudioBufferX( DWORD__ size )
 650 {
 651     if( size )
 652         this->initialize( size );
 653     else
 654     {
 655         m_size = size;
 656         m_data = m_ptr_curr = m_ptr_end = NULL;
 657     }
 658 }
 659
 660
 661
 662
 663 //-----------------------------------------------------------------------------
 664 // name: initialize()
 665 // desc: ...
 666 //-----------------------------------------------------------------------------
 667 BOOL__ AudioBufferX::initialize( DWORD__ size )
 668 {
 669     m_size = size;
 670     m_data = (SAMPLE *)malloc( size * sizeof(SAMPLE) );
 671
 672     if( !m_data )
 673         return FALSE;
 674
 675     // clear the memory
 676     memset( m_data, 0, size * sizeof(SAMPLE) );
 677
 678     // set the pointers
 679     m_ptr_curr = m_data;
 680     m_ptr_end = m_data + size;
 681
 682     return TRUE;
 683 }
 684
 685
 686
 687
 688 //-----------------------------------------------------------------------------
 689 // name: cleanup()
 690 // desc: ...
 691 //-----------------------------------------------------------------------------
 692 void AudioBufferX::cleanup()
 693 {
 694     if( m_data )
 695     {
 696         free( m_data );
 697         m_data = NULL;
 698     }
 699
 700     m_size = 0;
 701     m_ptr_curr = m_ptr_end = NULL;
 702 }
 703
 704
 705
 706
 707 //-----------------------------------------------------------------------------
 708 // name: size()
 709 // desc: ...
 710 //-----------------------------------------------------------------------------
 711 DWORD__ AudioBufferX::size()
 712 {
 713     return m_size;
 714 }
 715
 716
 717
 718
 719 //-----------------------------------------------------------------------------
 720 // name: data()
 721 // desc: ...
 722 //-----------------------------------------------------------------------------
 723 SAMPLE * AudioBufferX::data()
 724 {
 725     return m_data;
 726 }
 727
 728
 729
 730
 731 //-----------------------------------------------------------------------------
 732 // name: AudioBufferIn()
 733 // desc: ...
 734 //-----------------------------------------------------------------------------
 735 AudioBufferIn::AudioBufferIn( DWORD__ size )
 736     : AudioBufferX( size )
 737 { }
 738
 739
 740
 741
 742 //-----------------------------------------------------------------------------
 743 // name: ~AudioBufferIn()
 744 // desc: ...
 745 //-----------------------------------------------------------------------------
 746 AudioBufferIn::~AudioBufferIn()
 747 {
 748     this->cleanup();
 749 }
 750
 751
 752
 753
 754 //-----------------------------------------------------------------------------
 755 // name: reset()
 756 // desc: ...
 757 //-----------------------------------------------------------------------------
 758 BOOL__ AudioBufferIn::reset()
 759 {
 760     m_ptr_curr = m_data;
 761
 762     return TickIn::reset();
 763 }
 764
 765
 766
 767
 768 //-----------------------------------------------------------------------------
 769 // name: tick_in()
 770 // desc: ...
 771 //-----------------------------------------------------------------------------
 772 BOOL__ AudioBufferIn::tick_in( SAMPLE * s )
 773 {
 774     if( !m_data )
 775         return FALSE;
 776
 777     *s = *m_ptr_curr++;
 778
 779     return TRUE;
 780 }
 781
 782
 783
 784
 785 //-----------------------------------------------------------------------------
 786 // name: tick_in()
 787 // desc: ...
 788 //-----------------------------------------------------------------------------
 789 BOOL__ AudioBufferIn::tick_in( SAMPLE * l, SAMPLE * r )
 790 {
 791     if( !m_data || m_ptr_curr + 2 >= m_ptr_end )
 792         return FALSE;
 793
 794     *l = *m_ptr_curr++;
 795     *r = *m_ptr_curr++;
 796
 797     return TRUE;
 798 }
 799
 800
 801
 802
 803 //-----------------------------------------------------------------------------
 804 // name: tick_in()
 805 // desc: ...
 806 //-----------------------------------------------------------------------------
 807 BOOL__ AudioBufferIn::tick_in( SAMPLE * in, DWORD__ n )
 808 {
 809     if( !m_data || m_ptr_curr + n >= m_ptr_end )
 810         return FALSE;
 811
 812     while( n-- )
 813         *in++ = *m_ptr_curr++;
 814
 815     return TRUE;
 816 }
 817
 818
 819
 820
 821 //-----------------------------------------------------------------------------
 822 // name: AudioBufferOut()
 823 // desc: ...
 824 //-----------------------------------------------------------------------------
 825 AudioBufferOut::AudioBufferOut( DWORD__ size )
 826     : AudioBufferX( size )
 827 { }
 828
 829
 830
 831
 832 //-----------------------------------------------------------------------------
 833 // name: ~AudioBufferOut()
 834 // desc: ...
 835 //-----------------------------------------------------------------------------
 836 AudioBufferOut::~AudioBufferOut()
 837 {
 838     this->cleanup();
 839 }
 840
 841
 842
 843
 844 //-----------------------------------------------------------------------------
 845 // name: reset()
 846 // desc: ...
 847 //-----------------------------------------------------------------------------
 848 BOOL__ AudioBufferOut::reset()
 849 {
 850     m_ptr_curr = m_data;
 851
 852     return TickOut::reset();
 853 }
 854
 855
 856
 857
 858 //-----------------------------------------------------------------------------
 859 // name: tick_out()
 860 // desc: ...
 861 //-----------------------------------------------------------------------------
 862 BOOL__ AudioBufferOut::tick_out( SAMPLE s )
 863 {
 864     if( !m_data )
 865         return FALSE;
 866
 867     *m_ptr_curr++ = s;
 868
 869     return TRUE;
 870 }
 871
 872
 873
 874
 875 //-----------------------------------------------------------------------------
 876 // name: tick_out()
 877 // desc: ...
 878 //-----------------------------------------------------------------------------
 879 BOOL__ AudioBufferOut::tick_out( SAMPLE l, SAMPLE r )
 880 {
 881     if( !m_data || m_ptr_curr + 2 >= m_ptr_end )
 882         return FALSE;
 883
 884     *m_ptr_curr++ = l;
 885     *m_ptr_curr++ = r;
 886
 887     return TRUE;
 888 }
 889
 890
 891
 892
 893 //-----------------------------------------------------------------------------
 894 // name: tick_out()
 895 // desc: ...
 896 //-----------------------------------------------------------------------------
 897 BOOL__ AudioBufferOut::tick_out( const SAMPLE * out, DWORD__ n )
 898 {
 899     if( !m_data || m_ptr_curr + n >= m_ptr_end )
 900         return FALSE;
 901
 902     while( n-- )
 903         *m_ptr_curr++ = *out++;
 904
 905     return TRUE;
 906 }