v2/util_buffers.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: util_buffers.cpp
  27 // desc: buffer implementation
  28 //
  29 // author: Ge Wang (gewang@cs.princeton.edu)
  30 //         Perry R. Cook (prc@cs.princeton.edu)
  31 //         Ananya Misra (amisra@cs.princeton.edu)
  32 // date: Spring 2004
  33 //       Summer 2005 - updated to allow many readers
  34 //-----------------------------------------------------------------------------
  35 #include <stdlib.h>
  36 #include "util_buffers.h"
  37 #include "chuck_errmsg.h"
  38
  39
  40
  41
  42 //-----------------------------------------------------------------------------
  43 // name: CBufferAdvance()
  44 // desc: constructor
  45 //-----------------------------------------------------------------------------
  46 CBufferAdvance::CBufferAdvance()
  47 {
  48     m_data = NULL;
  49     m_data_width = m_write_offset = m_max_elem = 0; // = m_read_offset
  50 }
  51
  52
  53
  54
  55 //-----------------------------------------------------------------------------
  56 // name: ~CBufferAdvance()
  57 // desc: destructor
  58 //-----------------------------------------------------------------------------
  59 CBufferAdvance::~CBufferAdvance()
  60 {
  61     this->cleanup();
  62 }
  63
  64
  65
  66
  67 //-----------------------------------------------------------------------------
  68 // name: initialize()
  69 // desc: initialize
  70 //-----------------------------------------------------------------------------
  71 BOOL__ CBufferAdvance::initialize( UINT__ num_elem, UINT__ width )
  72 {
  73     // cleanup
  74     cleanup();
  75
  76     // allocate
  77     m_data = (BYTE__ *)malloc( num_elem * width );
  78     if( !m_data )
  79         return false;
  80
  81     m_data_width = width;
  82     //m_read_offset = 0;
  83     m_write_offset = 0;
  84     m_max_elem = (SINT__)num_elem;
  85
  86     return true;
  87 }
  88
  89
  90
  91
  92 //-----------------------------------------------------------------------------
  93 // name: cleanup()
  94 // desc: cleanup
  95 //-----------------------------------------------------------------------------
  96 void CBufferAdvance::cleanup()
  97 {
  98     if( !m_data )
  99         return;
 100
 101     free( m_data );
 102
 103     m_data = NULL;
 104     m_data_width = 0;
 105     m_write_offset = m_max_elem = 0; // = m_read_offset
 106 }
 107
 108
 109
 110
 111 //-----------------------------------------------------------------------------
 112 // name: UINT__ join()
 113 // desc: shred can call this to get an index into the vector of read pointers
 114 //-----------------------------------------------------------------------------
 115 UINT__ CBufferAdvance::join( Chuck_Event * event )
 116 {
 117     // TODO: necessary?
 118     m_mutex.acquire();
 119
 120     // index of new pointer that will be pushed back
 121     UINT__ read_offset_index;
 122
 123     // add new pointer pointing (as pointers do) to current write offset
 124     // (shreds don't get interrupted, so m_write_offset will always be correct, right?)
 125     // (uh, hope so...)
 126     if( !m_free.empty() )
 127     {
 128         read_offset_index = m_free.front();
 129         m_free.pop();
 130         //assert( read_offset_index < m_read_offsets.size() );
 131         m_read_offsets[read_offset_index] = ReadOffset( m_write_offset, event );
 132     }
 133     else
 134     {
 135         read_offset_index = m_read_offsets.size();
 136         m_read_offsets.push_back( ReadOffset( m_write_offset, event ) );
 137     }
 138
 139     // TODO: necessary?
 140     m_mutex.release();
 141
 142     // return index
 143     return read_offset_index;
 144 }
 145
 146
 147 //-----------------------------------------------------------------------------
 148 // name: resign
 149 // desc: shred quits buffer; frees its index
 150 //-----------------------------------------------------------------------------
 151 void CBufferAdvance::resign( UINT__ read_offset_index )
 152 {
 153     // make sure read_offset_index passed in is valid
 154     if( read_offset_index < 0 || read_offset_index >= m_read_offsets.size() )
 155         return;
 156
 157     // TODO: necessary?
 158     m_mutex.acquire();
 159
 160     // add this index to free queue
 161     m_free.push( read_offset_index );
 162
 163     // "invalidate" the pointer at that index
 164     m_read_offsets[read_offset_index].read_offset = -1;
 165
 166     // TODO: necessary?
 167     m_mutex.release();
 168 }
 169
 170
 171 //-----------------------------------------------------------------------------
 172 // name: put()
 173 // desc: put
 174 //-----------------------------------------------------------------------------
 175 /*void CBufferAdvance::put( void * data, UINT__ num_elem )
 176 {
 177     UINT__ i, j;
 178     BYTE__ * d = (BYTE__ *)data;
 179
 180     // copy
 181     for( i = 0; i < num_elem; i++ )
 182     {
 183         for( j = 0; j < m_data_width; j++ )
 184         {
 185             m_data[m_write_offset*m_data_width+j] = d[i*m_data_width+j];
 186         }
 187
 188         // move the write
 189         m_write_offset++;
 190
 191         // wrap
 192         if( m_write_offset >= m_max_elem )
 193             m_write_offset = 0;
 194     }
 195 }*/
 196
 197
 198 void CBufferAdvance::put( void * data, UINT__ num_elem )
 199 {
 200     UINT__ i, j;
 201     BYTE__ * d = (BYTE__ *)data;
 202
 203     // TODO: necessary?
 204     m_mutex.acquire();
 205
 206     // copy
 207     for( i = 0; i < num_elem; i++ )
 208     {
 209         for( j = 0; j < m_data_width; j++ )
 210         {
 211             m_data[m_write_offset*m_data_width+j] = d[i*m_data_width+j];
 212         }
 213
 214         // move the write
 215         m_write_offset++;
 216         // wrap
 217         if( m_write_offset >= m_max_elem )
 218             m_write_offset = 0;
 219
 220         // possibility of expelling evil shreds
 221         for( j = 0; j < m_read_offsets.size(); j++ )
 222         {
 223             if( m_write_offset == m_read_offsets[j].read_offset )
 224             {
 225                 // inform shred with index j that it has lost its privileges?
 226                 // invalidate its read_offset
 227                 // m_read_offsets[j].read_offset = -1;
 228             }
 229
 230             if( m_read_offsets[j].event )
 231                 m_read_offsets[j].event->queue_broadcast();
 232         }
 233     }
 234
 235     // TODO: necessary?
 236     m_mutex.release();
 237 }
 238
 239
 240
 241
 242 //-----------------------------------------------------------------------------
 243 // name: get()
 244 // desc: get
 245 //-----------------------------------------------------------------------------
 246 /*UINT__ CBufferAdvance::get( void * data, UINT__ num_elem )
 247 {
 248     UINT__ i, j;
 249     BYTE__ * d = (BYTE__ *)data;
 250
 251     // read catch up with write
 252     if( m_read_offset == m_write_offset )
 253         return 0;
 254
 255     // copy
 256     for( i = 0; i < num_elem; i++ )
 257     {
 258         for( j = 0; j < m_data_width; j++ )
 259         {
 260             d[i*m_data_width+j] = m_data[m_read_offset*m_data_width+j];
 261         }
 262
 263         // move read
 264         m_read_offset++;
 265
 266         // catch up
 267         if( m_read_offset == m_write_offset )
 268         {
 269             i++;
 270             break;
 271         }
 272
 273         // wrap
 274         if( m_read_offset >= m_max_elem )
 275             m_read_offset = 0;
 276     }
 277
 278     // return number of elems
 279     return 1;
 280 }*/
 281
 282
 283 BOOL__ CBufferAdvance::empty( UINT__ read_offset_index )
 284 {
 285     // make sure index is valid
 286     if( read_offset_index >= m_read_offsets.size() )
 287         return TRUE;
 288     if( m_read_offsets[read_offset_index].read_offset < 0 )
 289         return TRUE;
 290
 291     SINT__ m_read_offset = m_read_offsets[read_offset_index].read_offset;
 292
 293     // see if caught up
 294     return m_read_offset == m_write_offset;
 295 }
 296
 297
 298 UINT__ CBufferAdvance::get( void * data, UINT__ num_elem, UINT__ read_offset_index )
 299 {
 300     UINT__ i, j;
 301     BYTE__ * d = (BYTE__ *)data;
 302
 303     // TODO: necessary?
 304     m_mutex.acquire();
 305
 306     // make sure index is valid
 307     if( read_offset_index >= m_read_offsets.size() )
 308     {
 309         m_mutex.release();
 310         return 0;
 311     }
 312     if( m_read_offsets[read_offset_index].read_offset < 0 )
 313     {
 314         m_mutex.release();
 315         return 0;
 316     }
 317
 318     SINT__ m_read_offset = m_read_offsets[read_offset_index].read_offset;
 319
 320     // read catch up with write
 321     if( m_read_offset == m_write_offset )
 322     {
 323         m_mutex.release();
 324         return 0;
 325     }
 326
 327     // copy
 328     for( i = 0; i < num_elem; i++ )
 329     {
 330         for( j = 0; j < m_data_width; j++ )
 331         {
 332             d[i*m_data_width+j] = m_data[m_read_offset*m_data_width+j];
 333         }
 334
 335         // move read
 336         m_read_offset++;
 337         // wrap
 338         if( m_read_offset >= m_max_elem )
 339             m_read_offset = 0;
 340
 341         // catch up
 342         if( m_read_offset == m_write_offset )
 343         {
 344             i++;
 345             break;
 346         }
 347     }
 348
 349     // update read offset at given index
 350     m_read_offsets[read_offset_index].read_offset = m_read_offset;
 351
 352     // TODO: necessary?
 353     m_mutex.release();
 354
 355     // return number of elems
 356     return i;
 357 }
 358
 359
 360
 361
 362 //-----------------------------------------------------------------------------
 363 // name: CBufferSimple()
 364 // desc: constructor
 365 //-----------------------------------------------------------------------------
 366 CBufferSimple::CBufferSimple()
 367 {
 368     m_data = NULL;
 369     m_data_width = m_read_offset = m_write_offset = m_max_elem = 0;
 370 }
 371
 372
 373
 374
 375 //-----------------------------------------------------------------------------
 376 // name: ~CBufferSimple()
 377 // desc: destructor
 378 //-----------------------------------------------------------------------------
 379 CBufferSimple::~CBufferSimple()
 380 {
 381     this->cleanup();
 382 }
 383
 384
 385
 386
 387 //-----------------------------------------------------------------------------
 388 // name: initialize()
 389 // desc: initialize
 390 //-----------------------------------------------------------------------------
 391 BOOL__ CBufferSimple::initialize( UINT__ num_elem, UINT__ width )
 392 {
 393     // cleanup
 394     cleanup();
 395
 396     // allocate
 397     m_data = (BYTE__ *)malloc( num_elem * width );
 398     if( !m_data )
 399         return false;
 400
 401     m_data_width = width;
 402     m_read_offset = 0;
 403     m_write_offset = 0;
 404     m_max_elem = num_elem;
 405
 406     return true;
 407 }
 408
 409
 410
 411
 412 //-----------------------------------------------------------------------------
 413 // name: cleanup()
 414 // desc: cleanup
 415 //-----------------------------------------------------------------------------
 416 void CBufferSimple::cleanup()
 417 {
 418     if( !m_data )
 419         return;
 420
 421     free( m_data );
 422
 423     m_data = NULL;
 424     m_data_width = m_read_offset = m_write_offset = m_max_elem = 0;
 425 }
 426
 427
 428
 429
 430 //-----------------------------------------------------------------------------
 431 // name: put()
 432 // desc: put
 433 //-----------------------------------------------------------------------------
 434 void CBufferSimple::put( void * data, UINT__ num_elem )
 435 {
 436     UINT__ i, j;
 437     BYTE__ * d = (BYTE__ *)data;
 438
 439     // copy
 440     for( i = 0; i < num_elem; i++ )
 441     {
 442         for( j = 0; j < m_data_width; j++ )
 443         {
 444             m_data[m_write_offset*m_data_width+j] = d[i*m_data_width+j];
 445         }
 446
 447         // move the write
 448         m_write_offset++;
 449
 450         // wrap
 451         if( m_write_offset >= m_max_elem )
 452             m_write_offset = 0;
 453     }
 454 }
 455
 456
 457
 458
 459 //-----------------------------------------------------------------------------
 460 // name: get()
 461 // desc: get
 462 //-----------------------------------------------------------------------------
 463 UINT__ CBufferSimple::get( void * data, UINT__ num_elem )
 464 {
 465     UINT__ i, j;
 466     BYTE__ * d = (BYTE__ *)data;
 467
 468     // read catch up with write
 469     if( m_read_offset == m_write_offset )
 470         return 0;
 471
 472     // copy
 473     for( i = 0; i < num_elem; i++ )
 474     {
 475         for( j = 0; j < m_data_width; j++ )
 476         {
 477             d[i*m_data_width+j] = m_data[m_read_offset*m_data_width+j];
 478         }
 479
 480         // move read
 481         m_read_offset++;
 482
 483         // catch up
 484         if( m_read_offset == m_write_offset )
 485         {
 486             i++;
 487             break;
 488         }
 489
 490         // wrap
 491         if( m_read_offset >= m_max_elem )
 492             m_read_offset = 0;
 493     }
 494
 495     // return number of elems
 496     return 1; // shouldn't it return i?
 497 }
 498
 499
 500
 501
 502 //-----------------------------------------------------------------------------
 503 // name: AccumBuffer()
 504 // desc: constructor
 505 //-----------------------------------------------------------------------------
 506 AccumBuffer::AccumBuffer()
 507 {
 508     m_data = NULL;
 509     m_write_offset = m_max_elem = 0;
 510 }
 511
 512
 513
 514
 515 //-----------------------------------------------------------------------------
 516 // name: ~AccumBuffer()
 517 // desc: destructor
 518 //-----------------------------------------------------------------------------
 519 AccumBuffer::~AccumBuffer()
 520 {
 521     this->cleanup();
 522 }
 523
 524
 525
 526
 527 //-----------------------------------------------------------------------------
 528 // name: resize()
 529 // desc: resize
 530 //-----------------------------------------------------------------------------
 531 t_CKINT AccumBuffer::resize( t_CKINT size )
 532 {
 533     // if the same, then done
 534     if( size == m_max_elem ) return size;
 535
 536     // allocate
 537     SAMPLE * next = (SAMPLE *)malloc( size * sizeof(SAMPLE) );
 538     // zero it
 539     memset( next, 0, size * sizeof(SAMPLE) );
 540     if( !next )
 541     {
 542         // log
 543         EM_log( CK_LOG_WARNING, "AccumBuffer:resize(%ld) failed to allocated..." );
 544         // clean up
 545         this->cleanup();
 546         // done
 547         return FALSE;
 548     }
 549
 550     // if no current
 551     if( !m_data )
 552     {
 553         // reset everything
 554         m_data = next;
 555         m_write_offset = 0;
 556         m_max_elem = size;
 557     }
 558     else
 559     {
 560         // retrieve next
 561         this->get( next, size );
 562         // clean up
 563         this->cleanup();
 564         // copy
 565         m_data = next;
 566         // write pointer is at the end
 567         m_write_offset = 0;
 568         // update max elem
 569         m_max_elem = size;
 570     }
 571
 572     return TRUE;
 573 }
 574
 575
 576
 577
 578 //-----------------------------------------------------------------------------
 579 // name: cleanup()
 580 // desc: cleanup
 581 //-----------------------------------------------------------------------------
 582 void AccumBuffer::cleanup()
 583 {
 584     if( !m_data )
 585         return;
 586
 587     free( m_data );
 588     m_data = NULL;
 589     m_write_offset = m_max_elem = 0;
 590 }
 591
 592
 593
 594
 595 //-----------------------------------------------------------------------------
 596 // name: put()
 597 // desc: put
 598 //-----------------------------------------------------------------------------
 599 void AccumBuffer::put( SAMPLE data )
 600 {
 601     // copy
 602     m_data[m_write_offset] = data;
 603     // move the write
 604     m_write_offset++;
 605     // wrap
 606     if( m_write_offset >= m_max_elem )
 607         m_write_offset = 0;
 608 }
 609
 610
 611
 612
 613 //-----------------------------------------------------------------------------
 614 // name: get()
 615 // desc: get
 616 //-----------------------------------------------------------------------------
 617 void AccumBuffer::get( SAMPLE * buffer, t_CKINT num_elem )
 618 {
 619     // left to copy
 620     t_CKINT left = num_elem;
 621     // amount
 622     t_CKINT amount = m_max_elem - m_write_offset;
 623     // to copy
 624     t_CKINT tocopy = ck_min( left, amount );
 625     // update left
 626     left -= tocopy;
 627     // copy after the write pointer
 628     memcpy( buffer, m_data + m_write_offset, tocopy * sizeof(SAMPLE) );
 629
 630     // more?
 631     if( left )
 632     {
 633         // amount
 634         amount = m_write_offset;
 635         // to copy
 636         t_CKINT tocopy2 = ck_min( left, amount );
 637         // update left
 638         left -= tocopy2;
 639         // copy before the write pointer
 640         memcpy( buffer + tocopy, m_data, tocopy2 * sizeof(SAMPLE) );
 641
 642         // more?
 643         if( left )
 644         {
 645             // make sure
 646             assert( m_max_elem == (tocopy + tocopy2) );
 647             assert( num_elem > m_max_elem );
 648             // zero it out
 649             memset( buffer + m_max_elem, 0, (num_elem - m_max_elem) * sizeof(SAMPLE) );
 650         }
 651     }
 652 }
 653
 654
 655
 656
 657 //-----------------------------------------------------------------------------
 658 // name: DeccumBuffer()
 659 // desc: constructor
 660 //-----------------------------------------------------------------------------
 661 DeccumBuffer::DeccumBuffer()
 662 {
 663     m_data = NULL;
 664     m_read_offset = m_max_elem = 0;
 665 }
 666
 667
 668
 669
 670 //-----------------------------------------------------------------------------
 671 // name: ~DeccumBuffer()
 672 // desc: destructor
 673 //-----------------------------------------------------------------------------
 674 DeccumBuffer::~DeccumBuffer()
 675 {
 676     this->cleanup();
 677 }
 678
 679
 680
 681
 682 //-----------------------------------------------------------------------------
 683 // name: resize()
 684 // desc: resize
 685 //-----------------------------------------------------------------------------
 686 t_CKINT DeccumBuffer::resize( t_CKINT size )
 687 {
 688     // if the same, then done
 689     if( size == m_max_elem ) return size;
 690
 691     // allocate
 692     SAMPLE * next = (SAMPLE *)malloc( size * sizeof(SAMPLE) );
 693     // zero it
 694     memset( next, 0, size * sizeof(SAMPLE) );
 695     if( !next )
 696     {
 697         // log
 698         EM_log( CK_LOG_WARNING, "DeccumBuffer:resize(%ld) failed to allocated..." );
 699         // clean up
 700         this->cleanup();
 701         // done
 702         return FALSE;
 703     }
 704
 705     // if no current
 706     if( !m_data )
 707     {
 708         // reset everything
 709         m_data = next;
 710         m_read_offset = 0;
 711         m_max_elem = size;
 712     }
 713     else
 714     {
 715         // retrieve next
 716         this->get( next, size );
 717         // clean up
 718         this->cleanup();
 719         // copy
 720         m_data = next;
 721         // read pointer is at the end
 722         m_read_offset = 0;
 723         // update max elem
 724         m_max_elem = size;
 725     }
 726
 727     return TRUE;
 728 }
 729
 730
 731
 732
 733 //-----------------------------------------------------------------------------
 734 // name: cleanup()
 735 // desc: cleanup
 736 //-----------------------------------------------------------------------------
 737 void DeccumBuffer::cleanup()
 738 {
 739     if( !m_data )
 740         return;
 741
 742     free( m_data );
 743     m_data = NULL;
 744     m_read_offset = m_max_elem = 0;
 745 }
 746
 747
 748
 749
 750 //-----------------------------------------------------------------------------
 751 // name: put()
 752 // desc: put
 753 //-----------------------------------------------------------------------------
 754 void DeccumBuffer::get( SAMPLE * data )
 755 {
 756     // copy
 757     *data = m_data[m_read_offset];
 758     // zero
 759     m_data[m_read_offset] = 0;
 760     // move the write
 761     m_read_offset++;
 762     // wrap
 763     if( m_read_offset >= m_max_elem )
 764         m_read_offset = 0;
 765 }
 766
 767
 768
 769
 770 //-----------------------------------------------------------------------------
 771 // name: get()
 772 // desc: get
 773 //-----------------------------------------------------------------------------
 774 void DeccumBuffer::get( SAMPLE * buffer, t_CKINT num_elem )
 775 {
 776     // left to copy
 777     t_CKINT left = num_elem;
 778     // amount
 779     t_CKINT amount = m_max_elem - m_read_offset;
 780     // to copy
 781     t_CKINT tocopy = ck_min( left, amount );
 782     // update left
 783     left -= tocopy;
 784     // copy after the write pointer
 785     memcpy( buffer, m_data + m_read_offset, tocopy * sizeof(SAMPLE) );
 786
 787     // more?
 788     if( left )
 789     {
 790         // amount
 791         amount = m_read_offset;
 792         // to copy
 793         t_CKINT tocopy2 = ck_min( left, amount );
 794         // update left
 795         left -= tocopy2;
 796         // copy before the write pointer
 797         memcpy( buffer + tocopy, m_data, tocopy2 * sizeof(SAMPLE) );
 798
 799         // more?
 800         if( left )
 801         {
 802             // make sure
 803             assert( m_max_elem == (tocopy + tocopy2) );
 804             assert( num_elem > m_max_elem );
 805             // zero it out
 806             memset( buffer + m_max_elem, 0, (num_elem - m_max_elem) * sizeof(SAMPLE) );
 807         }
 808     }
 809 }
 810
 811
 812
 813
 814 //-----------------------------------------------------------------------------
 815 // name: put()
 816 // desc: put
 817 //-----------------------------------------------------------------------------
 818 void DeccumBuffer::put( SAMPLE * buffer, t_CKINT num_elem )
 819 {
 820     // left to add
 821     t_CKINT left = num_elem;
 822     // amount
 823     t_CKINT amount = m_max_elem - m_read_offset;
 824     // to add
 825     t_CKINT tocopy = ck_min( left, amount );
 826     // update left
 827     left -= tocopy;
 828     // copy after the write pointer
 829     t_CKINT i;
 830     for( i = 0; i < tocopy; i++ )
 831         m_data[m_read_offset+i] += buffer[i];
 832
 833     // more?
 834     if( left )
 835     {
 836         // amount
 837         amount = m_read_offset;
 838         // to copy
 839         t_CKINT tocopy2 = ck_min( left, amount );
 840         // update left
 841         left -= tocopy2;
 842         // copy before the write pointer
 843         for( i = 0; i < tocopy2; i++ )
 844             m_data[i] += buffer[tocopy+i];
 845
 846         // more?
 847         if( left )
 848         {
 849             // make sure
 850             assert( m_max_elem == (tocopy + tocopy2) );
 851             assert( num_elem > m_max_elem );
 852             // log
 853             EM_log( CK_LOG_WARNING, "(IFFT): discarding data during OLA synthesis..." );
 854         }
 855     }
 856 }