reactos/base/applications/sndrec32/audio_wavein.cpp

/* PROJECT:         ReactOS sndrec32
 * LICENSE:         GPL - See COPYING in the top level directory
 * FILE:            base/applications/sndrec32/audio_wavein.cpp
 * PURPOSE:         Sound recording
 * PROGRAMMERS:     Marco Pagliaricci (irc: rendar)
 */



#include "stdafx.h"
#include "audio_wavein.hpp"



_AUDIO_NAMESPACE_START_


void
audio_wavein::init_( void )
{
    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;
}


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


    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;

}


void 
audio_wavein::free_buffers_mem_( void )
{


    //
    // Frees memory
    //

    if ( main_buffer )
        delete[] main_buffer;


    if ( wave_headers )
        delete[] wave_headers;


    main_buffer = 0;
    wave_headers = 0;

}


void 
audio_wavein::init_headers_( void )
{



    //
    // 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;
    }

}


void 
audio_wavein::prep_headers_( void )
{
    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 );



}

void 
audio_wavein::unprep_headers_( void )
{
    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 );

}


void 
audio_wavein::add_buffers_to_driver_( void )
{
    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 );

}



void
audio_wavein::close( void ) 
{




    //
    // 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;




    //
    // Wakeing 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_();
    
}


void
audio_wavein::open( void )
{

    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!
    //
}



void
audio_wavein::start_recording( void )
{

    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

    }

}



void
audio_wavein::stop_recording( void )
{
        

    MMRESULT err;
    DWORD wait;


    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 )
        wait = 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;

}



DWORD WINAPI 
audio_wavein::recording_procedure( LPVOID arg )
{


    MSG msg;
    WAVEHDR * phdr;
    DWORD wait;
    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 )
        wait = 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 gooing to stop, so the
                        // recording thread can go to sleep!
                        //

                        wait = 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;				
}






_AUDIO_NAMESPACE_END_