me/portaudio
Watch
1
0
Fork
You've already forked portaudio
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

added tutorial doxygen pages converted from old trac wiki

Browse source
This commit is contained in:
rbencina 2012-01-25 06:44:05 +00:00
commit 692afbcbaa
17 changed files with 1015 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

8
doc/src/mainpage.dox
View file

@ -11,7 +11,7 @@ PortAudio is a cross-platform, open-source C language library for real-time audi
- @ref api_overview<br>
A top-down view of the PortAudio API, its capabilities, functions and data structures
- <a href="http://www.portaudio.com/trac/wiki/TutorialDir/TutorialStart">PortAudio Tutorials</a><br>
- @ref tutorial_start<br>
Get started writing code with PortAudio tutorials
- @ref examples_src "Examples"<br>
@ -36,7 +36,7 @@ Documentation for non-portable platform-specific host API extensions
- <a href="http://music.columbia.edu/mailman/listinfo/portaudio/">Our mailing list for users and developers</a><br>
- <a href="http://www.portaudio.com/trac">The PortAudio wiki</a>
- <a href="http://www.assembla.com/spaces/portaudio/wiki">The PortAudio wiki</a>
@section developer_resources Developer Resources
@ -45,11 +45,11 @@ Documentation for non-portable platform-specific host API extensions
- @ref srcguide
@endif
- <a href="http://www.portaudio.com/trac">Our Trac wiki and issue tracking system</a>
- <a href="http://www.assembla.com/spaces/portaudio/wiki">Our wiki and issue tracking system</a>
- <a href="http://www.portaudio.com/docs/proposals/014-StyleGuide.html">Coding 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 <a href="http://www.portaudio.com/trac/report/3">check out the starter tickets in Trac</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 <a href="http://www.assembla.com/spaces/portaudio/tickets">check out the starter tickets in Trac</a>.
@section older_api_versions Older API Versions

68
doc/src/tutorial/blocking_read_write.dox Normal file
View file

@ -0,0 +1,68 @@
/** @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
*/

29
doc/src/tutorial/compile_cmake.dox Normal file
View file

@ -0,0 +1,29 @@
/** @page compile_cmake Creating MSVC Build Files via CMake
@ingroup tutorial
This is a simple "How-to" for creating build files for Microsoft Visual C++ via CMake and the CMakeLists.txt file
1. Install CMake if you haven't got it already ([http://www.cmake.org], minimum version required is 2.8).
2. If you want ASIO support you need to D/L the ASIO2 SDK from Steinberg, and place it according to \ref compile_windows_asio_msvc
3. Run the CMake GUI application and browse to <b>source files</b> directory and <b>build</b> directory:
a. The <b>source files</b> directory (<i>"Where is the source code"</i>) is where the portaudio CMakeLists.txt file is located.
b. The <b>build</b> directory (<i>"Where to build the binaries"</i>) is pretty much anywhere you like. A common practice though is to have the build directory located <b>outside</b> the
source files tree (a so called "out-of-source build")
4. Click <i>Configure</i>. This will prompt you to select which build files to generate. <b>Note</b> Only Microsoft Visual C++ build files currently supported!
5. In the CMake option list, enable the PORTAUDIO_xxx options you need, then click <i>Configure</i> again (Note that after this there are no options marked with red color)
6. Click <i>Generate</i> and you'll now (hopefully) have your VS build files in your previously defined <b>build</b> directory.
Both ASIO and DirectX SDK are automatically searched for by the CMake script, so if you have DirectX SDK installed and have placed the ASIO2 SDK according to point 2 above, you should be able to build portaudio with !DirectSound and ASIO support.
Should you later on decide to change a portaudio option, just jump in at step 5 above (MSVC will then prompt you to reload projects/solutions/workspace)
--- Robert Bielik
Back to the Tutorial: \ref tutorial_start
*/

77
doc/src/tutorial/compile_linux.dox Normal file
View file

@ -0,0 +1,77 @@
/** @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
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
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:
@code
gcc -lrt -lasound -ljack -lpthread -o YOUR_BINARY main.c libportaudio.a
@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.
*/

121
doc/src/tutorial/compile_mac_coreaudio.dox Normal file
View file

@ -0,0 +1,121 @@
/** @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
@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
*/

97
doc/src/tutorial/compile_windows.dox Normal file
View file

@ -0,0 +1,97 @@
/** @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) PortAudio for Windows 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 can declare these paths by hand. Alternatively, you can copy dsound.h and dsconf.h to portaudio\\include. There should also be a file named ''dsound.lib'' in C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0A\\Lib.
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. 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, double click the portaudio.sln file located in build\\msvc\\. Doing so will open Visual Studio or Visual C++. Click "Finish" if a 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
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:
C/C++ -> Optimization -> Omit frame pointers = Yes
C/C++ -> Code Generation -> Runtime library = /MT
Optional: C/C++ -> Code Generation -> Floating point model = fast
NOTE: For most users it is not 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 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.
@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 which 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. Right now those 6 entries are not from 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.
2) Make sure your project doesn't try to build the PortAudio ASIO implementation files:
src\\hostapi\\pa_asio.cpp src\\hostapi\\iasiothiscallresolver.cpp
If you're using one of the shipped projects, remove them from the project.
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
Back to the Tutorial: \ref tutorial_start
*/

