exile/v1/src/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 //-----------------------------------------------------------------------------
  32 #include "util_buffers.h"
  33 #include <stdlib.h>
  34
  35
  36
  37
  38 //-----------------------------------------------------------------------------
  39 // name: Cbuffer()
  40 // desc: constructor
  41 //-----------------------------------------------------------------------------
  42 CBuffer::CBuffer()
  43 {
  44     m_data = NULL;
  45     m_data_width = m_read_offset = m_write_offset = m_max_elem = 0;
  46 }
  47
  48
  49
  50
  51 //-----------------------------------------------------------------------------
  52 // name: ~CBuffer()
  53 // desc: destructor
  54 //-----------------------------------------------------------------------------
  55 CBuffer::~CBuffer()
  56 {
  57     this->cleanup();
  58 }
  59
  60
  61
  62
  63 //-----------------------------------------------------------------------------
  64 // name: initialize()
  65 // desc: initialize
  66 //-----------------------------------------------------------------------------
  67 BOOL__ CBuffer::initialize( UINT__ num_elem, UINT__ width )
  68 {
  69     // cleanup
  70     cleanup();
  71
  72     // allocate
  73     m_data = (BYTE__ *)malloc( num_elem * width );
  74     if( !m_data )
  75         return false;
  76
  77     m_data_width = width;
  78     m_read_offset = 0;
  79     m_write_offset = 0;
  80     m_max_elem = num_elem;
  81
  82     return true;
  83 }
  84
  85
  86
  87
  88 //-----------------------------------------------------------------------------
  89 // name: cleanup()
  90 // desc: cleanup
  91 //-----------------------------------------------------------------------------
  92 void CBuffer::cleanup()
  93 {
  94     if( !m_data )
  95         return;
  96
  97     free( m_data );
  98
  99     m_data = NULL;
 100     m_data_width = m_read_offset = m_write_offset = m_max_elem = 0;
 101 }
 102
 103
 104
 105
 106 //-----------------------------------------------------------------------------
 107 // name: put()
 108 // desc: put
 109 //-----------------------------------------------------------------------------
 110 void CBuffer::put( void * data, UINT__ num_elem )
 111 {
 112     UINT__ i, j;
 113     BYTE__ * d = (BYTE__ *)data;
 114
 115     // copy
 116     for( i = 0; i < num_elem; i++ )
 117     {
 118         for( j = 0; j < m_data_width; j++ )
 119         {
 120             m_data[m_write_offset*m_data_width+j] = d[i*m_data_width+j];
 121         }
 122
 123         // move the write
 124         m_write_offset++;
 125
 126         // wrap
 127         if( m_write_offset >= m_max_elem )
 128             m_write_offset = 0;
 129     }
 130 }
 131
 132
 133
 134
 135 //-----------------------------------------------------------------------------
 136 // name: get()
 137 // desc: get
 138 //-----------------------------------------------------------------------------
 139 UINT__ CBuffer::get( void * data, UINT__ num_elem )
 140 {
 141     UINT__ i, j;
 142     BYTE__ * d = (BYTE__ *)data;
 143
 144     // read catch up with write
 145     if( m_read_offset == m_write_offset )
 146         return 0;
 147
 148     // copy
 149     for( i = 0; i < num_elem; i++ )
 150     {
 151         for( j = 0; j < m_data_width; j++ )
 152         {
 153             d[i*m_data_width+j] = m_data[m_read_offset*m_data_width+j];
 154         }
 155
 156         // move read
 157         m_read_offset++;
 158
 159         // catch up
 160         if( m_read_offset == m_write_offset )
 161         {
 162             i++;
 163             break;
 164         }
 165
 166         // wrap
 167         if( m_read_offset >= m_max_elem )
 168             m_read_offset = 0;
 169     }
 170
 171     // return number of elems
 172     return 1;
 173 }