jamulus/src/buffer.cpp

/******************************************************************************\
 * Copyright (c) 2004-2006
 *
 * Author(s):
 *  Volker Fischer
 *
 * Note: we assuming here that put and get operations are secured by a mutex
 *       and do not take place at the same time
 *
 ******************************************************************************
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later 
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
\******************************************************************************/

#include "buffer.h"


/* Implementation *************************************************************/
void CNetBuf::Init ( const int iNewBlockSize, const int iNewNumBlocks )
{
    /* total size -> size of one block times number of blocks */
    iBlockSize = iNewBlockSize;
    iMemSize = iNewBlockSize * iNewNumBlocks;

    /* fade in first block added to the buffer */
    bFadeInNewPutData = true;

    /* allocate and clear memory for actual data buffer */
    vecdMemory.Init(iMemSize);

    /* use the "get" flag to make sure the buffer is cleared */
    Clear(CT_GET);

    /* initialize number of samples for fading effect */
    if (FADE_IN_OUT_NUM_SAM < iBlockSize)
        iNumSamFading = iBlockSize;
    else
        iNumSamFading = FADE_IN_OUT_NUM_SAM;

    if (FADE_IN_OUT_NUM_SAM_EXTRA > iBlockSize)
        iNumSamFadingExtra = iBlockSize;
    else
        iNumSamFadingExtra = FADE_IN_OUT_NUM_SAM;

    /* init variables for extrapolation (in case a fade out is needed) */
    dExPDiff = 0.0;
    dExPLastV = 0.0;
}

bool CNetBuf::Put(CVector<double>& vecdData)
{
#ifdef _DEBUG_
static FILE* pFileBI = fopen("bufferin.dat", "w");
fprintf(pFileBI, "%d %d\n", GetAvailSpace() / iBlockSize, iMemSize / iBlockSize);
fflush(pFileBI);
#endif

    bool bPutOK = true;

    /* get size of data to be added to the buffer */
    const int iInSize = vecdData.Size();

    /* Check if there is not enough space available -> correct */
    if (GetAvailSpace() < iInSize)
    {
        /* not enough space in buffer for put operation, correct buffer to
           prepare for new data */
        Clear(CT_PUT);

        /* set flag to fade in new block to avoid clicks */
        bFadeInNewPutData = true;

        bPutOK = false; /* return error flag */
    }

    /* fade in new block if required */
    if (bFadeInNewPutData)
        FadeInAudioDataBlock(vecdData);

    /* copy new data in internal buffer */
    int iCurPos = 0;
    if (iPutPos + iInSize > iMemSize)
    {
        /* remaining space size for second block */
        const int iRemSpace = iPutPos + iInSize - iMemSize;

        /* data must be written in two steps because of wrap around */
        while (iPutPos < iMemSize)
            vecdMemory[iPutPos++] = vecdData[iCurPos++];

        for (iPutPos = 0; iPutPos < iRemSpace; iPutPos++)
            vecdMemory[iPutPos] = vecdData[iCurPos++];
    }
    else
    {
        /* data can be written in one step */
        const int iEnd = iPutPos + iInSize;
        while (iPutPos < iEnd)
            vecdMemory[iPutPos++] = vecdData[iCurPos++];
    }

    /* set buffer state flag */
    if (iPutPos == iGetPos)
        eBufState = CNetBuf::BS_FULL;
    else
        eBufState = CNetBuf::BS_OK;

    return bPutOK;
}

bool CNetBuf::Get(CVector<double>& vecdData)
{
    bool bGetOK = true; /* init return value */
    bool bFadeOutExtrap = false;

    /* get size of data to be get from the buffer */
    const int iInSize = vecdData.Size();

    /* Check if there is not enough data available -> correct */
    if (GetAvailData() < iInSize)
    {
        /* not enough data in buffer for get operation, correct buffer to
           prepare for getting data */
        Clear(CT_GET);

        /* set flag to fade in next new block in buffer and fade out last
           block by extrapolation to avoid clicks */
        bFadeInNewPutData = true;
        bFadeOutExtrap = true;

        bGetOK = false; /* return error flag */
    }

    /* copy data from internal buffer in output buffer */
    int iCurPos = 0;
    if (iGetPos + iInSize > iMemSize)
    {
        /* remaining data size for second block */
        const int iRemData = iGetPos + iInSize - iMemSize;

        /* data must be read in two steps because of wrap around */
        while (iGetPos < iMemSize)
            vecdData[iCurPos++] = vecdMemory[iGetPos++];

        for (iGetPos = 0; iGetPos < iRemData; iGetPos++)
            vecdData[iCurPos++] = vecdMemory[iGetPos];
    }
    else
    {
        /* data can be read in one step */
        const int iEnd = iGetPos + iInSize;
        while (iGetPos < iEnd)
            vecdData[iCurPos++] = vecdMemory[iGetPos++];
    }

    /* set buffer state flag */
    if (iPutPos == iGetPos)
        eBufState = CNetBuf::BS_EMPTY;
    else
        eBufState = CNetBuf::BS_OK;


    /* extrapolate data from old block to avoid "clicks"
       we have to do this method since we cannot fade out the old block
       anymore since it is already gone (processed or send through the
       network) */
    if (bFadeOutExtrap)
        FadeOutExtrapolateAudioDataBlock(vecdData, dExPDiff, dExPLastV);

    /* save some paramters from last block which is needed in case we do not
       have enough data for next "get" operation and need to extrapolate the
       signal to avoid "clicks"
       we assume here that "iBlockSize" is larger than 1! */
    dExPDiff = vecdData[iInSize - 1] - vecdData[iInSize - 2];
    dExPLastV = vecdData[iInSize - 1];

    return bGetOK;
}