95
doc/src/tutorial/compile_windows_asio_msvc.dox Normal file
View file

@ -0,0 +1,95 @@
/** @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
@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_waveformat.c (portaudio\src\os\win)
pa_x86_plain_converters.c (portaudio\src\os\win)
patest_saw.c (portaudio\test) (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: and enter the following relative include paths.
@code
..\portaudio\include,..\portaudio\src\common,..\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.
You should now be able to build any of the test executables in the portaudio\test directory.
We suggest that you start with patest_saw.c because it's one of the simplest test files.
--- Chris Share, Tom McCandless, Ross Bencina
[wiki:UsingThePortAudioSvnRepository SVN instructions]
Back to the Tutorial: \ref tutorial_start
*/

53
doc/src/tutorial/compile_windows_mingw.dox Normal file
View file

@ -0,0 +1,53 @@
/** @page compile_windows_mingw Building Portaudio for Windows with MinGW
@ingroup tutorial
@section comp_mingw1 Portaudio for Windows With MinGW
<i>The following document is still being reviewed</i>
= 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
*/

15
doc/src/tutorial/exploring.dox Normal file
View file

@ -0,0 +1,15 @@
/** @page exploring Exploring PortAudio
@ingroup tutorial
Now that you have a good idea of how PortAudio works, you can try out the test programs.
For an example of playing a sine wave, see "[http://www.portaudio.com/trac/browser/portaudio/trunk/examples/paex_sine.c examples/paex_sine.c]".
For an example of recording and playing back a sound, see "[http://www.portaudio.com/trac/browser/portaudio/trunk/examples/paex_record.c 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.
*/

29
doc/src/tutorial/initializing_portaudio.dox Normal file
View file

@ -0,0 +1,29 @@
/** @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
*/

48
doc/src/tutorial/open_default_stream.dox Normal file
View file

@ -0,0 +1,48 @@
/** @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
*/

111
doc/src/tutorial/querying_devices.dox Normal file
View file

@ -0,0 +1,111 @@
/** @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 ihas 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
*/

35
doc/src/tutorial/start_stop_abort.dox Normal file
View file

@ -0,0 +1,35 @@
/** @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 mutexs 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
*/

20
doc/src/tutorial/terminating_portaudio.dox Normal file
View file

@ -0,0 +1,20 @@
/** @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
*/

78
doc/src/tutorial/tutorial_start.dox Normal file
View file

@ -0,0 +1,78 @@
/** @page tutorial_start PortAudio Tutorials
@ingroup tutorial
@section tut_start1 Overview of PortAudio
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 sound card or audio interface. 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 Microsoft Windows®, Mac OS X and Linux. In addition to the C language, third-party language bindings make it possible to call PortAudio from other programming languages including C++, C#, Python, PureBasic, FreePascal and Lazarus.
Among the operating systems and audio subsystems supported by PortAudio:
- Windows
- MME
- DirectSound
- WASAPI
- ASIO
- Mac OS X
- Core Audio
- Linux
- ALSA
- JACK
- OSS
Below are the steps to writing a PortAudio application:
- 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.
@section tut_start2 Compiling
First thing you'll need to know, after you've gotten PortAudio from the [wiki:UsingThePortAudioSvnRepository Subversion Repository] is how to compile your application, which of course, depends on your environment:
<i>ED: not actually sure this is how it should be organized, since it's possible to compile for multiple interfaces.</i>
- Windows
- \ref compile_windows
- \ref compile_windows_mingw
- \ref compile_windows_asio_msvc
- \ref compile_cmake
- Mac OS X
- \ref compile_mac_coreaudio
- POSIX
- \ref compile_linux
- Others?
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
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 patest_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 "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 tips on programming PortAudio located here: [http://www.assembla.com/spaces/portaudio/wiki/Tips].
If you are upgrading from V18, you may want to see our [http://www.portaudio.com/docs/proposals/index.html Proposed Enhancements to PortAudio], which describes the differences between V18 and V19.
- \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
- \ref exploring
Once you understand how PortAudio works, you might be interested in \ref exploring.
TO DO:
* Complete tutorial with utility and info about querying devices/opening non-default devices
Next: \ref writing_a_callback
*/

69
doc/src/tutorial/utility_functions.dox Normal file
View file

@ -0,0 +1,69 @@
/** @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
*/

66
doc/src/tutorial/writing_a_callback.dox Normal file
View file

@ -0,0 +1,66 @@
/** @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. In addition, if you want your audio to reach the speakers on time, you'll need to make sure whatever code you run in the callback runs quickly. What is safe or not safe will vary from platform to platform, but as a rule of thumb, don't do anything like allocating or freeing memory, reading or writing files, printf(), or anything else that might take an unbounded amount of time or rely on the OS or require a context switch. <i>Ed: is this still true?: Also do not call any PortAudio functions in the callback except for Pa_StreamTime() and Pa_GetCPULoad().</i>
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
*/