jamulus/windows/sound.cpp

/******************************************************************************\
 * Copyright (c) 2004-2006
 *
 * Author(s):
 *  Volker Fischer
 *
 * Description:
 * Sound card interface for Windows operating systems
 *
 ******************************************************************************
 *
 * 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 "Sound.h"


/* Implementation *************************************************************/
/******************************************************************************\
* Wave in                                                                      *
\******************************************************************************/
bool CSound::Read(CVector<short>& psData)
{
    int     i;
    bool    bError;

    /* Check if device must be opened or reinitialized */
    if (bChangParamIn == TRUE)
    {
        OpenInDevice();

        /* Reinit sound interface */
        InitRecording(iBufferSizeIn, bBlockingRec);

        /* Reset flag */
        bChangParamIn = FALSE;
    }

    /* Wait until data is available */
    if (!(m_WaveInHeader[iWhichBufferIn].dwFlags & WHDR_DONE))
    {
        if (bBlockingRec == TRUE)
            WaitForSingleObject(m_WaveInEvent, INFINITE);
        else
            return FALSE;
    }

    /* Check if buffers got lost */
    int iNumInBufDone = 0;
    for (i = 0; i < iCurNumSndBufIn; i++)
    {
        if (m_WaveInHeader[i].dwFlags & WHDR_DONE)
            iNumInBufDone++;
    }

    /* If the number of done buffers equals the total number of buffers, it is
       very likely that a buffer got lost -> set error flag */
    if (iNumInBufDone == iCurNumSndBufIn)
        bError = TRUE;
    else
        bError = FALSE;

    /* Copy data from sound card in output buffer */
    for (i = 0; i < iBufferSizeIn; i++)
        psData[i] = psSoundcardBuffer[iWhichBufferIn][i];

    /* Add the buffer so that it can be filled with new samples */
    AddInBuffer();

    /* In case more than one buffer was ready, reset event */
    ResetEvent(m_WaveInEvent);

    return bError;
}

void CSound::AddInBuffer()
{
    /* Unprepare old wave-header */
    waveInUnprepareHeader(
        m_WaveIn, &m_WaveInHeader[iWhichBufferIn], sizeof(WAVEHDR));

    /* Prepare buffers for sending to sound interface */
    PrepareInBuffer(iWhichBufferIn);

    /* Send buffer to driver for filling with new data */
    waveInAddBuffer(m_WaveIn, &m_WaveInHeader[iWhichBufferIn], sizeof(WAVEHDR));

    /* Toggle buffers */
    iWhichBufferIn++;
    if (iWhichBufferIn == iCurNumSndBufIn)
        iWhichBufferIn = 0;
}

void CSound::PrepareInBuffer(int iBufNum)
{
    /* Set struct entries */
    m_WaveInHeader[iBufNum].lpData = (LPSTR) &psSoundcardBuffer[iBufNum][0];
    m_WaveInHeader[iBufNum].dwBufferLength = iBufferSizeIn * BYTES_PER_SAMPLE;
    m_WaveInHeader[iBufNum].dwFlags = 0;

    /* Prepare wave-header */
    waveInPrepareHeader(m_WaveIn, &m_WaveInHeader[iBufNum], sizeof(WAVEHDR));
}

void CSound::InitRecording(int iNewBufferSize, bool bNewBlocking)
{
    /* Check if device must be opened or reinitialized */
    if (bChangParamIn == TRUE)
    {
        OpenInDevice();

        /* Reset flag */
        bChangParamIn = FALSE;
    }

    /* Set internal parameter */
    iBufferSizeIn = iNewBufferSize;
    bBlockingRec = bNewBlocking;

    /* Reset interface so that all buffers are returned from the interface */
    waveInReset(m_WaveIn);
    waveInStop(m_WaveIn);
    
    /* Reset current buffer ID (it is important to do this BEFORE calling
       "AddInBuffer()" */
    iWhichBufferIn = 0;

    /* Create memory for sound card buffer */
    for (int i = 0; i < iCurNumSndBufIn; i++)
    {
        /* Unprepare old wave-header in case that we "re-initialized" this
           module. Calling "waveInUnprepareHeader()" with an unprepared
           buffer (when the module is initialized for the first time) has
           simply no effect */
        waveInUnprepareHeader(m_WaveIn, &m_WaveInHeader[i], sizeof(WAVEHDR));

        if (psSoundcardBuffer[i] != NULL)
            delete[] psSoundcardBuffer[i];

        psSoundcardBuffer[i] = new short[iBufferSizeIn];


        /* Send all buffers to driver for filling the queue ----------------- */
        /* Prepare buffers before sending them to the sound interface */
        PrepareInBuffer(i);

        AddInBuffer();
    }

    /* Notify that sound capturing can start now */
    waveInStart(m_WaveIn);

    /* This reset event is very important for initialization, otherwise we will
       get errors! */
    ResetEvent(m_WaveInEvent);
}

