audio_waveout Class Reference

#include <audio_waveout.hpp>

Collaboration diagram for audio_waveout:

Public Member Functions
	audio_waveout (const audio_format &aud_fmt, audio_producer &a_buf)
	~audio_waveout (void)
void	open (void)
void	play (void)
void	pause (void)
void	stop (void)
void	close (void)
audio_waveout_status	current_status (void)
BYTE *	buf (void)
unsigned int	bufsz (void)
unsigned int	samplevalue_max (void)
unsigned	tot_samples_buf (void)
unsigned int	nsample (unsigned int nsamp)

Protected Member Functions
void	init_ (void)
void	alloc_buffers_mem_ (unsigned int, float)
void	free_buffers_mem_ (void)
void	init_headers_ (void)
void	prep_headers_ (void)
void	unprep_headers_ (void)

Protected Attributes
WAVEFORMATEX	wave_format
WAVEHDR *	wave_headers
HWAVEOUT	waveout_handle
const audio_format &	aud_info
audio_producer &	audio_buf
DWORD	playthread_id
audio_waveout_status	status
float	buf_secs
BYTE *	main_buffer
unsigned int	mb_size
unsigned int	buffers

Static Private Member Functions
static DWORD WINAPI	playing_procedure (LPVOID)

Private Attributes
HANDLE	wakeup_playthread

Friends
class	audio_buffer

Detailed Description

Definition at line 27 of file audio_waveout.hpp.

Constructor & Destructor Documentation

audio_waveout()

audio_waveout::audio_waveout ( const audio_format &  aud_fmt, audio_producer &  a_buf  )

inline

Definition at line 73 of file audio_waveout.hpp.

                                             : wave_headers(0),
                                               aud_info(aud_fmt),
                                               audio_buf(a_buf),
                                               status(WAVEOUT_NOTREADY),
                                               main_buffer(0),
                                               mb_size(0),
                                               buffers(_AUDIO_DEFAULT_WAVEOUTBUFFERS)
        {
            /* Initializing internal wavein data */
            init_();
        }

~audio_waveout()

audio_waveout::~audio_waveout ( void  )

inline

Definition at line 87 of file audio_waveout.hpp.

        {
        }

Member Function Documentation

alloc_buffers_mem_()

void audio_waveout::alloc_buffers_mem_ ( unsigned int  buffs, float  secs  )

protected

Definition at line 26 of file audio_waveout.cpp.

{
    unsigned int onebuf_size = 0, tot_size = 0;
 
    /* Release old memory */
    if (main_buffer)
        delete[] main_buffer;
 
    if (wave_headers)
        delete[] wave_headers;
 
    /* Calcs size of the buffers */
    onebuf_size = (unsigned int)((float)aud_info.byte_rate() * secs);
    tot_size = onebuf_size * buffs;
    /* Allocs memory for the audio buffers */
    main_buffer = new BYTE[tot_size];
    /* Allocs memory for the `WAVEHDR' structures */
    wave_headers = (WAVEHDR *) new BYTE[sizeof(WAVEHDR) * buffs];
    /* Zeros memory */
    ZeroMemory(main_buffer, tot_size);
    ZeroMemory(wave_headers, sizeof(WAVEHDR) * buffs);
    /* Updates total size of the buffers */
    mb_size = tot_size;
}

Referenced by open().

buf()

BYTE * audio_waveout::buf ( void  )

inline

Definition at line 104 of file audio_waveout.hpp.

        {
            return main_buffer;
        }

bufsz()

unsigned int audio_waveout::bufsz ( void  )

inline

Definition at line 109 of file audio_waveout.hpp.

        {
            return mb_size;
        }

close()

void audio_waveout::close

(

void

)

Definition at line 325 of file audio_waveout.cpp.

{
    MMRESULT err;
 
    /* If the `wave_out' object is playing audio, or it is in paused state,
       we have to call the `stop' member function, to flush pending buffers */
    if ((status == WAVEOUT_PLAYING) || (status== WAVEOUT_PAUSED))
    {
        stop();
    }
 
    /* When we have flushed all pending buffers, the wave out handle can be successfully closed */
    err = waveOutClose(waveout_handle);
    if (err != MMSYSERR_NOERROR)
    {
        MessageBox(0, _T("waveOutClose Error"), 0, 0);
        /* TODO: throw error */
    }
 
    free_buffers_mem_();
}

current_status()

audio_waveout_status audio_waveout::current_status ( void  )

inline

