audio_wavein Class Reference

#include <audio_wavein.hpp>

Collaboration diagram for audio_wavein:

Public Member Functions
	audio_wavein (const audio_format &a_info, audio_receiver &a_receiver)
	~audio_wavein (void)
void	open (void)
void	close (void)
void	start_recording (void)
void	stop_recording (void)
audio_wavein_status	current_status (void) const
float	buffer_secs (void) const
void	buffer_secs (float bsecs)
unsigned int	total_buffers (void) const
void	total_buffers (unsigned int tot_bufs)
audio_format	format (void) const
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)
void	add_buffers_to_driver_ (void)

Protected Attributes
WAVEFORMATEX	wave_format
WAVEHDR *	wave_headers
HWAVEIN	wavein_handle
audio_format	aud_info
audio_receiver &	audio_rcvd
DWORD	recthread_id
audio_wavein_status	status
float	buf_secs
BYTE *	main_buffer
unsigned int	mb_size
unsigned int	buffers

Static Private Member Functions
static DWORD WINAPI	recording_procedure (LPVOID)

Private Attributes
HANDLE	wakeup_recthread
HANDLE	data_flushed_event

Detailed Description

Definition at line 26 of file audio_wavein.hpp.

Constructor & Destructor Documentation

audio_wavein()

audio_wavein::audio_wavein ( const audio_format &  a_info, audio_receiver &  a_receiver  )

inline

Definition at line 81 of file audio_wavein.hpp.

                                                 : wave_headers(0),
                                                   aud_info(a_info),
                                                   audio_rcvd(a_receiver),
                                                   status(WAVEIN_NOTREADY),
                                                   main_buffer(0),
                                                   mb_size(0),
                                                   buffers(_AUDIO_DEFAULT_WAVEINBUFFERS)
        {
            /* Initializing internal wavein data */
            init_();
            aud_info = a_info;
        }

~audio_wavein()

audio_wavein::~audio_wavein ( void  )

inline

Definition at line 96 of file audio_wavein.hpp.

        {
            //close(); TODO!
        }

Member Function Documentation

add_buffers_to_driver_()

void audio_wavein::add_buffers_to_driver_ ( void  )

protected

Definition at line 135 of file audio_wavein.cpp.

{
    MMRESULT err;
    bool error = false;
 
    /* If there is no memory for memory or headers, throw error */
    if ((!wave_headers) || (!main_buffer) || (!wavein_handle))
    {
        /* TODO: throw error! */
    }
 
    for (unsigned int i = 0; i < buffers; ++i)
    {
        err = waveInAddBuffer(wavein_handle, &wave_headers[i], sizeof(WAVEHDR));
        if (err != MMSYSERR_NOERROR)
            error = true;
    }
 
    if (error)
        MessageBox(0, TEXT("waveInAddBuffer Error."), 0, 0);
}

Referenced by start_recording().

alloc_buffers_mem_()

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

protected

Definition at line 27 of file audio_wavein.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_wavein::buf ( void  )

inline

Definition at line 149 of file audio_wavein.hpp.

        {
            return main_buffer;
        }

buffer_secs() [1/2]

void audio_wavein::buffer_secs ( float  bsecs )

inline

Definition at line 119 of file audio_wavein.hpp.

        {
            /* Some checking */
            if (bsecs <= 0)
                return;
 
            /* Set seconds length for each buffer */
            buf_secs = bsecs;
        }

buffer_secs() [2/2]

float audio_wavein::buffer_secs ( void  ) const

inline

Definition at line 114 of file audio_wavein.hpp.

        {
            return buf_secs;
        }

bufsz()

unsigned int audio_wavein::bufsz ( void  )

inline

Definition at line 154 of file audio_wavein.hpp.

        {
            return mb_size;
        }

close()

void audio_wavein::close

(

void

)

Definition at line 158 of file audio_wavein.cpp.

{
    /* If wavein object is already in the status NOTREADY, nothing to do */
    if (status == WAVEIN_NOTREADY)
        return;
 
    /* If the wavein is recording, then stop recording and close it */
    if (status == WAVEIN_RECORDING)
        stop_recording();
 
    /* Updating status */
    status = WAVEIN_NOTREADY;
 
    /* Waking up recording thread, so it can receive
       the `MM_WIM_CLOSE' message then dies */
    if (wakeup_recthread)
        SetEvent(wakeup_recthread);
 
    /* Closing wavein stream */
    while ((waveInClose(wavein_handle)) != MMSYSERR_NOERROR)
        Sleep(1);
 
    /* Release buffers memory */
    free_buffers_mem_();
 
    /* Re-initialize variables to the initial state */
    init_();
}