void CSound::OpenInDevice()
{
    /* Open wave-input and set call-back mechanism to event handle */
    if (m_WaveIn != NULL)
    {
        waveInReset(m_WaveIn);
        waveInClose(m_WaveIn);
    }

    MMRESULT result = waveInOpen(&m_WaveIn, iCurInDev, &sWaveFormatEx,
        (DWORD) m_WaveInEvent, NULL, CALLBACK_EVENT);

    if (result != MMSYSERR_NOERROR)
    {
        throw CGenErr("Sound Interface Start, waveInOpen() failed. This error "
            "usually occurs if another application blocks the sound in.");
    }
}

void CSound::SetInDev(int iNewDev)
{
    /* Set device to wave mapper if iNewDev is invalid */
    if ((iNewDev >= iNumDevs) || (iNewDev < 0))
        iNewDev = WAVE_MAPPER;

    /* Change only in case new device id is not already active */
    if (iNewDev != iCurInDev)
    {
        iCurInDev = iNewDev;
        bChangParamIn = TRUE;
    }
}

void CSound::SetInNumBuf(int iNewNum)
{
    /* check new parameter */
    if ((iNewNum >= MAX_SND_BUF_IN) || (iNewNum < 1))
        iNewNum = NUM_SOUND_BUFFERS_IN;

    /* Change only if parameter is different */
    if (iNewNum != iCurNumSndBufIn)
    {
        iCurNumSndBufIn = iNewNum;
        bChangParamIn = TRUE;
    }
}


/******************************************************************************\
* Wave out                                                                     *
\******************************************************************************/
bool CSound::Write(CVector<short>& psData)
{
    int     i, j;
    int     iCntPrepBuf;
    int     iIndexDoneBuf;
    bool    bError;

    /* Check if device must be opened or reinitialized */
    if (bChangParamOut == TRUE)
    {
        OpenOutDevice();

        /* Reinit sound interface */
        InitPlayback(iBufferSizeOut, bBlockingPlay);

        /* Reset flag */
        bChangParamOut = FALSE;
    }

    /* Get number of "done"-buffers and position of one of them */
    GetDoneBuffer(iCntPrepBuf, iIndexDoneBuf);

    /* Now check special cases (Buffer is full or empty) */
    if (iCntPrepBuf == 0)
    {
        if (bBlockingPlay == TRUE)
        {
            /* Blocking wave out routine. Needed for transmitter. Always
               ensure that the buffer is completely filled to avoid buffer
               underruns */
            while (iCntPrepBuf == 0)
            {
                WaitForSingleObject(m_WaveOutEvent, INFINITE);

                GetDoneBuffer(iCntPrepBuf, iIndexDoneBuf);
            }
        }
        else
        {
            /* All buffers are filled, dump new block ----------------------- */
// It would be better to kill half of the buffer blocks to set the start
// back to the middle: TODO
            return TRUE; /* An error occurred */
        }
    }
    else if (iCntPrepBuf == iCurNumSndBufOut)
    {
        /* ---------------------------------------------------------------------
           Buffer is empty -> send as many cleared blocks to the sound-
           interface until half of the buffer size is reached */
        /* Send half of the buffer size blocks to the sound-interface */
        for (j = 0; j < iCurNumSndBufOut / 2; j++)
        {
            /* First, clear these buffers */
            for (i = 0; i < iBufferSizeOut; i++)
                psPlaybackBuffer[j][i] = 0;

            /* Then send them to the interface */
            AddOutBuffer(j);
        }

        /* Set index for done buffer */
        iIndexDoneBuf = iCurNumSndBufOut / 2;

        bError = TRUE;
    }
    else
        bError = FALSE;

    /* Copy stereo data from input in soundcard buffer */
    for (i = 0; i < iBufferSizeOut; i++)
        psPlaybackBuffer[iIndexDoneBuf][i] = psData[i];

    /* Now, send the current block */
    AddOutBuffer(iIndexDoneBuf);

    return bError;
}

void CSound::GetDoneBuffer(int& iCntPrepBuf, int& iIndexDoneBuf)
{
    /* Get number of "done"-buffers and position of one of them */
    iCntPrepBuf = 0;
    for (int i = 0; i < iCurNumSndBufOut; i++)
    {
        if (m_WaveOutHeader[i].dwFlags & WHDR_DONE)
        {
            iCntPrepBuf++;
            iIndexDoneBuf = i;
        }
    }
}

