cbuf.cpp

一个语音信号端点检测的程序

//
// Circular buffer member functions
//
// Bruce T. Lowerre, Public domain, 1995, 1997
//
// $Log: cbuf.cc,v $
// Revision 1.6  1997/08/06 19:35:15  lowerre
// removed sampling rate from classes
//
// Revision 1.5  1997/07/30 19:26:29  lowerre
// modifies read and peek routines, again!
//
// Revision 1.4  1997/07/21 22:13:11  lowerre
// found bugs in the read routines, reader not being updated properly
//
// Revision 1.3  1997/06/04 18:50:03  lowerre
// added eod check to available read
// fixed eod check in peek and read
//
// Revision 1.2  1997/06/04 18:14:42  lowerre
// added eod boolean to read and peek
//
// Revision 1.1  1997/05/14 20:02:24  lowerre
// Initial revision
//
//
//


/*
 * This defines the cbuf (circular buffer) class routines.  This class is used to
 * handle speech utterances, which are either pre-recorded or live.
 */

#include "cbuf.h"
#include <string.h>


/*
 * CBUF_CHAR::CBUF_CHAR - the class constructor for a circular buffer of size usize
 *		It is assumed that the samples are bytes (either mu-law or a-law).
 *              The buffer length is allocated with 4 additional bytes because
 *              the start and end markers take room.
 */
cbuf_char::cbuf_char
(
   long	usize			// size of circular buffer
)
{
    buffer = new char[usize + 4];	// the actual buffer
    size = usize;
    reset ();
} // end cbuf_char::cbuf_char


/*
 * CBUF_SHORT::CBUF_SHORT - the class constructor for a circular buffer of size usize
 *		It is assumed that the samples are shorts.
 *              The buffer length is allocated with 4 additional shorts because
 *              the start and end markers take room.
 */
cbuf_short::cbuf_short
(
    long	usize			// size of circular buffer
)
{
    buffer = new short[usize + 4];	// the actual buffer
    size = usize;
    reset ();
} // end cbuf_short::cbuf_short


/*
 * CBUF_LONG::CBUF_LONG - the class constructor for a circular buffer of size usize
 *		It is assumed that the samples are longs.
 *              The buffer length is allocated with 4 additional longs because
 *              the start and end markers take room.
 */
cbuf_long::cbuf_long
(
    long	usize			// size of circular buffer
)
{
    buffer = new long[usize + 4];	// the actual buffer
    size = usize;
    reset ();
} // end cbuf_long::cbuf_long


/*
 * CBUF_FLOAT::CBUF_FLOAT - the class constructor for a circular buffer of size usize
 *		It is assumed that the samples are floats.
 *              The buffer length is allocated with 4 additional shorts because
 *              the start and end markers take room.
 */
cbuf_float::cbuf_float
(
    long	usize			// size of circular buffer
)
{
    buffer = new float[usize + 4];	// the actual buffer
    size = usize;
    reset ();
} // end cbuf_float::cbuf_float


/*
 * CBUF::AVAILABLE_READ - get the number of elements available to read
 *                        This is complicated by the circular nature of the
 *                        buffer plus the eod marker.
 */
long cbuf::available_read
(
    BOOLEAN	ckeod			// if True, then check eod marker
)
{
    long	first = reader,		// first actual element available
		last = writer;		// last actual element available + 1

    if (ckeod && eod >= 0)
        last = eod;			// end of data has been set

    if (last < first)
        last += size;			// wraps around
    return (last - first);
} // end cbuf::available_read


/*
 * CBUF::AVAILABLE_READALL - get the number of elements available to readall
 *                           This is complicated by the circular nature of the
 *                           buffer plus the eod marker.
 */
long cbuf::available_readall ()
{
    long	first,			// first actual element available
		last;			// last actual element available + 1

    if (keeper < 0)
        first = reader;			// keeper not set
    else
        first = keeper;
    if (eod >= 0)
        last = eod;			// set last available
    else
    if ((last = writer - 1) < 0)
        last += size;			// wrap around
    if (last < first)
        last += size;			// wraps around
    return (last - first);
} // end cbuf::available_readall


/*
 * CBUF::AVAILABLE_WRITE - get the number of empty elements available to write
 *                         This is complicated by the circular nature of the
 *                         buffer plus the keeper pointer.
 */
long cbuf::available_write ()
{
    long	first = writer,		// first element available
		last = reader;		// last element available + 1

    if (keeper >= 0)
        last = keeper;			// keeper has been set
    if (last <= first)
        last += size;			// wraps around
    return (last - first);
} // end cbuf::available_write


/*
 * CBUF::SETKEEPER - Set the keeper pointer count number of elements before
 *                   the current read pointer.  There is no error for wrap around.
 */
void cbuf::setkeeper
(
    long	count			// set the keeper count elements before reader
)
{
    keeper = reader - count;
    while (keeper < 0)
        keeper += size;			// wraps around
} // end cbuf::setkeeper


/*
 * CBUF::SETEOD - Set the eod (end of data) pointer count number of elements before
 *                the current read pointer.  There is no error for wrap around.
 */
void cbuf::seteod
(
    long	count			// set the eod count elements before reader
)
{
    if (count < 0)
        eod = writer;			// set to the writer pointer
    else
    {
        eod = reader - count;
        while (eod < 0)
            eod += size;		// wraps around
    }
} // end cbuf::seteod


/*
 * CBUF::ADVANCEOD - Advance the eod (end of data) pointer the specified number of elements.
 */
