## Important Files and Folders:
include/portaudio.h = header file for PortAudio API. Specifies API.
- src/common/ = platform independant code, host independant
+ src/common/ = platform independent code, host independent
code for all implementations.
src/os = os specific (but host api neutral) code
src/hostapi = implementations for different host apis
test/patest_record.c = record and playback some audio
test/patest_maxsines.c = how many sine waves can we play? Tests Pa_GetCPULoad().
test/patest_sine.c = output a sine wave in a simple PA app
- test/patest_sync.c = test syncronization of audio and video
+ test/patest_sync.c = test synchronization of audio and video
test/patest_wire.c = pass input to output, wire simulator
Copyright (C) 2011 Free Software Foundation, Inc.
This config.lt script is free software; the Free Software Foundation
-gives unlimited permision to copy, distribute and modify it."
+gives unlimited permission to copy, distribute and modify it."
while test $[#] != 0
do
# to PKG_CHECK_MODULES(), but does not set variables or print errors.
#
# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
-# only at the first occurence in configure.ac, so if the first place
+# only at the first occurrence in configure.ac, so if the first place
# it's called might be skipped (such as if it is within an "if", you
# have to call PKG_CHECK_EXISTS manually
# --------------------------------------------------------------
mblaauw:
- Changed some exception handling code in HostApi's constructor.
- - Added accessors to PortAudio PaStream from PortAudioCpp Stream (their absense being pointed out
+ - Added accessors to PortAudio PaStream from PortAudioCpp Stream (their absence being pointed out
by Tom Jordan).
- Fixed a bug/typo in MemFunToCallbackInterfaceAdapter::init() thanks to Fredrik Viklund.
- Fixed issue with concrete Stream classes possibly throwing an exception and fixed documentation w.r.t. this.
the std::exception base class's what() member function (which had throw(), i.e. no-throw guarantee).
- Changed the iterators so that they have a set of public typedefs instead of deriving the C++ standard
library std::iterator<> struct. G++ 2.95 doesn't support std::exception<> and composition-by-aggregation
- is prefered over composition-by-inheritance in this case.
+ is preferred over composition-by-inheritance in this case.
- Changed some minor things to avoid G++ warning messages.
mblaauw:
- Renamed this file (/WHATSNEW.txt) to /CHANGELOG.
- Renamed /PA_ISSUES.txt to /PA_ISSUES.
- Added /INSTALL file with some build info for GNU/Linux and VC6.
- - Added MSVC 6.0 projects for building PortAudioCpp as a staticly or dynamically linkable library.
+ - Added MSVC 6.0 projects for building PortAudioCpp as a statically or dynamically linkable library.
- Moved build files to /build/(gnu/ or vc6/).
- Moved Doxygen configuration files to /doc/ and output to /doc/api_reference/.
- Added a /doc/README with some info how to generate Doxygen documentation.
mblaauw:
- Changed some things in SingleDirectionStreamParameters to ease it's usage.
- Placed all SingleDirectionStreamParameters stuff into a separate file.
- + Totally redid the callback stuff, now it's less ackward and supports C++ functions.
+ + Totally redid the callback stuff, now it's less awkward and supports C++ functions.
PortAudioCpp v19 revision 08 03/06/20:
Copyright (C) 2011 Free Software Foundation, Inc.
This config.lt script is free software; the Free Software Foundation
-gives unlimited permision to copy, distribute and modify it."
+gives unlimited permission to copy, distribute and modify it."
while test $[#] != 0
do
}
catch (const portaudio::PaException &e)
{
- std::cout << "A PortAudio error occured: " << e.paErrorText() << std::endl;
+ std::cout << "A PortAudio error occurred: " << e.paErrorText() << std::endl;
}
catch (const portaudio::PaCppException &e)
{
- std::cout << "A PortAudioCpp error occured: " << e.what() << std::endl;
+ std::cout << "A PortAudioCpp error occurred: " << e.what() << std::endl;
}
catch (const std::exception &e)
{
- std::cout << "A generic exception occured: " << e.what() << std::endl;
+ std::cout << "A generic exception occurred: " << e.what() << std::endl;
}
catch (...)
{
- std::cout << "An unknown exception occured." << std::endl;
+ std::cout << "An unknown exception occurred." << std::endl;
}
return 0;
}
catch (const portaudio::PaException &e)
{
- std::cout << "A PortAudio error occured: " << e.paErrorText() << std::endl;
+ std::cout << "A PortAudio error occurred: " << e.paErrorText() << std::endl;
}
catch (const portaudio::PaCppException &e)
{
- std::cout << "A PortAudioCpp error occured: " << e.what() << std::endl;
+ std::cout << "A PortAudioCpp error occurred: " << e.what() << std::endl;
}
catch (const std::exception &e)
{
- std::cout << "A generic exception occured: " << e.what() << std::endl;
+ std::cout << "A generic exception occurred: " << e.what() << std::endl;
}
catch (...)
{
- std::cout << "An unknown exception occured." << std::endl;
+ std::cout << "An unknown exception occurred." << std::endl;
}
return 0;
//////
/// @brief Adapts the given Device to an ASIO specific extension.
///
- /// Deleting the AsioDeviceAdapter does not affect the underlaying
+ /// Deleting the AsioDeviceAdapter does not affect the underlying
/// Device.
//////
class AsioDeviceAdapter
{
public:
// query info: name, max in channels, max out channels,
- // default low/hight input/output latency, default sample rate
+ // default low/high input/output latency, default sample rate
PaDeviceIndex index() const;
const char *name() const;
int maxInputChannels() const;
/// other code.
///
/// To know what exceptions each function may throw, look up
- /// the errors that can occure in the PortAudio documentation
+ /// the errors that can occur in the PortAudio documentation
/// for the equivalent functions.
///
/// Some functions are likely to throw an exception (such as
/// A single System can support multiple HostApi's each one typically having
/// a set of Devices using that HostApi (usually driver type). All Devices in
/// the HostApi can be enumerated and the default input/output Device for this
- /// HostApi can be retreived.
+ /// HostApi can be retrieved.
//////
class HostApi
{
/// Other platforms should be easily supported as PortAudioCpp is platform-independent and (reasonably) C++ standard compliant.
/// </p>
/// <p>
-/// This documentation mainly provides information specific to PortAudioCpp. For a more complete explaination of all of the
+/// This documentation mainly provides information specific to PortAudioCpp. For a more complete explanation of all of the
/// concepts used, please consult the PortAudio documentation.
/// </p>
/// <p>
/// clients need to explicitly call close() to ensure the stream closed successfully.
///
/// The Stream object can be used to manipulate the Stream's state. Also, time-constant
- /// and time-varying information about the Stream can be retreived.
+ /// and time-varying information about the Stream can be retrieved.
//////
class Stream
{
/// @brief System singleton which represents the PortAudio system.
///
/// The System is used to initialize/terminate PortAudio and provide
- /// a single acccess point to the PortAudio System (instance()).
+ /// a single access point to the PortAudio System (instance()).
/// It can be used to iterate through all HostApi 's in the System as
/// well as all devices in the System. It also provides some utility
/// functionality of PortAudio.
//////
/// Sets the requested sample rate. If this sample rate isn't supported by the hardware, the
/// Stream will fail to open. The real-life sample rate used might differ slightly due to
- /// imperfections in the sound card hardware; use Stream::sampleRate() to retreive the
+ /// imperfections in the sound card hardware; use Stream::sampleRate() to retrieve the
/// best known estimate for this value.
//////
void StreamParameters::setSampleRate(double sampleRate)
e.printStackTrace();
}
- assertTrue( "caught no expection", (caught != null) );
+ assertTrue( "caught no exception", (caught != null) );
assertTrue( "exception should say stream is stopped", caught
.getMessage().contains( "stopped" ) );
caught = e;
e.printStackTrace();
}
- assertTrue( "caught no expection", (caught != null) );
+ assertTrue( "caught no exception", (caught != null) );
assertTrue( "exception should say stream is stopped", caught
.getMessage().contains( "null" ) );
e.printStackTrace();
}
- assertTrue( "caught no expection", (caught != null) );
+ assertTrue( "caught no exception", (caught != null) );
assertTrue( "exception should say tried to", caught.getMessage()
.contains( "Tried to write short" ) );
Service pack 5:
Latest known URL:
http://msdn2.microsoft.com/en-us/vstudio/aa718363.aspx
- Yes there EXISTS a service pack 6 , but the processor pack (below) isnt compatible with it.
+ Yes there EXISTS a service pack 6 , but the processor pack (below) isn't compatible with it.
Processor Pack(only works with above SP5)
Latest known URL:
@subsection read_write_io_method The Read/Write I/O Method
-As an alternative to the callback I/O method, PortAudio provides a synchronous read/write interface for acquiring and playing audio. This can be useful for applications that don't require the lowest possibly latency, or don't warrant the increased complexity of synchronising with an asynchronous callback funciton. This I/O method is also useful when calling PortAudio from programming languages that don't support asynchronous callbacks.
+As an alternative to the callback I/O method, PortAudio provides a synchronous read/write interface for acquiring and playing audio. This can be useful for applications that don't require the lowest possibly latency, or don't warrant the increased complexity of synchronising with an asynchronous callback function. This I/O method is also useful when calling PortAudio from programming languages that don't support asynchronous callbacks.
To open a Stream in read/write mode you pass a NULL stream callback function pointer to Pa_OpenStream().
"make install" should install the same set of files that are installed using the usual configure script included with PortAudio along with a few extra files (similar to pkg-config metadata files) which make it easier for other CMake projects to use the installed libraries.
-On Windows, you can use CMake to generate Visual Studio project files which can be used to create the PortAudio libraries. The following serves as an example (and should be done from a directory outside the PortAudio tree) which will create Visual Studio 2015 project files targetting a 64-bit build:
+On Windows, you can use CMake to generate Visual Studio project files which can be used to create the PortAudio libraries. The following serves as an example (and should be done from a directory outside the PortAudio tree) which will create Visual Studio 2015 project files targeting a 64-bit build:
C:\PABUILD> cmake {portaudio path} -G "Visual Studio 14 2015 Win64"
cp /usr/local/lib/libportaudio.a /YOUR/PROJECT/DIR
@endcode
-You may also need to copy portaudio.h, located in the include/ directory of PortAudio into your project. Note that you will usually need to link with the approriate libraries that you used, such as ALSA and JACK, as well as with librt and libpthread. For example:
+You may also need to copy portaudio.h, located in the include/ directory of PortAudio into your project. Note that you will usually need to link with the appropriate libraries that you used, such as ALSA and JACK, as well as with librt and libpthread. For example:
@code
gcc main.c libportaudio.a -lrt -lm -lasound -ljack -pthread -o YOUR_BINARY
if( err != paNoError ) goto error;
@endcode
-You can communicate with your callback routine through the data structure you passed in on the open call, or through global variables, or using other interprocess communication techniques, but please be aware that your callback function may be called at interrupt time when your foreground process is least expecting it. So avoid sharing complex data structures that are easily corrupted like double linked lists, and avoid using locks such as mutexs as this may cause your callback function to block and therefore drop audio. Such techniques may even cause deadlock on some platforms.
+You can communicate with your callback routine through the data structure you passed in on the open call, or through global variables, or using other interprocess communication techniques, but please be aware that your callback function may be called at interrupt time when your foreground process is least expecting it. So avoid sharing complex data structures that are easily corrupted like double linked lists, and avoid using locks such as mutexes as this may cause your callback function to block and therefore drop audio. Such techniques may even cause deadlock on some platforms.
PortAudio will continue to call your callback and process audio until you stop the stream. This can be done in one of several ways, but, before we do so, we'll want to see that some of our audio gets processed by sleeping for a few seconds. This is easy to do with Pa_Sleep(), which is used by many of the examples in the patests/ directory for exactly this purpose. Note that, for a variety of reasons, you can not rely on this function for accurate scheduling, so your stream may not run for exactly the same amount of time as you expect, but it's good enough for our example.
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return 0;
return 0;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return 0;
Pa_CloseStream( stream );
}
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
free( data.recordedSamples );
if( err != paNoError )
{
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
err = 1; /* Always return 0 or 1, but no other return codes. */
PaUtil_FreeMemory( data.ringBufferData );
if( err != paNoError )
{
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
err = 1; /* Always return 0 or 1, but no other return codes. */
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return paNoError;
error:
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", paInit.result() );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( paInit.result() ) );
return 1;
Pa_Terminate();
free( data.buffer );
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
// Print more information about the error.
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
#endif /* __cplusplus */
-/** Retrieve legal native buffer sizes for the specificed device, in sample frames.
+/** Retrieve legal native buffer sizes for the specified device, in sample frames.
@param device The global index of the device about which the query is being made.
@param minBufferSizeFrames A pointer to the location which will receive the minimum buffer size value.
@param stream The stream to operate on.
@param sampleRate The new sample rate.
- Note that this function may fail if the stream is alredy running and the
+ Note that this function may fail if the stream is already running and the
ASIO driver does not support switching the sample rate of a running stream.
Returns paIncompatibleStreamHostApi if stream is not a paASIO stream.
* Returns a statically allocated string with the device's name
* for the given channel. NULL will be returned on failure.
*
- * This function's implemenation is not complete!
+ * This function's implementation is not complete!
*
* @param device The PortAudio device index.
* @param channel The channel number who's name is requested.
* @return a statically allocated string with the name of the device.
* Because this string is statically allocated, it must be
- * coppied if it is to be saved and used by the user after
+ * copied if it is to be saved and used by the user after
* another call to this function.
*
*/
const char *PaMacCore_GetChannelName( int device, int channelIndex, bool input );
-/** Retrieve the range of legal native buffer sizes for the specificed device, in sample frames.
+/** Retrieve the range of legal native buffer sizes for the specified device, in sample frames.
@param device The global index of the PortAudio device about which the query is being made.
@param minBufferSizeFrames A pointer to the location which will receive the minimum buffer size value.
* are supported by the device. */
#define paMacCoreFailIfConversionRequired (0x02)
-/** These flags set the SR conversion quality, if required. The wierd ordering
+/** These flags set the SR conversion quality, if required. The weird ordering
* allows Maximum Quality to be the default.*/
#define paMacCoreConversionQualityMin (0x0100)
#define paMacCoreConversionQualityMedium (0x0200)
/** Stream category.
Note:
- values are equal to WASAPI AUDIO_STREAM_CATEGORY enum
- - supported since Windows 8.0, noop on earler versions
+ - supported since Windows 8.0, noop on earlier versions
- values 1,2 are deprecated on Windows 10 and not included into enumeration
@version Available as of 19.6.0
/** Stream option.
Note:
- values are equal to WASAPI AUDCLNT_STREAMOPTIONS enum
- - supported since Windows 8.1, noop on earler versions
+ - supported since Windows 8.1, noop on earlier versions
@version Available as of 19.6.0
*/
/** Get current audio format of the device assigned to the opened stream.
Format is represented by PaWinWaveFormat or WAVEFORMATEXTENSIBLE structure.
- Use this function to reconfirm format if PA's processor is overriden and
+ Use this function to reconfirm format if PA's processor is overridden and
paWinWasapiRedirectHostProcessor flag is specified.
@param pStream Pointer to PaStream object.
@param formatSize Size of PaWinWaveFormat or WAVEFORMATEXTENSIBLE structure in bytes.
@param bOutput TRUE (1) for output stream, FALSE (0) for input stream.
- @return Non-negative value indicating the number of bytes copied into format decriptor
+ @return Non-negative value indicating the number of bytes copied into format descriptor
or, a PaErrorCode (which is always negative) if PortAudio is not initialized
or an error is encountered.
*/
@param formatSize Size of PaWinWaveFormat or WAVEFORMATEXTENSIBLE structure in bytes.
@param device Device index.
- @return Non-negative value indicating the number of bytes copied into format decriptor
+ @return Non-negative value indicating the number of bytes copied into format descriptor
or, a PaErrorCode (which is always negative) if PortAudio is not initialized
or an error is encountered.
*/
@param formatSize Size of PaWinWaveFormat or WAVEFORMATEXTENSIBLE structure in bytes.
@param device Device index.
- @return Non-negative value indicating the number of bytes copied into format decriptor
+ @return Non-negative value indicating the number of bytes copied into format descriptor
or, a PaErrorCode (which is always negative) if PortAudio is not initialized
or an error is encountered.
*/
/** Get number of frames per host buffer.
It is max value of frames of WASAPI buffer which can be locked for operations.
- Use this method as helper to findout max values of inputFrames/outputFrames
+ Use this method as helper to find out max values of inputFrames/outputFrames
of PaWasapiHostProcessorCallback.
@param pStream Pointer to PaStream object.
under Windows Vista x64 when application is WOW64(32-bit) and Event-Driven method simply
times out (event handle is never signalled on buffer completion). Please note, such WOW64 bug
does not exist in Vista x86 or Windows 7.
- Polling can be setup by speciying 'paWinWasapiPolling' flag. Our WASAPI implementation detects
+ Polling can be setup by specifying 'paWinWasapiPolling' flag. Our WASAPI implementation detects
WOW64 bug and sets 'paWinWasapiPolling' automatically.
Thread priority:
If devices are specified here, the corresponding device parameter
to Pa_OpenStream() should be set to paUseHostApiSpecificDeviceSpecification,
otherwise an paInvalidDevice error will result.
- The total number of channels accross all specified devices
+ The total number of channels across all specified devices
must agree with the corresponding channelCount parameter to
Pa_OpenStream() otherwise a paInvalidChannelCount error will result.
*/
# to NONDIR_REPLACEMENT.
# value returned in "$func_dirname_result"
# basename: Compute filename of FILE.
-# value retuned in "$func_basename_result"
+# value returned in "$func_basename_result"
# Implementation must be kept synchronized with func_dirname
# and func_basename. For efficiency, we do not delegate to
# those functions but instead duplicate the functionality here.
{
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
namespace, but it is not one of the ones we know about and
- have already dealt with, above (inluding dump-script), then
+ have already dealt with, above (including dump-script), then
report an error. Otherwise, targets might begin to believe
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
namespace. The first time any user complains about this, we'll
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
return 0;
error:
- fprintf( stderr, "An error occured while using PortAudio\n" );
+ fprintf( stderr, "An error occurred while using PortAudio\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
return 0;
error:
- fprintf( stderr, "An error occured while using PABLIO\n" );
+ fprintf( stderr, "An error occurred while using PABLIO\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
return 0;
error:
- fprintf( stderr, "An error occured while using PABLIO\n" );
+ fprintf( stderr, "An error occurred while using PABLIO\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
/*================= Recordings ===================================*/
/*================================================================*/
/**
- * Allocate memory for containg a mono audio signal. Set up recording for writing.
+ * Allocate memory for containing a mono audio signal. Set up recording for writing.
*/
int PaQa_InitializeRecording( PaQaRecording *recording, int maxSamples, int sampleRate );
printf( "OK" );
}
- // Print the # errors so far to make it easier to see where the error occured.
+ // Print the # errors so far to make it easier to see where the error occurred.
printf( " - #errs = %d\n", g_testsFailed );
PaQa_TeardownLoopbackContext( &loopbackContext );
/**
* Scan every combination of output to input device.
* If a loopback is found the analyse the combination.
- * The scan can be overriden using the -i and -o command line options.
+ * The scan can be overridden using the -i and -o command line options.
*/
static int ScanForLoopback(UserOptions *userOptions)
{
for( i=0; i<numSamples; i++ )
{
float value = *input++;
- // Use assymmetric conversion to avoid clipping.
+ // Use asymmetric conversion to avoid clipping.
short sval = value * 32767.0;
*data++ = sval;
}
for( i=0; i<numSamples; i++ )
{
float value = *input++;
- // Use assymmetric conversion to avoid clipping.
+ // Use asymmetric conversion to avoid clipping.
int ival = value * ((double) 0x007FFFF0);
ival = ival << 8;
*data++ = ival;
of memory which are allocated at the same time (such as during initialization)
and need to be deallocated at the same time. The allocation group maintains
a list of allocated blocks, and can free all allocations at once. This
- can be usefull for cleaning up after a partially initialized object fails.
+ can be useful for cleaning up after a partially initialized object fails.
The allocation group implementation is built on top of the lower
level allocation functions defined in pa_util.h
while( count-- )
{
- float samp = *src * const_1_div_32768_; /* FIXME: i'm concerned about this being asymetrical with float->int16 -rb */
+ float samp = *src * const_1_div_32768_; /* FIXME: i'm concerned about this being asymmetrical with float->int16 -rb */
*dest = samp;
src += sourceStride;
/** Choose an available sample format which is most appropriate for
representing the requested format. If the requested format is not available
- higher quality formats are considered before lower quality formates.
+ higher quality formats are considered before lower quality formats.
@param availableFormats A variable containing the logical OR of all available
formats.
@param format The desired format.
PaUtil_SelectConverter() uses this table to lookup the appropriate
conversion functions. The fields of this structure are initialized
with default conversion functions. Fields may be NULL, indicating that
- no conversion function is available. User code may substitue optimised
+ no conversion function is available. User code may substitute optimised
conversion functions by assigning different function pointers to
these fields.
/** A table of pointers to all required zeroer functions.
PaUtil_SelectZeroer() uses this table to lookup the appropriate
conversion functions. The fields of this structure are initialized
- with default conversion functions. User code may substitue optimised
+ with default conversion functions. User code may substitute optimised
conversion functions by assigning different function pointers to
these fields.
example.
A PA_VALIDATE_ENDIANNESS macro is provided to compare the compile time
- and runtime endiannes and raise an assertion if they don't match.
+ and runtime endianness and raise an assertion if they don't match.
*/
/* If this is an apple, we need to do detect endianness this way */
#if defined(__APPLE__)
- /* we need to do some endian detection that is sensitive to harware arch */
+ /* we need to do some endian detection that is sensitive to hardware arch */
#if defined(__LITTLE_ENDIAN__)
#if !defined( PA_LITTLE_ENDIAN )
#define PA_LITTLE_ENDIAN
#endif
#else
/* this is not an apple, so first check the existing defines, and, failing that,
- detect well-known architechtures. */
+ detect well-known architectures. */
#if defined(PA_LITTLE_ENDIAN) || defined(PA_BIG_ENDIAN)
/* endianness define has been set externally, such as by autoconf */
#include "pa_types.h"
#include "pa_hostapi.h"
#include "pa_stream.h"
-#include "pa_trace.h" /* still usefull?*/
+#include "pa_trace.h" /* still useful?*/
#include "pa_debugprint.h"
#ifndef PA_GIT_REVISION
}
/*
- NOTE: make sure this validation list is kept syncronised with the one in
+ NOTE: make sure this validation list is kept synchronised with the one in
pa_hostapi.h
ValidateOpenStreamParameters() checks that parameters to Pa_OpenStream()
PaDeviceIndex *hostApiInputDevice,
PaDeviceIndex *hostApiOutputDevice )
{
- int inputHostApiIndex = -1, /* Surpress uninitialised var warnings: compiler does */
+ int inputHostApiIndex = -1, /* Suppress uninitialised var warnings: compiler does */
outputHostApiIndex = -1; /* not see that if inputParameters and outputParame- */
/* ters are both nonzero, these indices are set. */
}
/* Check for parameter errors.
- NOTE: make sure this validation list is kept syncronised with the one
+ NOTE: make sure this validation list is kept synchronised with the one
in pa_hostapi.h
*/
When a stream is opened, the buffer processor should be initialized using
PaUtil_InitializeBufferProcessor. This function initializes internal state
- and allocates temporary buffers as neccesary according to the supplied
+ and allocates temporary buffers as necessary according to the supplied
configuration parameters. Some of the parameters correspond to those requested
by the user in their call to Pa_OpenStream(), others reflect the requirements
of the host API implementation - they indicate host buffer sizes, formats,
PaUtil_SetInterleavedInputChannels, PaUtil_SetNonInterleavedInputChannel.
Which function you call will depend on whether the host buffer(s) are
interleaved or not.
- - If the available host data is split accross two buffers (for example a
+ - If the available host data is split across two buffers (for example a
data range at the end of a circular buffer and another range at the
beginning of the circular buffer), also call
PaUtil_Set2ndInputFrameCount, PaUtil_Set2ndInputChannel,
PaUtil_SetInterleavedOutputChannels, PaUtil_SetNonInterleavedOutputChannel.
Which function you call will depend on whether the host buffer(s) are
interleaved or not.
- - If the available host output buffer space is split accross two buffers
+ - If the available host output buffer space is split across two buffers
(for example a data range at the end of a circular buffer and another
range at the beginning of the circular buffer), call
PaUtil_Set2ndOutputFrameCount, PaUtil_Set2ndOutputChannel,
}PaUtilHostBufferSizeMode;
-/** @brief An auxilliary data structure used internally by the buffer processor
+/** @brief An auxiliary data structure used internally by the buffer processor
to represent host input and output buffers. */
typedef struct PaUtilChannelDescriptor{
void *data;
unsigned long frameCount );
-/** Indicate that no input is avalable. This function should be used when
+/** Indicate that no input is available. This function should be used when
priming the output of a full-duplex stream opened with the
paPrimeOutputBuffersUsingStreamCallback flag. Note that it is not necessary
- to call this or any othe PaUtil_Set*Input* functions for ouput-only streams.
+ to call this or any other PaUtil_Set*Input* functions for ouput-only streams.
@param bufferProcessor The buffer processor.
*/
If the stream callback is called its result is stored in *callbackResult. If
the stream callback returns paComplete or paAbort, all output buffers will be
- full of valid data - some of which may be zeros to acount for data that
+ full of valid data - some of which may be zeros to account for data that
wasn't generated by the terminating callback.
@return The number of frames processed. This usually corresponds to the
- number of frames specified by the PaUtil_Set*FrameCount functions, exept in
+ number of frames specified by the PaUtil_Set*FrameCount functions, except in
the paUtilVariableHostBufferSizePartialUsageAllowed buffer size mode when a
smaller value may be returned.
*/
int *callbackResult );
-/** Determine whether any callback generated output remains in the bufffer
+/** Determine whether any callback generated output remains in the buffer
processor's internal buffers. This method may be used to determine when to
continue calling PaUtil_EndBufferProcessing() after the callback has returned
a callbackResult of paComplete.
host api specific extension functions which aren't passed a rep pointer
by pa_front.c.
- @param hostApi A pointer to a host API represenation pointer. Apon success
+ @param hostApi A pointer to a host API representation pointer. Upon success
this will receive the requested representation pointer.
@param type A valid host API type identifier.
/** Convert a PortAudio device index into a host API specific device index.
- @param hostApiDevice Pointer to a device index, on success this will recieve the
+ @param hostApiDevice Pointer to a device index, on success this will receive the
converted device index value.
@param device The PortAudio device index to convert.
@param hostApi The host api which the index should be converted for.
void *PaUtil_AllocateMemory( long size );
-/** Realease block if non-NULL. block may be NULL */
+/** Release block if non-NULL. block may be NULL */
void PaUtil_FreeMemory( void *block );
{
/* Configuration consists of setting all of ALSA's parameters.
* These parameters come in two flavors: hardware parameters
- * and software paramters. Hardware parameters will affect
+ * and software parameters. Hardware parameters will affect
* the way the device is initialized, software parameters
* affect the way ALSA interacts with me, the user-level client.
*/
/* self->framesPerPeriod = framesPerHostBuffer; */
- /* ... fill up the configuration space with all possibile
+ /* ... fill up the configuration space with all possible
* combinations of parameters this device will accept */
ENSURE_( alsa_snd_pcm_hw_params_any( pcm, hwParams ), paUnanticipatedHostError );
self->framesPerUserBuffer = framesPerUserBuffer;
self->neverDropInput = streamFlags & paNeverDropInput;
- /* XXX: Ignore paPrimeOutputBuffersUsingStreamCallback untill buffer priming is fully supported in pa_process.c */
+ /* XXX: Ignore paPrimeOutputBuffersUsingStreamCallback until buffer priming is fully supported in pa_process.c */
/*
if( outParams & streamFlags & paPrimeOutputBuffersUsingStreamCallback )
self->primeBuffers = 1;
{
framesPerHostBuffer *= 2;
}
- /* One extra period is preferrable to one less (should be more robust) */
+ /* One extra period is preferable to one less (should be more robust) */
if( bufferSize / framesPerHostBuffer < numPeriods )
{
framesPerHostBuffer /= 2;
* directly is obtained from ALSA, we then request as much directly accessible memory as possible within this amount
* from ALSA. The buffer memory is registered with the PA buffer processor and processing is carried out with
* PaUtil_EndBufferProcessing. Finally, the number of processed frames is reported to ALSA. The processing can
- * happen in several iterations untill we have consumed the known number of available frames (or an xrun is detected).
+ * happen in several iterations until we have consumed the known number of available frames (or an xrun is detected).
*/
static void *CallbackThreadFunc( void *userData )
{
/* There is still buffered output that needs to be processed */
}
- /* Wait for data to become available, this comes down to polling the ALSA file descriptors untill we have
+ /* Wait for data to become available, this comes down to polling the ALSA file descriptors until we have
* a number of available frames.
*/
PA_ENSURE( PaAlsaStream_WaitForFrames( stream, &framesAvail, &xrun ) );
08-20-01 More conversion, PA_StreamTime, Pa_GetHostError : Stephane Letz
08-21-01 PaUInt8 bug correction, implementation of ASIOSTFloat32LSB and ASIOSTFloat32MSB native formats : Stephane Letz
08-24-01 MAX_INT32_FP hack, another Uint8 fix : Stephane and Phil
- 08-27-01 Implementation of hostBufferSize < userBufferSize case, better management of the ouput buffer when
+ 08-27-01 Implementation of hostBufferSize < userBufferSize case, better management of the output buffer when
the stream is stopped : Stephane Letz
08-28-01 Check the stream pointer for null in bufferSwitchTimeInfo, correct bug in bufferSwitchTimeInfo when
the stream is stopped : Stephane Letz
10-26-01 Management of hostBufferSize and userBufferSize of any size : Stephane Letz
10-27-01 Improve calculus of hostBufferSize to be multiple or divisor of userBufferSize if possible : Stephane and Phil
10-29-01 Change MAX_INT32_FP to (2147483520.0f) to prevent roundup to 0x80000000 : Phil Burk
- 10-31-01 Clear the ouput buffer and user buffers in PaHost_StartOutput, correct bug in GetFirstMultiple : Stephane Letz
+ 10-31-01 Clear the output buffer and user buffers in PaHost_StartOutput, correct bug in GetFirstMultiple : Stephane Letz
11-06-01 Rename functions : Stephane Letz
11-08-01 New Pa_ASIO_Adaptor_Init function to init Callback adpatation variables, cleanup of Pa_ASIO_Callback_Input: Stephane Letz
11-29-01 Break apart device loading to debug random failure in Pa_ASIO_QueryDeviceInfo ; Phil Burk
- 01-03-02 Desallocate all resources in PaHost_Term for cases where Pa_CloseStream is not called properly : Stephane Letz
+ 01-03-02 Deallocate all resources in PaHost_Term for cases where Pa_CloseStream is not called properly : Stephane Letz
02-01-02 Cleanup, test of multiple-stream opening : Stephane Letz
19-02-02 New Pa_ASIO_loadDriver that calls CoInitialize on each thread on Windows : Stephane Letz
09-04-02 Correct error code management in PaHost_Term, removes various compiler warning : Stephane Letz
12-06-02 Rehashed into new multi-api infrastructure, added support for all ASIO sample formats : Ross Bencina
18-06-02 Added pa_asio.h, PaAsio_GetAvailableLatencyValues() : Ross B.
21-06-02 Added SelectHostBufferSize() which selects host buffer size based on user latency parameters : Ross Bencina
- ** NOTE maintanance history is now stored in CVS **
+ ** NOTE maintenance history is now stored in CVS **
*/
/** @file
#include "pa_win_coinitialize.h"
-/* This version of pa_asio.cpp is currently only targetted at Win32,
+/* This version of pa_asio.cpp is currently only targeted at Win32,
It would require a few tweaks to work with pre-OS X Macintosh.
To make configuration easier, we define WIN32 here to make sure
that the ASIO SDK knows this is Win32.
enough to store at least two complete data blocks.
1) Determine the amount of latency to be added to the
- prefered ASIO latency.
+ preferred ASIO latency.
2) Make sure we have at lest one additional latency frame.
3) Divide the number of frames by the desired block size to
get the number (rounded up to pure integer) of blocks to
while( lBlockingBufferSize > (lBlockingBufferSizePow2<<=1) );
lBlockingBufferSize = lBlockingBufferSizePow2;
- /* Compute total intput latency in seconds */
+ /* Compute total input latency in seconds */
stream->streamRepresentation.streamInfo.inputLatency =
(double)( PaUtil_GetBufferProcessorInputLatencyFrames(&stream->bufferProcessor )
+ PaUtil_GetBufferProcessorInputLatencyFrames(&stream->blockingState->bufferProcessor)
enough to store at least two complete data blocks.
1) Determine the amount of latency to be added to the
- prefered ASIO latency.
+ preferred ASIO latency.
2) Make sure we have at lest one additional latency frame.
3) Divide the number of frames by the desired block size to
get the number (rounded up to pure integer) of blocks to
//TAKEN FROM THE ASIO SDK
// the actual processing callback.
- // Beware that this is normally in a seperate thread, hence be sure that
+ // Beware that this is normally in a separate thread, hence be sure that
// you take care about thread synchronization. This is omitted here for
// simplicity.
static ASIOTime *bufferSwitchTimeInfo( ASIOTime *timeInfo, long index, ASIOBool directProcess )
{
// the actual processing callback.
- // Beware that this is normally in a seperate thread, hence be sure that
+ // Beware that this is normally in a separate thread, hence be sure that
// you take care about thread synchronization.
break;
case kAsioSupportsTimeInfo:
- // informs the driver wether the asioCallbacks.bufferSwitchTimeInfo() callback
+ // informs the driver whether the asioCallbacks.bufferSwitchTimeInfo() callback
// is supported.
// For compatibility with ASIO 1.0 drivers the host application should always support
// the "old" bufferSwitch method, too.
break;
case kAsioSupportsTimeCode:
- // informs the driver wether application is interested in time code info.
+ // informs the driver whether application is interested in time code info.
// If an application does not need to know about time code, the driver has less work
// to do.
ret = 0;
blockingState->stopFlag = TRUE;
/* Wait until requested number of buffers has been freed. Time
- out after twice the blocking i/o ouput buffer could have
+ out after twice the blocking i/o output buffer could have
been consumed. */
DWORD timeout = (DWORD)( 2 * blockingState->writeRingBuffer.bufferSize * 1000
/ stream->streamRepresentation.streamInfo.sampleRate );
unsigned int i; /* Just a counter. */
- /* Check if the stream ist still available ready to recieve new data. */
+ /* Check if the stream is still available ready to receive new data. */
if( blockingState->stopFlag || !stream->isActive )
{
PA_DEBUG(("Warning! Stream no longer available for writing in WriteStream()\n"));
- Latency: Latency settings are generally ignored. They may be used as a
hint for buffer size in paHostFramesPerBufferUnspecified, or the value may
be used in cases where additional buffering is needed, such as doing input and
-output on seperate devices. Latency settings are always automatically bound
+output on separate devices. Latency settings are always automatically bound
to "safe" values, however, so setting extreme values here should not be
an issue.
return true;
}
/*
- * Function declared in pa_mac_core.h. retrives channel names.
+ * Function declared in pa_mac_core.h. retrieves channel names.
*/
const char *PaMacCore_GetChannelName( int device, int channelIndex, bool input )
{
/* set device format first, but only touch the device if the user asked */
if( inStreamParams ) {
/*The callback never calls back if we don't set the FPB */
- /*This seems wierd, because I would think setting anything on the device
+ /*This seems weird, because I would think setting anything on the device
would be disruptive.*/
paResult = setBestFramesPerBuffer( *audioDevice, FALSE,
requestedFramesPerBuffer,
}
if( outStreamParams && !inStreamParams ) {
/*The callback never calls back if we don't set the FPB */
- /*This seems wierd, because I would think setting anything on the device
+ /*This seems weird, because I would think setting anything on the device
would be disruptive.*/
paResult = setBestFramesPerBuffer( *audioDevice, TRUE,
requestedFramesPerBuffer,
else
{
inputChannelCount = 0;
- inputSampleFormat = hostInputSampleFormat = paFloat32; /* Surpress 'uninitialised var' warnings. */
+ inputSampleFormat = hostInputSampleFormat = paFloat32; /* Suppress 'uninitialised var' warnings. */
}
if( outputParameters )
else
{
outputChannelCount = 0;
- outputSampleFormat = hostOutputSampleFormat = paFloat32; /* Surpress 'uninitialized var' warnings. */
+ outputSampleFormat = hostOutputSampleFormat = paFloat32; /* Suppress 'uninitialized var' warnings. */
}
/* validate platform specific flags */
/* -----------------------------------------------------------------*\
This output may be useful for debugging,
- But printing durring the callback is a bad enough idea that
- this is not enabled by enableing the usual debugging calls.
+ But printing during the callback is a bad enough idea that
+ this is not enabled by enabling the usual debugging calls.
\* -----------------------------------------------------------------*/
/*
static int renderCount = 0;
static PaError CloseStream( PaStream* s )
{
/* This may be called from a failed OpenStream.
- Therefore, each piece of info is treated seperately. */
+ Therefore, each piece of info is treated separately. */
PaError result = paNoError;
PaMacCoreStream *stream = (PaMacCoreStream*)s;
goto done;
/* we need to update the value. Here's what we do:
- * - Lock the mutex, so noone else can write.
+ * - Lock the mutex, so no one else can write.
* - update the value.
* - unlock.
* - broadcast to all listeners.
goto done;
/* we need to update the value. Here's what we do:
- * - Lock the mutex, so noone else can write.
+ * - Lock the mutex, so no one else can write.
* - update the value.
* - unlock.
* - broadcast to all listeners.
}
/*
- * this is the BlioCallback function. It expects to recieve a PaMacBlio Object
+ * this is the BlioCallback function. It expects to receive a PaMacBlio Object
* pointer as userData.
*
*/
errorText = "Audio Unit: Format Not Supported";
result = paInternalError; break;
case kAudioUnitErr_Uninitialized:
- errorText = "Audio Unit: Unitialized";
+ errorText = "Audio Unit: Uninitialized";
result = paInternalError; break;
case kAudioUnitErr_InvalidScope:
errorText = "Audio Unit: Invalid Scope";
/*
- * Durring testing of core audio, I found that serious crashes could occur
+ * During testing of core audio, I found that serious crashes could occur
* if properties such as sample rate were changed multiple times in rapid
* succession. The function below could be used to with a condition variable.
* to prevent propertychanges from happening until the last property
* change is acknowledged. Instead, I implemented a busy-wait, which is simpler
- * to implement b/c in second round of testing (nov '09) property changes occured
+ * to implement b/c in second round of testing (nov '09) property changes occurred
* quickly and so there was no real way to test the condition variable implementation.
* therefore, this function is not used, but it is aluded to in commented code below,
* since it represents a theoretically better implementation.
if( err )
return ERR( err );
- /* -- otherwise, something wierd happened: we didn't set the rate, and we got no errors. Just bail. */
+ /* -- otherwise, something weird happened: we didn't set the rate, and we got no errors. Just bail. */
return paInternalError;
}
is available, it uses the smallest available size.
actualFramesPerBuffer will be set to the actual value on successful return.
OK to pass NULL to actualFramesPerBuffer.
- The logic is very simmilar too setBestSampleRate only failure here is
+ The logic is very similar too setBestSampleRate only failure here is
not usually catastrophic.
*/
PaError setBestFramesPerBuffer( const AudioDeviceID device,
#define INPUT_ELEMENT (1)
#define OUTPUT_ELEMENT (0)
-/* Normal level of debugging: fine for most apps that don't mind the occational warning being printf'ed */
+/* Normal level of debugging: fine for most apps that don't mind the occasional warning being printf'ed */
/*
*/
#define MAC_CORE_DEBUG
# define DBUG(MSG)
#endif
-/* Verbose Debugging: useful for developement */
+/* Verbose Debugging: useful for development */
/*
#define MAC_CORE_VERBOSE_DEBUG
*/
is available, it uses the smallest available size.
actualFramesPerBuffer will be set to the actual value on successful return.
OK to pass NULL to actualFramesPerBuffer.
- The logic is very simmilar too setBestSampleRate only failure here is
+ The logic is very similar too setBestSampleRate only failure here is
not usually catastrophic.
*/
PaError setBestFramesPerBuffer( const AudioDeviceID device,
/*
- Use the earliest version of DX required, no need to polute the namespace
+ Use the earliest version of DX required, no need to pollute the namespace
*/
#ifdef PAWIN_USE_DIRECTSOUNDFULLDUPLEXCREATE
#define DIRECTSOUND_VERSION 0x0800
property, and the other is using DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE.
I tried both methods and only the second worked. I found two postings on the
net from people who had the same problem with the first method, so I think the method used here is
- more common/likely to work. The probem is that IKsPropertySet_Get returns S_OK
+ more common/likely to work. The problem is that IKsPropertySet_Get returns S_OK
but the fields of the device description are not filled in.
The mechanism we use works by registering an enumeration callback which is called for
/************************************************************************************
** Extract capabilities from an output device, and add it to the device info list
** if successful. This function assumes that there is enough room in the
-** device info list to accomodate all entries.
+** device info list to accommodate all entries.
**
** The device will not be added to the device list if any errors are encountered.
*/
/************************************************************************************
** Extract capabilities from an input device, and add it to the device info list
** if successful. This function assumes that there is enough room in the
-** device info list to accomodate all entries.
+** device info list to accommodate all entries.
**
** The device will not be added to the device list if any errors are encountered.
*/
/* create half duplex buffers. also used for full-duplex streams which didn't
succeed when using the full duplex API. that could happen because
- DX8 or greater isnt installed, the i/o devices aren't the same
+ DX8 or greater isn't installed, the i/o devices aren't the same
physical device. etc.
*/
#else
- /* tick using WaitForSingleObject timout */
+ /* tick using WaitForSingleObject timeout */
while ( WaitForSingleObject( stream->processingCompleted, timerPeriodMs ) == WAIT_TIMEOUT )
{
TimerCallback( 0, 0, (DWORD_PTR)pArg, 0, 0 );
{
if( paWinDsDSoundEntryPoints.hInstance_ != NULL )
{
- /* ensure that we crash reliably if the entry points arent initialised */
+ /* ensure that we crash reliably if the entry points aren't initialised */
paWinDsDSoundEntryPoints.DirectSoundCreate = 0;
paWinDsDSoundEntryPoints.DirectSoundEnumerateW = 0;
paWinDsDSoundEntryPoints.DirectSoundEnumerateA = 0;
#endif
/*
- Use the earliest version of DX required, no need to polute the namespace
+ Use the earliest version of DX required, no need to pollute the namespace
*/
#ifdef PAWIN_USE_DIRECTSOUNDFULLDUPLEXCREATE
#define DIRECTSOUND_VERSION 0x0800
/* douglas:
we have to do this querying in a slightly different order. apparently
- some sound cards will give you different info based on their settins.
+ some sound cards will give you different info based on their settings.
e.g. a card might give you stereo at 22kHz but only mono at 44kHz.
the correct order for OSS is: format, channels, sample rate
*/
#ifdef PTHREAD_CANCELED
pthread_testcancel();
#else
- /* avoid indefinite waiting on thread not supporting cancelation */
+ /* avoid indefinite waiting on thread not supporting cancellation */
if( stream->callbackStop || stream->callbackAbort )
{
PA_DEBUG(( "Cancelling PaOssStream_WaitForFrames\n" ));
#ifdef PTHREAD_CANCELED
pthread_testcancel();
#else
- /* avoid indefinite waiting on thread not supporting cancelation */
+ /* avoid indefinite waiting on thread not supporting cancellation */
if( stream->callbackStop || stream->callbackAbort )
{
PA_DEBUG(( "Cancelling PaOssStream_WaitForFrames\n" ));
#ifdef PTHREAD_CANCELED
pthread_testcancel();
#else
- if( stream->callbackAbort ) /* avoid indefinite waiting on thread not supporting cancelation */
+ if( stream->callbackAbort ) /* avoid indefinite waiting on thread not supporting cancellation */
{
PA_DEBUG(( "Aborting callback thread\n" ));
break;
callbackResult = paComplete;
}
- if( stream->callbackAbort ) /* avoid indefinite waiting on thread not supporting cancelation */
+ if( stream->callbackAbort ) /* avoid indefinite waiting on thread not supporting cancellation */
{
PA_DEBUG(( "Aborting callback thread\n" ));
break;
*
* Aspect StreamState: After returning, the stream shall be in the Active state, implying that an eventual
* callback will be repeatedly called in a separate thread. If a separate thread is started this function
- * will block untill it has started processing audio, otherwise audio processing is started directly.
+ * will block until it has started processing audio, otherwise audio processing is started directly.
*/
static PaError StartStream( PaStream *s )
{
else
{
inputChannelCount = 0;
- inputSampleFormat = hostInputSampleFormat = paInt16; /* Surpress 'uninitialised var' warnings. */
+ inputSampleFormat = hostInputSampleFormat = paInt16; /* Suppress 'uninitialised var' warnings. */
}
if( outputParameters )
else
{
outputChannelCount = 0;
- outputSampleFormat = hostOutputSampleFormat = paInt16; /* Surpress 'uninitialized var' warnings. */
+ outputSampleFormat = hostOutputSampleFormat = paInt16; /* Suppress 'uninitialized var' warnings. */
}
/*
typedef struct _PIPE_TERMINATION {
ULONG Flags;
ULONG OutsideFactors;
- ULONG Weigth;
+ ULONG Weight;
KS_FRAMING_RANGE PhysicalRange;
KS_FRAMING_RANGE_WEIGHTED OptimalRange;
KS_COMPRESSION Compression;
PA_THREAD_FUNC ProcThreadEvent(void *param);
PA_THREAD_FUNC ProcThreadPoll(void *param);
-// Error codes (availabe since Windows 7)
+// Error codes (available since Windows 7)
#ifndef AUDCLNT_E_BUFFER_ERROR
#define AUDCLNT_E_BUFFER_ERROR AUDCLNT_ERR(0x018)
#endif
#define AUDCLNT_E_INVALID_DEVICE_PERIOD AUDCLNT_ERR(0x020)
#endif
-// Stream flags (availabe since Windows 7)
+// Stream flags (available since Windows 7)
#ifndef AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY
#define AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY 0x08000000
#endif
PaWinUtilComInitializationResult comInitializationResult;
- // this is the REAL number of devices, whether they are usefull to PA or not!
+ // this is the REAL number of devices, whether they are useful to PA or not!
UINT32 deviceCount;
PaWasapiDeviceInfo *devInfo;
// ------------------------------------------------------------------------------------------
/*! \class ThreadSleepScheduler
Allows to emulate thread sleep of less than 1 millisecond under Windows. Scheduler
- calculates number of times the thread must run untill next sleep of 1 millisecond.
+ calculates number of times the thread must run until next sleep of 1 millisecond.
It does not make thread sleeping for real number of microseconds but rather controls
how many of imaginary microseconds the thread task can allow thread to sleep.
*/
// Align frames to HD Audio packet size of 128 bytes for Exclusive mode only.
// Not aligning on Windows Vista will cause Event timeout, although Windows 7 will
// return AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED error to realign buffer. Aligning is necessary
- // for Exclusive mode only! when audio data is feeded directly to hardware.
+ // for Exclusive mode only! when audio data is fed directly to hardware.
if (pSub->shareMode == AUDCLNT_SHAREMODE_EXCLUSIVE)
{
(*nFramesPerLatency) = AlignFramesPerBuffer((*nFramesPerLatency),
REFERENCE_TIME userPeriodicity;
// Align frames backwards, so device will likely make buffer read ready when we are ready
- // to read it (our sheduling will wait for amount of millisoconds of frames_per_buffer)
+ // to read it (our scheduling will wait for amount of millisoconds of frames_per_buffer)
alignedFrames = AlignFramesPerBuffer(pSub->params.frames_per_buffer,
pSub->wavex.Format.nSamplesPerSec, pSub->wavex.Format.nBlockAlign, ALIGN_BWD);
_RecalculateBuffersCount(pSub, userFramesPerBuffer, MakeFramesFromHns(pSub->period, pSub->wavex.Format.nSamplesPerSec),
fullDuplex);
- // No error, client is succesfully created
+ // No error, client is successfully created
(*pa_error) = paNoError;
done:
else
{
inputChannelCount = 0;
- inputSampleFormat = hostInputSampleFormat = paInt16; /* Surpress 'uninitialised var' warnings. */
+ inputSampleFormat = hostInputSampleFormat = paInt16; /* Suppress 'uninitialised var' warnings. */
}
// Try create device: Output
else
{
outputChannelCount = 0;
- outputSampleFormat = hostOutputSampleFormat = paInt16; /* Surpress 'uninitialized var' warnings. */
+ outputSampleFormat = hostOutputSampleFormat = paInt16; /* Suppress 'uninitialized var' warnings. */
}
// log full-duplex
// serious problem #2 - No, Not a problem, as framesPerHostCallback take into account
// sample size while it is not a problem for PA full-duplex, we must care of
- // preriod only!
+ // period only!
/*if (stream->out.framesPerHostCallback != stream->in.framesPerHostCallback)
{
PRINT(("WASAPI: OpenStream: framesPerHostCallback discrepancy\n"));
((BYTE **)user_buffer)[i] = ((BYTE **)_buffer)[i];
}
- // Findout if there are tail frames, flush them all before reading hardware
+ // Find out if there are tail frames, flush them all before reading hardware
if ((available = PaUtil_GetRingBufferReadAvailable(stream->in.tailBuffer)) != 0)
{
ring_buffer_size_t buf1_size = 0, buf2_size = 0, read, desired;
((const BYTE **)user_buffer)[i] = ((const BYTE **)_buffer)[i];
}
- // Blocking (potentially, untill 'frames' are consumed) loop
+ // Blocking (potentially, until 'frames' are consumed) loop
while (frames != 0)
{
// Check if blocking call must be interrupted
if (WaitForSingleObject(stream->hCloseRequest, 0) != WAIT_TIMEOUT)
break;
- // Findout if any frames available
+ // Find out if any frames available
frames = 0;
if ((hr = _PollGetInputFramesAvailable(stream, &frames)) != S_OK)
return hr;
UINT32 sleepTime;
// According to the issue [https://github.com/PortAudio/portaudio/issues/303] glitches may occur when user frames
- // equal to 1/2 of the host buffer frames, therefore the emperical workaround for this problem is to lower
+ // equal to 1/2 of the host buffer frames, therefore the empirical workaround for this problem is to lower
// the sleep time by 2
if (userFramesOut != 0)
{
// Request fine (1 ms) granularity of the system timer functions to guarantee correct logic around WaitForSingleObject
SystemTimer_SetGranularity(&timer, 1);
- // Claculate sleep time of the processing loop (inside WaitForSingleObject)
+ // Calculate sleep time of the processing loop (inside WaitForSingleObject)
sleepTime = ConfigureLoopSleepTimeAndScheduler(stream, &scheduler);
// Setup data processors
break;
}
- // process equal ammount of frames
+ // process equal amount of frames
if (o_frames >= i_frames)
{
- // process input ammount of frames
+ // process input amount of frames
UINT32 o_processed = i_frames;
// get host output buffer
else
{
userInputChannels = 0;
- inputSampleFormat = hostInputSampleFormat = paInt16; /* Supress 'uninitialised var' warnings. */
+ inputSampleFormat = hostInputSampleFormat = paInt16; /* Suppress 'uninitialised var' warnings. */
}
if( outputParameters )
else
{
userOutputChannels = 0;
- outputSampleFormat = hostOutputSampleFormat = paInt16; /* Supress 'uninitialized var' warnings. */
+ outputSampleFormat = hostOutputSampleFormat = paInt16; /* Suppress 'uninitialized var' warnings. */
}
/* validate platform specific flags */
This is where the PortAudio "WDM-KS" host implementation comes in.
It directly connects PortAudio to the same Kernel Streaming API which
-those ASIO bridges use. This avoids the mixing penatly of DirectX,
+those ASIO bridges use. This avoids the mixing penalty of DirectX,
giving at least as good latency as any ASIO driver, but it has the
advantage of working with ANY Windows audio hardware which is available
through the normal MME/DirectX routes without the user requiring
RDB20020417 - stopped counting WAVE_MAPPER when there were no real devices
refactoring, renaming and fixed a few edge case bugs
RDB20020531 - converted to V19 framework
- ** NOTE maintanance history is now stored in CVS **
+ ** NOTE maintenance history is now stored in CVS **
*/
/** @file
/* When client suggestedLatency could result in many host buffers, we aim to have around 8,
based off Windows documentation that suggests that the kmixer uses 8 buffers. This choice
- is somewhat arbitrary here, since we havn't observed significant stability degredation
+ is somewhat arbitrary here, since we haven't observed significant stability degredation
with using either more, or less buffers.
*/
#define PA_MME_TARGET_HOST_BUFFER_COUNT_ 8
stream->primeStreamUsingCallback = ( (streamFlags&paPrimeOutputBuffersUsingStreamCallback) && streamCallback ) ? 1 : 0;
/* time to sleep when throttling due to >100% cpu usage.
- -a quater of a buffer's duration */
+ -a quarter of a buffer's duration */
stream->throttledSleepMsecs =
(unsigned long)(stream->bufferProcessor.framesPerHostBuffer *
stream->bufferProcessor.samplePeriod * .25 * 1000);
if( waitResult == WAIT_FAILED )
{
result = paUnanticipatedHostError;
- /** @todo FIXME/REVIEW: can't return host error info from an asyncronous thread. see http://www.portaudio.com/trac/ticket/143 */
+ /** @todo FIXME/REVIEW: can't return host error info from an asynchronous thread. see http://www.portaudio.com/trac/ticket/143 */
done = 1;
}
else if( waitResult == WAIT_TIMEOUT )
if( outputUnderflow && !done && !stream->stopProcessing )
{
/* Recover from underflow in the case where the
- underflow occured while processing the buffer
+ underflow occurred while processing the buffer
we just finished */
result = CatchUpOutputBuffers( stream );
}
}
- /* we queue all channels of a single buffer frame (accross all
+ /* we queue all channels of a single buffer frame (across all
devices, because some multidevice multichannel drivers work
better this way */
for( j=0; j<stream->output.deviceCount; ++j )
/** Spawn a thread.
*
* Intended for spawning the callback thread from the main thread. This function can even block (for a certain
- * time or indefinitely) untill notified by the callback thread (using PaUnixThread_NotifyParent), which can be
+ * time or indefinitely) until notified by the callback thread (using PaUnixThread_NotifyParent), which can be
* useful in order to make sure that callback has commenced before returning from Pa_StartStream.
* @param threadFunc: The function to be executed in the child thread.
* @param waitForChild: If not 0, wait for child thread to call PaUnixThread_NotifyParent. Less than 0 means
/** Terminate thread.
*
- * @param wait: If true, request that background thread stop and wait untill it does, else cancel it.
+ * @param wait: If true, request that background thread stop and wait until it does, else cancel it.
* @param exitResult: If non-null this will upon return contain the exit status of the thread.
*/
PaError PaUnixThread_Terminate( PaUnixThread* self, int wait, PaError* exitResult );
/* case 7: */
case 8:
/* RoBi: PAWIN_SPEAKER_7POINT1_SURROUND fits normal surround sound setups better than PAWIN_SPEAKER_7POINT1, f.i. NVidia HDMI Audio
- output is silent on channels 5&6 with NVidia drivers, and channel 7&8 with Micrsoft HD Audio driver using PAWIN_SPEAKER_7POINT1.
+ output is silent on channels 5&6 with NVidia drivers, and channel 7&8 with Microsoft HD Audio driver using PAWIN_SPEAKER_7POINT1.
With PAWIN_SPEAKER_7POINT1_SURROUND both setups work OK. */
return PAWIN_SPEAKER_7POINT1_SURROUND;
}
/* Note that Alec Rogers proposed the following as an alternate method to
generate the default channel mask, however it doesn't seem to be an improvement
over the above, since some drivers will matrix outputs mapping to non-present
- speakers accross multiple physical speakers.
+ speakers across multiple physical speakers.
if(nChannels==1) {
pwfFormat->dwChannelMask = SPEAKER_FRONT_CENTER;
specified device. Returns 0 if the query fails for any reason.
@param wcharDevicePath A system level PnP interface path, supplied as a WCHAR unicode string.
- Declard as void* to avoid introducing a dependency on wchar_t here.
+ Declared as void* to avoid introducing a dependency on wchar_t here.
@param isInput A flag specifying whether to query for input (non-zero) or output (zero) channels.
*/
o- inline dither code
o- implement Dither only (no-clip) versions
o- implement int8 and uint8 versions
- o- test thouroughly
+ o- test thoroughly
o- the packed 24 bit functions could benefit from unrolling and avoiding
byte and word sized register access.
/*
-EMT64/AMD64 uses different asm
- -VC2005 doesnt allow _WIN64 with inline assembly either!
+ -VC2005 doesn't allow _WIN64 with inline assembly either!
*/
void PaUtil_InitializeX86PlainConverters( void )
{
return 0;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return 1;
data.phase = 0;
data.sampsToGo = SAMPLE_RATE * 20; /* 20 seconds. */
- /* initialise portaudio subsytem */
+ /* initialise portaudio subsystem */
err = Pa_Initialize();
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
if( err != paNoError )
{
- fprintf( stderr, "An error occured while using portaudio\n" );
+ fprintf( stderr, "An error occurred while using portaudio\n" );
if( err == paUnanticipatedHostError )
{
fprintf( stderr, " unanticipated host error.\n");
return paNoError;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
fprintf( stderr, "Host Error message: %s\n", Pa_GetLastHostErrorInfo()->errorText );
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return 0;
error:
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return 1;
done:
if (err)
{
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
err = 1; /* Though PlaySine() already called Pa_Terminate(), */
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
This test uses the same method to overload the stream as does
patest_out_underflow.c -- it generates sine waves until the cpu load
exceeds a certain level. However this test is only concerned with
- input and so doesn't ouput any sound.
+ input and so doesn't output any sound.
@author Ross Bencina <rossb@audiomulch.com>
@author Phil Burk <philburk@softsynth.com>
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
int jackCount = 0;
int isInput = 0;
- printf("PortAudio Test: WASAPI Jack Configuratin");
+ printf("PortAudio Test: WASAPI Jack Configuration");
err = Pa_Initialize();
if( err != paNoError ) goto error;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return paNoError;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
done:
if (err)
{
- fprintf(stderr, "An error occured while using the portaudio stream\n");
+ fprintf(stderr, "An error occurred while using the portaudio stream\n");
fprintf(stderr, "Error number: %d\n", err );
fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err));
}
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
unsigned int i;
int result = paContinue;
- /* supress unused parameter warnings */
+ /* suppress unused parameter warnings */
(void) inputBuffer;
(void) timeInfo;
(void) statusFlags;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return paNoError;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
fprintf( stderr, "Host Error message: %s\n", Pa_GetLastHostErrorInfo()->errorText );
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
printf("Hit ENTER to quit.\n"); fflush(stdout);
#define CHANNEL_COUNT (2)
-/* seach parameters. we test all buffer counts in this range */
+/* search parameters. we test all buffer counts in this range */
#define MIN_WMME_BUFFER_COUNT (2)
#define MAX_WMME_BUFFER_COUNT (12)
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
return err;
error:
Pa_Terminate();
- fprintf( stderr, "An error occured while using the portaudio stream\n" );
+ fprintf( stderr, "An error occurred while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
projects / portaudio / commitdiff