[PD-cvs] pd/src s_audio_paring.c,1.1.4.1.2.1,1.1.4.1.2.1.2.1

31 Jul 2007


      Update of /cvsroot/pure-data/pd/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv11847
Modified Files:
      Tag: desiredata
    s_audio_paring.c 
Log Message:
cleanup and remove fprintf
Index: s_audio_paring.c
===================================================================
RCS file: /cvsroot/pure-data/pd/src/s_audio_paring.c,v
retrieving revision 1.1.4.1.2.1
retrieving revision 1.1.4.1.2.1.2.1
diff -C2 -d -r1.1.4.1.2.1 -r1.1.4.1.2.1.2.1
*** s_audio_paring.c	24 Jan 2006 01:29:54 -0000	1.1.4.1.2.1
--- s_audio_paring.c	31 Jul 2007 00:10:37 -0000	1.1.4.1.2.1.2.1
***************
*** 32,40 ****
   * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-  *
   */
  /*
   * modified 2002/07/13 by olaf.matthes@gmx.de to allow any number if channels
-  *
   */
--- 32,38 ----
***************
*** 45,53 ****
  #include <string.h>
! /***************************************************************************
!  * Initialize FIFO.
!  */
! long PD_RingBuffer_Init( RingBuffer *rbuf, long numBytes, void *dataPtr )
! {
      rbuf->bufferSize = numBytes;
      rbuf->buffer = (char *)dataPtr;
--- 43,48 ----
  #include <string.h>
! /* Initialize FIFO. */
! long PD_RingBuffer_Init(RingBuffer *rbuf, long numBytes, void *dataPtr) {
      rbuf->bufferSize = numBytes;
      rbuf->buffer = (char *)dataPtr;
***************
*** 57,103 ****
  /***************************************************************************
  ** Return number of bytes available for reading. */
! long PD_RingBuffer_GetReadAvailable( RingBuffer *rbuf )
! {
      long ret = rbuf->writeIndex - rbuf->readIndex;
!     if (ret < 0)
!         ret += 2 * rbuf->bufferSize;
!     if (ret < 0 || ret > rbuf->bufferSize)
!         fprintf(stderr,
!             "consistency check failed: PD_RingBuffer_GetReadAvailable\n");
!     return ( ret );
  }
! /***************************************************************************
! ** Return number of bytes available for writing. */
! long PD_RingBuffer_GetWriteAvailable( RingBuffer *rbuf )
! {
!     return ( rbuf->bufferSize - PD_RingBuffer_GetReadAvailable(rbuf));
  }
! /***************************************************************************
! ** Clear buffer. Should only be called when buffer is NOT being read. */
! void PD_RingBuffer_Flush( RingBuffer *rbuf )
! {
      rbuf->writeIndex = rbuf->readIndex = 0;
  }
! /***************************************************************************
! ** Get address of region(s) to which we can write data.
! ** If the region is contiguous, size2 will be zero.
! ** If non-contiguous, size2 will be the size of second region.
! ** Returns room available to be written or numBytes, whichever is smaller.
! */
! long PD_RingBuffer_GetWriteRegions( RingBuffer *rbuf, long numBytes,
!                                  void **dataPtr1, long *sizePtr1,
!                                  void **dataPtr2, long *sizePtr2 )
! {
!     long   index;
!     long   available = PD_RingBuffer_GetWriteAvailable( rbuf );
!     if( numBytes > available ) numBytes = available;
      /* Check to see if write is not contiguous. */
      index = rbuf->writeIndex;
!     while (index >= rbuf->bufferSize)
!         index -= rbuf->bufferSize;
!     if( (index + numBytes) > rbuf->bufferSize )
!     {
          /* Write data in two blocks that wrap the buffer. */
          long   firstHalf = rbuf->bufferSize - index;
--- 52,83 ----
  /***************************************************************************
  ** Return number of bytes available for reading. */
! long PD_RingBuffer_GetReadAvailable(RingBuffer *rbuf) {
      long ret = rbuf->writeIndex - rbuf->readIndex;
!     if (ret < 0) ret += 2 * rbuf->bufferSize;
!     if (ret < 0 || ret > rbuf->bufferSize) error("consistency check failed: PD_RingBuffer_GetReadAvailable");
!     return ret;
  }
! /* Return number of bytes available for writing. */
! long PD_RingBuffer_GetWriteAvailable(RingBuffer *rbuf) {
!     return rbuf->bufferSize - PD_RingBuffer_GetReadAvailable(rbuf);
  }
! /* Clear buffer. Should only be called when buffer is NOT being read. */
! void PD_RingBuffer_Flush(RingBuffer *rbuf) {
      rbuf->writeIndex = rbuf->readIndex = 0;
  }
! /* Get address of region(s) to which we can write data. If the region is contiguous, size2 will be zero.
!    If non-contiguous, size2 will be the size of second region.
!    Returns room available to be written or numBytes, whichever is smaller. */
! long PD_RingBuffer_GetWriteRegions(RingBuffer *rbuf, long numBytes,
! void **dataPtr1, long *sizePtr1, void **dataPtr2, long *sizePtr2) {
!     long index;
!     long available = PD_RingBuffer_GetWriteAvailable(rbuf);
!     if (numBytes > available) numBytes = available;
      /* Check to see if write is not contiguous. */
      index = rbuf->writeIndex;
!     while (index >= rbuf->bufferSize) index -= rbuf->bufferSize;
!     if ((index + numBytes) > rbuf->bufferSize) {
          /* Write data in two blocks that wrap the buffer. */
          long   firstHalf = rbuf->bufferSize - index;
***************
*** 106,112 ****
          *dataPtr2 = &rbuf->buffer[0];
          *sizePtr2 = numBytes - firstHalf;
!     }
!     else
!     {
          *dataPtr1 = &rbuf->buffer[index];
          *sizePtr1 = numBytes;
--- 86,90 ----
          *dataPtr2 = &rbuf->buffer[0];
          *sizePtr2 = numBytes - firstHalf;
!     } else {
          *dataPtr1 = &rbuf->buffer[index];
          *sizePtr1 = numBytes;
***************
*** 120,128 ****
  /***************************************************************************
  */
! long PD_RingBuffer_AdvanceWriteIndex( RingBuffer *rbuf, long numBytes )
! {
!     long ret = (rbuf->writeIndex + numBytes);
!     if ( ret >= 2 * rbuf->bufferSize)
!         ret -= 2 * rbuf->bufferSize;    /* check for end of buffer */
      return rbuf->writeIndex = ret;
  }
--- 98,104 ----
  /***************************************************************************
  */
! long PD_RingBuffer_AdvanceWriteIndex(RingBuffer *rbuf, long numBytes) {
!     long ret = rbuf->writeIndex + numBytes;
!     if (ret >= 2 * rbuf->bufferSize) ret -= 2 * rbuf->bufferSize;    /* check for end of buffer */
      return rbuf->writeIndex = ret;
  }
***************
*** 134,151 ****
  ** Returns room available to be written or numBytes, whichever is smaller.
  */
! long PD_RingBuffer_GetReadRegions( RingBuffer *rbuf, long numBytes,
!                                 void **dataPtr1, long *sizePtr1,
!                                 void **dataPtr2, long *sizePtr2 )
! {
!     long   index;
!     long   available = PD_RingBuffer_GetReadAvailable( rbuf );
!     if( numBytes > available ) numBytes = available;
      /* Check to see if read is not contiguous. */
      index = rbuf->readIndex;
!     while (index >= rbuf->bufferSize)
!         index -= rbuf->bufferSize;
!     
!     if( (index + numBytes) > rbuf->bufferSize )
!     {
          /* Write data in two blocks that wrap the buffer. */
          long firstHalf = rbuf->bufferSize - index;
--- 110,122 ----
  ** Returns room available to be written or numBytes, whichever is smaller.
  */
! long PD_RingBuffer_GetReadRegions(RingBuffer *rbuf, long numBytes,
! void **dataPtr1, long *sizePtr1, void **dataPtr2, long *sizePtr2) {
!     long index;
!     long available = PD_RingBuffer_GetReadAvailable(rbuf);
!     if (numBytes > available) numBytes = available;
      /* Check to see if read is not contiguous. */
      index = rbuf->readIndex;
!     while (index >= rbuf->bufferSize) index -= rbuf->bufferSize;
!     if ((index + numBytes) > rbuf->bufferSize) {
          /* Write data in two blocks that wrap the buffer. */
          long firstHalf = rbuf->bufferSize - index;
***************
*** 154,160 ****
          *dataPtr2 = &rbuf->buffer[0];
          *sizePtr2 = numBytes - firstHalf;
!     }
!     else
!     {
          *dataPtr1 = &rbuf->buffer[index];
          *sizePtr1 = numBytes;
--- 125,129 ----
          *dataPtr2 = &rbuf->buffer[0];
          *sizePtr2 = numBytes - firstHalf;
!     } else {
          *dataPtr1 = &rbuf->buffer[index];
          *sizePtr1 = numBytes;
***************
*** 164,194 ****
      return numBytes;
  }
! /***************************************************************************
! */
! long PD_RingBuffer_AdvanceReadIndex( RingBuffer *rbuf, long numBytes )
! {
      long ret = (rbuf->readIndex + numBytes);
!     if( ret >= 2 * rbuf->bufferSize)
!         ret -= 2 * rbuf->bufferSize;
      return rbuf->readIndex = ret;
  }
! /***************************************************************************
! ** Return bytes written. */
! long PD_RingBuffer_Write( RingBuffer *rbuf, const void *data, long numBytes )
! {
      long size1, size2, numWritten;
      void *data1, *data2;
      numWritten = PD_RingBuffer_GetWriteRegions( rbuf, numBytes, &data1, &size1, &data2, &size2 );
!     if( size2 > 0 )
!     {
! 
!         memcpy( data1, data, size1 );
          data = ((char *)data) + size1;
!         memcpy( data2, data, size2 );
!     }
!     else
!     {
!         memcpy( data1, data, size1 );
      }
      PD_RingBuffer_AdvanceWriteIndex( rbuf, numWritten );
--- 133,154 ----
      return numBytes;
  }
! 
! long PD_RingBuffer_AdvanceReadIndex( RingBuffer *rbuf, long numBytes ) {
      long ret = (rbuf->readIndex + numBytes);
!     if( ret >= 2 * rbuf->bufferSize) ret -= 2 * rbuf->bufferSize;
      return rbuf->readIndex = ret;
  }
! /* Return bytes written. */
! long PD_RingBuffer_Write(RingBuffer *rbuf, const void *data, long numBytes) {
      long size1, size2, numWritten;
      void *data1, *data2;
      numWritten = PD_RingBuffer_GetWriteRegions( rbuf, numBytes, &data1, &size1, &data2, &size2 );
!     if (size2 > 0) {
!         memcpy(data1, data, size1);
          data = ((char *)data) + size1;
!         memcpy(data2, data, size2);
!     } else {
!         memcpy(data1, data, size1);
      }
      PD_RingBuffer_AdvanceWriteIndex( rbuf, numWritten );
***************
*** 196,215 ****
  }
! /***************************************************************************
! ** Return bytes read. */
! long PD_RingBuffer_Read( RingBuffer *rbuf, void *data, long numBytes )
! {
      long size1, size2, numRead;
      void *data1, *data2;
      numRead = PD_RingBuffer_GetReadRegions( rbuf, numBytes, &data1, &size1, &data2, &size2 );
!     if( size2 > 0 )
!     {
!         memcpy( data, data1, size1 );
          data = ((char *)data) + size1;
!         memcpy( data, data2, size2 );
!     }
!     else
!     {
!         memcpy( data, data1, size1 );
      }
      PD_RingBuffer_AdvanceReadIndex( rbuf, numRead );
--- 156,170 ----
  }
! /* Return bytes read. */
! long PD_RingBuffer_Read(RingBuffer *rbuf, void *data, long numBytes) {
      long size1, size2, numRead;
      void *data1, *data2;
      numRead = PD_RingBuffer_GetReadRegions( rbuf, numBytes, &data1, &size1, &data2, &size2 );
!     if (size2 > 0) {
!         memcpy(data, data1, size1);
          data = ((char *)data) + size1;
!         memcpy(data, data2, size2);
!     } else {
!         memcpy(data, data1, size1);
      }
      PD_RingBuffer_AdvanceReadIndex( rbuf, numRead );

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

[PD-cvs] pd/src s_audio_paring.c,1.1.4.1.2.1,1.1.4.1.2.1.2.1