void cbuf::advanceod
(
    long	count			// number of elements to advance
)
{
    eod += count;
    while (eod >= size)
        eod -= size;
} // end cbuf::advanceod


/*
 * CBUF_CHAR::READ - Read up to howmany elements from the circular buffer and place
 *              them in where.  Return number of elements actually read.
 *              The reader pointer is updated.
 */
long cbuf_char::read
(
    char	*where,			// where to put it
    long	howmany,		// how many to read
    BOOLEAN	ckeod			// if True, don't read past eod marker
)
{
    long	count,
		lastw;

    if (ckeod && eod >= 0)
        lastw = eod;
    else
        lastw = writer;
    for (count = 0; count < howmany; reader++)
    {
        if (reader >= size)
            reader -= size;		// wrap around
        if (reader == lastw)
            break;
        where[count++] = buffer[reader];// move one element
    }
    return (count);
} // end cbuf_char::read


/*
 * CBUF_SHORT::READ - Read up to howmany elements from the circular buffer and place
 *              them in where.  Return number of elements actually read.
 *              The reader pointer is updated.
 */
long cbuf_short::read
(
    short	*where,			// where to put it
    long	howmany,		// how many to read
    BOOLEAN	ckeod			// if True, don't read past eod marker
)
{
    long	count,
		lastw;

    if (ckeod && eod >= 0)
        lastw = eod;
    else
        lastw = writer;
    for (count = 0; count < howmany; reader++)
    {
        if (reader >= size)
            reader -= size;		// wrap around
        if (reader == lastw)
            break;
        where[count++] = buffer[reader];// move one element
    }
    return (count);
} // end cbuf_short::read


/*
 * CBUF_LONG::READ - Read up to howmany elements from the circular buffer and place
 *              them in where.  Return number of elements actually read.
 *              The reader pointer is updated.
 */
long cbuf_long::read
(
    long	*where,			// where to put it
    long	howmany,		// how many to read
    BOOLEAN	ckeod			// if True, don't read past eod marker
)
{
    long	count,
		lastw;

    if (ckeod && eod >= 0)
        lastw = eod;
    else
        lastw = writer;
    for (count = 0; count < howmany; reader++)
    {
        if (reader >= size)
            reader -= size;		// wrap around
        if (reader == lastw)
            break;
        where[count++] = buffer[reader];// move one element
    }
    return (count);
} // end cbuf_long::read


/*
 * CBUF_FLOAT::READ - Read up to howmany elements from the circular buffer and place
 *              them in where.  Return number of elements actually read.
 *              The reader pointer is updated.
 */
long cbuf_float::read
(
    float	*where,			// where to put it
    long	howmany,		// how many to read
    BOOLEAN	ckeod			// if True, don't read past eod marker
)
{
    long	count,
		lastw;

    if (ckeod && eod >= 0)
        lastw = eod;
    else
        lastw = writer;
    for (count = 0; count < howmany; reader++)
    {
        if (reader >= size)
            reader -= size;		// wrap around
        if (reader == lastw)
            break;
        where[count++] = buffer[reader];// move one element
    }
    return (count);
} // end cbuf_float::read


/*
 * CBUF_CHAR::PEEK - Read up to howmany elements from the circular buffer and place
 *              them in where.  Return number of elements actually read.
 *              Same as read but the reader pointer is NOT updated.
 */
long cbuf_char::peek
(
    char	*where,			// where to put it
    long	howmany,		// how many to read
    BOOLEAN	ckeod			// if True, don't read past eod marker
)
{
    long	count,
		rdr = reader,
		lastw;

    if (ckeod && eod >= 0)
        lastw = eod;
    else
        lastw = writer;
    for (count = 0; count < howmany; rdr++)
    {
        if (rdr >= size)
            rdr -= size;		// wrap around
        if (rdr == lastw)
            break;
        where[count++] = buffer[rdr];	// move one element
    }
    return (count);
} // end cbuf_char::peek


/*
 * CBUF_SHORT::PEEK - Read up to howmany elements from the circular buffer and place
 *              them in where.  Return number of elements actually read.
 *              Same as read but the reader pointer is NOT updated.
 */
long cbuf_short::peek
(
    short	*where,			// where to put it
    long	howmany,		// how many to read
    BOOLEAN	ckeod			// if True, don't read past eod marker
)
{
    long	count,
		rdr = reader,
		lastw;

    if (ckeod && eod >= 0)
        lastw = eod;
    else
        lastw = writer;
    for (count = 0; count < howmany; rdr++)
    {
        if (rdr >= size)
            rdr -= size;		// wrap around
        if (rdr == lastw)
            break;
        where[count++] = buffer[rdr];	// move one element
    }
    return (count);
} // end cbuf_short::peek


/*
 * CBUF_LONG::PEEK - Read up to howmany elements from the circular buffer and place
 *              them in where.  Return number of elements actually read.
 *              Same as read but the reader pointer is NOT updated.
 */
long cbuf_long::peek
(
    long	*where,			// where to put it
    long	howmany,		// how many to read
    BOOLEAN	ckeod			// if True, don't read past eod marker
)
{
    long	count,
		rdr = reader,
		lastw;

    if (ckeod && eod >= 0)
        lastw = eod;
    else
        lastw = writer;
    for (count = 0; count < howmany; rdr++)
    {
        if (rdr >= size)
            rdr -= size;		// wrap around
        if (rdr == lastw)
            break;
        where[count++] = buffer[rdr];	// move one element