void CSound::AddOutBuffer(int iBufNum)
{
    /* Unprepare old wave-header */
    waveOutUnprepareHeader(
        m_WaveOut, &m_WaveOutHeader[iBufNum], sizeof(WAVEHDR));

    /* Prepare buffers for sending to sound interface */
    PrepareOutBuffer(iBufNum);

    /* Send buffer to driver for filling with new data */
    waveOutWrite(m_WaveOut, &m_WaveOutHeader[iBufNum], sizeof(WAVEHDR));
}

void CSound::PrepareOutBuffer(int iBufNum)
{
    /* Set Header data */
    m_WaveOutHeader[iBufNum].lpData = (LPSTR) &psPlaybackBuffer[iBufNum][0];
    m_WaveOutHeader[iBufNum].dwBufferLength = iBufferSizeOut * BYTES_PER_SAMPLE;
    m_WaveOutHeader[iBufNum].dwFlags = 0;

    /* Prepare wave-header */
    waveOutPrepareHeader(m_WaveOut, &m_WaveOutHeader[iBufNum], sizeof(WAVEHDR));
}

void CSound::InitPlayback(int iNewBufferSize, bool bNewBlocking)
{
    int i, j;

    /* Check if device must be opened or reinitialized */
    if (bChangParamOut == TRUE)
    {
        OpenOutDevice();

        /* Reset flag */
        bChangParamOut = FALSE;
    }

    /* Set internal parameters */
    iBufferSizeOut = iNewBufferSize;
    bBlockingPlay = bNewBlocking;

    /* Reset interface */
    waveOutReset(m_WaveOut);

    for (j = 0; j < iCurNumSndBufOut; j++)
    {
        /* Unprepare old wave-header (in case header was not prepared before,
           simply nothing happens with this function call */
        waveOutUnprepareHeader(m_WaveOut, &m_WaveOutHeader[j], sizeof(WAVEHDR));

        /* Create memory for playback buffer */
        if (psPlaybackBuffer[j] != NULL)
            delete[] psPlaybackBuffer[j];

        psPlaybackBuffer[j] = new short[iBufferSizeOut];

        /* Clear new buffer */
        for (i = 0; i < iBufferSizeOut; i++)
            psPlaybackBuffer[j][i] = 0;

        /* Prepare buffer for sending to the sound interface */
        PrepareOutBuffer(j);

        /* Initially, send all buffers to the interface */
        AddOutBuffer(j);
    }
}

void CSound::OpenOutDevice()
{
    if (m_WaveOut != NULL)
    {
        waveOutReset(m_WaveOut);
        waveOutClose(m_WaveOut);
    }

    MMRESULT result = waveOutOpen(&m_WaveOut, iCurOutDev, &sWaveFormatEx,
        (DWORD) m_WaveOutEvent, NULL, CALLBACK_EVENT);

    if (result != MMSYSERR_NOERROR)
        throw CGenErr("Sound Interface Start, waveOutOpen() failed.");
}

void CSound::SetOutDev(int iNewDev)
{
    /* Set device to wave mapper if iNewDev is invalid */
    if ((iNewDev >= iNumDevs) || (iNewDev < 0))
        iNewDev = WAVE_MAPPER;

    /* Change only in case new device id is not already active */
    if (iNewDev != iCurOutDev)
    {
        iCurOutDev = iNewDev;
        bChangParamOut = TRUE;
    }
}

void CSound::SetOutNumBuf(int iNewNum)
{
    /* check new parameter */
    if ((iNewNum >= MAX_SND_BUF_OUT) || (iNewNum < 1))
        iNewNum = NUM_SOUND_BUFFERS_OUT;

    /* Change only if parameter is different */
    if (iNewNum != iCurNumSndBufOut)
    {
        iCurNumSndBufOut = iNewNum;
        bChangParamOut = TRUE;
    }
}


