mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-11-15 01:54:55 -05:00
461 lines
9.9 KiB
C++
461 lines
9.9 KiB
C++
/*
|
|
* RingBuffer.cpp
|
|
* simple_mp3_playback
|
|
*
|
|
* Created by Ben Allison on 11/10/07.
|
|
* Copyright 2007 Nullsoft, Inc. All rights reserved.
|
|
*
|
|
*/
|
|
|
|
#include "RingBuffer.h"
|
|
#include "../replicant/foundation/error.h"
|
|
|
|
#include "bfc/platform/types.h"
|
|
#include "bfc/platform/minmax.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <algorithm>
|
|
|
|
#ifdef MIN
|
|
#undef MIN
|
|
#endif // MIN
|
|
|
|
#define MIN(a,b) ((a<b)?(a):(b))
|
|
|
|
|
|
RingBuffer::~RingBuffer()
|
|
{
|
|
if ( ringBuffer )
|
|
free( ringBuffer );
|
|
|
|
ringBuffer = 0;
|
|
}
|
|
|
|
void RingBuffer::Reset()
|
|
{
|
|
if ( ringBuffer )
|
|
free( ringBuffer );
|
|
|
|
ringBuffer = 0;
|
|
}
|
|
|
|
bool RingBuffer::reserve( size_t bytes )
|
|
{
|
|
Reset();
|
|
|
|
ringBufferSize = bytes;
|
|
|
|
ringBuffer = (char *)calloc( ringBufferSize, sizeof( char ) );
|
|
if ( !ringBuffer )
|
|
return false;
|
|
|
|
clear();
|
|
|
|
return true;
|
|
}
|
|
|
|
int RingBuffer::expand( size_t bytes )
|
|
{
|
|
if ( bytes > ringBufferSize )
|
|
{
|
|
char *new_buffer = (char *)realloc( ringBuffer, bytes );
|
|
if ( !new_buffer )
|
|
return NErr_OutOfMemory;
|
|
|
|
size_t write_offset = ringReadPosition - ringBuffer;
|
|
size_t read_offset = ringWritePosition - ringBuffer;
|
|
|
|
/* update write pointer for the new buffer */
|
|
ringWritePosition = new_buffer + write_offset;
|
|
|
|
if ( write_offset > read_offset || !ringBufferUsed ) /* ringBufferUsed will resolve the ambiguity when ringWritePosition == ringReadPosition */
|
|
{
|
|
/* the ring buffer looks like [ RXXXW ], so we don't need to move anything.
|
|
Just update the read pointer */
|
|
|
|
ringReadPosition = new_buffer + write_offset;
|
|
}
|
|
else
|
|
{
|
|
/* [XXW RXX] needs to become [XXW RXX] */
|
|
size_t end_bytes = ringBufferSize - read_offset; // number of bytes that we need to relocate (the RXX portion)
|
|
char *new_read_pointer = &new_buffer[ bytes - end_bytes ];
|
|
|
|
memmove( new_read_pointer, ringReadPosition, end_bytes );
|
|
|
|
ringReadPosition = new_read_pointer; /* update read pointer */
|
|
}
|
|
|
|
ringBufferSize = bytes;
|
|
ringBuffer = new_buffer;
|
|
|
|
return NErr_Success;
|
|
}
|
|
else
|
|
return NErr_NoAction;
|
|
}
|
|
|
|
bool RingBuffer::empty() const
|
|
{
|
|
return ( ringBufferUsed == 0 );
|
|
}
|
|
|
|
size_t RingBuffer::read( void *dest, size_t len )
|
|
{
|
|
int8_t *out = (int8_t *)dest; // lets us do pointer math easier
|
|
size_t toCopy = MIN( ringBufferUsed, len );
|
|
size_t copied = 0;
|
|
|
|
len -= toCopy;
|
|
|
|
// read to the end of the ring buffer
|
|
size_t end = ringBufferSize - ( ringReadPosition - ringBuffer );
|
|
size_t read1 = MIN( end, toCopy );
|
|
|
|
memcpy( out, ringReadPosition, read1 );
|
|
|
|
copied += read1;
|
|
ringReadPosition += read1;
|
|
|
|
if ( ringReadPosition == ringBuffer + ringBufferSize )
|
|
ringReadPosition = ringBuffer;
|
|
|
|
// update positions
|
|
ringBufferUsed -= read1;
|
|
toCopy -= read1;
|
|
out = (int8_t *)out + read1;
|
|
|
|
// see if we still have more to read after wrapping around
|
|
if ( toCopy )
|
|
{
|
|
memcpy( out, ringReadPosition, toCopy );
|
|
|
|
copied += toCopy;
|
|
ringReadPosition += toCopy;
|
|
ringBufferUsed -= toCopy;
|
|
|
|
if ( ringReadPosition == ringBuffer + ringBufferSize )
|
|
ringReadPosition = ringBuffer;
|
|
}
|
|
|
|
return copied;
|
|
}
|
|
|
|
size_t RingBuffer::at(size_t offset, void *dest, size_t len) const
|
|
{
|
|
size_t toCopy = ringBufferUsed;
|
|
|
|
// make a local copy of this so we don't blow the original
|
|
char *ringReadPosition = this->ringReadPosition;
|
|
|
|
/* --- do a "dummy read" to deal with the offset request --- */
|
|
size_t dummy_end = ringBufferSize-(ringReadPosition-ringBuffer);
|
|
|
|
offset = MIN(toCopy, offset);
|
|
size_t read0 = MIN(dummy_end, offset);
|
|
ringReadPosition+=read0;
|
|
|
|
if (ringReadPosition == ringBuffer + ringBufferSize)
|
|
ringReadPosition = ringBuffer;
|
|
|
|
// update positions
|
|
toCopy -= read0;
|
|
offset -= read0;
|
|
|
|
// do second-half read (wraparound)
|
|
if ( offset )
|
|
{
|
|
ringReadPosition += offset;
|
|
toCopy -= offset;
|
|
}
|
|
|
|
// dummy read done
|
|
|
|
/* --- set up destination buffer and copy size --- */
|
|
int8_t *out = (int8_t *)dest; // lets us do pointer math easier
|
|
|
|
if ( toCopy > len )
|
|
toCopy = len;
|
|
|
|
size_t copied=0;
|
|
|
|
/* --- read to the end of the ring buffer --- */
|
|
size_t end = ringBufferSize - ( ringReadPosition - ringBuffer );
|
|
size_t read1 = MIN( end, toCopy );
|
|
|
|
memcpy( out, ringReadPosition, read1 );
|
|
|
|
copied += read1;
|
|
ringReadPosition += read1;
|
|
|
|
if (ringReadPosition == ringBuffer + ringBufferSize)
|
|
ringReadPosition = ringBuffer;
|
|
|
|
// update positions
|
|
toCopy -= read1;
|
|
out = (int8_t *)out + read1;
|
|
|
|
/* --- see if we still have more to read after wrapping around --- */
|
|
if (toCopy)
|
|
{
|
|
memcpy(out, ringReadPosition, toCopy);
|
|
|
|
copied += toCopy;
|
|
ringReadPosition += toCopy;
|
|
}
|
|
|
|
return copied;
|
|
}
|
|
|
|
size_t RingBuffer::peek( void *dest, size_t len ) const
|
|
{
|
|
int8_t *out = (int8_t *)dest; // lets us do pointer math easier
|
|
|
|
size_t toCopy = MIN( ringBufferUsed, len );
|
|
size_t copied = 0;
|
|
|
|
// make a local copy of this so we don't blow the original
|
|
char *ringReadPosition = this->ringReadPosition;
|
|
|
|
// read to the end of the ring buffer
|
|
size_t end = ringBufferSize - ( ringReadPosition - ringBuffer );
|
|
size_t read1 = MIN( end, toCopy );
|
|
|
|
memcpy( out, ringReadPosition, read1 );
|
|
|
|
copied += read1;
|
|
ringReadPosition += read1;
|
|
|
|
if ( ringReadPosition == ringBuffer + ringBufferSize )
|
|
ringReadPosition = ringBuffer;
|
|
|
|
// update positions
|
|
toCopy -= read1;
|
|
out = (int8_t *)out + read1;
|
|
|
|
// see if we still have more to read after wrapping around
|
|
if ( toCopy )
|
|
{
|
|
memcpy( out, ringReadPosition, toCopy );
|
|
|
|
copied += toCopy;
|
|
ringReadPosition += toCopy;
|
|
}
|
|
|
|
return copied;
|
|
}
|
|
|
|
size_t RingBuffer::advance( size_t len )
|
|
{
|
|
size_t toCopy = MIN( ringBufferUsed, len );
|
|
size_t copied = 0;
|
|
|
|
len -= toCopy;
|
|
|
|
// read to the end of the ring buffer
|
|
size_t end = ringBufferSize - ( ringReadPosition - ringBuffer );
|
|
size_t read1 = MIN( end, toCopy );
|
|
|
|
copied += read1;
|
|
ringReadPosition += read1;
|
|
|
|
if ( ringReadPosition == ringBuffer + ringBufferSize )
|
|
ringReadPosition = ringBuffer;
|
|
|
|
// update positions
|
|
toCopy -= read1;
|
|
ringBufferUsed -= read1;
|
|
|
|
// see if we still have more to read after wrapping around
|
|
if ( toCopy )
|
|
{
|
|
copied += toCopy;
|
|
ringReadPosition += toCopy;
|
|
ringBufferUsed -= toCopy;
|
|
|
|
if ( ringReadPosition == ringBuffer + ringBufferSize )
|
|
ringReadPosition = ringBuffer;
|
|
}
|
|
|
|
return copied;
|
|
}
|
|
|
|
size_t RingBuffer::avail() const
|
|
{
|
|
return ringBufferSize - ringBufferUsed;
|
|
}
|
|
|
|
size_t RingBuffer::write( const void *buffer, size_t bytes )
|
|
{
|
|
size_t used = ringBufferUsed;
|
|
size_t avail = ringBufferSize - used;
|
|
|
|
bytes = MIN( avail, bytes );
|
|
|
|
// write to the end of the ring buffer
|
|
size_t end = ringBufferSize - ( ringWritePosition - ringBuffer );
|
|
size_t copied = 0;
|
|
size_t write1 = MIN( end, bytes );
|
|
|
|
memcpy( ringWritePosition, buffer, write1 );
|
|
|
|
copied += write1;
|
|
ringWritePosition += write1;
|
|
|
|
if ( ringWritePosition == ringBuffer + ringBufferSize )
|
|
ringWritePosition = ringBuffer;
|
|
|
|
// update positions
|
|
ringBufferUsed += write1;
|
|
bytes -= write1;
|
|
buffer = (const int8_t *)buffer + write1;
|
|
|
|
// see if we still have more to write after wrapping around
|
|
if ( bytes )
|
|
{
|
|
memcpy( ringWritePosition, buffer, bytes );
|
|
|
|
copied += bytes;
|
|
ringWritePosition += bytes;
|
|
ringBufferUsed += bytes;
|
|
|
|
if ( ringWritePosition == ringBuffer + ringBufferSize )
|
|
ringWritePosition = ringBuffer;
|
|
}
|
|
|
|
return copied;
|
|
}
|
|
|
|
size_t RingBuffer::drain( Drainer *drainer, size_t max_bytes )
|
|
{
|
|
// read to the end of the ring buffer
|
|
size_t used = ringBufferUsed;
|
|
size_t bytes = used;
|
|
|
|
bytes = MIN(bytes, max_bytes);
|
|
|
|
size_t copied = 0;
|
|
size_t end = ringBufferSize-(ringReadPosition-ringBuffer);
|
|
size_t drain1 = MIN(end, bytes);
|
|
|
|
if (!drain1)
|
|
return 0;
|
|
|
|
size_t read1 = drainer->Write(ringReadPosition, drain1);
|
|
if (read1 == 0)
|
|
return 0;
|
|
|
|
copied+=read1;
|
|
ringReadPosition+=read1;
|
|
if (ringReadPosition == ringBuffer + ringBufferSize)
|
|
ringReadPosition=ringBuffer;
|
|
|
|
// update positions
|
|
ringBufferUsed -= read1;
|
|
bytes-=read1;
|
|
|
|
// see if we still have more to read after wrapping around
|
|
if (drain1 == read1 && bytes)
|
|
{
|
|
size_t read2 = drainer->Write(ringReadPosition, bytes);
|
|
|
|
copied += read2;
|
|
ringReadPosition += read2;
|
|
ringBufferUsed -= read2;
|
|
|
|
if (ringReadPosition == ringBuffer + ringBufferSize)
|
|
ringReadPosition=ringBuffer;
|
|
}
|
|
|
|
return copied;
|
|
}
|
|
|
|
size_t RingBuffer::fill(Filler *filler, size_t max_bytes)
|
|
{
|
|
// write to the end of the ring buffer
|
|
size_t used = ringBufferUsed;
|
|
size_t bytes = ringBufferSize - used;
|
|
|
|
bytes = MIN(bytes, max_bytes);
|
|
|
|
size_t copied = 0;
|
|
size_t end = ringBufferSize-(ringWritePosition-ringBuffer);
|
|
size_t fill1 = MIN(end, bytes);
|
|
|
|
if (!fill1)
|
|
return 0;
|
|
|
|
size_t write1 = filler->Read(ringWritePosition, fill1);
|
|
if (write1 == 0)
|
|
return 0;
|
|
|
|
copied+=write1;
|
|
ringWritePosition+=write1;
|
|
|
|
if (ringWritePosition == ringBuffer + ringBufferSize)
|
|
ringWritePosition=ringBuffer;
|
|
|
|
// update positions
|
|
ringBufferUsed += write1;
|
|
bytes-=write1;
|
|
|
|
// see if we still have more to write after wrapping around
|
|
if (fill1 == write1 && bytes)
|
|
{
|
|
size_t write2 = filler->Read(ringWritePosition, bytes);
|
|
|
|
copied += write2;
|
|
ringWritePosition += write2;
|
|
ringBufferUsed += write2;
|
|
|
|
if (ringWritePosition == ringBuffer + ringBufferSize)
|
|
ringWritePosition=ringBuffer;
|
|
}
|
|
|
|
return copied;
|
|
}
|
|
|
|
size_t RingBuffer::size() const
|
|
{
|
|
return ringBufferUsed;
|
|
}
|
|
|
|
void RingBuffer::clear()
|
|
{
|
|
ringBufferUsed = 0;
|
|
ringWritePosition = ringBuffer;
|
|
ringReadPosition = ringBuffer;
|
|
}
|
|
|
|
void *RingBuffer::LockBuffer()
|
|
{
|
|
return ringBuffer;
|
|
}
|
|
|
|
void RingBuffer::UnlockBuffer( size_t written )
|
|
{
|
|
ringWritePosition = ringBuffer+written;
|
|
ringBufferUsed = written;
|
|
}
|
|
|
|
size_t RingBuffer::write_position() const
|
|
{
|
|
return (size_t)ringWritePosition;
|
|
}
|
|
|
|
size_t RingBuffer::read_position() const
|
|
{
|
|
return (size_t)ringReadPosition;
|
|
}
|
|
|
|
void RingBuffer::get_read_buffer(size_t bytes, const void **buffer, size_t *bytes_available) const
|
|
{
|
|
size_t toCopy = MIN( ringBufferUsed, bytes );
|
|
|
|
// read to the end of the ring buffer
|
|
size_t end = ringBufferSize-(ringReadPosition-ringBuffer);
|
|
|
|
*bytes_available = MIN(end, toCopy);
|
|
*buffer = ringReadPosition;
|
|
}
|