Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-29 10:35:28 +00:00
Code Issues Projects Releases Packages Wiki Activity

[SNDREC32]

Browse source 
* Attempt to fix a.. crime against style.

svn path=/trunk/; revision=61314
This commit is contained in:
Amine Khaldi 2013-12-21 13:29:23 +00:00
parent b4e3ee3563
commit 5170eaeaaf
20 changed files with 1846 additions and 4418 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
reactos/base/applications/sndrec32/audio_api.hpp
View file

@ -1,12 +1,7 @@
#ifndef __AUDIO_API__
#define __AUDIO_API__
//#include "audio_def.hpp"
//#include "audio_format.hpp"
#include "audio_membuffer.hpp"
//#include "audio_producer.hpp"
//#include "audio_receiver.hpp"
//#include "audio_resampler_acm.hpp"
#include "audio_wavein.hpp"
#include "audio_waveout.hpp"

47
reactos/base/applications/sndrec32/audio_def.hpp
View file

@ -5,21 +5,10 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#ifndef _AUDIO_DEF__H_
#define _AUDIO_DEF__H_
//#include <iostream>
//
// Defaults
//
/* Defaults */
#define _AUDIO_DEFAULT_FORMAT A44100_16BIT_STEREO
@ -31,40 +20,16 @@
#define _AUDIO_DEFAULT_BUFSECS 1.0f
//
// Namespace stuff
//
/* Namespace stuff */
#define _AUDIO_NAMESPACE_START_ namespace snd {
#define _AUDIO_NAMESPACE_END_ };
//
// Platform depend stuff
//
//#include <windows.h>
#include <mmsystem.h> //Windows MultiMedia (WINMM) audio apis
#include <mmreg.h> //codecs stuff
#include <msacm.h> //codecs stuff
/* Platform depend stuff */
#include <mmsystem.h> // Windows MultiMedia (WINMM) audio apis
#include <mmreg.h> // codecs stuff
#include <msacm.h> // codecs stuff
//#pragma comment(lib, "winmm.lib")
//#pragma comment(lib, "msacm32.lib")
#endif //ifdef _AUDIO_DEF__H_

24
reactos/base/applications/sndrec32/audio_format.cpp
View file

@ -5,31 +5,15 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#include "stdafx.h"
#include "audio_format.hpp"
_AUDIO_NAMESPACE_START_
/* Standard audio formats (declared as externs in `audio_format.hpp') */
//
// Standard audio formats (declared as
// externs in `audio_format.hpp')
//
audio_format UNNKOWN_FORMAT( 0, 0, 0);
audio_format A44100_16BIT_STEREO( 44100, 16, 2 );
audio_format A44100_16BIT_MONO( 44100, 16, 1 );
audio_format UNNKOWN_FORMAT(0, 0, 0);
audio_format A44100_16BIT_STEREO(44100, 16, 2);
audio_format A44100_16BIT_MONO(44100, 16, 1);
_AUDIO_NAMESPACE_END_

176
reactos/base/applications/sndrec32/audio_format.hpp
View file

@ -5,159 +5,91 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#ifndef _AUDIOFORMAT__H_
#define _AUDIOFORMAT__H_
#include "audio_def.hpp"
_AUDIO_NAMESPACE_START_
class audio_format
{
protected:
unsigned int samples_psec;
unsigned short int bits_psample;
unsigned short int chan;
public:
//
// Ctors
//
audio_format( unsigned int samples_per_second,
unsigned short int bits_per_sample, unsigned short int channels )
: samples_psec( samples_per_second ), bits_psample( bits_per_sample ),
chan( channels )
{ }
//
// Dtor
//
virtual ~audio_format( void )
{ }
//
// Operators
//
bool operator==( audio_format & eq ) const
/* Ctors */
audio_format(unsigned int samples_per_second,
unsigned short int bits_per_sample,
unsigned short int channels) : samples_psec(samples_per_second),
bits_psample(bits_per_sample),
chan(channels)
{
//
// The same audio format is when samples per second,
// bit per sample, and channels mono/stereo are equal.
//
return (( samples_psec == eq.samples_psec )
&& ( bits_psample == eq.bits_psample ) && ( chan == eq.chan ));
}
//
// Public Functions
//
unsigned int sample_rate( void ) const
{ return samples_psec; }
unsigned short int bits( void ) const
{ return bits_psample; }
unsigned short int channels( void ) const
{ return chan; }
unsigned int byte_rate( void ) const
{ return ( samples_psec * chan * ( bits_psample / 8 )); }
unsigned int block_align( void ) const
{ return ( chan * ( bits_psample / 8 )); }
unsigned int samples_in_seconds( float seconds ) const
/* Dtor */
virtual ~audio_format(void)
{
return ( unsigned int )
((( float )samples_psec * ( float ) chan ) * seconds );
}
unsigned int samples_in_bytes ( unsigned int bytes ) const
/* Operators */
bool operator==(audio_format & eq) const
{
return ( bytes / (( bits_psample / 8 ) * chan ));
/* The same audio format is when samples per second,
bit per sample, and channels mono/stereo are equal */
return ((samples_psec == eq.samples_psec) &&
(bits_psample == eq.bits_psample) &&
(chan == eq.chan));
}
unsigned int bytes_in_samples( unsigned int samples ) const
/* Public Functions */
unsigned int sample_rate(void) const
{
return ( samples * (( bits_psample / 8 ) * chan ));
return samples_psec;
}
unsigned short int bits(void) const
{
return bits_psample;
}
unsigned short int channels(void) const
{
return chan;
}
unsigned int byte_rate(void) const
{
return (samples_psec * chan * (bits_psample / 8));
}
unsigned int block_align(void) const
{
return (chan * (bits_psample / 8));
}
unsigned int samples_in_seconds(float seconds) const
{
return (unsigned int)(((float)samples_psec * (float) chan) * seconds);
}
unsigned int samples_in_bytes(unsigned int bytes) const
{
return (bytes / ((bits_psample / 8) * chan));
}
unsigned int bytes_in_samples(unsigned int samples) const
{
return (samples * ((bits_psample / 8) * chan));
}
};
extern audio_format UNKNOWN_FORMAT;
extern audio_format A44100_16BIT_STEREO;
extern audio_format A44100_16BIT_MONO;
_AUDIO_NAMESPACE_END_
#endif //ifdef _AUDIOFORMAT__H_
#endif /* _AUDIOFORMAT__H_ */

470
reactos/base/applications/sndrec32/audio_membuffer.cpp
View file