int CNetBuf::GetAvailSpace() const
{
    /* calculate available space in buffer */
    int iAvSpace = iGetPos - iPutPos;

    /* check for special case and wrap around */
    if (iAvSpace < 0)
        iAvSpace += iMemSize; /* wrap around */
    else if ((iAvSpace == 0) && (eBufState == BS_EMPTY))
        iAvSpace = iMemSize;

    return iAvSpace;
}

int CNetBuf::GetAvailData() const
{
    /* calculate available data in buffer */
    int iAvData = iPutPos - iGetPos;

    /* check for special case and wrap around */
    if (iAvData < 0)
        iAvData += iMemSize; /* wrap around */
    else if ((iAvData == 0) && (eBufState == BS_FULL))
        iAvData = iMemSize;

    return iAvData;
}

void CNetBuf::Clear(const EClearType eClearType)
{

    int iMiddleOfBuffer;

#if 0
    /* with the following operation we set the new get pos to a block
       boundary (one block below the middle of the buffer in case of odd
       number of blocks, e.g.:
       [buffer size]: [get pos]
       1: 0   /   2: 0   /   3: 1   /   4: 1   /   ... */
    iMiddleOfBuffer = (((iMemSize - iBlockSize) / 2) / iBlockSize) * iBlockSize;
#else
// old code

// somehow the old code seems to work better than the sophisticated new one....?
    /* 1: 0   /   2: 1   /   3: 1   /   4: 2   /   ... */
    iMiddleOfBuffer = ((iMemSize / 2) / iBlockSize) * iBlockSize;
#endif
    
    
    /* different behaviour for get and put corrections */
    if (eClearType == CT_GET)
    {
        /* clear buffer */
        vecdMemory.Reset(0.0);

        /* correct buffer so that after the current get operation the pointer
           are at maximum distance */
        iPutPos = 0;
        iGetPos = iMiddleOfBuffer;

        /* check for special case */
        if (iPutPos == iGetPos)
            eBufState = CNetBuf::BS_FULL;
        else
            eBufState = CNetBuf::BS_OK;
    }
    else
    {
        /* in case of "put" correction, do not delete old data but only shift
           the pointers */
        iPutPos = iMiddleOfBuffer;

        /* adjust put pointer relative to current get pointer, take care of
           wrap around */
        iPutPos += iGetPos;
        if (iPutPos > iMemSize)
            iPutPos -= iMemSize;

        /* fade out old data right before new put pointer */
        int iCurPos = iPutPos - iNumSamFading;
        int i = iNumSamFading;

        if (iCurPos < 0)
        {
            /* wrap around */
            iCurPos += iMemSize;

            /* data must be processed in two steps because of wrap around */
            while (iCurPos < iMemSize)
            {
                vecdMemory[iCurPos++] *= ((double) i / iNumSamFading);
                i--;
            }

            for (iCurPos = 0; iCurPos < iPutPos; iCurPos++)
            {
                vecdMemory[iCurPos] *= ((double) i / iNumSamFading);
                i--;
            }
        }
        else
        {
            /* data can be processed in one step */
            while (iCurPos < iPutPos)
            {
                vecdMemory[iCurPos++] *= ((double) i / iNumSamFading);
                i--;
            }
        }

        /* check for special case */
        if (iPutPos == iGetPos)
        {
            eBufState = CNetBuf::BS_EMPTY;
        }
        else
        {
            eBufState = CNetBuf::BS_OK;
        }
    }
}

void CNetBuf::FadeInAudioDataBlock(CVector<double>& vecdData)
{
    /* apply linear fading */
    for (int i = 0; i < iNumSamFading; i++)
    {
        vecdData[i] *= ((double) i / iNumSamFading);
    }

    /* reset flag */
    bFadeInNewPutData = false;
}

void CNetBuf::FadeOutExtrapolateAudioDataBlock(CVector<double>& vecdData,
                                               const double dExPDiff,
                                               const double dExPLastV)
{
    /* apply linear extrapolation and linear fading */
    for (int i = 0; i < iNumSamFadingExtra; i++)
    {
        /* calculate extrapolated value */
        vecdData[i] = ((i + 1) * dExPDiff + dExPLastV);

        /* linear fading */
        vecdData[i] *= ((double) (iNumSamFadingExtra - i) / iNumSamFadingExtra);
    }
}



/* conversion buffer implementation *******************************************/
void CConvBuf::Init ( const int iNewMemSize )
{
    /* set memory size */
    iMemSize = iNewMemSize;

    /* allocate and clear memory for actual data buffer */
    vecsMemory.Init(iMemSize);

    iPutPos = 0;
}

bool CConvBuf::Put ( const CVector<short>& vecsData)
{
    const int iVecSize = vecsData.Size();

    /* copy new data in internal buffer */
    int iCurPos = 0;
    const int iEnd = iPutPos + iVecSize;
    while ( iPutPos < iEnd )
    {
        vecsMemory[iPutPos++] = vecsData[iCurPos++];
    }

    bool bBufOk = false;
    if ( iEnd == iMemSize )
    {
        bBufOk = true;
    }

    return bBufOk;
}

CVector<short> CConvBuf::Get()
{
    iPutPos = 0;
    return vecsMemory;
}