Definition at line 99 of file audio_waveout.hpp.

        {
            return status;
        }

free_buffers_mem_()

void audio_waveout::free_buffers_mem_ ( void  )

protected

Definition at line 134 of file audio_waveout.cpp.

{
    /* Frees memory */
    if (main_buffer)
        delete[] main_buffer;
 
    if (wave_headers)
        delete[] wave_headers;
 
    main_buffer = 0;
    wave_headers = 0;
}

Referenced by close().

init_()

_AUDIO_NAMESPACE_START_ void audio_waveout::init_ ( void  )

protected

Definition at line 14 of file audio_waveout.cpp.

{
    ZeroMemory((LPVOID)&wave_format, sizeof(WAVEFORMATEX));
    wave_format.cbSize = sizeof(WAVEFORMATEX);
    waveout_handle = 0;
    playthread_id = 0;
    wakeup_playthread = 0;
    buf_secs = _AUDIO_DEFAULT_WAVEOUTBUFSECS;
    status = WAVEOUT_NOTREADY;
}

Referenced by audio_waveout().

init_headers_()

void audio_waveout::init_headers_ ( void  )

protected

Definition at line 52 of file audio_waveout.cpp.

{
    /* If there is no memory for memory or headers, simply return */
    if ((!wave_headers) || (!main_buffer))
        return;
 
    /* This is the size for one buffer */
    DWORD buf_sz = mb_size / buffers;
    /* This is the base address for one buffer */
    BYTE *buf_addr = main_buffer;
 
    ZeroMemory(wave_headers, sizeof(WAVEHDR) * buffers);
 
    /* Initializes headers */
    for (unsigned int i = 0; i < buffers; ++i)
    {
        /* Sets the correct base address and length for the little buffer */
        wave_headers[i].dwBufferLength = mb_size / buffers;
        wave_headers[i].lpData = (LPSTR) buf_addr;
 
        /* Unsets the WHDR_DONE flag */
        wave_headers[i].dwFlags &= ~WHDR_DONE;
 
        /* Sets the WAVEHDR user data with an unique little buffer ID# */
        wave_headers[i].dwUser = (unsigned int)i;
 
        /* Increments little buffer base address */
        buf_addr += buf_sz;
    }
}

Referenced by open(), and stop().

nsample()

unsigned int audio_waveout::nsample ( unsigned int  nsamp )

inline

Definition at line 129 of file audio_waveout.hpp.

        {
            unsigned int svalue;
 
            if (aud_info.bits() == 16)
                svalue = (unsigned int)abs(*((short *)(main_buffer + aud_info.bytes_in_samples(nsamp))));
            else if (aud_info.bits() == 8)
               svalue = (unsigned int)((ptrdiff_t) *(main_buffer + aud_info.bytes_in_samples(nsamp)));
            else
                svalue = 0;
 
            return svalue;
        }

open()

void audio_waveout::open

(

void

)

Definition at line 148 of file audio_waveout.cpp.

{
    MMRESULT err;
    HANDLE playthread_handle = 0;
 
    /* Checkin the status of the object */
    if (status != WAVEOUT_NOTREADY)
    {
        /* TODO: throw error */
    }
 
    /* Creating the EVENT object that will be signaled when
       the playing thread has to wake up */
    wakeup_playthread = CreateEvent(0, FALSE, FALSE, 0);
    if (!wakeup_playthread)
    {
        status = WAVEOUT_ERR;
        /* TODO: throw error */
    }
 
    /* Inialize buffers for recording audio data from the wavein audio line */
    alloc_buffers_mem_(buffers, buf_secs);
    init_headers_();
 
    /* Sound format that will be captured by wavein */
    wave_format.wFormatTag = WAVE_FORMAT_PCM;
    wave_format.nChannels = aud_info.channels();
    wave_format.nSamplesPerSec = aud_info.sample_rate();
    wave_format.wBitsPerSample = aud_info.bits();
    wave_format.nBlockAlign = aud_info.block_align();
    wave_format.nAvgBytesPerSec = aud_info.byte_rate();
 
    /* Creating the recording thread */
    playthread_handle = CreateThread(NULL,
                                     0,
                                     audio_waveout::playing_procedure,
                                     (PVOID)this,
                                     0,
                                     &playthread_id);
    /* Checking thread handle */
    if (!playthread_handle)
    {
        /* Updating status */
        status = WAVEOUT_ERR;
        /* TODO: throw error */
    }
 
    /* We don't need the thread handle anymore, so we can close it from now.
       (We'll just need the thread ID for the `waveInOpen' API) */
    CloseHandle(playthread_handle);
 
    /* Reset the `audio_source' to the start position */
    audio_buf.set_position_start();
    /* Opens the WAVE_OUT device */
    err = waveOutOpen(&waveout_handle,
                      WAVE_MAPPER,
                      &wave_format,
                      playthread_id,
                      0,
                      CALLBACK_THREAD | WAVE_ALLOWSYNC);
    if (err != MMSYSERR_NOERROR)
    {
        MessageBox(0, _T("waveOutOpen Error"), 0, 0);
        /* TODO: throw error */
    }
 
    status = WAVEOUT_READY;
}

pause()

void audio_waveout::pause

(

void

)

Definition at line 272 of file audio_waveout.cpp.

{
    MMRESULT err;
 
    /* If the waveout object is not playing audio, do nothing */
    if (status == WAVEOUT_PLAYING)
    {
        /* Updating status */
        status = WAVEOUT_PAUSED;
        /* Tells to audio driver to pause audio */
        err = waveOutPause(waveout_handle);
        if (err != MMSYSERR_NOERROR)
        {
            MessageBox(0, _T("waveOutPause Error"), 0, 0);
            /* TODO: throw error */
        }
    }
}

play()

void audio_waveout::play

(

void

)

Definition at line 218 of file audio_waveout.cpp.

{
    MMRESULT err;
    unsigned int i;
 
    if (!main_buffer)
    {
        /* TODO; throw error, or assert */
        return;
    }
 
    /* If the status is PAUSED, we have to resume the audio playing */
    if (status == WAVEOUT_PAUSED)
    {
        /* Updates status */
        status = WAVEOUT_PLAYING;
        /* Tells to the driver to resume audio playing */
        waveOutRestart(waveout_handle);
        /* Wakeup playing thread */
        SetEvent(wakeup_playthread);
        return;
    } /* if status == WAVEOUT_PAUSED */
 
    if (status != WAVEOUT_READY)
        return;
 
    /* Prepares WAVEHDR structures */
    prep_headers_();
    /* Sets correct status */
    status = WAVEOUT_PLAYING;
    /* Reads the audio from the start */
    //audio_buf.set_position_start();
 
    /* Reads the first N bytes from the audio buffer, where N = the total
       size of all little buffers */
    audio_buf.read(main_buffer, mb_size);
 
    /* Wakeup the playing thread */
    SetEvent(wakeup_playthread);
 
    /* Sends all the little buffers to the audio driver, so it can play
       the sound data */
    for (i = 0; i < buffers; ++i)
    {
        err = waveOutWrite(waveout_handle, &wave_headers[i], sizeof(WAVEHDR));
        if (err != MMSYSERR_NOERROR)
        {
            MessageBox(0, _T("waveOutWrite Error"), 0, 0);
            /* TODO: throw error */
        }
    }
}

playing_procedure()

DWORD WINAPI audio_waveout::playing_procedure ( LPVOID  arg )

staticprivate

Definition at line 348 of file audio_waveout.cpp.