@ -5,510 +5,232 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#include "stdafx.h"
#include "audio_membuffer.hpp"
_AUDIO_NAMESPACE_START_
//////////////////////////////////////
/////// Protected Functions /////////
//////////////////////////////////////
/* Protected Functions */
void
audio_membuffer::alloc_mem_( unsigned int bytes )
audio_membuffer::alloc_mem_(unsigned int bytes)
{
//
// Some checking
//
if ( bytes == 0 )
/* Some checking */
if (bytes == 0)
return;
//
// Checks previsiously alloc'd memory
// and frees it.
//
if ( audio_data )
/* Checks previsiously alloc'd memory and frees it */
if (audio_data)
delete[] audio_data;
/* Allocs new memory and zeros it */
audio_data = new BYTE[bytes];
memset(audio_data, 0, bytes * sizeof(BYTE));
//
// Allocs new memory and zeros it.
//
audio_data = new BYTE[ bytes ];
memset( audio_data, 0, bytes * sizeof( BYTE ));
//
// Sets the correct buffer size
//
/* Sets the correct buffer size */
buf_size = bytes;
init_size = bytes;
}
void
audio_membuffer::free_mem_( void )
audio_membuffer::free_mem_(void)
{
if ( audio_data )
if (audio_data)
delete[] audio_data;
buf_size = 0;
audio_data = 0;
}
void
audio_membuffer::resize_mem_( unsigned int new_size )
audio_membuffer::resize_mem_(unsigned int new_size)
{
if ( new_size == 0 )
if (new_size == 0)
return;
//
// The new_size, cannot be <= of the
// `bytes_received' member value of the
// parent class `audio_receiver'.
// We cannot touch received audio data,
// so we have to alloc at least
// bytes_received+1 bytes.
//
// But we can truncate unused memory, so
// `new_size' can be < of `buf_size'.
//
if ( new_size <= bytes_received )
/* The new_size, cannot be <= of the `bytes_received' member value of the
parent class `audio_receiver'. We cannot touch received audio data,
so we have to alloc at least bytes_received+1 bytes. But we can truncate
unused memory, so `new_size' can be < of `buf_size' */
if (new_size <= bytes_received)
return;
BYTE * new_mem;
/* Allocs new memory and zeros it */
new_mem = new BYTE[new_size];
memset(new_mem, 0, new_size * sizeof(BYTE));
//
// Allocs new memory and zeros it.
//
new_mem = new BYTE[ new_size ];
memset( new_mem, 0, new_size * sizeof( BYTE ));
if ( audio_data )
if (audio_data)
{
//
// Copies received audio data, and discard
// unused memory.
//
memcpy( new_mem, audio_data, bytes_received );
//
// Frees old memory.
//
/* Copies received audio data, and discard unused memory */
memcpy(new_mem, audio_data, bytes_received);
/* Frees old memory */
delete[] audio_data;
//
// Commit new memory.
//
/* Commit new memory */
audio_data = new_mem;
buf_size = new_size;
} else {
audio_data = new_mem;
buf_size = new_size;
}
if ( buffer_resized )
buffer_resized( new_size );
if (buffer_resized)
buffer_resized(new_size);
}
void
audio_membuffer::truncate_( void )
audio_membuffer::truncate_(void)
{
//
// If `buf_size' is already = to the
// `bytes_received' of audio data, then
// this operation is useless; simply return.
//
if ( bytes_received == buf_size )
/* If `buf_size' is already = to the `bytes_received' of audio data,
then this operation is useless; simply return */
if (bytes_received == buf_size)
return;
if ( audio_data )
if (audio_data)
{
//
// Allocs a new buffer.
//
BYTE * newbuf = new BYTE[ bytes_received ];
//
// Copies audio data.
//
memcpy( newbuf, audio_data, bytes_received );
//
// Frees old memory.
//
/* Allocs a new buffer */
BYTE * newbuf = new BYTE[bytes_received];
/* Copies audio data */
memcpy(newbuf, audio_data, bytes_received);
/* Frees old memory */
delete[] audio_data;
//
// Commit the new buffer.
//
/* Commit the new buffer */
audio_data = newbuf;
buf_size = bytes_received;
//
// Buffer truncation successfull.
// Now the buffer size is exactly big
// as much audio data was received.
//
/* Buffer truncation successfull. Now the buffer size is exactly big
as much audio data was received */
}
}
//////////////////////////////////////
/////// Public Functions ///////////
//////////////////////////////////////
/* Public Functions */
void
audio_membuffer::clear( void )
audio_membuffer::clear(void)
{
free_mem_();
bytes_received = 0;
}
void
audio_membuffer::reset( void )
audio_membuffer::reset(void)
{
//
// Frees memory and reset
// to initial state.
//
/* Frees memory and reset to initial state */
clear();
//
// Alloc memory of size specified
// at the constructor.
//
alloc_mem_( init_size );
/* Alloc memory of size specified at the constructor */
alloc_mem_(init_size);
}
void
audio_membuffer::alloc_bytes( unsigned int bytes )
audio_membuffer::alloc_bytes(unsigned int bytes)
{
alloc_mem_( bytes );
alloc_mem_(bytes);
}
void
audio_membuffer::alloc_seconds( unsigned int secs )
audio_membuffer::alloc_seconds(unsigned int secs)
{
alloc_mem_( aud_info.byte_rate() * secs );
alloc_mem_(aud_info.byte_rate() * secs);
}
void
audio_membuffer::alloc_seconds( float secs )
audio_membuffer::alloc_seconds(float secs)
{
alloc_mem_(( unsigned int )(( float ) aud_info.byte_rate() * secs ));
alloc_mem_((unsigned int)((float)aud_info.byte_rate() * secs));
}
void
audio_membuffer::resize_bytes( unsigned int bytes )
audio_membuffer::resize_bytes(unsigned int bytes)
{
resize_mem_( bytes );
resize_mem_(bytes);
}
void
audio_membuffer::resize_seconds( unsigned int secs )
audio_membuffer::resize_seconds(unsigned int secs)
{
resize_mem_( aud_info.byte_rate() * secs );
resize_mem_(aud_info.byte_rate() * secs);
}
void
audio_membuffer::resize_seconds( float secs )
audio_membuffer::resize_seconds(float secs)
{
resize_mem_(( unsigned int )
(( float )aud_info.byte_rate() * secs )
);
resize_mem_((unsigned int)((float)aud_info.byte_rate() * secs));
}
///////////////////////////////////////
/////// Inherited Functions /////////
///////////////////////////////////////
/* Inherited Functions */
void
audio_membuffer::audio_receive
( unsigned char * data, unsigned int size )
audio_membuffer::audio_receive(unsigned char *data, unsigned int size)
{
//
// If there isn't a buffer, allocs memory for
// it of size*2, and copies audio data arrival.
//
if (( audio_data == 0 ) || ( buf_size == 0 ))
/* If there isn't a buffer, allocs memory for it of size*2, and copies audio data arrival */
if ((audio_data == 0) || (buf_size == 0))
{
alloc_mem_( size * 2 );
memcpy( audio_data, data, size );
alloc_mem_(size * 2);
memcpy(audio_data, data, size);
return;
}
//
// If buffer's free memory is < of `size',
// we have to realloc buffer memory of
// buf_size*2, while free memory is enough
// to contain `size' bytes.
//
// In this case free memory is represented
// by `buf_size - bytes_recorded'.
//
unsigned int tot_mem = buf_size,
free_mem = buf_size - bytes_received;
if ( free_mem < size )
/* If buffer's free memory is < of `size', we have to realloc buffer memory
of buf_size*2, while free memory is enough to contain `size' bytes.
In this case free memory is represented by `buf_size - bytes_recorded' */
unsigned int tot_mem = buf_size, free_mem = buf_size - bytes_received;
if (free_mem < size)
{
//
// Calcs new buffer size.
// TODO: flags for other behaviour?
while ( free_mem < size )
/* Calcs new buffer size */
/* TODO: flags for other behaviour? */
while (free_mem < size)
{
tot_mem *= 2;
free_mem = tot_mem - bytes_received;
}
//
// Resize buffer memory.
//
resize_mem_( tot_mem );
/* Resize buffer memory */
resize_mem_(tot_mem);
}
//
// Now we have enough free space in the
// buffer, so let's copy audio data arrivals.
//
memcpy( audio_data + bytes_received, data, size );
if ( audio_arrival )
audio_arrival( aud_info.samples_in_bytes( size ));
/* Now we have enough free space in the buffer, so let's copy audio data arrivals */
memcpy(audio_data + bytes_received, data, size);
if (audio_arrival)
audio_arrival(aud_info.samples_in_bytes(size));
}
unsigned int
audio_membuffer::read( BYTE * out_buf, unsigned int bytes )
audio_membuffer::read(BYTE *out_buf, unsigned int bytes)
{
//
// Some checking
//
if ( !audio_data )
/* Some checking */
if (!audio_data)
return 0;
if ( bytes_played_ >= bytes_received )
if (bytes_played_ >= bytes_received)
return 0;
unsigned int to_play = bytes_received - bytes_played_;
unsigned int to_copy = bytes > to_play ? to_play : bytes;
/* Copies the audio data out */
if ((out_buf) && (to_copy) && (audio_data))
memcpy(out_buf, audio_data + bytes_played_, to_copy);
unsigned int to_play =
bytes_received - bytes_played_;
unsigned int to_copy =
bytes > to_play ? to_play : bytes;
//
// Copies the audio data out.
//
if (( out_buf ) && ( to_copy ) && ( audio_data ))
memcpy( out_buf, audio_data + bytes_played_, to_copy );
//
// Increments the number of total bytes
// played (audio data gone out from the
// `audio_producer' object).
//
/* Increments the number of total bytes played (audio data gone out from
the `audio_producer' object) */
bytes_played_ += to_copy;
if (audio_arrival)
audio_arrival(aud_info.samples_in_bytes(to_copy));
if ( audio_arrival )
audio_arrival( aud_info.samples_in_bytes( to_copy ));
//
// Returns the exact size of audio data
// produced.
//
/* Returns the exact size of audio data produced */
return to_copy;
}
bool
audio_membuffer::finished( void )
audio_membuffer::finished(void)
{
if ( bytes_played_ < bytes_received )
if (bytes_played_ < bytes_received)
return false;
else
return true;
}
_AUDIO_NAMESPACE_END_

