diff options
| author | sanine <sanine.not@pm.me> | 2022-08-27 23:52:56 -0500 |
|---|---|---|
| committer | sanine <sanine.not@pm.me> | 2022-08-27 23:52:56 -0500 |
| commit | a4dd0ad63c00f4dee3b86dfd3075d1d61b2b3180 (patch) | |
| tree | 13bd5bfa15e6fea2a12f176bae79adf9c6fd0933 /portaudio/doc/src | |
| parent | bde3e4f1bb7b8f8abca0884a7d994ee1c17a66b1 (diff) | |
add plibsys
Diffstat (limited to 'portaudio/doc/src')
21 files changed, 0 insertions, 1367 deletions
diff --git a/portaudio/doc/src/api_overview.dox b/portaudio/doc/src/api_overview.dox deleted file mode 100644 index e5704ce..0000000 --- a/portaudio/doc/src/api_overview.dox +++ /dev/null @@ -1,162 +0,0 @@ -/** @page api_overview PortAudio API Overview - -This page provides a top-down overview of the entire PortAudio API. It describes how all of the PortAudio data types and functions fit together. It provides links to the documentation for each function and data type. You can find all of the detailed documentation for each API function and data type on the portaudio.h page. - -@section introduction Introduction - -PortAudio provides a uniform application programming interface (API) across all supported platforms. You can think of the PortAudio library as a wrapper that converts calls to the PortAudio API into calls to platform-specific native audio APIs. Operating systems often offer more than one native audio API and some APIs (such as JACK) may be available on multiple target operating systems. PortAudio supports all the major native audio APIs on each supported platform. The diagram below illustrates the relationship between your application, PortAudio, and the supported native audio APIs: - -@image html portaudio-external-architecture-diagram.png - -PortAudio provides a uniform interface to native audio APIs. However, it doesn't always provide totally uniform functionality. There are cases where PortAudio is limited by the capabilities of the underlying native audio API. For example, PortAudio doesn't provide sample rate conversion if you request a sample rate that is not supported by the native audio API. Another example is that the ASIO SDK only allows one device to be open at a time, so PortAudio/ASIO doesn't currently support opening multiple ASIO devices simultaneously. - -@section key_abstractions Key abstractions: Host APIs, Devices and Streams - -The PortAudio processing model includes three main abstractions: <i>Host APIs</i>, audio <i>Devices</i> and audio <i>Streams</i>. - -Host APIs represent platform-specific native audio APIs. Some examples of Host APIs are Core Audio on Mac OS, WMME and DirectSound on Windows and OSS and ALSA on Linux. The diagram in the previous section shows many of the supported native APIs. Sometimes it's useful to know which Host APIs you're dealing with, but it is easy to use PortAudio without ever interacting directly with the Host API abstraction. - -Devices represent individual hardware audio interfaces or audio ports on the host platform. Devices have names and certain capabilities such as supported sample rates and the number of supported input and output channels. PortAudio provides functions to enumerate available Devices and to query for Device capabilities. - -Streams manage active audio input and output from and to Devices. Streams may be half duplex (input or output) or full duplex (simultaneous input and output). Streams operate at a specific sample rate with particular sample formats, buffer sizes and internal buffering latencies. You specify these parameters when you open the Stream. Audio data is communicated between a Stream and your application via a user provided asynchronous callback function or by invoking synchronous read and write functions. - -PortAudio supports audio input and output in a variety of sample formats: 8, 16, 24 and 32 bit integer formats and 32 bit floating point, irrespective of the formats supported by the native audio API. PortAudio also supports multichannel buffers in both interleaved and non-interleaved (separate buffer per channel) formats and automatically performs conversion when necessary. If requested, PortAudio can clamp out-of range samples and/or dither to a native format. - -The PortAudio API offers the following functionality: -- Initialize and terminate the library -- Enumerate available Host APIs -- Enumerate available Devices either globally, or within each Host API -- Discover default or recommended Devices and Device settings -- Discover Device capabilities such as supported audio data formats and sample rates -- Create and control audio Streams to acquire audio from and output audio to Devices -- Provide Stream timing information to support synchronising audio with other parts of your application -- Retrieve version and error information. - -These functions are described in more detail below. - - -@section top_level_functions Initialization, termination and utility functions - -The PortAudio library must be initialized before it can be used and terminated to clean up afterwards. You initialize PortAudio by calling Pa_Initialize() and clean up by calling Pa_Terminate(). - -You can query PortAudio for version information using Pa_GetVersion() to get a numeric version number and Pa_GetVersionText() to get a string. - -The size in bytes of the various sample formats represented by the @ref PaSampleFormat enumeration can be obtained using Pa_GetSampleSize(). - -Pa_Sleep() sleeps for a specified number of milliseconds. This isn't intended for use in production systems; it's provided only as a simple portable way to implement tests and examples where the main thread sleeps while audio is acquired or played by an asynchronous callback function. - -@section host_apis Host APIs - -A Host API acts as a top-level grouping for all of the Devices offered by a single native platform audio API. Each Host API has a unique type identifier, a name, zero or more Devices, and nominated default input and output Devices. - -Host APIs are usually referenced by index: an integer of type @ref PaHostApiIndex that ranges between zero and Pa_GetHostApiCount() - 1. You can enumerate all available Host APIs by counting across this range. - -You can retrieve the index of the default Host API by calling Pa_GetDefaultHostApi(). - -Information about a Host API, such as it's name and default devices, is stored in a @ref PaHostApiInfo structure. You can retrieve a pointer to a particular Host API's @ref PaHostApiInfo structure by calling Pa_GetHostApiInfo() with the Host API's index as a parameter. - -Most PortAudio functions reference Host APIs by @ref PaHostApiIndex indices. Each Host API also has a unique type identifier defined in the @ref PaHostApiTypeId enumeration. -You can call Pa_HostApiTypeIdToHostApiIndex() to retrieve the current @ref PaHostApiIndex for a particular @ref PaHostApiTypeId. - -@section devices Devices - -A Device represents an audio endpoint provided by a particular native audio API. This usually corresponds to a specific input or output port on a hardware audio interface, or to the interface as a whole. Each Host API operates independently, so a single physical audio port may be addressable via different Devices exposed by different Host APIs. - -A Device has a name, is associated with a Host API, and has a maximum number of supported input and output channels. PortAudio provides recommended default latency values and a default sample rate for each Device. To obtain more detailed information about device capabilities you can call Pa_IsFormatSupported() to query whether it is possible to open a Stream using particular Devices, parameters and sample rate. - -Although each Device conceptually belongs to a specific Host API, most PortAudio functions and data structures refer to Devices using a global, Host API-independent index of type @ref PaDeviceIndex – an integer of that ranges between zero and Pa_GetDeviceCount() - 1. The reasons for this are partly historical but it also makes it easy for applications to ignore the Host API abstraction and just work with Devices and Streams. - -If you want to enumerate Devices belonging to a particular Host API you can count between 0 and PaHostApiInfo::deviceCount - 1. You can convert this Host API-specific index value to a global @ref PaDeviceIndex value by calling Pa_HostApiDeviceIndexToDeviceIndex(). - -Information about a Device is stored in a @ref PaDeviceInfo structure. You can retrieve a pointer to a Devices's @ref PaDeviceInfo structure by calling Pa_GetDeviceInfo() with the Device's index as a parameter. - -You can retrieve the indices of the global default input and output devices using Pa_GetDefaultInputDevice() and Pa_GetDefaultOutputDevice(). Default Devices for each Host API are stored in the Host API's @ref PaHostApiInfo structures. - -For an example of enumerating devices and printing information about their capabilities see the pa_devs.c program in the test directory of the PortAudio distribution. - -@section streams Streams - -A Stream represents an active flow of audio data between your application and one or more audio Devices. A Stream operates at a specific sample rate with specific sample formats and buffer sizes. - -@subsection io_methods I/O Methods: callback and read/write - -PortAudio offers two methods for communicating audio data between an open Stream and your Application: (1) an asynchronous callback interface, where PortAudio calls a user defined callback function when new audio data is available or required, and (2) synchronous read and write functions which can be used in a blocking or non-blocking manner. You choose between the two methods when you open a Stream. The two methods are discussed in more detail below. - -@subsection opening_and_closing_streams Opening and Closing Streams - -You call Pa_OpenStream() to open a Stream, specifying the Device(s) to use, the number of input and output channels, sample formats, suggested latency values and flags that control dithering, clipping and overflow handling. You specify many of these parameters in two PaStreamParameters structures, one for input and one for output. If you're using the callback I/O method you also pass a callback buffer size, callback function pointer and user data pointer. - -Devices may be full duplex (supporting simultaneous input and output) or half duplex (supporting input or output) – usually this reflects the structure of the underlying native audio API. When opening a Stream you can specify one full duplex Device for both input and output, or two different Devices for input and output. Some Host APIs only support full-duplex operation with a full-duplex device (e.g. ASIO) but most are able to aggregate two half duplex devices into a full duplex Stream. PortAudio requires that all devices specified in a call to Pa_OpenStream() belong to the same Host API. - -A successful call to Pa_OpenStream() creates a pointer to a @ref PaStream – an opaque handle representing the open Stream. All PortAudio API functions that operate on open Streams take a pointer to a @ref PaStream as their first parameter. - -PortAudio also provides Pa_OpenDefaultStream() – a simpler alternative to Pa_OpenStream() which you can use when you want to open the default audio Device(s) with default latency parameters. - -You call Pa_CloseStream() to close a Stream when you've finished using it. - -@subsection starting_and_stopping_streams Starting and Stopping Streams - -Newly opened Streams are initially stopped. You call Pa_StartStream() to start a Stream. You can stop a running Stream using Pa_StopStream() or Pa_AbortStream() (the Stop function plays out all internally queued audio data, while Abort tries to stop as quickly as possible). An open Stream can be started and stopped multiple times. You can call Pa_IsStreamStopped() to query whether a Stream is running or stopped. - -By calling Pa_SetStreamFinishedCallback() it is possible to register a special @ref PaStreamFinishedCallback that will be called when the Stream has completed playing any internally queued buffers. This can be used in conjunction with the @ref paComplete stream callback return value (see below) to avoid blocking on a call to Pa_StopStream() while queued audio data is still playing. - -@subsection callback_io_method The Callback I/O Method - -So-called 'callback Streams' operate by periodically invoking a callback function you supply to Pa_OpenStream(). The callback function must implement the @ref PaStreamCallback signature. It gets called by PortAudio every time PortAudio needs your application to consume or produce audio data. The callback is passed pointers to buffers containing the audio to process. The format (interleave, sample data type) and size of these buffers is determined by the parameters passed to Pa_OpenStream() when the Stream was opened. - -Stream callbacks usually return @ref paContinue to indicate that PortAudio should keep the stream running. It is possible to deactivate a Stream from the stream callback by returning either @ref paComplete or @ref paAbort. In this case the Stream enters a deactivated state after the last buffer has finished playing (@ref paComplete) or as soon as possible (@ref paAbort). You can detect the deactivated state by calling Pa_IsStreamActive() or by using Pa_SetStreamFinishedCallback() to subscribe to a stream finished notification. Note that even if the stream callback returns @ref paComplete it's still necessary to call Pa_StopStream() or Pa_AbortStream() to enter the stopped state. - -Many of the tests in the /tests directory of the PortAudio distribution implement PortAudio stream callbacks. For example see: patest_sine.c (audio output), patest_record.c (audio input), patest_wire.c (audio pass-through) and pa_fuzz.c (simple audio effects processing). - -<strong>IMPORTANT:</strong> The stream callback function often needs to operate with very high or real-time priority. As a result there are strict requirements placed on the type of code that can be executed in a stream callback. In general this means avoiding any code that might block, including: acquiring locks, calling OS API functions including allocating memory. With the exception of Pa_GetStreamCpuLoad() you may not call PortAudio API functions from within the stream callback. - -@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 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(). - -To write audio data to a Stream call Pa_WriteStream() and to read data call Pa_ReadStream(). These functions will block if the internal buffers are full, making them safe to call in a tight loop. If you want to avoid blocking you can query the amount of available read or write space using Pa_GetStreamReadAvailable() or Pa_GetStreamWriteAvailable() and use the returned values to limit the amount of data you read or write. - -For examples of the read/write I/O method see the following examples in the /tests directory of the PortAudio distribution: patest_read_record.c (audio input), patest_write_sine.c (audio output), patest_read_write_wire.c (audio pass-through). - -@subsection stream_info Retrieving Stream Information - -You can retrieve information about an open Stream by calling Pa_GetStreamInfo(). This returns a @ref PaStreamInfo structure containing the actual input and output latency and sample rate of the stream. It's possible for these values to be different from the suggested values passed to Pa_OpenStream(). - -When using a callback stream you can call Pa_GetStreamCpuLoad() to retrieve a rough estimate of the amount of CPU time your callback function is using. - -@subsection stream_timing Stream Timing Information - -When using the callback I/O method your stream callback function receives timing information via a pointer to a PaStreamCallbackTimeInfo structure. This structure contains the current time along with the estimated hardware capture and playback time of the first sample of the input and output buffers. All times are measured in seconds relative to a Stream-specific clock. The current Stream clock time can be retrieved using Pa_GetStreamTime(). - -You can use the stream callback @ref PaStreamCallbackTimeInfo times in conjunction with timestamps returned by Pa_GetStreamTime() to implement time synchronization schemes such as time aligning your GUI display with rendered audio, or maintaining synchronization between MIDI and audio playback. - -@section error_handling Error Handling - -Most PortAudio functions return error codes using values from the @ref PaError enumeration. All error codes are negative values. Some functions return values greater than or equal to zero for normal results and a negative error code in case of error. - -You can convert @ref PaError error codes to human readable text by calling Pa_GetErrorText(). - -PortAudio usually tries to translate error conditions into portable @ref PaError error codes. However if an unexpected error is encountered the @ref paUnanticipatedHostError code may be returned. In this case a further mechanism is provided to query for Host API-specific error information. If PortAudio returns @ref paUnanticipatedHostError you can call Pa_GetLastHostErrorInfo() to retrieve a pointer to a @ref PaHostErrorInfo structure that provides more information, including the Host API that encountered the error, a native API error code and error text. - -@section host_api_extensions Host API and Platform-specific Extensions - -The public PortAudio API only exposes functionality that can be provided across all target platforms. In some cases individual native audio APIs offer unique functionality. Some PortAudio Host APIs expose this functionality via Host API-specific extensions. Examples include access to low-level buffering and priority parameters, opening a Stream with only a subset of a Device's channels, or accessing channel metadata such as channel names. - -Host API-specific extensions are provided in the form of additional functions and data structures defined in Host API-specific header files found in the /include directory. - -The @ref PaStreamParameters structure passed to Pa_IsFormatSupported() and Pa_OpenStream() has a field named @ref PaStreamParameters::hostApiSpecificStreamInfo that is sometimes used to pass low level information when opening a Stream. - -See the documentation for the individual Host API-specific header files for details of the extended functionality they expose: - -- pa_asio.h -- pa_jack.h -- pa_linux_alsa.h -- pa_mac_core.h -- pa_win_ds.h -- pa_win_wasapi.h -- pa_win_wmme.h -- pa_win_waveformat.h - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/images/portaudio-external-architecture-diagram.png b/portaudio/doc/src/images/portaudio-external-architecture-diagram.png Binary files differdeleted file mode 100644 index 64c0905..0000000 --- a/portaudio/doc/src/images/portaudio-external-architecture-diagram.png +++ /dev/null diff --git a/portaudio/doc/src/license.dox b/portaudio/doc/src/license.dox deleted file mode 100644 index 8d0c51f..0000000 --- a/portaudio/doc/src/license.dox +++ /dev/null @@ -1,38 +0,0 @@ -/** @page License PortAudio License - -PortAudio Portable Real-Time Audio Library <br> -Copyright (c) 1999-2011 Ross Bencina, Phil Burk - - - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files -(the "Software"), to deal in the Software without restriction, -including without limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of the Software, -and to permit persons to whom the Software is furnished to do so, -subject to the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR -ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF -CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -<br> - -The text above constitutes the entire PortAudio license; however, -the PortAudio community also makes the following non-binding requests: - -Any person wishing to distribute modifications to the Software is -requested to send the modifications to the original developer so that -they can be incorporated into the canonical version. It is also -requested that these non-binding requests be included along with the -license above. - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/mainpage.dox b/portaudio/doc/src/mainpage.dox deleted file mode 100644 index 53e0060..0000000 --- a/portaudio/doc/src/mainpage.dox +++ /dev/null @@ -1,63 +0,0 @@ -/* doxygen index page */ -/** @mainpage - -@section overview Overview - -PortAudio is a cross-platform, open-source C language library for real-time audio input and output. -The library provides functions that allow your software to acquire and output real-time audio streams from your computer's hardware audio interfaces. It is designed to simplify writing cross-platform audio applications, and also to simplify the development of audio software in general by hiding the complexities of dealing directly with each native audio API. PortAudio is used to implement sound recording, editing and mixing applications, software synthesizers, effects processors, music players, internet telephony applications, software defined radios and more. Supported platforms include MS Windows, Mac OS X and Linux. Third-party language bindings make it possible to call PortAudio from other programming languages including @ref java_binding "Java", C++, C#, Python, PureBasic, FreePascal and Lazarus. - -@section start_here Start here - -- @ref api_overview <br> -A top-down view of the PortAudio API, its capabilities, functions and data structures - -- @ref tutorial_start <br> -Get started writing code with PortAudio tutorials - -- @ref examples_src "Examples"<br> -Simple example programs demonstrating PortAudio usage - -- @ref License <br> -PortAudio is licenced under the MIT Expat open source licence. We make a non-binding request for you to contribute your changes back to the project. - - -@section reference API Reference - -- portaudio.h Portable API<br> -Detailed documentation for each portable API function and data type - -- @ref public_header "Host API Specific Extensions"<br> -Documentation for non-portable platform-specific host API extensions - - -@section resources Resources - -- <a href="http://www.portaudio.com">The PortAudio website</a> - -- <a href="http://www.portaudio.com/contacts.html">Our mailing list for users and developers</a><br> - -- <a href="https://github.com/PortAudio/portaudio/wiki">The PortAudio wiki</a> - -@section developer_resources Developer Resources - -@if INTERNAL -- @ref srcguide -@endif - -- <a href="https://github.com/PortAudio/portaudio/">Our repository on GitHub</a> - -- <a href="https://github.com/PortAudio/portaudio/wiki/DeveloperGuidelines">Developer guidelines</a> - -- <a href="https://github.com/PortAudio/portaudio/wiki/ImplementationStyleGuidelines">Implementation style guidelines</a> - -If you're interested in helping out with PortAudio development we're more than happy for you to be involved. -Just drop by the PortAudio mailing list and ask how you can help. -Or check out these <a href="https://github.com/PortAudio/portaudio/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22"> -recommended starter issues</a>. - -@section older_api_versions Older API Versions - -This documentation covers the current API version: PortAudio V19, API version 2.0. API 2.0 differs in a number of ways from previous versions (most often encountered in PortAudio V18), please consult the enhancement proposals for details of what was added/changed for V19: -http://www.portaudio.com/docs/proposals/index.html - -*/ diff --git a/portaudio/doc/src/srcguide.dox b/portaudio/doc/src/srcguide.dox deleted file mode 100644 index 26fd941..0000000 --- a/portaudio/doc/src/srcguide.dox +++ /dev/null @@ -1,55 +0,0 @@ -/* - define all of the file groups used to structure the documentation. -*/ - -/** - @defgroup public_header Public API definitions for users of PortAudio -*/ - -/** - @internal - @defgroup common_src Source code common to all implementations -*/ - -/** - @internal - @defgroup win_src Source code common to all Windows implementations -*/ - -/** - @internal - @defgroup unix_src Source code common to all Unix implementations -*/ - -/** - @internal - @defgroup macosx_src Source code common to all Macintosh implementations -*/ - -/** - @internal - @defgroup hostapi_src Source code for specific Host APIs -*/ - -/** - @internal - @defgroup test_src Test programs -*/ - -/** - @defgroup examples_src Example programs demonstrating PortAudio usage -*/ - -/** - @internal - @page srcguide A guide to the PortAudio sources - - - \ref public_header - - \ref examples_src - - \ref common_src - - \ref win_src - - \ref unix_src - - \ref macosx_src - - \ref hostapi_src - - \ref test_src -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/blocking_read_write.dox b/portaudio/doc/src/tutorial/blocking_read_write.dox deleted file mode 100644 index 8905ee3..0000000 --- a/portaudio/doc/src/tutorial/blocking_read_write.dox +++ /dev/null @@ -1,68 +0,0 @@ -/** @page blocking_read_write Blocking Read/Write Functions -@ingroup tutorial - -PortAudio V19 adds a huge advance over previous versions with a feature called Blocking I/O. Although it may have lower performance that the callback method described earlier in this tutorial, blocking I/O is easier to understand and is, in some cases, more compatible with third party systems than the callback method. Most people starting audio programming also find Blocking I/O easier to learn. - -Blocking I/O works in much the same way as the callback method except that instead of providing a function to provide (or consume) audio data, you must feed data to (or consume data from) PortAudio at regular intervals, usually inside a loop. The example below, excepted from patest_read_write_wire.c, shows how to open the default device, and pass data from its input to its output for a set period of time. Note that we use the default high latency values to help avoid underruns since we are usually reading and writing audio data from a relatively low priority thread, and there is usually extra buffering required to make blocking I/O work. - -Note that not all API's implement Blocking I/O at this point, so for maximum portability or performance, you'll still want to use callbacks. - -@code - /* -- initialize PortAudio -- */ - err = Pa_Initialize(); - if( err != paNoError ) goto error; - - /* -- setup input and output -- */ - inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */ - inputParameters.channelCount = NUM_CHANNELS; - inputParameters.sampleFormat = PA_SAMPLE_TYPE; - inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultHighInputLatency ; - inputParameters.hostApiSpecificStreamInfo = NULL; - - outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ - outputParameters.channelCount = NUM_CHANNELS; - outputParameters.sampleFormat = PA_SAMPLE_TYPE; - outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultHighOutputLatency; - outputParameters.hostApiSpecificStreamInfo = NULL; - - /* -- setup stream -- */ - err = Pa_OpenStream( - &stream, - &inputParameters, - &outputParameters, - SAMPLE_RATE, - FRAMES_PER_BUFFER, - paClipOff, /* we won't output out of range samples so don't bother clipping them */ - NULL, /* no callback, use blocking API */ - NULL ); /* no callback, so no callback userData */ - if( err != paNoError ) goto error; - - /* -- start stream -- */ - err = Pa_StartStream( stream ); - if( err != paNoError ) goto error; - printf("Wire on. Will run one minute.\n"); fflush(stdout); - - /* -- Here's the loop where we pass data from input to output -- */ - for( i=0; i<(60*SAMPLE_RATE)/FRAMES_PER_BUFFER; ++i ) - { - err = Pa_WriteStream( stream, sampleBlock, FRAMES_PER_BUFFER ); - if( err ) goto xrun; - err = Pa_ReadStream( stream, sampleBlock, FRAMES_PER_BUFFER ); - if( err ) goto xrun; - } - /* -- Now we stop the stream -- */ - err = Pa_StopStream( stream ); - if( err != paNoError ) goto error; - - /* -- don't forget to cleanup! -- */ - err = Pa_CloseStream( stream ); - if( err != paNoError ) goto error; - - Pa_Terminate(); - return 0; -@endcode - - -Previous: \ref querying_devices | Next: \ref exploring - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/compile_cmake.dox b/portaudio/doc/src/tutorial/compile_cmake.dox deleted file mode 100644 index 8db400e..0000000 --- a/portaudio/doc/src/tutorial/compile_cmake.dox +++ /dev/null @@ -1,57 +0,0 @@ -/** @page compile_cmake PortAudio on Windows, OS X or Linux via. CMake -@ingroup tutorial - -@section cmake_building Building PortAudio stand-alone on Windows, OS X or Linux - -CMake can be used to generate Visual Studio solutions on Windows, Makefiles (on Linux and OS X) and build metadata for other build systems for PortAudio. You should obtain a recent version of CMake from [http://www.cmake.org] if you do not have one already. If you are unfamiliar with CMake, this section will provide some information on using CMake to build PortAudio. - -On Linux, CMake serves a very similar purpose to an autotools "configure" script - except it can generate build metadata apart from Makefiles. The equivalent of the following on POSIX'y systems: - - build_path> {portaudio path}/configure --prefix=/install_location - build_path> make - build_path> make install - -Would be: - - build_path> cmake {portaudio path} -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=/install_location - build_path> make - build_path> make install - -The "-G" option specifies the type of build metadata which will be generated. You can obtain a list of supported build metadata formats by invoking (on any platform): - - cmake -G - -"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 targeting a 64-bit build: - - C:\PABUILD> cmake {portaudio path} -G "Visual Studio 14 2015 Win64" - -After executing the above, you can either open the generated solution with Visual Studio or use CMake to invoke the build process. The following shows an example of how to build a release configuration (assuming the above command was executed previously in the same directory): - - C:\PABUILD> cmake --build . --config Release - -If you want ASIO support you need to obtain the ASIO2 SDK from Steinberg and place it according to \ref compile_windows_asio_msvc. Both ASIO and the DirectX SDK are automatically searched for by the CMake script - if they are found, they will be enabled by default. - -@section cmake_using Using PortAudio in your CMake project - -PortAudio defines the following CMake targets: - - - "portaudio_static" for a static library and - - "portaudio" for a dynamic library - -If you installed PortAudio as described above in \ref cmake_building and the install prefix you used (CMAKE_INSTALL_PREFIX) is in your system PATH or CMAKE_MODULE_PATH CMake variable, you should be able to use: - - find_package(portaudio) - -To define the "portaudio_static" and "portaudio" targets in your CMake project. - -If you do not want to install portaudio into your system but would rather just have it get built as part of your own project (which may be particularly convenient on Windows), you may also use: - - add_subdirectory("path to PortAudio location" "some binary directory" EXCLUDE_FROM_ALL) - -EXCLUDE_FROM_ALL is not strictly necessary, but will ensure that targets which you don't use in your project won't get built. - -Back to \ref tutorial_start - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/compile_linux.dox b/portaudio/doc/src/tutorial/compile_linux.dox deleted file mode 100644 index 2c993ca..0000000 --- a/portaudio/doc/src/tutorial/compile_linux.dox +++ /dev/null @@ -1,83 +0,0 @@ -/** @page compile_linux Building Portaudio for Linux -@ingroup tutorial - -<i>Note: this page has not been reviewed, and may contain errors.</i> - -@section comp_linux1 Installing ALSA Development Kit - -The OSS sound API is very old and not well supported. It is recommended that you use the ALSA sound API. -The PortAudio configure script will look for the ALSA SDK. You can install the ALSA SDK on Ubuntu using: - -@code -sudo apt-get install libasound-dev -@endcode - -You might need to use yum, or some other package manager, instead of apt-get on your machine. -If you do not install ALSA then you might get a message when testing that says you have no audio devices. - -You can find out more about ALSA here: http://www.alsa-project.org/ - -@section comp_linux2 Configuring and Compiling PortAudio - -You can build PortAudio in Linux Environments using the standard configure/make tools: - -@code -./configure && make -@endcode - -That will build PortAudio using Jack, ALSA and OSS in whatever combination they are found on your system. For example, if you have Jack and OSS but not ALSA, it will build using Jack and OSS but not ALSA. This step also builds a number of tests, which can be found in the bin directory of PortAudio. It's a good idea to run some of these tests to make sure PortAudio is working correctly. - -@section comp_linux3 Using PortAudio in your Projects - -To use PortAudio in your apps, you can simply install the .so files: - -@code -sudo make install -@endcode - -Projects built this way will expect PortAudio to be installed on target systems in order to run. If you want to build a more self-contained binary, you may use the libportaudio.a file: - -@code -cp lib/.libs/libportaudio.a /YOUR/PROJECT/DIR -@endcode - -On some systems you may need to use: - -@code -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 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 -@endcode - -@section comp_linux4 Linux Extensions - -Note that the ALSA PortAudio back-end adds a few extensions to the standard API that you may take advantage of. To use these functions be sure to include the pa_linux_alsa.h file found in the include file in the PortAudio folder. This file contains further documentation on the following functions: - - PaAlsaStreamInfo/PaAlsa_InitializeStreamInfo:: - Objects of the !PaAlsaStreamInfo type may be used for the !hostApiSpecificStreamInfo attribute of a !PaStreamParameters object, in order to specify the name of an ALSA device to open directly. Specify the device via !PaAlsaStreamInfo.deviceString, after initializing the object with PaAlsa_InitializeStreamInfo. - - PaAlsa_EnableRealtimeScheduling:: - PA ALSA supports real-time scheduling of the audio callback thread (using the FIFO pthread scheduling policy), via the extension PaAlsa_EnableRealtimeScheduling. Call this on the stream before starting it with the <i>enableScheduling</i> parameter set to true or false, to enable or disable this behaviour respectively. - - PaAlsa_GetStreamInputCard:: - Use this function to get the ALSA-lib card index of the stream's input device. - - PaAlsa_GetStreamOutputCard:: - Use this function to get the ALSA-lib card index of the stream's output device. - -Of particular importance is PaAlsa_EnableRealtimeScheduling, which allows ALSA to run at a high priority to prevent ordinary processes on the system from preempting audio playback. Without this, low latency audio playback will be irregular and will contain frequent drop-outs. - -@section comp_linux5 Linux Debugging - -Eliot Blennerhassett writes: - -On linux build, use e.g. "libtool gdb bin/patest_sine8" to debug that program. -This is because on linux bin/patest_sine8 is a libtool shell script that wraps -bin/.libs/patest_sine8 and allows it to find the appropriate libraries within -the build tree. - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/compile_mac_coreaudio.dox b/portaudio/doc/src/tutorial/compile_mac_coreaudio.dox deleted file mode 100644 index 068391e..0000000 --- a/portaudio/doc/src/tutorial/compile_mac_coreaudio.dox +++ /dev/null @@ -1,122 +0,0 @@ -/** @page compile_mac_coreaudio Building Portaudio for Mac OS X -@ingroup tutorial - -@section comp_mac_ca_1 Requirements - -* OS X 10.4 or later. PortAudio v19 currently only compiles and runs on OS X version 10.4 or later. Because of its heavy reliance on memory barriers, it's not clear how easy it would be to back-port PortAudio to OS X version 10.3. Leopard support requires the 2007 snapshot or later. - -* Apple's Xcode and its related tools installed in the default location. There is no Xcode project for PortAudio. - -* Mac 10.4 SDK. Look for "/Developer/SDKs/MacOSX10.4u.sdk" folder on your system. It may be installed with XCode. If not then you can download it from Apple Developer Connection. http://connect.apple.com/ - -@section comp_mac_ca_2 Building - -To build PortAudio, simply use the Unix-style "./configure && make": - -@code - ./configure && make -@endcode - -You do <b>not</b> need to do "make install", and we don't recommend it; however, you may be using software that instructs you to do so, in which case you should follow those instructions. (Note from Phil: I had to do "sudo make install" after the command above, otherwise XCode complained that it could not find "/usr/local/lib/libportaudio.dylib" when I compiled an example.) - -The result of these steps will be a file named "libportaudio.dylib" in the directory "usr/local/lib/". - -By default, this will create universal binaries and therefore requires the Universal SDK from Apple, included with XCode 2.1 and higher. - -@section comp_mac_ca_3 Other Build Options - -There are a variety of other options for building PortAudio. The default described above is recommended as it is the most supported and tested; however, your needs may differ and require other options, which are described below. - -@subsection comp_mac_ca_3.1 Building Non-Universal Libraries - -By default, PortAudio is built as a universal binary. This includes 64-bit versions if you are compiling on 10.5, Leopard. If you want a "thin", or single architecture library, you have two options: - - * build a non-universal library using configure options. - * use lipo(1) on whatever part of the library you plan to use. - -Note that the first option may require an extremely recent version of PortAudio (February 5th '08 at least). - -@subsection comp_mac_ca_3.2 Building with <i>--disable-mac-universal</i> - -To build a non-universal library for the host architecture, simply use the <i>--disable-mac-universal</i> option with configure. - -@code - ./configure --disable-mac-universal && make -@endcode - -The <i>--disable-mac-universal</i> option may also be used in conjunction with environment variables to give you more control over the universal binary build process. For example, to build a universal binary for the i386 and ppc architectures using the 10.4u sdk (which is the default on 10.4, but not 10.5), you might specify this configure command line: - -@code - CFLAGS="-O2 -g -Wall -arch i386 -arch ppc -isysroot /Developer/SDKs/MacOSX10.4u.sdk -mmacosx-version-min=10.3" \ - LDFLAGS="-arch i386 -arch ppc -isysroot /Developer/SDKs/MacOSX10.4u.sdk -mmacosx-version-min=10.3" \ - ./configure --disable-mac-universal --disable-dependency-tracking -@endcode - -For more info, see Apple's documentation on the matter: - - * http://developer.apple.com/technotes/tn2005/tn2137.html - * http://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/intro/chapter_1_section_1.html - -@subsection comp_mac_ca_3.3 Using lipo - -The second option is to build normally, and use lipo (1) to extract the architectures you want. For example, if you want a "thin", i386 library only: - -@code - lipo lib/.libs/libportaudio.a -thin i386 -output libportaudio.a -@endcode - -or if you want to extract a single architecture fat file: - -@code - lipo lib/.libs/libportaudio.a -extract i386 -output libportaudio.a -@endcode - -@subsection comp_mac_ca_3.4 Building With Debug Options - -By default, PortAudio on the mac is built without any debugging options. This is because asserts are generally inappropriate for a production environment and debugging information has been suspected, though not proven, to cause trouble with some interfaces. If you would like to compile with debugging, you must run configure with the appropriate flags. For example: - -@code - ./configure --enable-mac-debug && make -@endcode - -This will enable -g and disable -DNDEBUG which will effectively enable asserts. - -@section comp_mac_ca_4 Using the Library in XCode Projects - -If you are planning to follow the rest of the tutorial, several project types will work. You can create a "Standard Tool" under "Command Line Utility". If you are not following the rest of the tutorial, any type of project should work with PortAudio, but these instructions may not work perfectly. - -Once you've compiled PortAudio, the easiest and recommended way to use PortAudio in your XCode project is to add "<portaudio>/include/portaudio.h" and "<portaudio>/lib/.libs/libportaudio.a" to your project. Because "<portaudio>/lib/.libs/" is a hidden directory, you won't be able to navigate to it using the finder or the standard Mac OS file dialogs by clicking on files and folders. You can use command-shift-G in the finder to specify the exact path, or, from the shell, if you are in the portaudio directory, you can enter this command: - -@code - open lib/.libs -@endcode - -Then drag the "libportaudio.a" file into your XCode project and place it in the "External Frameworks and Libraries" group, if the project type has it. If not you can simply add it to the top level folder of the project. - -You will need to add the following frameworks to your XCode project: - - - CoreAudio.framework - - AudioToolbox.framework - - AudioUnit.framework - - CoreServices.framework - - CoreFoundation.framework - -@section comp_mac_ca_5 Using the Library in Other Projects - -For gcc/Make style projects, include "include/portaudio.h" and link "libportaudio.a", and use the frameworks listed in the previous section. How you do so depends on your build. - -@section comp_mac_ca_6 Using Mac-only Extensions to PortAudio - -For additional, Mac-only extensions to the PortAudio interface, you may also want to grab "include/pa_mac_core.h". This file contains some special, mac-only features relating to sample-rate conversion, channel mapping, performance and device hogging. See "src/hostapi/coreaudio/notes.txt" for more details on these features. - -@section comp_mac_ca_7 What Happened to Makefile.darwin? - -Note, there used to be a special makefile just for darwin. This is no longer supported because you can build universal binaries from the standard configure routine. If you find this file in your directory structure it means you have an outdated version of PortAudio. - -@code - make -f Makefile.darwin -@endcode - -Back to the Tutorial: \ref tutorial_start - -*/ diff --git a/portaudio/doc/src/tutorial/compile_windows.dox b/portaudio/doc/src/tutorial/compile_windows.dox deleted file mode 100644 index 2258939..0000000 --- a/portaudio/doc/src/tutorial/compile_windows.dox +++ /dev/null @@ -1,108 +0,0 @@ -/** @page compile_windows Building PortAudio for Windows using Microsoft Visual Studio -@ingroup tutorial - -Below is a list of steps to build PortAudio into a dll and lib file. The resulting dll file may contain all five current win32 PortAudio APIs: MME, DirectSound, WASAPI, WDM/KS and ASIO, depending on the preprocessor definitions set in step 9 below. - -PortAudio can be compiled using Visual C++ Express Edition which is available free from Microsoft. If you do not already have a C++ development environment, simply download and install. These instructions have been observed to succeed using Visual Studio 2010 as well. - -1) Building PortAudio with DirectSound support requires the files <i>dsound.h</i> and <i>dsconf.h</i>. Download and install the DirectX SDK from http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=3021d52b-514e-41d3-ad02-438a3ba730ba to obtain these files. If you installed the DirectX SDK then the DirectSound libraries and header files should be found automatically by Visual Studio/Visual C++. If you get an error saying dsound.h or dsconf.h is missing, you will need to add an extra include path to the Visual Studio project file referencing the DirectX includes directory. - -2) For ASIO support, download the ASIO SDK from Steinberg at http://www.steinberg.net/en/company/developer.html . The SDK is free, but you will need to set up a developer account with Steinberg. To use the Visual Studio projects mentioned below, copy the entire ASIOSDK2 folder into src\\hostapi\\asio\\. Rename it from ASIOSDK2 to ASIOSDK. To build without ASIO (or other host API) see the "Building without ASIO support" section below. - -3) If you have Visual Studio 6.0, 7.0(VC.NET/2001) or 7.1(VC.2003), open portaudio.dsp and convert if needed. - -4) If you have Visual Studio 2005, Visual C++ 2008 Express Edition or Visual Studio 2010, open the portaudio.sln file located in build\\msvc\\. Doing so will open Visual Studio or Visual C++. Click "Finish" if a conversion wizard appears. The sln file contains four configurations: Win32 and Win64 in both Release and Debug variants. - -@section comp_win1 For Visual Studio 2005, Visual C++ 2008 Express Edition or Visual Studio 2010 - -The steps below describe settings for recent versions of Visual Studio. Similar settings can be set in earlier versions of Visual Studio. - -5) Open Project -> portaudio Properties and select "Configuration Properties" in the tree view. - -6) Select "all configurations" in the "Configurations" combo box above. Select "All Platforms" in the "Platforms" combo box. - -7) Now set a few options: - -Required: - -C/C++ -> Code Generation -> Runtime library = /MT - -Optional: - -C/C++ -> Optimization -> Omit frame pointers = Yes - -Optional: C/C++ -> Code Generation -> Floating point model = fast - -NOTE: When using PortAudio from C/C++ it is not usually necessary to explicitly set the structure member alignment; the default should work fine. However some languages require, for example, 4-byte alignment. If you are having problems with portaudio.h structure members not being properly read or written to, it may be necessary to explicitly set this value by going to C/C++ -> Code Generation -> Struct member alignment and setting it to an appropriate value (four is a common value). If your compiler is configurable, you should ensure that it is set to use the same structure member alignment value as used for the PortAudio build. - -Click "Ok" when you have finished setting these parameters. - -@section comp_win2 Preprocessor Definitions - -Since the preprocessor definitions are different for each configuration and platform, you'll need to edit these individually for each configuration/platform combination that you want to modify using the "Configurations" and "Platforms" combo boxes. - -8) To suppress PortAudio runtime debug console output, go to Project -> Properties -> Configuration Properties -> C/C++ -> Preprocessor. In the field 'Preprocessor Definitions', find PA_ENABLE_DEBUG_OUTPUT and remove it. The console will not output debug messages. - -9) Also in the preprocessor definitions you need to explicitly define the native audio APIs you wish to use. For Windows the available API definitions are: - -PA_USE_ASIO<br> -PA_USE_DS (DirectSound)<br> -PA_USE_WMME (MME)<br> -PA_USE_WASAPI<br> -PA_USE_WDMKS<br> -PA_USE_SKELETON - -For each of these, the value of 0 indicates that support for this API should not be included. The value 1 indicates that support for this API should be included. (PA_USE_SKELETON is not usually used, it is a code sample for developers wanting to support a new API). - -@section comp_win3 Building - -As when setting Preprocessor definitions, building is a per-configuration per-platform process. Follow these instructions for each configuration/platform combination that you're interested in. - -10) From the Build menu click Build -> Build solution. For 32-bit compilations, the dll file created by this process (portaudio_x86.dll) can be found in the directory build\\msvc\\Win32\\Release. For 64-bit compilations, the dll file is called portaudio_x64.dll, and is found in the directory build\\msvc\\x64\\Release. - -11) Now, any project that requires portaudio can be linked with portaudio_x86.lib (or _x64) and include the relevant headers (portaudio.h, and/or pa_asio.h , pa_x86_plain_converters.h) You may want to add/remove some DLL entry points. At the time of writing the following 6 entries are not part of the official PortAudio API defined in portaudio.h: - -(from portaudio.def) -@code -... -PaAsio_GetAvailableLatencyValues @50 -PaAsio_ShowControlPanel @51 -PaUtil_InitializeX86PlainConverters @52 -PaAsio_GetInputChannelName @53 -PaAsio_GetOutputChannelName @54 -PaUtil_SetLogPrintFunction @55 -@endcode - -@section comp_win4 Building without ASIO support - -To build PortAudio without ASIO support you need to: - -1) Make sure your project doesn't try to build any ASIO SDK files. If you're using one of the shipped projects, remove the ASIO related files from the project. In the shipped projects you can find them in the project tree under portaudio > Source Files > hostapi > ASIO > ASIOSDK - -2) Make sure your project doesn't try to build the PortAudio ASIO implementation files: - -@code -src\\hostapi\\pa_asio.cpp -src\\hostapi\\iasiothiscallresolver.cpp -@endcode - -If you're using one of the shipped projects, remove them from the project. In the shipped projects you can find them in the project tree under portaudio > Source Files > hostapi > ASIO - -3) Define the preprocessor symbols in the project properties as described in step 9 above. In VS2005 this can be accomplished by selecting -Project Properties -> Configuration Properties -> C/C++ -> Preprocessor -> Preprocessor Definitions. Omitting PA_USE_ASIO or setting it to 0 stops src\\os\\win\\pa_win_hostapis.c from trying to initialize the PortAudio ASIO implementation. - -4) Remove PaAsio_* entry points from portaudio.def - - ------ -David Viens, davidv@plogue.com - -Updated by Chris on 5/26/2011 - -Improvements by John Clements on 12/15/2011 - -Edits by Ross on 1/20/2014 - -Back to the Tutorial: \ref tutorial_start - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/compile_windows_asio_msvc.dox b/portaudio/doc/src/tutorial/compile_windows_asio_msvc.dox deleted file mode 100644 index cf3a0e5..0000000 --- a/portaudio/doc/src/tutorial/compile_windows_asio_msvc.dox +++ /dev/null @@ -1,97 +0,0 @@ -/** @page compile_windows_asio_msvc Building Portaudio for Windows with ASIO support using MSVC -@ingroup tutorial - -@section comp_win_asiomsvc1 Portaudio Windows ASIO with MSVC - -This tutorial describes how to build PortAudio with ASIO support using MSVC *from scratch*, without an existing Visual Studio project. For instructions for building PortAudio (including ASIO support) using the bundled Visual Studio project file see the compiling instructions for \ref compile_windows. - -ASIO is a low latency audio API from Steinberg. To compile an ASIO -application, you must first download the ASIO SDK from Steinberg. You also -need to obtain ASIO drivers for your audio device. Download the ASIO SDK from Steinberg at http://www.steinberg.net/en/company/developer.html . The SDK is free but you will need to set up a developer account with Steinberg. - -This tutorial assumes that you have 3 directories set up at the same level (side by side), one containing PortAudio, one containing the ASIO SDK and one containing your Visual Studio project: - -@code -/ASIOSDK2 -/portaudio -/DirContainingYourVisualStudioProject (should directly contain the .sln, .vcproj or .vcprojx etc.) -@endcode - -First, make sure that the Steinberg SDK and the portaudio files are "side by side" in the same directory. - -Open Microsoft Visual C++ and create a new blank Console exe Project/Workspace in that same directory. - -For example, the paths for all three groups might read like this: - -@code -C:\Program Files\Microsoft Visual Studio\VC98\My Projects\ASIOSDK2 -C:\Program Files\Microsoft Visual Studio\VC98\My Projects\portaudio -C:\Program Files\Microsoft Visual Studio\VC98\My Projects\Sawtooth -@endcode - - -Next, add the following Steinberg ASIO SDK files to the project Source Files: - -@code -asio.cpp (ASIOSDK2\common) -asiodrivers.cpp (ASIOSDK2\host) -asiolist.cpp (ASIOSDK2\host\pc) -@endcode - - -Then, add the following PortAudio files to the project Source Files: - -@code -pa_asio.cpp (portaudio\src\hostapi\asio) -pa_allocation.c (portaudio\src\common) -pa_converters.c (portaudio\src\common) -pa_cpuload.c (portaudio\src\common) -pa_dither.c (portaudio\src\common) -pa_front.c (portaudio\src\common) -pa_process.c (portaudio\src\common) -pa_ringbuffer.c (portaudio\src\common) -pa_stream.c (portaudio\src\common) -pa_trace.c (portaudio\src\common) -pa_win_hostapis.c (portaudio\src\os\win) -pa_win_util.c (portaudio\src\os\win) -pa_win_coinitialize.c (portaudio\src\os\win) -pa_win_waveformat.c (portaudio\src\os\win) -pa_x86_plain_converters.c (portaudio\src\os\win) -paex_saw.c (portaudio\examples) (Or another file containing main() - for the console exe to be built.) -@endcode - - -Although not strictly necessary, you may also want to add the following files to the project Header Files: - -@code -portaudio.h (portaudio\include) -pa_asio.h (portaudio\include) -@endcode - -These header files define the interfaces to the PortAudio API. - - -Next, go to Project Settings > All Configurations > C/C++ > Preprocessor > Preprocessor Definitions and add -PA_USE_ASIO=1 to any entries that might be there. - -eg: WIN32;_CONSOLE;_MBCS changes to WIN32;_CONSOLE,_MBCS;PA_USE_ASIO=1 - -Then, on the same Project Settings tab, go down to Additional Include Directories (in VS2010 you'll find this setting under C/C++ > General) and enter the following relative include paths: - -@code -..\portaudio\include;..\portaudio\src\common;..\portaudio\src\os\win;..\asiosdk2\common;..\asiosdk2\host;..\asiosdk2\host\pc -@endcode - -You'll need to make sure the relative paths are correct for the particular directory layout you're using. The above should work fine if you use the side-by-side layout we recommended earlier. - -Some source code in the ASIO SDK is not compatible with the Win32 API UNICODE mode (The ASIO SDK expects the non-Unicode Win32 API). Therefore you need to make sure your project is set to not use Unicode. You do this by setting the project Character Set to "Use Multi-Byte Character Set" (NOT "Use Unicode Character Set"). In VS2010 the Character Set option can be found at Configuration Properties > General > Character Set. (An alternative to setting the project to non-Unicode is to patch asiolist.cpp to work when UNICODE is defined: put #undef UNICODE at the top of the file before windows.h is included.) - -You should now be able to build any of the test executables in the portaudio\\examples directory. -We suggest that you start with paex_saw.c because it's one of the simplest example files. - ---- Chris Share, Tom McCandless, Ross Bencina - -Back to the Tutorial: \ref tutorial_start - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/compile_windows_mingw.dox b/portaudio/doc/src/tutorial/compile_windows_mingw.dox deleted file mode 100644 index 30143dc..0000000 --- a/portaudio/doc/src/tutorial/compile_windows_mingw.dox +++ /dev/null @@ -1,56 +0,0 @@ -/** @page compile_windows_mingw Building Portaudio for Windows with MinGW -@ingroup tutorial - -@section comp_mingw1 Portaudio for Windows With MinGW - -<strong>This document contains old or out-of-date information. Please see -a draft of new MinGW information on our -Wiki: <a href="https://github.com/PortAudio/portaudio/wiki/Notes_about_building_PortAudio_with_MinGW"> -PortAudio Wiki: Notes about building PortAudio with MinGW</a></strong> - -= MinGW/MSYS = - -From the [http://www.mingw.org MinGW projectpage]: - -MinGW: A collection of freely available and freely distributable -Windows specific header files and import libraries, augmenting -the GNU Compiler Collection, (GCC), and its associated -tools, (GNU binutils). MinGW provides a complete Open Source -programming tool set which is suitable for the development of -native Windows programs that do not depend on any 3rd-party C -runtime DLLs. - -MSYS: A Minimal SYStem providing a POSIX compatible Bourne shell -environment, with a small collection of UNIX command line -tools. Primarily developed as a means to execute the configure -scripts and Makefiles used to build Open Source software, but -also useful as a general purpose command line interface to -replace Windows cmd.exe. - -MinGW provides a compiler/linker toolchain while MSYS is required -to actually run the PortAudio configure script. - -Once MinGW and MSYS are installed (see the [http://www.mingw.org/MinGWiki MinGW-Wiki]) open an MSYS shell and run the famous: - -@code -./configure -make -make install -@endcode - -The above should create a working version though you might want to -provide '--prefix=<path-to-install-dir>' to configure. - -'./configure --help' gives details as to what can be tinkered with. - ---- Mikael Magnusson - -To update your copy or check out a fresh copy of the source - -[wiki:UsingThePortAudioSvnRepository SVN instructions] - ---- Bob !McGwier - -Back to the Tutorial: \ref tutorial_start - -*/ diff --git a/portaudio/doc/src/tutorial/exploring.dox b/portaudio/doc/src/tutorial/exploring.dox deleted file mode 100644 index 9dd0873..0000000 --- a/portaudio/doc/src/tutorial/exploring.dox +++ /dev/null @@ -1,15 +0,0 @@ -/** @page exploring Exploring PortAudio -@ingroup tutorial - -Now that you have a good idea of how PortAudio works, you can try out the example programs. You'll find them in the examples/ directory in the PortAudio distribution. - -For an example of playing a sine wave, see examples/paex_sine.c. - -For an example of recording and playing back a sound, see examples/paex_record.c. - -I also encourage you to examine the source for the PortAudio libraries. If you have suggestions on ways to improve them, please let us know. If you want to implement PortAudio on a new platform, please let us know as well so we can coordinate people's efforts. - - -Previous: \ref blocking_read_write | Next: This is the end of the tutorial. - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/initializing_portaudio.dox b/portaudio/doc/src/tutorial/initializing_portaudio.dox deleted file mode 100644 index 9439c35..0000000 --- a/portaudio/doc/src/tutorial/initializing_portaudio.dox +++ /dev/null @@ -1,29 +0,0 @@ -/** @page initializing_portaudio Initializing PortAudio -@ingroup tutorial - -@section tut_init1 Initializing PortAudio - -Before making any other calls to PortAudio, you 'must' call Pa_Initialize(). This will trigger a scan of available devices which can be queried later. Like most PA functions, it will return a result of type paError. If the result is not paNoError, then an error has occurred. -@code -err = Pa_Initialize(); -if( err != paNoError ) goto error; -@endcode - -You can get a text message that explains the error message by passing it to Pa_GetErrorText( err ). For Example: - -@code -printf( "PortAudio error: %s\n", Pa_GetErrorText( err ) ); -@endcode - -It is also important, when you are done with PortAudio, to Terminate it: - -@code -err = Pa_Terminate(); -if( err != paNoError ) - printf( "PortAudio error: %s\n", Pa_GetErrorText( err ) ); -@endcode - - -Previous: \ref writing_a_callback | Next: \ref open_default_stream - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/open_default_stream.dox b/portaudio/doc/src/tutorial/open_default_stream.dox deleted file mode 100644 index 7512d1e..0000000 --- a/portaudio/doc/src/tutorial/open_default_stream.dox +++ /dev/null @@ -1,48 +0,0 @@ -/** @page open_default_stream Opening a Stream Using Defaults -@ingroup tutorial - -The next step is to open a stream, which is similar to opening a file. You can specify whether you want audio input and/or output, how many channels, the data format, sample rate, etc. Opening a ''default'' stream means opening the default input and output devices, which saves you the trouble of getting a list of devices and choosing one from the list. (We'll see how to do that later.) -@code -#define SAMPLE_RATE (44100) -static paTestData data; - -..... - - PaStream *stream; - PaError err; - - /* Open an audio I/O stream. */ - err = Pa_OpenDefaultStream( &stream, - 0, /* no input channels */ - 2, /* stereo output */ - paFloat32, /* 32 bit floating point output */ - SAMPLE_RATE, - 256, /* frames per buffer, i.e. the number - of sample frames that PortAudio will - request from the callback. Many apps - may want to use - paFramesPerBufferUnspecified, which - tells PortAudio to pick the best, - possibly changing, buffer size.*/ - patestCallback, /* this is your callback function */ - &data ); /*This is a pointer that will be passed to - your callback*/ - if( err != paNoError ) goto error; -@endcode - -The data structure and callback are described in \ref writing_a_callback. - -The above example opens the stream for writing, which is sufficient for playback. It is also possible to open a stream for reading, to do recording, or both reading and writing, for simultaneous recording and playback or even real-time audio processing. If you plan to do playback and recording at the same time, open only one stream with valid input and output parameters. - -There are some caveats to note about simultaneous read/write: - - - Some platforms can only open a read/write stream using the same device. - - Although multiple streams can be opened, it is difficult to synchronize them. - - Some platforms don't support opening multiple streams on the same device. - - Using multiple streams may not be as well tested as other features. - - The PortAudio library calls must be made from the same thread or synchronized by the user. - - -Previous: \ref initializing_portaudio | Next: \ref start_stop_abort - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/querying_devices.dox b/portaudio/doc/src/tutorial/querying_devices.dox deleted file mode 100644 index 1eac41a..0000000 --- a/portaudio/doc/src/tutorial/querying_devices.dox +++ /dev/null @@ -1,111 +0,0 @@ -/** @page querying_devices Enumerating and Querying PortAudio Devices -@ingroup tutorial - -@section tut_query1 Querying Devices - -It is often fine to use the default device as we did previously in this tutorial, but there are times when you'll want to explicitly choose the device from a list of available devices on the system. To see a working example of this, check out pa_devs.c in the tests/ directory of the PortAudio source code. To do so, you'll need to first initialize PortAudio and Query for the number of Devices: - -@code - int numDevices; - - numDevices = Pa_GetDeviceCount(); - if( numDevices < 0 ) - { - printf( "ERROR: Pa_CountDevices returned 0x%x\n", numDevices ); - err = numDevices; - goto error; - } -@endcode - - -If you want to get information about each device, simply loop through as follows: - -@code - const PaDeviceInfo *deviceInfo; - - for( i=0; i<numDevices; i++ ) - { - deviceInfo = Pa_GetDeviceInfo( i ); - ... - } -@endcode - -The Pa_DeviceInfo structure contains a wealth of information such as the name of the devices, the default latency associated with the devices and more. The structure has the following fields: - -@code -int structVersion -const char * name -PaHostApiIndex hostApi -int maxInputChannels -int maxOutputChannels -PaTime defaultLowInputLatency -PaTime defaultLowOutputLatency -PaTime defaultHighInputLatency -PaTime defaultHighOutputLatency -double defaultSampleRate -@endcode - -You may notice that you can't determine, from this information alone, whether or not a particular sample rate is supported. This is because some devices support ranges of sample rates, others support, a list of sample rates, and still others support some sample rates and number of channels combinations but not others. To get around this, PortAudio offers a function for testing a particular device with a given format: - -@code - const PaStreamParameters *inputParameters; - const PaStreamParameters *outputParameters; - double desiredSampleRate; - ... - PaError err; - - err = Pa_IsFormatSupported( inputParameters, outputParameters, desiredSampleRate ); - if( err == paFormatIsSupported ) - { - printf( "Hooray!\n"); - } - else - { - printf("Too Bad.\n"); - } -@endcode - -Filling in the inputParameters and outputParameters fields is shown in a moment. - -Once you've found a configuration you like, or one you'd like to go ahead and try, you can open the stream by filling in the PaStreamParameters structures, and calling Pa_OpenStream: - -@code - double srate = ... ; - PaStream *stream; - unsigned long framesPerBuffer = ... ; //could be paFramesPerBufferUnspecified, in which case PortAudio will do its best to manage it for you, but, on some platforms, the framesPerBuffer will change in each call to the callback - PaStreamParameters outputParameters; - PaStreamParameters inputParameters; - - bzero( &inputParameters, sizeof( inputParameters ) ); //not necessary if you are filling in all the fields - inputParameters.channelCount = inChan; - inputParameters.device = inDevNum; - inputParameters.hostApiSpecificStreamInfo = NULL; - inputParameters.sampleFormat = paFloat32; - inputParameters.suggestedLatency = Pa_GetDeviceInfo(inDevNum)->defaultLowInputLatency ; - inputParameters.hostApiSpecificStreamInfo = NULL; //See you specific host's API docs for info on using this field - - - bzero( &outputParameters, sizeof( outputParameters ) ); //not necessary if you are filling in all the fields - outputParameters.channelCount = outChan; - outputParameters.device = outDevNum; - outputParameters.hostApiSpecificStreamInfo = NULL; - outputParameters.sampleFormat = paFloat32; - outputParameters.suggestedLatency = Pa_GetDeviceInfo(outDevNum)->defaultLowOutputLatency ; - outputParameters.hostApiSpecificStreamInfo = NULL; //See you specific host's API docs for info on using this field - - err = Pa_OpenStream( - &stream, - &inputParameters, - &outputParameters, - srate, - framesPerBuffer, - paNoFlag, //flags that can be used to define dither, clip settings and more - portAudioCallback, //your callback function - (void *)this ); //data to be passed to callback. In C++, it is frequently (void *)this - //don't forget to check errors! -@endcode - - -Previous: \ref utility_functions | Next: \ref blocking_read_write - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/start_stop_abort.dox b/portaudio/doc/src/tutorial/start_stop_abort.dox deleted file mode 100644 index 0ddb460..0000000 --- a/portaudio/doc/src/tutorial/start_stop_abort.dox +++ /dev/null @@ -1,35 +0,0 @@ -/** @page start_stop_abort Starting, Stopping and Aborting a Stream -@ingroup tutorial - -@section tut_startstop1 Starting, Stopping and Aborting a Stream - -PortAudio will not start playing back audio until you start the stream. After calling Pa_StartStream(), PortAudio will start calling your callback function to perform the audio processing. - -@code - err = Pa_StartStream( stream ); - 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 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. - -@code - /* Sleep for several seconds. */ - Pa_Sleep(NUM_SECONDS*1000); -@endcode - -Now we need to stop playback. There are several ways to do this, the simplest of which is to call Pa_StopStream(): - -@code - err = Pa_StopStream( stream ); - if( err != paNoError ) goto error; -@endcode - -Pa_StopStream() is designed to make sure that the buffers you've processed in your callback are all played, which may cause some delay. Alternatively, you could call Pa_AbortStream(). On some platforms, aborting the stream is much faster and may cause some data processed by your callback not to be played. - -Another way to stop the stream is to return either paComplete, or paAbort from your callback. paComplete ensures that the last buffer is played whereas paAbort stops the stream as soon as possible. If you stop the stream using this technique, you will need to call Pa_StopStream() before starting the stream again. - -Previous: \ref open_default_stream | Next: \ref terminating_portaudio - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/terminating_portaudio.dox b/portaudio/doc/src/tutorial/terminating_portaudio.dox deleted file mode 100644 index 67f74f6..0000000 --- a/portaudio/doc/src/tutorial/terminating_portaudio.dox +++ /dev/null @@ -1,20 +0,0 @@ -/** @page terminating_portaudio Closing a Stream and Terminating PortAudio -@ingroup tutorial - -When you are done with a stream, you should close it to free up resources: - -@code - err = Pa_CloseStream( stream ); - if( err != paNoError ) goto error; -@endcode - -We've already mentioned this in \ref initializing_portaudio, but in case you forgot, be sure to terminate PortAudio when you are done: - -@code - err = Pa_Terminate( ); - if( err != paNoError ) goto error; -@endcode - -Previous: \ref start_stop_abort | Next: \ref utility_functions - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/tutorial_start.dox b/portaudio/doc/src/tutorial/tutorial_start.dox deleted file mode 100644 index 42fa4bf..0000000 --- a/portaudio/doc/src/tutorial/tutorial_start.dox +++ /dev/null @@ -1,61 +0,0 @@ -/** @page tutorial_start PortAudio Tutorials -@ingroup tutorial - -These tutorials takes you through a hands-on example of using PortAudio to make sound. If you'd prefer to start with a top-down overview of the PortAudio API, check out the @ref api_overview. - -@section tut_start1 Downloading - -First thing you need to do is download the PortAudio source code either <a href="http://www.portaudio.com/download.html">as a tarball from the website</a>, or <a href="http://www.portaudio.com/usingsvn.html">from the Subversion Repository</a>. - -@section tut_start2 Compiling - -Once you've downloaded PortAudio you'll need to compile it, which of course, depends on your environment: - - - Windows - - \ref compile_windows - - \ref compile_windows_mingw - - \ref compile_windows_asio_msvc - - Mac OS X - - \ref compile_mac_coreaudio - - POSIX - - \ref compile_linux - -You can also use CMake to generate project files for PortAudio on Windows, OS X or Linux or include PortAudio easily in your own CMake project. See \ref compile_cmake. - -Many platforms with GCC/make can use the simple ./configure && make combination and simply use the resulting libraries in their code. - -@section tut_start3 Programming with PortAudio - -Below are the steps to writing a PortAudio application using the callback technique: - - - Write a callback function that will be called by PortAudio when audio processing is needed. - - Initialize the PA library and open a stream for audio I/O. - - Start the stream. Your callback function will be now be called repeatedly by PA in the background. - - In your callback you can read audio data from the inputBuffer and/or write data to the outputBuffer. - - Stop the stream by returning 1 from your callback, or by calling a stop function. - - Close the stream and terminate the library. - -In addition to this "Callback" architecture, V19 also supports a "Blocking I/O" model which uses read and write calls which may be more familiar to non-audio programmers. Note that at this time, not all APIs support this functionality. - -In this tutorial, we'll show how to use the callback architecture to play a sawtooth wave. Much of the tutorial is taken from the file paex_saw.c, which is part of the PortAudio distribution. When you're done with this tutorial, you'll be armed with the basic knowledge you need to write an audio program. If you need more sample code, look in the "examples" and "test" directory of the PortAudio distribution. Another great source of info is the portaudio.h Doxygen page, which documents the entire V19 API. -Also see the page for <a href="https://github.com/PortAudio/portaudio/wiki/Tips">tips on programming PortAudio</a> -on the PortAudio wiki. - -@section tut_start4 Programming Tutorial Contents - -- \ref writing_a_callback -- \ref initializing_portaudio -- \ref open_default_stream -- \ref start_stop_abort -- \ref terminating_portaudio -- \ref utility_functions -- \ref querying_devices -- \ref blocking_read_write - -If you are upgrading from V18, you may want to look at the <a href="http://www.portaudio.com/docs/proposals/index.html">Proposed Enhancements to PortAudio</a>, which describes the differences between V18 and V19. - -Once you have a basic understanding of how to use PortAudio, you might be interested in \ref exploring. - -Next: \ref writing_a_callback - -*/ diff --git a/portaudio/doc/src/tutorial/utility_functions.dox b/portaudio/doc/src/tutorial/utility_functions.dox deleted file mode 100644 index c06bf3b..0000000 --- a/portaudio/doc/src/tutorial/utility_functions.dox +++ /dev/null @@ -1,69 +0,0 @@ -/** @page utility_functions Utility Functions -@ingroup tutorial - -In addition to the functions described elsewhere in this tutorial, PortAudio provides a number of Utility functions that are useful in a variety of circumstances. -You'll want to read the portaudio.h reference, which documents the entire V19 API for details, but we'll try to cover the basics here. - -@section tut_util2 Version Information - -PortAudio offers two functions to determine the PortAudio Version. This is most useful when you are using PortAudio as a dynamic library, but it may also be useful at other times. - -@code -int Pa_GetVersion (void) -const char * Pa_GetVersionText (void) -@endcode - -@section tut_util3 Error Text - -PortAudio allows you to get error text from an error number. - -@code -const char * Pa_GetErrorText (PaError errorCode) -@endcode - -@section tut_util4 Stream State - -PortAudio Streams exist in 3 states: Active, Stopped, and Callback Stopped. If a stream is in callback stopped state, you'll need to stop it before you can start it again. If you need to query the state of a PortAudio stream, there are two functions for doing so: - -@code -PaError Pa_IsStreamStopped (PaStream *stream) -PaError Pa_IsStreamActive (PaStream *stream) -@endcode - -@section tut_util5 Stream Info - -If you need to retrieve info about a given stream, such as latency, and sample rate info, there's a function for that too: - -@code -const PaStreamInfo * Pa_GetStreamInfo (PaStream *stream) -@endcode - -@section tut_util6 Stream Time - -If you need to synchronise other activities such as display updates or MIDI output with the PortAudio callback you need to know the current time according to the same timebase used by the stream callback timestamps. - -@code -PaTime Pa_GetStreamTime (PaStream *stream) -@endcode - -@section tut_util6CPU Usage - -To determine how much CPU is being used by the callback, use these: - -@code -double Pa_GetStreamCpuLoad (PaStream *stream) -@endcode - -@section tut_util7 Other utilities - -These functions allow you to determine the size of a sample from its format and sleep for a given amount of time. The sleep function should not be used for precise timing or synchronization because it makes few guarantees about the exact length of time it waits. It is most useful for testing. - -@code -PaError Pa_GetSampleSize (PaSampleFormat format) -void Pa_Sleep (long msec) -@endcode - - -Previous: \ref terminating_portaudio | Next: \ref querying_devices - -*/
\ No newline at end of file diff --git a/portaudio/doc/src/tutorial/writing_a_callback.dox b/portaudio/doc/src/tutorial/writing_a_callback.dox deleted file mode 100644 index f7d71b1..0000000 --- a/portaudio/doc/src/tutorial/writing_a_callback.dox +++ /dev/null @@ -1,70 +0,0 @@ -/** @page writing_a_callback Writing a Callback Function -@ingroup tutorial - -To write a program using PortAudio, you must include the "portaudio.h" include file. You may wish to read "portaudio.h" because it contains a complete description of the PortAudio functions and constants. Alternatively, you could browse the [http://www.portaudio.com/docs/v19-doxydocs/portaudio_8h.html "portaudio.h" Doxygen page] -@code -#include "portaudio.h" -@endcode -The next task is to write your own "callback" function. The "callback" is a function that is called by the PortAudio engine whenever it has captured audio data, or when it needs more audio data for output. - -Before we begin, it's important to realize that the callback is a delicate place. This is because some systems perform the callback in a special thread, or interrupt handler, and it is rarely treated the same as the rest of your code. -For most modern systems, you won't be able to cause crashes by making disallowed calls in the callback, but if you want your code to produce glitch-free audio, you will have to make sure you avoid function calls that may take an unbounded amount of time -to execute. Exactly what these are depend on your platform but almost certainly include the following: memory allocation/deallocation, I/O (including file I/O as well as console I/O, such as printf()), context switching (such as exec() or -yield()), mutex operations, or anything else that might rely on the OS. If you think short critical sections are safe please go read about priority inversion. Windows and Mac OS schedulers have no real-time safe priority inversion prevention. Other platforms require special mutex flags. In addition, it is not safe to call any PortAudio API functions in the callback except as explicitly permitted in the documentation. - - -Your callback function must return an int and accept the exact parameters specified in this typedef: - -@code -typedef int PaStreamCallback( const void *input, - void *output, - unsigned long frameCount, - const PaStreamCallbackTimeInfo* timeInfo, - PaStreamCallbackFlags statusFlags, - void *userData ) ; -@endcode -Here is an example callback function from the test file "patests/patest_saw.c". It calculates a simple left and right sawtooth signal and writes it to the output buffer. Notice that in this example, the signals are of float data type. The signals must be between -1.0 and +1.0. You can also use 16 bit integers or other formats which are specified during setup, but floats are easiest to work with. You can pass a pointer to your data structure through PortAudio which will appear as userData. - -@code -typedef struct -{ - float left_phase; - float right_phase; -} -paTestData; - -/* This routine will be called by the PortAudio engine when audio is needed. -** It may called at interrupt level on some machines so don't do anything -** that could mess up the system like calling malloc() or free(). -*/ -static int patestCallback( const void *inputBuffer, void *outputBuffer, - unsigned long framesPerBuffer, - const PaStreamCallbackTimeInfo* timeInfo, - PaStreamCallbackFlags statusFlags, - void *userData ) -{ - /* Cast data passed through stream to our structure. */ - paTestData *data = (paTestData*)userData; - float *out = (float*)outputBuffer; - unsigned int i; - (void) inputBuffer; /* Prevent unused variable warning. */ - - for( i=0; i<framesPerBuffer; i++ ) - { - *out++ = data->left_phase; /* left */ - *out++ = data->right_phase; /* right */ - /* Generate simple sawtooth phaser that ranges between -1.0 and 1.0. */ - data->left_phase += 0.01f; - /* When signal reaches top, drop back down. */ - if( data->left_phase >= 1.0f ) data->left_phase -= 2.0f; - /* higher pitch so we can distinguish left and right. */ - data->right_phase += 0.03f; - if( data->right_phase >= 1.0f ) data->right_phase -= 2.0f; - } - return 0; -} -@endcode - -Previous: \ref tutorial_start | Next: \ref initializing_portaudio - -*/ |