/******************************************************************************\
* Common                                                                       *
\******************************************************************************/
void CSound::Close()
{
    int         i;
    MMRESULT    result;

    /* Reset audio driver */
    if (m_WaveOut != NULL)
    {
        result = waveOutReset(m_WaveOut);
        if (result != MMSYSERR_NOERROR)
            throw CGenErr("Sound Interface, waveOutReset() failed.");
    }

    if (m_WaveIn != NULL)
    {
        result = waveInReset(m_WaveIn);
        if (result != MMSYSERR_NOERROR)
            throw CGenErr("Sound Interface, waveInReset() failed.");
    }

    /* Set event to ensure that thread leaves the waiting function */
    if (m_WaveInEvent != NULL)
        SetEvent(m_WaveInEvent);

    /* Wait for the thread to terminate */
    Sleep(500);

    /* Unprepare wave-headers */
    if (m_WaveIn != NULL)
    {
        for (i = 0; i < iCurNumSndBufIn; i++)
        {
            result = waveInUnprepareHeader(
                m_WaveIn, &m_WaveInHeader[i], sizeof(WAVEHDR));

            if (result != MMSYSERR_NOERROR)
            {
                throw CGenErr("Sound Interface, waveInUnprepareHeader()"
                    " failed.");
            }
        }

        /* Close the sound in device */
        result = waveInClose(m_WaveIn);
        if (result != MMSYSERR_NOERROR)
            throw CGenErr("Sound Interface, waveInClose() failed.");
    }

    if (m_WaveOut != NULL)
    {
        for (i = 0; i < iCurNumSndBufOut; i++)
        {
            result = waveOutUnprepareHeader(
                m_WaveOut, &m_WaveOutHeader[i], sizeof(WAVEHDR));

            if (result != MMSYSERR_NOERROR)
            {
                throw CGenErr("Sound Interface, waveOutUnprepareHeader()"
                    " failed.");
            }
        }

        /* Close the sound out device */
        result = waveOutClose(m_WaveOut);
        if (result != MMSYSERR_NOERROR)
            throw CGenErr("Sound Interface, waveOutClose() failed.");
    }

    /* Set flag to open devices the next time it is initialized */
    bChangParamIn = TRUE;
    bChangParamOut = TRUE;
}

CSound::CSound()
{
    int i;

    /* init number of sound buffers */
    iCurNumSndBufIn = NUM_SOUND_BUFFERS_IN;
    iCurNumSndBufOut = NUM_SOUND_BUFFERS_OUT;

    /* Should be initialized because an error can occur during init */
    m_WaveInEvent = NULL;
    m_WaveOutEvent = NULL;
    m_WaveIn = NULL;
    m_WaveOut = NULL;

    /* Init buffer pointer to zero */
    for (i = 0; i < MAX_SND_BUF_IN; i++)
    {
        memset(&m_WaveInHeader[i], 0, sizeof(WAVEHDR));
        psSoundcardBuffer[i] = NULL;
    }

    for (i = 0; i < MAX_SND_BUF_OUT; i++)
    {
        memset(&m_WaveOutHeader[i], 0, sizeof(WAVEHDR));
        psPlaybackBuffer[i] = NULL;
    }

    /* Init wave-format structure */
    sWaveFormatEx.wFormatTag = WAVE_FORMAT_PCM;
    sWaveFormatEx.nChannels = NUM_IN_OUT_CHANNELS;
    sWaveFormatEx.wBitsPerSample = BITS_PER_SAMPLE;
    sWaveFormatEx.nSamplesPerSec = SND_CRD_SAMPLE_RATE;
    sWaveFormatEx.nBlockAlign = sWaveFormatEx.nChannels *
        sWaveFormatEx.wBitsPerSample / 8;
    sWaveFormatEx.nAvgBytesPerSec = sWaveFormatEx.nBlockAlign *
        sWaveFormatEx.nSamplesPerSec;
    sWaveFormatEx.cbSize = 0;

    /* Get the number of digital audio devices in this computer, check range */
    iNumDevs = waveInGetNumDevs();

    if (iNumDevs > MAX_NUMBER_SOUND_CARDS)
        iNumDevs = MAX_NUMBER_SOUND_CARDS;

    /* At least one device must exist in the system */
    if (iNumDevs == 0)
        throw CGenErr("No audio device found.");

    /* Get info about the devices and store the names */
    for (i = 0; i < iNumDevs; i++)
    {
        if (!waveInGetDevCaps(i, &m_WaveInDevCaps, sizeof(WAVEINCAPS)))
            pstrDevices[i] = m_WaveInDevCaps.szPname;
    }

    /* We use an event controlled wave-in (wave-out) structure */
    /* Create events */
    m_WaveInEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    m_WaveOutEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    /* Set flag to open devices */
    bChangParamIn = TRUE;
    bChangParamOut = TRUE;

    /* Default device number, "wave mapper" */
    iCurInDev = WAVE_MAPPER;
    iCurOutDev = WAVE_MAPPER;

    /* Non-blocking wave out is default */
    bBlockingPlay = FALSE;

    /* Blocking wave in is default */
    bBlockingRec = TRUE;
}

CSound::~CSound()
{
    int i;

    /* Delete allocated memory */
    for (i = 0; i < iCurNumSndBufIn; i++)
    {
        if (psSoundcardBuffer[i] != NULL)
            delete[] psSoundcardBuffer[i];
    }

    for (i = 0; i < iCurNumSndBufOut; i++)
    {
        if (psPlaybackBuffer[i] != NULL)
            delete[] psPlaybackBuffer[i];
    }

    /* Close the handle for the events */
    if (m_WaveInEvent != NULL)
        CloseHandle(m_WaveInEvent);

    if (m_WaveOutEvent != NULL)
        CloseHandle(m_WaveOutEvent);
}