401
reactos/base/applications/sndrec32/audio_membuffer.hpp
View file

@ -5,342 +5,195 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#ifndef _AUDIOMEMBUFFER__H_
#define _AUDIOMEMBUFFER__H_
//#include "audio_def.hpp"
#include "audio_receiver.hpp"
#include "audio_format.hpp"
#include "audio_producer.hpp"
_AUDIO_NAMESPACE_START_
class audio_membuffer : public audio_receiver, public audio_producer
{
protected:
BYTE * audio_data;
audio_format aud_info;
unsigned int buf_size;
unsigned int init_size;
/* Protected Functions */
//
// Protected Functions
//
//allocs N bytes for the audio buffer.
void alloc_mem_( unsigned int );
//frees memory
void free_mem_( void );
//resizes memory, and copies old
//audio data to new-size memory
void resize_mem_( unsigned int );
//truncates and discards unused memory.
//`buf_size' will be the same as `bytes_received'.
void truncate_( void );
/* allocs N bytes for the audio buffer */
void alloc_mem_(unsigned int);
/* frees memory */
void free_mem_(void);
/* resizes memory, and copies old audio data to new-size memory */
void resize_mem_(unsigned int);
/* truncates and discards unused memory. `buf_size' will be the same as `bytes_received' */
void truncate_(void);
public:
void (* audio_arrival)(unsigned int);
void (* buffer_resized)(unsigned int);
void ( * audio_arrival )( unsigned int );
void ( * buffer_resized ) ( unsigned int );
//
// Ctors
//
audio_membuffer( void )
: audio_data( 0 ), aud_info( _AUDIO_DEFAULT_FORMAT ),
buf_size( 0 ), init_size( 0 )
{
//
// Allocs memory for at least 1 or some seconds
// of recording.
//
init_size = ( unsigned int )
(( float )aud_info.byte_rate() * _AUDIO_DEFAULT_BUFSECS );
alloc_mem_( init_size );
/* Ctors */
audio_membuffer(void) : audio_data(0),
aud_info(_AUDIO_DEFAULT_FORMAT),
buf_size(0),
init_size(0)
{
/* Allocs memory for at least 1 or some seconds of recording */
init_size = (unsigned int)((float)aud_info.byte_rate() * _AUDIO_DEFAULT_BUFSECS);
alloc_mem_(init_size);
}
audio_membuffer( audio_format aud_fmt )
: audio_data( 0 ), aud_info( aud_fmt ), buf_size( 0 ),
init_size( 0 )
{
//
// Allocs memory for at least 1 or some seconds
// of recording.
//
init_size = ( unsigned int )
(( float )aud_info.byte_rate() * _AUDIO_DEFAULT_BUFSECS );
alloc_mem_( init_size );
audio_membuffer(audio_format aud_fmt) : audio_data(0),
aud_info(aud_fmt),
buf_size(0),
init_size(0)
{
/* Allocs memory for at least 1 or some seconds of recording */
init_size = (unsigned int)((float)aud_info.byte_rate() * _AUDIO_DEFAULT_BUFSECS);
alloc_mem_(init_size);
}
audio_membuffer( audio_format aud_fmt, unsigned int seconds )
: audio_data( 0 ), aud_info( aud_fmt ), buf_size( 0 ),
init_size( 0 )
{
//
// Allocs memory for audio recording
// the specified number of seconds.
//
audio_membuffer(audio_format aud_fmt, unsigned int seconds) : audio_data(0),
aud_info(aud_fmt),
buf_size(0),
init_size(0)
{
/* Allocs memory for audio recording the specified number of seconds */
init_size = aud_info.byte_rate() * seconds;
alloc_mem_( init_size );
alloc_mem_(init_size);
}
audio_membuffer( audio_format aud_fmt, float seconds )
: audio_data( 0 ), aud_info( aud_fmt ), buf_size( 0 ),
init_size( 0 )
{
//
// Allocs memory for audio recording
// the specified number of seconds.
//
init_size = ( unsigned int )(( float ) aud_info.byte_rate() *
seconds <= 0 ? 1 : seconds );
alloc_mem_( init_size );
audio_membuffer(audio_format aud_fmt, float seconds) : audio_data(0),
aud_info(aud_fmt),
buf_size(0),
init_size(0)
{
/* Allocs memory for audio recording the specified number of seconds */
init_size = (unsigned int)((float)aud_info.byte_rate() * seconds <= 0 ? 1 : seconds);
alloc_mem_(init_size);
}
audio_membuffer( unsigned int bytes )
: audio_data( 0 ), aud_info( _AUDIO_DEFAULT_FORMAT ),
buf_size( 0 ), init_size( 0 )
{
//
// Allocs memory for the specified bytes
//
audio_membuffer(unsigned int bytes) : audio_data(0),
aud_info(_AUDIO_DEFAULT_FORMAT),
buf_size(0),
init_size(0)
{
/* Allocs memory for the specified bytes */
init_size = bytes;
alloc_mem_( init_size );
alloc_mem_(init_size);
}
//
// Dtor
//
virtual ~audio_membuffer( void )
{
//
// Frees memory and reset values.
//
/* Dtor */
virtual ~audio_membuffer(void)
{
/* Frees memory and reset values */
clear();
}
/* Public functions */
//
// Public functions
//
//returns the audio buffer size in bytes.
unsigned int mem_size( void ) const
{ return buf_size; }
//returns how many audio data has been
//received, in bytes.
unsigned int bytes_recorded( void ) const
{ return bytes_received; }
//returns the integer number of seconds
//that the buffer can record
unsigned int seconds_total( void ) const
{ return buf_size / aud_info.byte_rate(); }
//returns the integer number of seconds
//that the buffer can record
unsigned int seconds_recorded( void ) const
{ return bytes_received / aud_info.byte_rate(); }
//returns the float number of seconds
//that the buffer can record
float fseconds_total( void ) const
{ return ( float )(( float ) buf_size /
( float ) aud_info.byte_rate()); }
//returns the float number of seconds
//that has been recorded
float fseconds_recorded( void ) const
{ return ( float )(( float ) bytes_received /
( float ) aud_info.byte_rate()); }
unsigned int total_samples( void ) const
/* returns the audio buffer size in bytes */
unsigned int mem_size(void) const
{
return ( aud_info.samples_in_seconds( fseconds_total() ));
return buf_size;
}
unsigned int samples_received( void ) const
/* returns how many audio data has been received, in bytes */
unsigned int bytes_recorded(void) const
{
return ( aud_info.samples_in_bytes( bytes_received ));
return bytes_received;
}
/* returns the integer number of seconds that the buffer can record */
unsigned int seconds_total(void) const
{
return buf_size / aud_info.byte_rate();
}
/* returns the integer number of seconds that the buffer can record */
unsigned int seconds_recorded(void) const
{
return bytes_received / aud_info.byte_rate();
}
//returns a pointer to the audio buffer
BYTE * audio_buffer( void ) const
{ return audio_data; }
/* returns the float number of seconds that the buffer can record */
float fseconds_total(void) const
{
return (float)((float) buf_size / (float)aud_info.byte_rate());
}
/* returns the float number of seconds that has been recorded */
float fseconds_recorded(void) const
{
return (float)((float)bytes_received / (float)aud_info.byte_rate());
}
unsigned int total_samples(void) const
{
return (aud_info.samples_in_seconds(fseconds_total()));
}
//frees memory and resets values.
void clear( void );
unsigned int samples_received(void) const
{
return (aud_info.samples_in_bytes(bytes_received));
}
/* returns a pointer to the audio buffer */
BYTE * audio_buffer(void) const
{
return audio_data;
}
audio_format & audinfo( void ) { return aud_info; }
/* frees memory and resets values */
void clear(void);
audio_format & audinfo(void)
{
return aud_info;
}
//discard audio data, resets values,
//but, instead of clear() which frees memory,
//reset the memory to the initial size, ready
//for receiving "new" audio data.
void reset( void );
/* discard audio data, resets values, but, instead of clear() which
frees memory, reset the memory to the initial size, ready for
receiving "new" audio data. */
void reset(void);
/* truncates and discards unused memory. `buf_size' will be the same as `bytes_received' */
void truncate(void)
{
truncate_();
} /* TODO: fare truncate N bytes */
//truncates and discards unused memory.
//`buf_size' will be the same as `bytes_received'.
void truncate( void )
{ truncate_( ); }//TODO: fare truncate N bytes
/* if there is a buffer, discards current buffer memory and realloc
a new memory buffer with a new size expressed in bytes. */
void alloc_bytes(unsigned int);
/* if there is a buffer, discards current buffer memory and realloc
a new memory buffer with a new size expressed in seconds, integer and float. */
void alloc_seconds(unsigned int);
void alloc_seconds(float);
//if there is a buffer, discards current buffer
//memory and realloc a new memory buffer with a
//new size expressed in bytes.
void alloc_bytes( unsigned int );
/* resizes in bytes the current buffer, without discarding
previsiously audio data received */
void resize_bytes(unsigned int);
//if there is a buffer, discards current buffer
//memory and realloc a new memory buffer with a
//new size expressed in seconds, integer and float.
void alloc_seconds( unsigned int );
void alloc_seconds( float );
//resizes in bytes the current buffer,
//without discarding previsiously audio data received.
void resize_bytes( unsigned int );
//resizes in seconds the current buffer,
//without discarding previsiously audio data received.
/* resizes in seconds the current buffer, without discarding
previsiously audio data received */
void resize_seconds( unsigned int );
void resize_seconds( float );
/* Inherited Functions from `audio_receiver' */
void audio_receive(unsigned char *, unsigned int);
//
// Inherited Functions from `audio_receiver'
//
void audio_receive( unsigned char *, unsigned int );
//
// Inherited Functions from `audio_buffer'
//
unsigned int read( BYTE *, unsigned int );
bool finished( void );
/* Inherited Functions from `audio_buffer' */
unsigned int read(BYTE *, unsigned int);
bool finished(void);
};
_AUDIO_NAMESPACE_END_
#endif //ifdef _AUDIOMEMBUFFER__H_
#endif /* _AUDIOMEMBUFFER__H_ */

1
reactos/base/applications/sndrec32/audio_producer.cpp
View file

@ -7,4 +7,3 @@
#include "stdafx.h"
#include "audio_producer.hpp"

103
reactos/base/applications/sndrec32/audio_producer.hpp
View file

@ -8,120 +8,61 @@
#ifndef _AUDIOAUDBUF__H_
#define _AUDIOAUDBUF__H_
#include "audio_def.hpp"
//#include "audio_producer.hpp"
_AUDIO_NAMESPACE_START_
class audio_producer
{
protected:
unsigned int bytes_played_;
public:
/* Ctors */
audio_producer() : bytes_played_(0), play_finished(0)
{
}
/* Dtor */
virtual ~audio_producer(void)
{
}
//
// Ctors
//
/* Public Functions */
audio_producer ( ) : bytes_played_( 0 ), play_finished ( 0 )
{ }
/* reads N bytes from the buffer */
virtual unsigned int read(BYTE *, unsigned int) = 0;
virtual bool finished(void) = 0;
//
// Dtor
//
virtual ~audio_producer( void )
{ }
//
// Public Functions
//
//reads N bytes from the buffer
virtual unsigned int read( BYTE *, unsigned int ) = 0;
virtual bool finished ( void ) = 0;
unsigned int bytes_played( void ) const
unsigned int bytes_played(void) const
{
return bytes_played_;
}
void set_position( unsigned int pos )
void set_position(unsigned int pos)
{
bytes_played_ = pos;
}
void set_position_start( void )
void set_position_start(void)
{
bytes_played_ = 0 ;
bytes_played_ = 0;
}
void forward( unsigned int bytes )
void forward(unsigned int bytes)
{
bytes_played_ += bytes ;
bytes_played_ += bytes;
}
void backward( unsigned int bytes )
void backward(unsigned int bytes)
{
bytes_played_ += bytes ;
bytes_played_ += bytes;
}
void ( * play_finished )( void );
void (* play_finished)(void);
};
_AUDIO_NAMESPACE_END_
#endif //ifdef _AUDIOAUDBUF__H_
#endif /* _AUDIOAUDBUF__H_ */

98
reactos/base/applications/sndrec32/audio_receiver.hpp
View file

@ -5,104 +5,44 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#ifndef _AUDIORECEIVER_DEF__H_
#define _AUDIORECEIVER_DEF__H_
#include "audio_def.hpp"
_AUDIO_NAMESPACE_START_
class audio_receiver
{
//
// The `audio_wavein' class, while is
// recording audio, has to access to
// protected members of `audio_receiver'
// such as `bytes_received' protected
// variable.
//
friend class audio_wavein;
/* The `audio_wavein' class, while is recording audio, has to access to
protected members of `audio_receiver' such as `bytes_received'
protected variable */
friend class audio_wavein;
protected:
unsigned int bytes_received;
public:
//
// Ctors
//
/* Ctors */
audio_receiver(void) : bytes_received(0)
{
}
audio_receiver( void )
: bytes_received( 0 )
{ }
/* Dtor */
virtual ~audio_receiver(void)
{
}
/* Public Functions */
virtual void audio_receive(unsigned char *, unsigned int) = 0;
//
// Dtor
//
virtual ~audio_receiver( void )
{ }
//
// Public Functions
//
virtual void audio_receive( unsigned char *, unsigned int ) = 0;
void set_b_received( unsigned int r )
{ bytes_received = r; }
void set_b_received(unsigned int r)
{
bytes_received = r;
}
};
_AUDIO_NAMESPACE_END_
#endif //ifdef _AUDIORECEIVER_DEF__H_
#endif /* _AUDIORECEIVER_DEF__H_ */

373
reactos/base/applications/sndrec32/audio_resampler_acm.cpp
View file

@ -5,403 +5,206 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#include "stdafx.h"
#include "audio_resampler_acm.hpp"
//#include <stdio.h>
_AUDIO_NAMESPACE_START_
/////////////////////////////////////////
/////// Private Functions ////////
/////////////////////////////////////////
/* Private Functions */
void
audio_resampler_acm::init_( void )
audio_resampler_acm::init_(void)
{
/* Zeroing structures */
ZeroMemory(&acm_header, sizeof(ACMSTREAMHEADER));
ZeroMemory(&wformat_src, sizeof(WAVEFORMATEX));
ZeroMemory(&wformat_dst, sizeof(WAVEFORMATEX));
/* Setting structures sizes */
acm_header.cbStruct = sizeof(ACMSTREAMHEADER);
wformat_src.cbSize = sizeof(WAVEFORMATEX);
wformat_dst.cbSize = sizeof(WAVEFORMATEX);
//
// Zeroing structures
//
ZeroMemory( &acm_header, sizeof( ACMSTREAMHEADER ));
ZeroMemory( &wformat_src, sizeof( WAVEFORMATEX ));
ZeroMemory( &wformat_dst, sizeof( WAVEFORMATEX ));
//
// Setting structures sizes
//
acm_header.cbStruct = sizeof( ACMSTREAMHEADER );
wformat_src.cbSize = sizeof( WAVEFORMATEX );
wformat_dst.cbSize = sizeof( WAVEFORMATEX );
//
// Setting WAVEFORMATEX structure parameters
// according to `audio_format' in/out classes
//
/* Setting WAVEFORMATEX structure parameters
according to `audio_format' in/out classes */
wformat_src.wFormatTag = WAVE_FORMAT_PCM;
wformat_src.nSamplesPerSec = audfmt_in.sample_rate();
wformat_src.nChannels = audfmt_in.channels();
wformat_src.wBitsPerSample = audfmt_in.bits();
wformat_src.nAvgBytesPerSec = audfmt_in.byte_rate();
wformat_src.nAvgBytesPerSec = audfmt_in.byte_rate();
wformat_src.nBlockAlign = audfmt_in.block_align();
wformat_dst.wFormatTag = WAVE_FORMAT_PCM;
wformat_dst.nSamplesPerSec = audfmt_out.sample_rate();
wformat_dst.nChannels = audfmt_out.channels();
wformat_dst.wBitsPerSample = audfmt_out.bits();
wformat_dst.nAvgBytesPerSec = audfmt_out.byte_rate();
wformat_dst.nAvgBytesPerSec = audfmt_out.byte_rate();
wformat_dst.nBlockAlign = audfmt_out.block_align();
//
// Init acm structures completed successfull
//
/* Init acm structures completed successfull */
}
/////////////////////////////////////////
/////// Public Functions ////////
/////////////////////////////////////////
/* Public Functions */
void
audio_resampler_acm::open( void )
audio_resampler_acm::open(void)
{
MMRESULT err;
/* Opens ACM stream */
err = acmStreamOpen(&acm_stream,
0,
&wformat_src,
&wformat_dst,
0, 0, 0,
ACM_STREAMOPENF_NONREALTIME);
//
// Opens ACM stream
//
err = acmStreamOpen( &acm_stream, 0, &wformat_src, &wformat_dst,
0, 0, 0, ACM_STREAMOPENF_NONREALTIME );
if ( err != MMSYSERR_NOERROR )
if (err != MMSYSERR_NOERROR)
{
//TODO: throw error
MessageBox( 0, _T("acmOpen error: %i"), _T("ERROR"), MB_ICONERROR );
/* TODO: throw error */
MessageBox(0, _T("acmOpen error: %i"), _T("ERROR"), MB_ICONERROR);
}
/* Calcs source buffer length */
src_buflen = (unsigned int)((float)audfmt_in.byte_rate() * (float)buf_secs);
/* Calcs destination source buffer length with help of ACM apis */
err = acmStreamSize(acm_stream,
src_buflen,
&dst_buflen,
ACM_STREAMSIZEF_SOURCE);
//
// Calcs source buffer length
//
src_buflen = ( unsigned int )
(( float )audfmt_in.byte_rate() * ( float )buf_secs );
//
// Calcs destination source buffer length
// with help of ACM apis
//
err = acmStreamSize( acm_stream,
src_buflen, &dst_buflen, ACM_STREAMSIZEF_SOURCE );
if ( err != MMSYSERR_NOERROR )
if (err != MMSYSERR_NOERROR)
{
//TODO: throw error
MessageBox( 0, _T("acmStreamSize error"), _T("ERROR"), MB_ICONERROR );
/* TODO: throw error */
MessageBox(0, _T("acmStreamSize error"), _T("ERROR"), MB_ICONERROR);
}
//
// Initialize ACMSTREAMHEADER structure,
// and alloc memory for source and destination
// buffers.
//
/* Initialize ACMSTREAMHEADER structure,
and alloc memory for source and destination buffers */
acm_header.fdwStatus = 0;
acm_header.dwUser = 0;
acm_header.pbSrc = ( LPBYTE ) new BYTE [ src_buflen ];
acm_header.pbSrc = (LPBYTE) new BYTE[src_buflen];
acm_header.cbSrcLength = src_buflen;
acm_header.cbSrcLengthUsed = 0;
acm_header.dwSrcUser = src_buflen;
acm_header.pbDst = ( LPBYTE ) new BYTE [ dst_buflen ];
acm_header.pbDst = (LPBYTE) new BYTE[dst_buflen];
acm_header.cbDstLength = dst_buflen;
acm_header.cbDstLengthUsed = 0;
acm_header.dwDstUser = dst_buflen;
//
// Give ACMSTREAMHEADER initialized correctly to the
// driver.
//
err = acmStreamPrepareHeader( acm_stream, &acm_header, 0L );
if ( err != MMSYSERR_NOERROR )
/* Give ACMSTREAMHEADER initialized correctly to the driver */
err = acmStreamPrepareHeader(acm_stream, &acm_header, 0L);
if (err != MMSYSERR_NOERROR)
{
//TODO: throw error
MessageBox( 0, _T("acmStreamPrepareHeader error"), _T("ERROR"), MB_ICONERROR );
/* TODO: throw error */
MessageBox(0, _T("acmStreamPrepareHeader error"), _T("ERROR"), MB_ICONERROR);
}
//
// ACM stream successfully opened.
//
/* ACM stream successfully opened */
stream_opened = true;
}
void
audio_resampler_acm::close( void )
audio_resampler_acm::close(void)
{
MMRESULT err;
if ( acm_stream )
if (acm_stream)
{
if ( acm_header.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED )
if (acm_header.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED)
{
acm_header.cbSrcLength = src_buflen;
acm_header.cbDstLength = dst_buflen;
err = acmStreamUnprepareHeader( acm_stream, &acm_header, 0L );
if ( err != MMSYSERR_NOERROR )
err = acmStreamUnprepareHeader(acm_stream, &acm_header, 0L);
if (err != MMSYSERR_NOERROR)
{
//
// Free buffer memory
//
if ( acm_header.pbSrc != 0 )
/* Free buffer memory */
if (acm_header.pbSrc != 0)
delete[] acm_header.pbSrc;
if ( acm_header.pbDst != 0 )
if (acm_header.pbDst != 0)
delete[] acm_header.pbDst;
//
// Re-init structures
//
/* Re-init structures */
init_();
//
// Updating status
//
/* Updating status */
stream_opened = false;
//TODO: throw error
MessageBox( 0, _T("acmStreamUnPrepareHeader error"), _T("ERROR"), MB_ICONERROR );
/* TODO: throw error */
MessageBox(0, _T("acmStreamUnPrepareHeader error"), _T("ERROR"), MB_ICONERROR);
}
}
err = acmStreamClose( acm_stream, 0 );
err = acmStreamClose(acm_stream, 0);
acm_stream = 0;
if ( err != MMSYSERR_NOERROR )
if (err != MMSYSERR_NOERROR)
{
//
// Free buffer memory
//
if ( acm_header.pbSrc != 0 )
/* Free buffer memory */
if (acm_header.pbSrc != 0)
delete[] acm_header.pbSrc;
if ( acm_header.pbDst != 0 )
if (acm_header.pbDst != 0)
delete[] acm_header.pbDst;
//
// Re-init structures
//
/* Re-init structures */
init_();
//
// Updating status
//
/* Updating status */
stream_opened = false;
//TODO: throw error!
MessageBox( 0, _T("acmStreamClose error"), _T("ERROR"), MB_ICONERROR );
/* TODO: throw error! */
MessageBox(0, _T("acmStreamClose error"), _T("ERROR"), MB_ICONERROR);
}
} /* if acm_stream != 0 */
}//if acm_stream != 0
//
// Free buffer memory
//
if ( acm_header.pbSrc != 0 )
/* Free buffer memory */
if (acm_header.pbSrc != 0)
delete[] acm_header.pbSrc;
if ( acm_header.pbDst != 0 )
if (acm_header.pbDst != 0)
delete[] acm_header.pbDst;
//
// Re-init structures
//
/* Re-init structures */
init_();
//
// Updating status
//
/* Updating status */
stream_opened = false;
//
// ACM sream successfully closed.
//
/* ACM sream successfully closed */
}
void
audio_resampler_acm::audio_receive( unsigned char * data, unsigned int size )
audio_resampler_acm::audio_receive(unsigned char *data, unsigned int size)
{
MMRESULT err;
//
// Checking for acm stream opened
//
if ( stream_opened )
/* Checking for acm stream opened */
if (stream_opened)
{
//
// Copy audio data from extern to
// internal source buffer
//
memcpy( acm_header.pbSrc, data, size );
/* Copy audio data from extern to internal source buffer */
memcpy(acm_header.pbSrc, data, size);
acm_header.cbSrcLength = size;
acm_header.cbDstLengthUsed = 0;
err = acmStreamConvert( acm_stream, &acm_header, ACM_STREAMCONVERTF_BLOCKALIGN );
err = acmStreamConvert(acm_stream, &acm_header, ACM_STREAMCONVERTF_BLOCKALIGN);
if ( err != MMSYSERR_NOERROR )
if (err != MMSYSERR_NOERROR)
{
//TODO: throw error
MessageBox( 0, _T("acmStreamConvert error"), _T("ERROR"), MB_ICONERROR );
/* TODO: throw error */
MessageBox(0, _T("acmStreamConvert error"), _T("ERROR"), MB_ICONERROR);
}
/* Wait for sound conversion */
while ((ACMSTREAMHEADER_STATUSF_DONE & acm_header.fdwStatus) == 0);
//
// Wait for sound conversion
//
while(( ACMSTREAMHEADER_STATUSF_DONE & acm_header.fdwStatus ) == 0 );
//
// Copy resampled audio, to destination buffer.
//
//memcpy( pbOutputData, acm_header.pbDst, acm_header.cbDstLengthUsed );
/* Copy resampled audio, to destination buffer */
//memcpy(pbOutputData, acm_header.pbDst, acm_header.cbDstLengthUsed);
}
}
_AUDIO_NAMESPACE_END_

85
reactos/base/applications/sndrec32/audio_resampler_acm.hpp
View file

@ -5,34 +5,21 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#ifndef _AUDIORESAMPLERACM__H_
#define _AUDIORESAMPLERACM__H_
//#include "audio_def.hpp"
#include "audio_receiver.hpp"
#include "audio_format.hpp"
_AUDIO_NAMESPACE_START_
//TODO: inherit from a base resampler?
/* TODO: inherit from a base resampler? */
class audio_resampler_acm : public audio_receiver
{
private:
void init_( void );
void init_(void);
protected:
HACMSTREAM acm_stream;
ACMSTREAMHEADER acm_header;
DWORD src_buflen;
@ -47,61 +34,31 @@ class audio_resampler_acm : public audio_receiver
WAVEFORMATEX wformat_src;
WAVEFORMATEX wformat_dst;
public:
//
// Ctors
//
audio_resampler_acm( audio_format fmt_in, audio_format fmt_out )
: acm_stream( 0 ), src_buflen( 0 ), dst_buflen( 0 ),
stream_opened( false ), audfmt_in( fmt_in ), audfmt_out( fmt_out ),
buf_secs( _AUDIO_DEFAULT_BUFSECS )
{
/* Ctors */
audio_resampler_acm(audio_format fmt_in,
audio_format fmt_out) : acm_stream(0),
src_buflen(0),
dst_buflen(0),
stream_opened(false),
audfmt_in(fmt_in),
audfmt_out(fmt_out),
buf_secs(_AUDIO_DEFAULT_BUFSECS)
{
init_();
}
/* Dtor */
~audio_resampler_acm(void)
{
}
//
// Dtor
//
~audio_resampler_acm( void )
{ }
//
// Public functions
//
void open( void );
void close( void );
void audio_receive( unsigned char *, unsigned int );
/* Public functions */
void open(void);
void close(void);
void audio_receive(unsigned char *, unsigned int);
};
_AUDIO_NAMESPACE_END_
#endif //ifdef _AUDIORESAMPLERACM_H_
#endif /* _AUDIORESAMPLERACM__H_ */

872
reactos/base/applications/sndrec32/audio_wavein.cpp
View file

File diff suppressed because it is too large Load diff

335
reactos/base/applications/sndrec32/audio_wavein.hpp
View file

@ -5,324 +5,189 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#ifndef _AUDIOWAVEIN_H_
#define _AUDIOWAVEIN_H_
//#include "audio_def.hpp"
#include "audio_format.hpp"
#include "audio_receiver.hpp"
_AUDIO_NAMESPACE_START_
enum audio_wavein_status { WAVEIN_NOTREADY, WAVEIN_READY,
WAVEIN_RECORDING, WAVEIN_ERR,
WAVEIN_STOP, WAVEIN_FLUSHING
};
enum audio_wavein_status
{
WAVEIN_NOTREADY,
WAVEIN_READY,
WAVEIN_RECORDING,
WAVEIN_ERR,
WAVEIN_STOP,
WAVEIN_FLUSHING
};
class audio_wavein
{
private:
/* The new recording thread sends message to this procedure
about open recording, close, and sound data recorded */
static DWORD WINAPI recording_procedure(LPVOID);
//
// The new recording thread sends message to this procedure
// about open recording, close, and sound data recorded
//
static DWORD WINAPI recording_procedure( LPVOID );
//
// When this event is signaled, then the previsiously created
// recording thread will wake up and start recording audio
// and will pass audio data to an `audio_receiver' object.
//
/* When this event is signaled, then the previsiously created
recording thread will wake up and start recording audio
and will pass audio data to an `audio_receiver' object. */
HANDLE wakeup_recthread;
HANDLE data_flushed_event;
protected:
/* TODO: puts these structs in private?! */
//TODO: puts these structs in private?!
//
// Audio wavein device stuff
//
WAVEFORMATEX wave_format;
WAVEHDR * wave_headers;
HWAVEIN wavein_handle;
/* Audio wavein device stuff */
WAVEFORMATEX wave_format;
WAVEHDR *wave_headers;
HWAVEIN wavein_handle;
audio_format aud_info;
audio_receiver & audio_rcvd;
audio_receiver &audio_rcvd;
/* Audio Recorder Thread id */
DWORD recthread_id;
//
// Audio Recorder Thread id
//
DWORD recthread_id;
//
// Object status
//
/* Object status */
audio_wavein_status status;
//
// How many seconds of audio
// can record the internal buffer
// before flushing audio data
// to the `audio_receiver' class?
//
/* How many seconds of audio can record the internal buffer before
flushing audio data to the `audio_receiver' class? */
float buf_secs;
//
// The temporary buffers for the audio
// data incoming from the wavein device
// and its size, and its total number.
//
BYTE * main_buffer;
/* The temporary buffers for the audio data incoming from the wavein
device and its size, and its total number */
BYTE *main_buffer;
unsigned int mb_size;
unsigned int buffers;
/* Protected Functions */
/* initialize all structures and variables */
void init_(void);
void alloc_buffers_mem_(unsigned int, float);
void free_buffers_mem_(void);
//
// Protected Functions
//
//initialize all structures and variables.
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 );
void init_headers_(void);
void prep_headers_(void);
void unprep_headers_(void);
void add_buffers_to_driver_(void);
public:
//
// Ctors
//
audio_wavein(
const audio_format & a_info, audio_receiver & a_receiver )
: wave_headers( 0 ),
aud_info( a_info ), audio_rcvd( a_receiver ),
status( WAVEIN_NOTREADY ), main_buffer( 0 ), mb_size( 0 ),
buffers( _AUDIO_DEFAULT_WAVEINBUFFERS )
/* Ctors */
audio_wavein(const audio_format &a_info,
audio_receiver &a_receiver) : 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
//
/* Initializing internal wavein data */
init_();
aud_info = a_info;
}
//
// Dtor
//
~audio_wavein( void )
/* Dtor */
~audio_wavein(void)
{
//close(); TODO!
}
/* Public functions */
void open(void);
void close(void);
//
// Public functions
//
void start_recording(void);
void stop_recording(void);
void open( void );
void close ( void );
void start_recording( void );
void stop_recording( void );
audio_wavein_status current_status ( void ) const
audio_wavein_status current_status (void) const
{
return status;
}
float buffer_secs( void ) const
{ return buf_secs; }
float buffer_secs(void) const
{
return buf_secs;
}
void buffer_secs( float bsecs )
{
//
// Some checking
//
if ( bsecs <= 0 )
void buffer_secs(float bsecs)
{
/* Some checking */
if (bsecs <= 0)
return;
//
// Set seconds length for each
// buffer.
//
/* Set seconds length for each buffer */
buf_secs = bsecs;
}
unsigned int total_buffers( void ) const
{ return buffers; }
void total_buffers( unsigned int tot_bufs )
unsigned int total_buffers(void) const
{
return buffers;
}
//
// Some checking
//
if ( tot_bufs == 0 )
void total_buffers(unsigned int tot_bufs)
{
/* Some checking */
if (tot_bufs == 0)
return;
//
// Sets the number of total buffers.
//
/* Sets the number of total buffers */
buffers = tot_bufs;
}
audio_format format( void ) const
{ return aud_info; }
BYTE * buf( void ) { return main_buffer; }
unsigned int bufsz( void ) { return mb_size; }
unsigned int samplevalue_max( void )
audio_format format(void) const
{
return aud_info;
}
if ( aud_info.bits() == 16 )
return (unsigned int )65535;
BYTE *buf(void)
{
return main_buffer;
}
else if ( aud_info.bits() == 8 )
unsigned int bufsz(void)
{
return mb_size;
}
unsigned int samplevalue_max(void)
{
if (aud_info.bits() == 16)
return (unsigned int)65535;
else if (aud_info.bits() == 8)
return (unsigned int)255;
else
else
return 0;
}
unsigned tot_samples_buf( void )
unsigned tot_samples_buf(void)
{
return aud_info.samples_in_bytes( mb_size );
return aud_info.samples_in_bytes(mb_size);
}
unsigned int nsample ( unsigned int nsamp )
unsigned int nsample(unsigned int nsamp)
{
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 )));
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;
}
};
_AUDIO_NAMESPACE_END_
#endif //ifdef _AUDIOWAVEIN_H_
#endif /* _AUDIOWAVEIN_H_ */

1012
reactos/base/applications/sndrec32/audio_waveout.cpp
View file

File diff suppressed because it is too large Load diff

263
reactos/base/applications/sndrec32/audio_waveout.hpp
View file

@ -5,247 +5,142 @@
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#ifndef _AUDIOWAVEOUT__H_
#define _AUDIOWAVEOUT__H_
//#include "audio_def.hpp"
#include "audio_format.hpp"
#include "audio_producer.hpp"
_AUDIO_NAMESPACE_START_
enum audio_waveout_status { WAVEOUT_NOTREADY, WAVEOUT_READY,
WAVEOUT_PLAYING, WAVEOUT_FLUSHING,
WAVEOUT_PAUSED, WAVEOUT_STOP,
WAVEOUT_ERR,
};
enum audio_waveout_status
{
WAVEOUT_NOTREADY,
WAVEOUT_READY,
WAVEOUT_PLAYING,
WAVEOUT_FLUSHING,
WAVEOUT_PAUSED,
WAVEOUT_STOP,
WAVEOUT_ERR
};
class audio_waveout
{
friend class audio_buffer;
private:
static DWORD WINAPI
playing_procedure( LPVOID );
static DWORD WINAPI playing_procedure(LPVOID);
HANDLE wakeup_playthread;
protected:
WAVEFORMATEX wave_format;
WAVEHDR *wave_headers;
HWAVEOUT waveout_handle;
WAVEFORMATEX wave_format;
WAVEHDR * wave_headers;
HWAVEOUT waveout_handle;
const audio_format & aud_info;
audio_producer & audio_buf;
//
// Audio Playing Thread id
//
DWORD playthread_id;
const audio_format &aud_info;
audio_producer &audio_buf;
/* Audio Playing Thread id */
DWORD playthread_id;
audio_waveout_status status;
float buf_secs;
/* The temporary buffers for the audio data outgoing to the waveout
device and its size, and its total number */
/* base address for entire memory */
BYTE *main_buffer;
//
// The temporary buffers for the audio
// data outgoing to the waveout device
// and its size, and its total number.
//
//base address for entire memory
BYTE * main_buffer;
//size in bytes for the entire memory
/* size in bytes for the entire memory */
unsigned int mb_size;
//number of little buffers
/* number of little buffers */
unsigned int buffers;
/* Protected Functions */
//
// Protected 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 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);
public:
//
// Ctors
//
audio_waveout( const audio_format & aud_fmt,
audio_producer & a_buf )
: wave_headers( 0 ), aud_info( aud_fmt ),
audio_buf( a_buf ), status( WAVEOUT_NOTREADY ),
main_buffer( 0 ), mb_size( 0 ),
buffers( _AUDIO_DEFAULT_WAVEOUTBUFFERS )
/* Ctors */
audio_waveout(const audio_format &aud_fmt,
audio_producer &a_buf) : 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
//
/* Initializing internal wavein data */
init_();
}
//
// Dtor
//
~audio_waveout( void )
{ }
//
// Public Functions
//
void open ( void );
void play ( void );
void pause ( void );
void stop ( void );
void close ( void );
audio_waveout_status current_status( void )
{ return status; }
BYTE * buf( void ) { return main_buffer; }
unsigned int bufsz( void ) { return mb_size; }
unsigned int samplevalue_max( void )
/* Dtor */
~audio_waveout(void)
{
}
if ( aud_info.bits() == 16 )
return (unsigned int )65535;
/* Public Functions */
else if ( aud_info.bits() == 8 )
void open(void);
void play(void);
void pause(void);
void stop(void);
void close(void);
audio_waveout_status current_status(void)
{
return status;
}
BYTE *buf(void)
{
return main_buffer;
}
unsigned int bufsz(void)
{
return mb_size;
}
unsigned int samplevalue_max(void)
{
if (aud_info.bits() == 16)
return (unsigned int)65535;
else if (aud_info.bits() == 8)
return (unsigned int)255;
else
return 0;
}
unsigned tot_samples_buf( void )
unsigned tot_samples_buf(void)
{
return aud_info.samples_in_bytes( mb_size );
return aud_info.samples_in_bytes(mb_size);
}
unsigned int nsample ( unsigned int nsamp )
unsigned int nsample(unsigned int nsamp)
{
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 )));
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;
}
};
_AUDIO_NAMESPACE_END_
#endif //ifdef _AUDIOWAVEOUT__H_
#endif /* _AUDIOWAVEOUT__H_ */