{
    MSG msg;
    WAVEHDR *phdr;
    MMRESULT err;
    audio_waveout *_this = (audio_waveout *)arg;
    unsigned int read_size;
 
    /* Check the arg pointer */
    if (_this == 0)
        return 0;
 
    /* The thread can go to sleep for now. It will be wake up only when
       there is audio data to be recorded */
    if (_this->wakeup_playthread)
        WaitForSingleObject(_this->wakeup_playthread, INFINITE);
 
    /* Entering main polling loop */
    while (GetMessage(&msg, 0, 0, 0))
    {
        switch (msg.message)
        {
            case MM_WOM_DONE:
                phdr = (WAVEHDR *)msg.lParam;
 
                /* If the status of the `wave_out' object is different
                   than playing, then the thread can go to sleep */
                if ((_this->status != WAVEOUT_PLAYING) &&
                    (_this->status != WAVEOUT_FLUSHING) &&
                    (_this->wakeup_playthread))
                {
                    WaitForSingleObject(_this->wakeup_playthread, INFINITE);
                }
 
                /* The playing thread doesn't have to sleep, so let's checking
                   first if the little buffer has been sent to the audio driver
                   (it has the WHDR_DONE flag). If it is, we can read new audio
                   datas from the `audio_producer' object, refill the little buffer,
                   and resend it to the driver with waveOutWrite( ) API */
                if (phdr->dwFlags & WHDR_DONE)
                {
                    if (_this->status == WAVEOUT_PLAYING)
                    {
                        /* Here the thread is still playing a sound, so it can
                           read new audio data from the `audio_producer' object */
                        read_size = _this->audio_buf.read((BYTE *)phdr->lpData,
                                                          phdr->dwBufferLength);
                    } else
                        read_size = 0;
 
                    /* If the `audio_producer' object, has produced some
                       audio data, so `read_size' will be > 0 */
                    if (read_size)
                    {
                        /* Adjusts the correct effectively read size */
                        phdr->dwBufferLength = read_size;
 
                        /* Before sending the little buffer to the driver,
                           we have to remove the `WHDR_DONE' flag, because
                           the little buffer now contain new audio data that have to be played */
                        phdr->dwFlags &= ~WHDR_DONE;
 
                        /* Plays the sound of the little buffer */
                        err = waveOutWrite(_this->waveout_handle,
                                           phdr,
                                           sizeof(WAVEHDR));
 
                        /* Checking if any error has occured */
                        if (err != MMSYSERR_NOERROR)
                        {
                            MessageBox(0, _T("waveOutWrite Error"), 0, 0);
                            /* TODO: throw error */
                        }
                    }
                    else
                    {
                        /* Here `read_size' is 0, so the `audio_producer' object,
                           doesn't have any sound data to produce anymore. So,
                           now we have to see the little buffer #ID to establishing what to do */
                        if (phdr->dwUser == 0)
                        {
                            /* Here `read_size' is 0, and the buffer user data
                               contain 0, so this is the first of N little
                               buffers that came back with `WHDR_DONE' flag;
                               this means that this is the last little buffer
                               in which we have to read data to; so we can
                               _STOP_ reading data from the `audio_producer'
                               object: doing this is accomplished just setting
                               the current status as "WAVEOUT_FLUSHING" */
                            _this->status = WAVEOUT_FLUSHING;
                        }
                        else if (phdr->dwUser == (_this->buffers - 1))
                        {
                            /* Here `read_size' and the buffer user data, that
                               contain a buffer ID#, is equal to the number of
                               the total buffers - 1. This means that this is
                               the _LAST_ little buffer that has been played by
                               the audio driver. We can STOP the `wave_out'
                               object now, or restart the sound playing, if we have a infinite loop */
                            _this->stop();
 
                            /* Let the thread go to sleep */
                            if (_this->audio_buf.play_finished)
                                _this->audio_buf.play_finished();
 
                            if (_this->wakeup_playthread)
                                WaitForSingleObject(_this->wakeup_playthread,
                                                    INFINITE);
 
                        } /* if (phdr->dwUser == (_this->buffers - 1)) */
                    } /* if read_size != 0 */
                } /* (phdr->dwFlags & WHDR_DONE) */
                break; /* end case */
            case MM_WOM_CLOSE:
                /* The thread can exit now */
                return 0;
                break;
            case MM_WOM_OPEN:
                /* Do nothing */
                break;
        } /* end switch(msg.message) */
    } /* end while(GetMessage(...)) */
 
    return 0;
}

Referenced by open().

prep_headers_()

void audio_waveout::prep_headers_ ( void  )

protected

Definition at line 84 of file audio_waveout.cpp.

{
    MMRESULT err;
    bool error = false;
 
    /* If there is no memory for memory or headers, throw error */
    if ((!wave_headers) || (!main_buffer) || (!waveout_handle))
    {
        /* TODO: throw error! */
    }
 
    for (unsigned int i = 0; i < buffers; ++i)
    {
        err = waveOutPrepareHeader(waveout_handle, &wave_headers[i], sizeof(WAVEHDR));
        if (err != MMSYSERR_NOERROR)
            error = true;
    }
 
    if (error)
    {
        /* TODO: throw error indicating which header i-th is errorneous */
    }
}

Referenced by play().

samplevalue_max()

unsigned int audio_waveout::samplevalue_max ( void  )

inline

Definition at line 114 of file audio_waveout.hpp.

        {
            if (aud_info.bits() == 16)
                return (unsigned int)65535;
            else if (aud_info.bits() == 8)
                return (unsigned int)255;
            else
                return 0;
        }

stop()

void audio_waveout::stop

(

void

)

Definition at line 292 of file audio_waveout.cpp.

{
    MMRESULT err;
 
    /* Checks the current status */
    if ((status != WAVEOUT_PLAYING) &&
        (status != WAVEOUT_FLUSHING) &&
        (status != WAVEOUT_PAUSED))
    {
        /* Do nothing */
        return;
    }
 
    /* Sets a new status */
    status = WAVEOUT_STOP;
    /* Flushes pending audio datas */
    err = waveOutReset( waveout_handle );
    if (err != MMSYSERR_NOERROR)
    {
        MessageBox(0, _T("err WaveOutReset.\n"),_T("ERROR"), 0);
        /* TODO: throw error */
    }
 
    /* Sets the start position of the audio buffer */
    audio_buf.set_position_start();
    /* Cleans little buffers */
    unprep_headers_();
    init_headers_();
    /* Refreshes the status */
    status = WAVEOUT_READY;
}

Referenced by close(), and playing_procedure().

tot_samples_buf()

unsigned audio_waveout::tot_samples_buf ( void  )

inline

Definition at line 124 of file audio_waveout.hpp.

        {
            return aud_info.samples_in_bytes(mb_size);
        }

unprep_headers_()

void audio_waveout::unprep_headers_ ( void  )

protected

Definition at line 109 of file audio_waveout.cpp.

{
    MMRESULT err;
    bool error = false;
 
    /* If there is no memory for memory or headers, throw error */
    if ((!wave_headers) || (!main_buffer) || (!waveout_handle))
    {
        /* TODO: throw error! */
    }
 
    for (unsigned int i = 0; i < buffers; ++i)
    {
        err = waveOutUnprepareHeader(waveout_handle, &wave_headers[i], sizeof(WAVEHDR));
        if (err != MMSYSERR_NOERROR)
            error = true;
    }
 
    if (error)
    {
        /* TODO: throw error indicating which header i-th is errorneous */
    }
}

Referenced by stop().

Friends And Related Function Documentation

audio_buffer

friend class audio_buffer

friend

Definition at line 29 of file audio_waveout.hpp.

Member Data Documentation

aud_info

const audio_format& audio_waveout::aud_info

protected

Definition at line 40 of file audio_waveout.hpp.

Referenced by alloc_buffers_mem_(), nsample(), open(), samplevalue_max(), and tot_samples_buf().

audio_buf

audio_producer& audio_waveout::audio_buf

protected

Definition at line 41 of file audio_waveout.hpp.

Referenced by open(), play(), playing_procedure(), and stop().

buf_secs

float audio_waveout::buf_secs

protected

Definition at line 47 of file audio_waveout.hpp.

Referenced by init_(), and open().

buffers

unsigned int audio_waveout::buffers

protected

Definition at line 59 of file audio_waveout.hpp.

Referenced by init_headers_(), play(), playing_procedure(), prep_headers_(), and unprep_headers_().

main_buffer

BYTE* audio_waveout::main_buffer

protected

Definition at line 53 of file audio_waveout.hpp.

Referenced by alloc_buffers_mem_(), buf(), free_buffers_mem_(), init_headers_(), nsample(), play(), prep_headers_(), and unprep_headers_().

mb_size

unsigned int audio_waveout::mb_size

protected

Definition at line 56 of file audio_waveout.hpp.

Referenced by alloc_buffers_mem_(), bufsz(), init_headers_(), play(), and tot_samples_buf().

playthread_id

DWORD audio_waveout::playthread_id

protected

Definition at line 44 of file audio_waveout.hpp.

Referenced by init_(), and open().

status

audio_waveout_status audio_waveout::status

protected

Definition at line 46 of file audio_waveout.hpp.

Referenced by current_status(), and playing_procedure().

wakeup_playthread

HANDLE audio_waveout::wakeup_playthread

private

Definition at line 33 of file audio_waveout.hpp.

Referenced by init_(), open(), play(), and playing_procedure().

wave_format

WAVEFORMATEX audio_waveout::wave_format

protected

Definition at line 36 of file audio_waveout.hpp.

Referenced by init_(), and open().

wave_headers

WAVEHDR* audio_waveout::wave_headers

protected

Definition at line 37 of file audio_waveout.hpp.

Referenced by alloc_buffers_mem_(), free_buffers_mem_(), init_headers_(), play(), prep_headers_(), and unprep_headers_().

waveout_handle

HWAVEOUT audio_waveout::waveout_handle

protected

Definition at line 38 of file audio_waveout.hpp.

Referenced by close(), init_(), open(), pause(), play(), playing_procedure(), prep_headers_(), stop(), and unprep_headers_().

---

The documentation for this class was generated from the following files:

• base/applications/sndrec32/audio_waveout.hpp
• base/applications/sndrec32/audio_waveout.cpp