current_status()

audio_wavein_status audio_wavein::current_status ( void  ) const

inline

Definition at line 109 of file audio_wavein.hpp.

        {
            return status;
        }

format()

audio_format audio_wavein::format ( void  ) const

inline

Definition at line 144 of file audio_wavein.hpp.

        {
            return aud_info;
        }

free_buffers_mem_()

void audio_wavein::free_buffers_mem_ ( void  )

protected

Definition at line 54 of file audio_wavein.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_wavein::init_ ( void  )

protected

Definition at line 14 of file audio_wavein.cpp.

{
    ZeroMemory((LPVOID)&wave_format, sizeof(WAVEFORMATEX));
    wave_format.cbSize = sizeof(WAVEFORMATEX);
    wavein_handle = 0;
    recthread_id = 0;
    wakeup_recthread = 0;
    data_flushed_event = 0;
    buf_secs = _AUDIO_DEFAULT_WAVEINBUFSECS;
    status = WAVEIN_NOTREADY;
}

Referenced by audio_wavein(), and close().

init_headers_()

void audio_wavein::init_headers_ ( void  )

protected

Definition at line 69 of file audio_wavein.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;
    /* Initializes headers */
    for (unsigned int i = 0; i < buffers; ++i)
    {
        wave_headers[i].dwBufferLength = mb_size / buffers;
        wave_headers[i].lpData = (LPSTR)buf_addr;
        buf_addr += buf_sz;
    }
}

Referenced by open().

nsample()

unsigned int audio_wavein::nsample ( unsigned int  nsamp )

inline

Definition at line 176 of file audio_wavein.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_wavein::open

(

void

)

Definition at line 188 of file audio_wavein.cpp.

{
    MMRESULT err;
    HANDLE recthread_handle = 0;
 
    /* Checkin the status of the object */
    if (status != WAVEIN_NOTREADY)
    {
        /* TODO: throw error */
    }
 
    /* Creating the EVENT object that will be signaled
       when the recording thread has to wake up */
    wakeup_recthread = CreateEvent(0, FALSE, FALSE, 0);
 
    data_flushed_event = CreateEvent(0, FALSE, FALSE, 0);
 
    if ((!wakeup_recthread) || (!data_flushed_event))
    {
        status = WAVEIN_ERR;
        MessageBox(0, TEXT("Thread Error."), 0, 0);
        /* 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 */
    recthread_handle = CreateThread(NULL,
                                    0,
                                    audio_wavein::recording_procedure,
                                    (PVOID)this,
                                    0,
                                    &recthread_id);
    /* Checking thread handle */
    if (!recthread_handle)
    {
        /* Updating status */
        status = WAVEIN_ERR;
        MessageBox(0, TEXT("Thread Error."), 0, 0);
        /* 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(recthread_handle);
 
    /* Opening audio line wavein */
    err = waveInOpen(&wavein_handle,
                     0,
                     &wave_format,
                     recthread_id,
                     0,
                     CALLBACK_THREAD);
 
    if (err != MMSYSERR_NOERROR)
    {
        /* Updating status */
        status = WAVEIN_ERR;
 
        if (err == WAVERR_BADFORMAT)
            MessageBox(0, TEXT("waveInOpen Error"), 0, 0);
 
        /* TODO: throw error */
    }
 
    /* Update object status */
    status = WAVEIN_READY;
 
    /* Now `audio_wavein' object is ready for audio recording! */
}

prep_headers_()

void audio_wavein::prep_headers_ ( void  )

protected

Definition at line 89 of file audio_wavein.cpp.

{
    MMRESULT err;
    bool error = false;
 
    /* If there is no memory for memory or headers, throw error */
    if ((!wave_headers) || (!main_buffer) || (!wavein_handle))
    {
        /* TODO: throw error! */
    }
 
    for (unsigned int i = 0; i < buffers; ++i)
    {
        err = waveInPrepareHeader(wavein_handle, &wave_headers[i], sizeof(WAVEHDR));
        if (err != MMSYSERR_NOERROR)
            error = true;
    }
 
    if (error)
        MessageBox(0, TEXT("waveInPrepareHeader Error."), 0, 0);
}

Referenced by start_recording().

recording_procedure()

DWORD WINAPI audio_wavein::recording_procedure ( LPVOID  arg )

staticprivate

Definition at line 344 of file audio_wavein.cpp.

{
    MSG msg;
    WAVEHDR *phdr;
    audio_wavein *_this = (audio_wavein *)arg;
 
    /* 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_recthread)
        WaitForSingleObject(_this->wakeup_recthread, INFINITE);
 
    /* If status of the `audio_wavein' object is not ready or recording the thread can exit */
    if ((_this->status != WAVEIN_READY) && (_this->status != WAVEIN_RECORDING))
        return 0;
 
    /* Entering main polling loop */
    while (GetMessage(&msg, 0, 0, 0))
    {
        switch (msg.message)
        {
            case MM_WIM_DATA:
                phdr = (WAVEHDR *)msg.lParam;
 
                if ((_this->status == WAVEIN_RECORDING) ||
                    (_this->status == WAVEIN_FLUSHING))
                {
                    if (phdr->dwFlags & WHDR_DONE)
                    {
                        /* Flushes recorded audio data to the `audio_receiver' object */
                        _this->audio_rcvd.audio_receive((unsigned char *)phdr->lpData,
                                                        phdr->dwBytesRecorded);
 
                        /* Updating `audio_receiver' total bytes received
                           _AFTER_ calling `audio_receive' function */
                        _this->audio_rcvd.bytes_received += phdr->dwBytesRecorded;
                    }
 
                    /* If status is not flushing data, then we can re-add the buffer
                       for reusing it. Otherwise, if we are flushing pending data,
                       we cannot re-add buffer because we don't need it anymore */
                    if (_this->status != WAVEIN_FLUSHING)
                    {
                        /* Let the audio driver reuse the buffer */
                        waveInAddBuffer(_this->wavein_handle, phdr, sizeof(WAVEHDR));
                    } else {
                        /* If we are flushing pending data, we have to prepare
                           to stop recording. Set WAVEHDR flag to 0, and fires
                           the event `data_flushed_event', that will wake up
                           the main thread that is sleeping into wavein_in::stop_recording()
                           member function, waiting the last `MM_WIM_DATA' message
                           that contain pending data */
 
                        phdr->dwFlags = 0;
                        SetEvent(_this->data_flushed_event);
 
                        /* The recording is going to stop, so the recording thread can go to sleep! */
                        WaitForSingleObject(_this->wakeup_recthread, INFINITE);
                    }
                } /* if WAVEIN_RECORDING || WAVEIN_FLUSHING */
                break;
 
            case MM_WIM_CLOSE:
                /* The thread can exit now */
                return 0;
                break;
        } /* end switch(msg.message) */
    } /* end while(GetMessage(...)) */
 
    return 0;
}

Referenced by open().

samplevalue_max()

unsigned int audio_wavein::samplevalue_max ( void  )

inline

Definition at line 159 of file audio_wavein.hpp.

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

start_recording()

void audio_wavein::start_recording

(

void

)

Definition at line 270 of file audio_wavein.cpp.

{
    MMRESULT err;
    BOOL ev;
 
    if ((status != WAVEIN_READY) && (status != WAVEIN_STOP))
    {
        /* TODO: throw error */
    }
 
    /* Updating to the recording status */
    status = WAVEIN_RECORDING;
 
    /* Let's prepare header of type WAVEHDR that we will pass to the driver
       with our audio informations, and buffer informations */
    prep_headers_();
 
    /* The waveInAddBuffer function sends an input buffer to the given waveform-audio
       input device. When the buffer is filled, the application is notified. */
    add_buffers_to_driver_();
 
    /* Signaling event for waking up the recorder thread */
    ev = SetEvent(wakeup_recthread);
    if (!ev)
        MessageBox(0, TEXT("Event Error."), 0, 0);
 
    /* Start recording */
    err = waveInStart(wavein_handle);
    if (err != MMSYSERR_NOERROR)
    {
        /* Updating status */
        status = WAVEIN_ERR;
        MessageBox(0, TEXT("waveInStart Error."), 0, 0);
        /* TODO: throw error */
    }
}

stop_recording()

void audio_wavein::stop_recording

(

void

)

Definition at line 308 of file audio_wavein.cpp.

{
    MMRESULT err;
 
    if (status != WAVEIN_RECORDING)
        return;
 
    status = WAVEIN_FLUSHING;
 
    /* waveInReset will make all pending buffer as done */
    err = waveInReset(wavein_handle);
    if ( err != MMSYSERR_NOERROR )
    {
        /* TODO: throw error */
        MessageBox(0, TEXT("waveInReset Error."), 0, 0);
    }
 
    if (data_flushed_event)
        WaitForSingleObject(data_flushed_event, INFINITE);
 
    /* Stop recording */
    err = waveInStop(wavein_handle);
    if (err != MMSYSERR_NOERROR)
    {
        /* TODO: throw error */
        MessageBox(0, TEXT("waveInStop Error."), 0, 0);
    }
 
    /* The waveInUnprepareHeader function cleans up the preparation performed
       by the waveInPrepareHeader function */
    unprep_headers_();
 
    status = WAVEIN_STOP;
}

Referenced by close().

tot_samples_buf()

unsigned audio_wavein::tot_samples_buf ( void  )

inline

Definition at line 171 of file audio_wavein.hpp.

        {
            return aud_info.samples_in_bytes(mb_size);
        }

total_buffers() [1/2]

void audio_wavein::total_buffers ( unsigned int  tot_bufs )

inline

Definition at line 134 of file audio_wavein.hpp.

        {
            /* Some checking */
            if (tot_bufs == 0)
                return;
 
            /* Sets the number of total buffers */
            buffers = tot_bufs;
        }

total_buffers() [2/2]

unsigned int audio_wavein::total_buffers ( void  ) const

inline

Definition at line 129 of file audio_wavein.hpp.

        {
            return buffers;
        }

unprep_headers_()

void audio_wavein::unprep_headers_ ( void  )

protected

Definition at line 112 of file audio_wavein.cpp.

{
    MMRESULT err;
    bool error = false;
 
    /* If there is no memory for memory or headers, throw error */
    if ((!wave_headers) || (!main_buffer) || (!wavein_handle))
    {
        /* TODO: throw error! */
    }
 
    for (unsigned int i = 0; i < buffers; ++i)
    {
        err = waveInUnprepareHeader(wavein_handle, &wave_headers[i], sizeof(WAVEHDR));
        if (err != MMSYSERR_NOERROR)
            error = true;
    }
 
    if (error)
        MessageBox(0, TEXT("waveInUnPrepareHeader Error."), 0, 0);
}

Referenced by stop_recording().

Member Data Documentation

aud_info

audio_format audio_wavein::aud_info

protected

Definition at line 47 of file audio_wavein.hpp.

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

audio_rcvd

audio_receiver& audio_wavein::audio_rcvd

protected

Definition at line 48 of file audio_wavein.hpp.

Referenced by recording_procedure().

buf_secs

float audio_wavein::buf_secs

protected

Definition at line 58 of file audio_wavein.hpp.

Referenced by buffer_secs(), init_(), and open().

buffers

unsigned int audio_wavein::buffers

protected

Definition at line 64 of file audio_wavein.hpp.

Referenced by add_buffers_to_driver_(), init_headers_(), prep_headers_(), total_buffers(), and unprep_headers_().

data_flushed_event

HANDLE audio_wavein::data_flushed_event

private

Definition at line 37 of file audio_wavein.hpp.

Referenced by init_(), open(), recording_procedure(), and stop_recording().

main_buffer

BYTE* audio_wavein::main_buffer

protected

Definition at line 62 of file audio_wavein.hpp.

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

mb_size

unsigned int audio_wavein::mb_size

protected

Definition at line 63 of file audio_wavein.hpp.

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

recthread_id

DWORD audio_wavein::recthread_id

protected

Definition at line 51 of file audio_wavein.hpp.

Referenced by init_(), and open().

status

audio_wavein_status audio_wavein::status

protected

Definition at line 54 of file audio_wavein.hpp.

Referenced by current_status(), and recording_procedure().

wakeup_recthread

HANDLE audio_wavein::wakeup_recthread

private

Definition at line 36 of file audio_wavein.hpp.

Referenced by close(), init_(), open(), recording_procedure(), and start_recording().

wave_format

WAVEFORMATEX audio_wavein::wave_format

protected

Definition at line 43 of file audio_wavein.hpp.

Referenced by init_(), and open().

wave_headers

WAVEHDR* audio_wavein::wave_headers

protected

Definition at line 44 of file audio_wavein.hpp.

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

wavein_handle

HWAVEIN audio_wavein::wavein_handle

protected

Definition at line 45 of file audio_wavein.hpp.

Referenced by add_buffers_to_driver_(), close(), init_(), open(), prep_headers_(), recording_procedure(), start_recording(), stop_recording(), and unprep_headers_().

---

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

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