2
reactos/base/applications/sndrec32/kkaudio.hpp
View file

@ -10,4 +10,4 @@
#include "audio_producer.hpp"
#include "audio_receiver.hpp"
#endif //ifdef _KKAUDIO__H_
#endif /* _AUDIO__H_ */

1905
reactos/base/applications/sndrec32/sndrec32.cpp
View file

File diff suppressed because it is too large Load diff

82
reactos/base/applications/sndrec32/sndrec32.h
View file

@ -30,55 +30,48 @@
#define BUTTONS_H 30
#define BUTTONS_W 60
#define BUTTONS_CY 100
#define BUTTONS_CX ( CONTROLS_CX )
#define BUTTONS_CX (CONTROLS_CX)
#define BUTTONS_SPACE 5
#define SLIDER_CX CONTROLS_CX
#define SLIDER_CY 65
#define SLIDER_H 30
#define SLIDER_W 320
#define STRPOS_X 240
#define STRPOS_Y 5
#define STRDUR_X ( STRPOS_X )
#define STRDUR_Y ( STRPOS_Y + 13 )
#define STRBUF_X ( STRDUR_X )
#define STRBUF_Y ( STRDUR_Y + 13 )
#define STRDUR_X (STRPOS_X)
#define STRDUR_Y (STRPOS_Y + 13)
#define STRBUF_X (STRDUR_X)
#define STRBUF_Y (STRDUR_Y + 13)
#define STRFMT_X 10
#define STRFMT_Y ( STRPOS_Y )
#define STRFMT_Y (STRPOS_Y)
#define STRCHAN_X ( STRFMT_X )
#define STRCHAN_Y ( STRFMT_Y + 13 )
#define STRCHAN_X (STRFMT_X)
#define STRCHAN_Y (STRFMT_Y + 13)
#define WAVEBAR_X ( CONTROLS_CX + 90 )
#define WAVEBAR_Y ( STRPOS_Y )
#define WAVEBAR_X (CONTROLS_CX + 90)
#define WAVEBAR_Y (STRPOS_Y)
#define WAVEBAR_CX 130
#define WAVEBAR_CY 50
#define WAVEBAR_TIMERID 2
#define WAVEBAR_TIMERTIME 80
#define WAVEBAR_COLOR ( RGB( 0, 0, 255 ))
#define WAVEBAR_COLOR (RGB(0, 0, 255))
#define REFRESHA_X ( STRPOS_X )
#define REFRESHA_Y ( STRPOS_Y )
#define REFRESHA_CX ( REFRESHA_X + 100 )
#define REFRESHA_CY ( REFRESHA_Y + 55 )
#define REFRESHB_X ( STRFMT_X )
#define REFRESHB_Y ( STRFMT_Y )
#define REFRESHB_CX ( REFRESHB_X + 85 )
#define REFRESHB_CY ( REFRESHB_Y + 55 )
#define REFRESHA_X (STRPOS_X)
#define REFRESHA_Y (STRPOS_Y)
#define REFRESHA_CX (REFRESHA_X + 100)
#define REFRESHA_CY (REFRESHA_Y + 55)
#define REFRESHB_X (STRFMT_X)
#define REFRESHB_Y (STRFMT_Y)
#define REFRESHB_CX (REFRESHB_X + 85)
#define REFRESHB_CY (REFRESHB_Y + 55)
struct riff_hdr
{
@ -87,10 +80,8 @@ struct riff_hdr
DWORD format;
};
struct wave_hdr
{
DWORD Subchunkid;
DWORD Subchunk1Size;
WORD AudioFormat;
@ -108,32 +99,15 @@ struct data_chunk
//unsigned char data[];
};
/* Functions prototypes */
LRESULT CALLBACK Buttons_proc(HWND, UINT, WPARAM, LPARAM);
//
// Functions prototypes
//
LRESULT CALLBACK
Buttons_proc(HWND, UINT, WPARAM, LPARAM);
BOOL write_wav(TCHAR *);
BOOL open_wav(TCHAR *);
VOID enable_but(DWORD);
VOID disable_but(DWORD);
BOOL
write_wav( TCHAR * );
BOOL
open_wav( TCHAR * );
VOID enable_but( DWORD );
VOID disable_but( DWORD );
void
l_play_finished ( void );
void
l_audio_arrival ( unsigned int );
void
l_buffer_resized ( unsigned int );
void l_play_finished(void);
void l_audio_arrival(unsigned int);
void l_buffer_resized(unsigned int);

4
reactos/base/applications/sndrec32/stdafx.h
View file

@ -3,9 +3,9 @@
//#include "targetver.h"
#ifdef _UNICODE
#define _sntprintf_s _snwprintf_s
#define _sntprintf_s _snwprintf_s
#else
#define _sntprintf_s _snprintf_s
#define _sntprintf_s _snprintf_s
#endif
#define WIN32_NO_STATUS

6
reactos/base/applications/sndrec32/targetver.h
View file

@ -7,11 +7,11 @@
#pragma once
#ifndef WINVER
#define WINVER 0x0600
#ifndef WINVER
#define WINVER 0x0600
#endif
#ifndef _WIN32_WINNT
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif