Pd-cvs September 2004

pd-cvs@lists.iem.at

9 participants
149 discussions

pd/portaudio/pa_win_ds dsound_wrapper.c,1.2,1.3 dsound_wrapper.h,1.2,1.3 pa_win_ds.c,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_win_ds In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_win_ds Added Files: dsound_wrapper.c dsound_wrapper.h pa_win_ds.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_win_ds.c --- /* * $Id: pa_win_ds.c,v 1.3 2004/09/06 20:44:42 millerpuckette Exp $ * Portable Audio I/O Library DirectSound implementation * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 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. * * Any person wishing to distribute modifications to the Software is [...1783 lines suppressed...] return 0; } /***********************************************************************************/ static signed long GetStreamWriteAvailable( PaStream* s ) { PaWinDsStream *stream = (PaWinDsStream*)s; /* suppress unused variable warnings */ (void) stream; /* IMPLEMENT ME, see portaudio.h for required behavior*/ return 0; } --- NEW FILE: dsound_wrapper.c --- /* * $Id: dsound_wrapper.c,v 1.3 2004/09/06 20:44:41 millerpuckette Exp $ * Simplified DirectSound interface. * * Author: Phil Burk & Robert Marsanyi * * PortAudio Portable Real-Time Audio Library * For more information see: http://www.softsynth.com/portaudio/ * DirectSound Implementation * Copyright (c) 1999-2000 Phil Burk & Robert Marsanyi * * 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. * * 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. * * 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. * */ #include <stdio.h> #include <stdlib.h> #include <math.h> #include "dsound_wrapper.h" #include "pa_trace.h" /* Rather than linking with dxguid.a or using "#define INITGUID" to force a header file to instantiate the required GUID(s), we define them directly below. */ #include <initguid.h> // needed for the DEFINE_GUID macro DEFINE_GUID(IID_IDirectSoundNotify, 0xb0210783, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16); /************************************************************************************/ DSoundEntryPoints dswDSoundEntryPoints = { 0, 0, 0, 0, 0, 0, 0 }; /************************************************************************************/ static HRESULT WINAPI DummyDirectSoundCreate(LPGUID lpcGuidDevice, LPDIRECTSOUND *ppDS, LPUNKNOWN pUnkOuter) { (void)lpcGuidDevice; /* unused parameter */ (void)ppDS; /* unused parameter */ (void)pUnkOuter; /* unused parameter */ return E_NOTIMPL; } static HRESULT WINAPI DummyDirectSoundEnumerateW(LPDSENUMCALLBACKW lpDSEnumCallback, LPVOID lpContext) { (void)lpDSEnumCallback; /* unused parameter */ (void)lpContext; /* unused parameter */ return E_NOTIMPL; } static HRESULT WINAPI DummyDirectSoundEnumerateA(LPDSENUMCALLBACKA lpDSEnumCallback, LPVOID lpContext) { (void)lpDSEnumCallback; /* unused parameter */ (void)lpContext; /* unused parameter */ return E_NOTIMPL; } static HRESULT WINAPI DummyDirectSoundCaptureCreate(LPGUID lpcGUID, LPDIRECTSOUNDCAPTURE *lplpDSC, LPUNKNOWN pUnkOuter) { (void)lpcGUID; /* unused parameter */ (void)lplpDSC; /* unused parameter */ (void)pUnkOuter; /* unused parameter */ return E_NOTIMPL; } static HRESULT WINAPI DummyDirectSoundCaptureEnumerateW(LPDSENUMCALLBACKW lpDSCEnumCallback, LPVOID lpContext) { (void)lpDSCEnumCallback; /* unused parameter */ (void)lpContext; /* unused parameter */ return E_NOTIMPL; } static HRESULT WINAPI DummyDirectSoundCaptureEnumerateA(LPDSENUMCALLBACKA lpDSCEnumCallback, LPVOID lpContext) { (void)lpDSCEnumCallback; /* unused parameter */ (void)lpContext; /* unused parameter */ return E_NOTIMPL; } /************************************************************************************/ void DSW_InitializeDSoundEntryPoints(void) { dswDSoundEntryPoints.hInstance_ = LoadLibrary("dsound.dll"); if( dswDSoundEntryPoints.hInstance_ != NULL ) { dswDSoundEntryPoints.DirectSoundCreate = (HRESULT (WINAPI *)(LPGUID, LPDIRECTSOUND *, LPUNKNOWN)) GetProcAddress( dswDSoundEntryPoints.hInstance_, "DirectSoundCreate" ); if( dswDSoundEntryPoints.DirectSoundCreate == NULL ) dswDSoundEntryPoints.DirectSoundCreate = DummyDirectSoundCreate; dswDSoundEntryPoints.DirectSoundEnumerateW = (HRESULT (WINAPI *)(LPDSENUMCALLBACKW, LPVOID)) GetProcAddress( dswDSoundEntryPoints.hInstance_, "DirectSoundEnumerateW" ); if( dswDSoundEntryPoints.DirectSoundEnumerateW == NULL ) dswDSoundEntryPoints.DirectSoundEnumerateW = DummyDirectSoundEnumerateW; dswDSoundEntryPoints.DirectSoundEnumerateA = (HRESULT (WINAPI *)(LPDSENUMCALLBACKA, LPVOID)) GetProcAddress( dswDSoundEntryPoints.hInstance_, "DirectSoundEnumerateA" ); if( dswDSoundEntryPoints.DirectSoundEnumerateA == NULL ) dswDSoundEntryPoints.DirectSoundEnumerateA = DummyDirectSoundEnumerateA; dswDSoundEntryPoints.DirectSoundCaptureCreate = (HRESULT (WINAPI *)(LPGUID, LPDIRECTSOUNDCAPTURE *, LPUNKNOWN)) GetProcAddress( dswDSoundEntryPoints.hInstance_, "DirectSoundCaptureCreate" ); if( dswDSoundEntryPoints.DirectSoundCaptureCreate == NULL ) dswDSoundEntryPoints.DirectSoundCaptureCreate = DummyDirectSoundCaptureCreate; dswDSoundEntryPoints.DirectSoundCaptureEnumerateW = (HRESULT (WINAPI *)(LPDSENUMCALLBACKW, LPVOID)) GetProcAddress( dswDSoundEntryPoints.hInstance_, "DirectSoundCaptureEnumerateW" ); if( dswDSoundEntryPoints.DirectSoundCaptureEnumerateW == NULL ) dswDSoundEntryPoints.DirectSoundCaptureEnumerateW = DummyDirectSoundCaptureEnumerateW; dswDSoundEntryPoints.DirectSoundCaptureEnumerateA = (HRESULT (WINAPI *)(LPDSENUMCALLBACKA, LPVOID)) GetProcAddress( dswDSoundEntryPoints.hInstance_, "DirectSoundCaptureEnumerateA" ); if( dswDSoundEntryPoints.DirectSoundCaptureEnumerateA == NULL ) dswDSoundEntryPoints.DirectSoundCaptureEnumerateA = DummyDirectSoundCaptureEnumerateA; } else { /* initialize with dummy entry points to make live easy when ds isn't present */ dswDSoundEntryPoints.DirectSoundCreate = DummyDirectSoundCreate; dswDSoundEntryPoints.DirectSoundEnumerateW = DummyDirectSoundEnumerateW; dswDSoundEntryPoints.DirectSoundEnumerateA = DummyDirectSoundEnumerateA; dswDSoundEntryPoints.DirectSoundCaptureCreate = DummyDirectSoundCaptureCreate; dswDSoundEntryPoints.DirectSoundCaptureEnumerateW = DummyDirectSoundCaptureEnumerateW; dswDSoundEntryPoints.DirectSoundCaptureEnumerateA = DummyDirectSoundCaptureEnumerateA; } } /************************************************************************************/ void DSW_TerminateDSoundEntryPoints(void) { if( dswDSoundEntryPoints.hInstance_ != NULL ) { FreeLibrary( dswDSoundEntryPoints.hInstance_ ); dswDSoundEntryPoints.hInstance_ = NULL; /* ensure that we crash reliably if the entry points arent initialised */ dswDSoundEntryPoints.DirectSoundCreate = 0; dswDSoundEntryPoints.DirectSoundEnumerateW = 0; dswDSoundEntryPoints.DirectSoundEnumerateA = 0; dswDSoundEntryPoints.DirectSoundCaptureCreate = 0; dswDSoundEntryPoints.DirectSoundCaptureEnumerateW = 0; dswDSoundEntryPoints.DirectSoundCaptureEnumerateA = 0; } } /************************************************************************************/ void DSW_Term( DSoundWrapper *dsw ) { // Cleanup the sound buffers if (dsw->dsw_OutputBuffer) { IDirectSoundBuffer_Stop( dsw->dsw_OutputBuffer ); IDirectSoundBuffer_Release( dsw->dsw_OutputBuffer ); dsw->dsw_OutputBuffer = NULL; } if (dsw->dsw_InputBuffer) { IDirectSoundCaptureBuffer_Stop( dsw->dsw_InputBuffer ); IDirectSoundCaptureBuffer_Release( dsw->dsw_InputBuffer ); dsw->dsw_InputBuffer = NULL; } if (dsw->dsw_pDirectSoundCapture) { IDirectSoundCapture_Release( dsw->dsw_pDirectSoundCapture ); dsw->dsw_pDirectSoundCapture = NULL; } if (dsw->dsw_pDirectSound) { IDirectSound_Release( dsw->dsw_pDirectSound ); dsw->dsw_pDirectSound = NULL; } } /************************************************************************************/ HRESULT DSW_Init( DSoundWrapper *dsw ) { memset( dsw, 0, sizeof(DSoundWrapper) ); return 0; } /************************************************************************************/ HRESULT DSW_InitOutputDevice( DSoundWrapper *dsw, LPGUID lpGUID ) { // Create the DS object HRESULT hr = dswDSoundEntryPoints.DirectSoundCreate( lpGUID, &dsw->dsw_pDirectSound, NULL ); if( hr != DS_OK ) return hr; return hr; } /************************************************************************************/ HRESULT DSW_InitOutputBuffer( DSoundWrapper *dsw, unsigned long nFrameRate, WORD nChannels, int bytesPerBuffer ) { DWORD dwDataLen; DWORD playCursor; HRESULT result; LPDIRECTSOUNDBUFFER pPrimaryBuffer; HWND hWnd; HRESULT hr; WAVEFORMATEX wfFormat; DSBUFFERDESC primaryDesc; DSBUFFERDESC secondaryDesc; unsigned char* pDSBuffData; LARGE_INTEGER counterFrequency; dsw->dsw_OutputSize = bytesPerBuffer; dsw->dsw_OutputRunning = FALSE; dsw->dsw_OutputUnderflows = 0; dsw->dsw_FramesWritten = 0; dsw->dsw_BytesPerOutputFrame = nChannels * sizeof(short); // We were using getForegroundWindow() but sometimes the ForegroundWindow may not be the // applications's window. Also if that window is closed before the Buffer is closed // then DirectSound can crash. (Thanks for Scott Patterson for reporting this.) // So we will use GetDesktopWindow() which was suggested by Miller Puckette. // hWnd = GetForegroundWindow(); // // FIXME: The example code I have on the net creates a hidden window that // is managed by our code - I think we should do that - one hidden // window for the whole of Pa_DS // hWnd = GetDesktopWindow(); // Set cooperative level to DSSCL_EXCLUSIVE so that we can get 16 bit output, 44.1 KHz. // Exclusize also prevents unexpected sounds from other apps during a performance. if ((hr = IDirectSound_SetCooperativeLevel( dsw->dsw_pDirectSound, hWnd, DSSCL_EXCLUSIVE)) != DS_OK) { return hr; } // ----------------------------------------------------------------------- // Create primary buffer and set format just so we can specify our custom format. // Otherwise we would be stuck with the default which might be 8 bit or 22050 Hz. // Setup the primary buffer description ZeroMemory(&primaryDesc, sizeof(DSBUFFERDESC)); primaryDesc.dwSize = sizeof(DSBUFFERDESC); primaryDesc.dwFlags = DSBCAPS_PRIMARYBUFFER; // all panning, mixing, etc done by synth primaryDesc.dwBufferBytes = 0; primaryDesc.lpwfxFormat = NULL; // Create the buffer if ((result = IDirectSound_CreateSoundBuffer( dsw->dsw_pDirectSound, &primaryDesc, &pPrimaryBuffer, NULL)) != DS_OK) return result; // Define the buffer format wfFormat.wFormatTag = WAVE_FORMAT_PCM; wfFormat.nChannels = nChannels; wfFormat.nSamplesPerSec = nFrameRate; wfFormat.wBitsPerSample = 8 * sizeof(short); wfFormat.nBlockAlign = (WORD)(wfFormat.nChannels * (wfFormat.wBitsPerSample / 8)); wfFormat.nAvgBytesPerSec = wfFormat.nSamplesPerSec * wfFormat.nBlockAlign; wfFormat.cbSize = 0; /* No extended format info. */ // Set the primary buffer's format if((result = IDirectSoundBuffer_SetFormat( pPrimaryBuffer, &wfFormat)) != DS_OK) return result; // ---------------------------------------------------------------------- // Setup the secondary buffer description ZeroMemory(&secondaryDesc, sizeof(DSBUFFERDESC)); secondaryDesc.dwSize = sizeof(DSBUFFERDESC); secondaryDesc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2; secondaryDesc.dwBufferBytes = bytesPerBuffer; secondaryDesc.lpwfxFormat = &wfFormat; // Create the secondary buffer if ((result = IDirectSound_CreateSoundBuffer( dsw->dsw_pDirectSound, &secondaryDesc, &dsw->dsw_OutputBuffer, NULL)) != DS_OK) return result; // Lock the DS buffer if ((result = IDirectSoundBuffer_Lock( dsw->dsw_OutputBuffer, 0, dsw->dsw_OutputSize, (LPVOID*)&pDSBuffData, &dwDataLen, NULL, 0, 0)) != DS_OK) return result; // Zero the DS buffer ZeroMemory(pDSBuffData, dwDataLen); // Unlock the DS buffer if ((result = IDirectSoundBuffer_Unlock( dsw->dsw_OutputBuffer, pDSBuffData, dwDataLen, NULL, 0)) != DS_OK) return result; if( QueryPerformanceFrequency( &counterFrequency ) ) { int framesInBuffer = bytesPerBuffer / (nChannels * sizeof(short)); dsw->dsw_CounterTicksPerBuffer.QuadPart = (counterFrequency.QuadPart * framesInBuffer) / nFrameRate; } else { dsw->dsw_CounterTicksPerBuffer.QuadPart = 0; } // Let DSound set the starting write position because if we set it to zero, it looks like the // buffer is full to begin with. This causes a long pause before sound starts when using large buffers. hr = IDirectSoundBuffer_GetCurrentPosition( dsw->dsw_OutputBuffer, &playCursor, &dsw->dsw_WriteOffset ); if( hr != DS_OK ) { return hr; } dsw->dsw_FramesWritten = dsw->dsw_WriteOffset / dsw->dsw_BytesPerOutputFrame; /* printf("DSW_InitOutputBuffer: playCursor = %d, writeCursor = %d\n", playCursor, dsw->dsw_WriteOffset ); */ return DS_OK; } /************************************************************************************/ HRESULT DSW_StartOutput( DSoundWrapper *dsw ) { HRESULT hr; QueryPerformanceCounter( &dsw->dsw_LastPlayTime ); dsw->dsw_LastPlayCursor = 0; dsw->dsw_FramesPlayed = 0; hr = IDirectSoundBuffer_SetCurrentPosition( dsw->dsw_OutputBuffer, 0 ); if( hr != DS_OK ) { return hr; } // Start the buffer playback in a loop. if( dsw->dsw_OutputBuffer != NULL ) { hr = IDirectSoundBuffer_Play( dsw->dsw_OutputBuffer, 0, 0, DSBPLAY_LOOPING ); if( hr != DS_OK ) { return hr; } dsw->dsw_OutputRunning = TRUE; } return 0; } /************************************************************************************/ HRESULT DSW_StopOutput( DSoundWrapper *dsw ) { // Stop the buffer playback if( dsw->dsw_OutputBuffer != NULL ) { dsw->dsw_OutputRunning = FALSE; return IDirectSoundBuffer_Stop( dsw->dsw_OutputBuffer ); } else return 0; } /************************************************************************************/ HRESULT DSW_QueryOutputFilled( DSoundWrapper *dsw, long *bytesFilledPtr ) { HRESULT hr; DWORD playCursor; DWORD writeCursor; long bytesFilled; // Query to see where play position is. // We don't need the writeCursor but sometimes DirectSound doesn't handle NULLS correctly // so let's pass a pointer just to be safe. hr = IDirectSoundBuffer_GetCurrentPosition( dsw->dsw_OutputBuffer, &playCursor, &writeCursor ); if( hr != DS_OK ) { return hr; } bytesFilled = dsw->dsw_WriteOffset - playCursor; if( bytesFilled < 0 ) bytesFilled += dsw->dsw_OutputSize; // unwrap offset *bytesFilledPtr = bytesFilled; return hr; } /************************************************************************************ * Determine how much space can be safely written to in DS buffer. * Detect underflows and overflows. * Does not allow writing into safety gap maintained by DirectSound. */ HRESULT DSW_QueryOutputSpace( DSoundWrapper *dsw, long *bytesEmpty ) { HRESULT hr; DWORD playCursor; DWORD writeCursor; long numBytesEmpty; long playWriteGap; // Query to see how much room is in buffer. hr = IDirectSoundBuffer_GetCurrentPosition( dsw->dsw_OutputBuffer, &playCursor, &writeCursor ); if( hr != DS_OK ) { return hr; } // Determine size of gap between playIndex and WriteIndex that we cannot write into. playWriteGap = writeCursor - playCursor; if( playWriteGap < 0 ) playWriteGap += dsw->dsw_OutputSize; // unwrap /* DirectSound doesn't have a large enough playCursor so we cannot detect wrap-around. */ /* Attempt to detect playCursor wrap-around and correct it. */ if( dsw->dsw_OutputRunning && (dsw->dsw_CounterTicksPerBuffer.QuadPart != 0) ) { /* How much time has elapsed since last check. */ LARGE_INTEGER currentTime; LARGE_INTEGER elapsedTime; long bytesPlayed; long bytesExpected; long buffersWrapped; QueryPerformanceCounter( &currentTime ); elapsedTime.QuadPart = currentTime.QuadPart - dsw->dsw_LastPlayTime.QuadPart; dsw->dsw_LastPlayTime = currentTime; /* How many bytes does DirectSound say have been played. */ bytesPlayed = playCursor - dsw->dsw_LastPlayCursor; if( bytesPlayed < 0 ) bytesPlayed += dsw->dsw_OutputSize; // unwrap dsw->dsw_LastPlayCursor = playCursor; /* Calculate how many bytes we would have expected to been played by now. */ bytesExpected = (long) ((elapsedTime.QuadPart * dsw->dsw_OutputSize) / dsw->dsw_CounterTicksPerBuffer.QuadPart); buffersWrapped = (bytesExpected - bytesPlayed) / dsw->dsw_OutputSize; if( buffersWrapped > 0 ) { playCursor += (buffersWrapped * dsw->dsw_OutputSize); bytesPlayed += (buffersWrapped * dsw->dsw_OutputSize); } /* Maintain frame output cursor. */ dsw->dsw_FramesPlayed += (bytesPlayed / dsw->dsw_BytesPerOutputFrame); } numBytesEmpty = playCursor - dsw->dsw_WriteOffset; if( numBytesEmpty < 0 ) numBytesEmpty += dsw->dsw_OutputSize; // unwrap offset /* Have we underflowed? */ if( numBytesEmpty > (dsw->dsw_OutputSize - playWriteGap) ) { if( dsw->dsw_OutputRunning ) { dsw->dsw_OutputUnderflows += 1; } dsw->dsw_WriteOffset = writeCursor; numBytesEmpty = dsw->dsw_OutputSize - playWriteGap; } *bytesEmpty = numBytesEmpty; return hr; } /************************************************************************************/ HRESULT DSW_ZeroEmptySpace( DSoundWrapper *dsw ) { HRESULT hr; LPBYTE lpbuf1 = NULL; LPBYTE lpbuf2 = NULL; DWORD dwsize1 = 0; DWORD dwsize2 = 0; long bytesEmpty; hr = DSW_QueryOutputSpace( dsw, &bytesEmpty ); // updates dsw_FramesPlayed if (hr != DS_OK) return hr; if( bytesEmpty == 0 ) return DS_OK; // Lock free space in the DS hr = IDirectSoundBuffer_Lock( dsw->dsw_OutputBuffer, dsw->dsw_WriteOffset, bytesEmpty, (void **) &lpbuf1, &dwsize1, (void **) &lpbuf2, &dwsize2, 0); if (hr == DS_OK) { // Copy the buffer into the DS ZeroMemory(lpbuf1, dwsize1); if(lpbuf2 != NULL) { ZeroMemory(lpbuf2, dwsize2); } // Update our buffer offset and unlock sound buffer dsw->dsw_WriteOffset = (dsw->dsw_WriteOffset + dwsize1 + dwsize2) % dsw->dsw_OutputSize; IDirectSoundBuffer_Unlock( dsw->dsw_OutputBuffer, lpbuf1, dwsize1, lpbuf2, dwsize2); dsw->dsw_FramesWritten += bytesEmpty / dsw->dsw_BytesPerOutputFrame; } return hr; } /************************************************************************************/ HRESULT DSW_WriteBlock( DSoundWrapper *dsw, char *buf, long numBytes ) { HRESULT hr; LPBYTE lpbuf1 = NULL; LPBYTE lpbuf2 = NULL; DWORD dwsize1 = 0; DWORD dwsize2 = 0; // Lock free space in the DS hr = IDirectSoundBuffer_Lock( dsw->dsw_OutputBuffer, dsw->dsw_WriteOffset, numBytes, (void **) &lpbuf1, &dwsize1, (void **) &lpbuf2, &dwsize2, 0); if (hr == DS_OK) { // Copy the buffer into the DS CopyMemory(lpbuf1, buf, dwsize1); if(lpbuf2 != NULL) { CopyMemory(lpbuf2, buf+dwsize1, dwsize2); } // Update our buffer offset and unlock sound buffer dsw->dsw_WriteOffset = (dsw->dsw_WriteOffset + dwsize1 + dwsize2) % dsw->dsw_OutputSize; IDirectSoundBuffer_Unlock( dsw->dsw_OutputBuffer, lpbuf1, dwsize1, lpbuf2, dwsize2); dsw->dsw_FramesWritten += numBytes / dsw->dsw_BytesPerOutputFrame; } return hr; } /************************************************************************************/ DWORD DSW_GetOutputStatus( DSoundWrapper *dsw ) { DWORD status; if (IDirectSoundBuffer_GetStatus( dsw->dsw_OutputBuffer, &status ) != DS_OK) return( DSERR_INVALIDPARAM ); else return( status ); } /* These routines are used to support audio input. * Do NOT compile these calls when using NT4 because it does * not support the entry points. */ /************************************************************************************/ HRESULT DSW_InitInputDevice( DSoundWrapper *dsw, LPGUID lpGUID ) { HRESULT hr = dswDSoundEntryPoints.DirectSoundCaptureCreate( lpGUID, &dsw->dsw_pDirectSoundCapture, NULL ); if( hr != DS_OK ) return hr; return hr; } /************************************************************************************/ HRESULT DSW_InitInputBuffer( DSoundWrapper *dsw, unsigned long nFrameRate, WORD nChannels, int bytesPerBuffer ) { DSCBUFFERDESC captureDesc; WAVEFORMATEX wfFormat; HRESULT result; dsw->dsw_BytesPerInputFrame = nChannels * sizeof(short); // Define the buffer format wfFormat.wFormatTag = WAVE_FORMAT_PCM; wfFormat.nChannels = nChannels; wfFormat.nSamplesPerSec = nFrameRate; wfFormat.wBitsPerSample = 8 * sizeof(short); wfFormat.nBlockAlign = (WORD)(wfFormat.nChannels * (wfFormat.wBitsPerSample / 8)); wfFormat.nAvgBytesPerSec = wfFormat.nSamplesPerSec * wfFormat.nBlockAlign; wfFormat.cbSize = 0; /* No extended format info. */ dsw->dsw_InputSize = bytesPerBuffer; // ---------------------------------------------------------------------- // Setup the secondary buffer description ZeroMemory(&captureDesc, sizeof(DSCBUFFERDESC)); captureDesc.dwSize = sizeof(DSCBUFFERDESC); captureDesc.dwFlags = 0; captureDesc.dwBufferBytes = bytesPerBuffer; captureDesc.lpwfxFormat = &wfFormat; // Create the capture buffer if ((result = IDirectSoundCapture_CreateCaptureBuffer( dsw->dsw_pDirectSoundCapture, &captureDesc, &dsw->dsw_InputBuffer, NULL)) != DS_OK) return result; dsw->dsw_ReadOffset = 0; // reset last read position to start of buffer return DS_OK; } /************************************************************************************/ HRESULT DSW_StartInput( DSoundWrapper *dsw ) { // Start the buffer playback if( dsw->dsw_InputBuffer != NULL ) { return IDirectSoundCaptureBuffer_Start( dsw->dsw_InputBuffer, DSCBSTART_LOOPING ); } else return 0; } /************************************************************************************/ HRESULT DSW_StopInput( DSoundWrapper *dsw ) { // Stop the buffer playback if( dsw->dsw_InputBuffer != NULL ) { return IDirectSoundCaptureBuffer_Stop( dsw->dsw_InputBuffer ); } else return 0; } /************************************************************************************/ HRESULT DSW_QueryInputFilled( DSoundWrapper *dsw, long *bytesFilled ) { HRESULT hr; DWORD capturePos; DWORD readPos; long filled; // Query to see how much data is in buffer. // We don't need the capture position but sometimes DirectSound doesn't handle NULLS correctly // so let's pass a pointer just to be safe. hr = IDirectSoundCaptureBuffer_GetCurrentPosition( dsw->dsw_InputBuffer, &capturePos, &readPos ); if( hr != DS_OK ) { return hr; } filled = readPos - dsw->dsw_ReadOffset; if( filled < 0 ) filled += dsw->dsw_InputSize; // unwrap offset *bytesFilled = filled; return hr; } /************************************************************************************/ HRESULT DSW_ReadBlock( DSoundWrapper *dsw, char *buf, long numBytes ) { HRESULT hr; LPBYTE lpbuf1 = NULL; LPBYTE lpbuf2 = NULL; DWORD dwsize1 = 0; DWORD dwsize2 = 0; // Lock free space in the DS hr = IDirectSoundCaptureBuffer_Lock ( dsw->dsw_InputBuffer, dsw->dsw_ReadOffset, numBytes, (void **) &lpbuf1, &dwsize1, (void **) &lpbuf2, &dwsize2, 0); if (hr == DS_OK) { // Copy from DS to the buffer CopyMemory( buf, lpbuf1, dwsize1); if(lpbuf2 != NULL) { CopyMemory( buf+dwsize1, lpbuf2, dwsize2); } // Update our buffer offset and unlock sound buffer dsw->dsw_ReadOffset = (dsw->dsw_ReadOffset + dwsize1 + dwsize2) % dsw->dsw_InputSize; IDirectSoundCaptureBuffer_Unlock ( dsw->dsw_InputBuffer, lpbuf1, dwsize1, lpbuf2, dwsize2); } return hr; } --- NEW FILE: dsound_wrapper.h --- #ifndef __DSOUND_WRAPPER_H #define __DSOUND_WRAPPER_H /* * $Id: dsound_wrapper.h,v 1.3 2004/09/06 20:44:42 millerpuckette Exp $ * Simplified DirectSound interface. * * Author: Phil Burk & Robert Marsanyi * * For PortAudio Portable Real-Time Audio Library * For more information see: http://www.softsynth.com/portaudio/ * DirectSound Implementation * Copyright (c) 1999-2000 Phil Burk & Robert Marsanyi * * 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. * * 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. * * 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. * */ /* on Borland compilers, WIN32 doesn't seem to be defined by default, which breaks DSound.h. Adding the define here fixes the problem. - rossb. */ #ifdef __BORLANDC__ #if !defined(WIN32) #define WIN32 #endif #endif #include <DSound.h> #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ typedef struct { HINSTANCE hInstance_; HRESULT (WINAPI *DirectSoundCreate)(LPGUID, LPDIRECTSOUND *, LPUNKNOWN); HRESULT (WINAPI *DirectSoundEnumerateW)(LPDSENUMCALLBACKW, LPVOID); HRESULT (WINAPI *DirectSoundEnumerateA)(LPDSENUMCALLBACKA, LPVOID); HRESULT (WINAPI *DirectSoundCaptureCreate)(LPGUID, LPDIRECTSOUNDCAPTURE *, LPUNKNOWN); HRESULT (WINAPI *DirectSoundCaptureEnumerateW)(LPDSENUMCALLBACKW, LPVOID); HRESULT (WINAPI *DirectSoundCaptureEnumerateA)(LPDSENUMCALLBACKA, LPVOID); }DSoundEntryPoints; extern DSoundEntryPoints dswDSoundEntryPoints; void DSW_InitializeDSoundEntryPoints(void); void DSW_TerminateDSoundEntryPoints(void); #define DSW_NUM_POSITIONS (4) #define DSW_NUM_EVENTS (5) #define DSW_TERMINATION_EVENT (DSW_NUM_POSITIONS) typedef struct { /* Output */ LPDIRECTSOUND dsw_pDirectSound; LPDIRECTSOUNDBUFFER dsw_OutputBuffer; DWORD dsw_WriteOffset; /* last write position */ INT dsw_OutputSize; INT dsw_BytesPerOutputFrame; /* Try to detect play buffer underflows. */ LARGE_INTEGER dsw_CounterTicksPerBuffer; /* counter ticks it should take to play a full buffer */ LARGE_INTEGER dsw_LastPlayTime; UINT dsw_LastPlayCursor; UINT dsw_OutputUnderflows; BOOL dsw_OutputRunning; /* use double which lets us can play for several thousand years with enough precision */ double dsw_FramesWritten; double dsw_FramesPlayed; /* Input */ INT dsw_BytesPerInputFrame; LPDIRECTSOUNDCAPTURE dsw_pDirectSoundCapture; LPDIRECTSOUNDCAPTUREBUFFER dsw_InputBuffer; UINT dsw_ReadOffset; /* last read position */ UINT dsw_InputSize; } DSoundWrapper; HRESULT DSW_Init( DSoundWrapper *dsw ); void DSW_Term( DSoundWrapper *dsw ); HRESULT DSW_InitOutputBuffer( DSoundWrapper *dsw, unsigned long nFrameRate, WORD nChannels, int bufSize ); HRESULT DSW_StartOutput( DSoundWrapper *dsw ); HRESULT DSW_StopOutput( DSoundWrapper *dsw ); DWORD DSW_GetOutputStatus( DSoundWrapper *dsw ); HRESULT DSW_WriteBlock( DSoundWrapper *dsw, char *buf, long numBytes ); HRESULT DSW_ZeroEmptySpace( DSoundWrapper *dsw ); HRESULT DSW_QueryOutputSpace( DSoundWrapper *dsw, long *bytesEmpty ); HRESULT DSW_Enumerate( DSoundWrapper *dsw ); HRESULT DSW_InitInputBuffer( DSoundWrapper *dsw, unsigned long nFrameRate, WORD nChannels, int bufSize ); HRESULT DSW_StartInput( DSoundWrapper *dsw ); HRESULT DSW_StopInput( DSoundWrapper *dsw ); HRESULT DSW_ReadBlock( DSoundWrapper *dsw, char *buf, long numBytes ); HRESULT DSW_QueryInputFilled( DSoundWrapper *dsw, long *bytesFilled ); HRESULT DSW_QueryOutputFilled( DSoundWrapper *dsw, long *bytesFilled ); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* __DSOUND_WRAPPER_H */

1 0

pd/portaudio/pa_win_wmme pa_win_wmme.c,1.2,1.3 pa_win_wmme.h,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_win_wmme In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_win_wmme Added Files: pa_win_wmme.c pa_win_wmme.h Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_win_wmme.h --- #ifndef PA_WIN_WMME_H #define PA_WIN_WMME_H /* * $Id: pa_win_wmme.h,v 1.3 2004/09/06 20:44:42 millerpuckette Exp $ * PortAudio Portable Real-Time Audio Library * MME specific extensions * * Copyright (c) 1999-2000 Ross Bencina and 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. * * 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. * * 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. * */ /** @file @brief WMME-specific PortAudio API extension header file. */ #include "portaudio.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #define paWinMmeUseLowLevelLatencyParameters (0x01) #define paWinMmeUseMultipleDevices (0x02) /* use mme specific multiple device feature */ /* By default, the mme implementation drops the processing thread's priority to THREAD_PRIORITY_NORMAL and sleeps the thread if the CPU load exceeds 100% This flag disables any priority throttling. The processing thread will always run at THREAD_PRIORITY_TIME_CRITICAL. */ #define paWinMmeDontThrottleOverloadedProcessingThread (0x08) typedef struct PaWinMmeDeviceAndChannelCount{ PaDeviceIndex device; int channelCount; }PaWinMmeDeviceAndChannelCount; typedef struct PaWinMmeStreamInfo{ unsigned long size; /**< sizeof(PaWinMmeStreamInfo) */ PaHostApiTypeId hostApiType; /**< paMME */ unsigned long version; /**< 1 */ unsigned long flags; /* low-level latency setting support These settings control the number and size of host buffers in order to set latency. They will be used instead of the generic parameters to Pa_OpenStream() if flags contains the PaWinMmeUseLowLevelLatencyParameters flag. If PaWinMmeStreamInfo structures with PaWinMmeUseLowLevelLatencyParameters are supplied for both input and output in a full duplex stream, then the input and output framesPerBuffer must be the same, or the larger of the two must be a multiple of the smaller, otherwise a paIncompatibleHostApiSpecificStreamInfo error will be returned from Pa_OpenStream(). */ unsigned long framesPerBuffer; unsigned long bufferCount; /* formerly numBuffers */ /* multiple devices per direction support If flags contains the PaWinMmeUseMultipleDevices flag, this functionality will be used, otherwise the device parameter to Pa_OpenStream() will be used instead. If devices are specified here, the corresponding device parameter to Pa_OpenStream() should be set to paUseHostApiSpecificDeviceSpecification, otherwise an paInvalidDevice error will result. The total number of channels accross all specified devices must agree with the corresponding channelCount parameter to Pa_OpenStream() otherwise a paInvalidChannelCount error will result. */ PaWinMmeDeviceAndChannelCount *devices; unsigned long deviceCount; }PaWinMmeStreamInfo; /** Retrieve the number of wave in handles used by a PortAudio WinMME stream. Returns zero if the stream is output only. @return A non-negative value indicating the number of wave in handles or, a PaErrorCode (which are always negative) if PortAudio is not initialized or an error is encountered. @see PaWinMME_GetStreamInputHandle */ int PaWinMME_GetStreamInputHandleCount( PaStream* stream ); /** Retrieve a wave in handle used by a PortAudio WinMME stream. @param stream The stream to query. @param handleIndex The zero based index of the wave in handle to retrieve. This should be in the range [0, PaWinMME_GetStreamInputHandle(stream)-1]. @return A valid wave in handle, or NULL if an error occurred. @see PaWinMME_GetStreamInputHandle */ HWAVEIN PaWinMME_GetStreamInputHandle( PaStream* stream, int handleIndex ); /** Retrieve the number of wave out handles used by a PortAudio WinMME stream. Returns zero if the stream is input only. @return A non-negative value indicating the number of wave out handles or, a PaErrorCode (which are always negative) if PortAudio is not initialized or an error is encountered. @see PaWinMME_GetStreamOutputHandle */ int PaWinMME_GetStreamOutputHandleCount( PaStream* stream ); /** Retrieve a wave out handle used by a PortAudio WinMME stream. @param stream The stream to query. @param handleIndex The zero based index of the wave out handle to retrieve. This should be in the range [0, PaWinMME_GetStreamOutputHandleCount(stream)-1]. @return A valid wave out handle, or NULL if an error occurred. @see PaWinMME_GetStreamOutputHandleCount */ HWAVEOUT PaWinMME_GetStreamOutputHandle( PaStream* stream, int handleIndex ); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* PA_WIN_WMME_H */ --- NEW FILE: pa_win_wmme.c --- /* * $Id: pa_win_wmme.c,v 1.3 2004/09/06 20:44:42 millerpuckette Exp $ * pa_win_wmme.c * Implementation of PortAudio for Windows MultiMedia Extensions (WMME) * * PortAudio Portable Real-Time Audio Library * Latest Version at: http://www.portaudio.com * * Authors: Ross Bencina and Phil Burk * Copyright (c) 1999-2000 Ross Bencina and 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: * [...3584 lines suppressed...] HWAVEOUT PaWinMME_GetStreamOutputHandle( PaStream* s, int handleIndex ) { PaWinMmeStream *stream; PaError result = GetWinMMEStreamPointer( &stream, s ); if( result == paNoError && PA_IS_OUTPUT_STREAM_(stream) && handleIndex >= 0 && (unsigned int)handleIndex < stream->output.deviceCount ) return ((HWAVEOUT*)stream->output.waveHandles)[handleIndex]; else return 0; }

1 0

pd/portaudio/pa_unix pa_unix_hostapis.c,1.2,1.3 pa_unix_util.c,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_unix In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_unix Added Files: pa_unix_hostapis.c pa_unix_util.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_unix_util.c --- /* * $Id: pa_unix_util.c,v 1.3 2004/09/06 20:44:41 millerpuckette Exp $ * Portable Audio I/O Library * UNIX platform-specific support functions * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2000 Ross Bencina * * 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. * * 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. * * 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. */ #include <unistd.h> #include <stdlib.h> #include <sys/time.h> #include "pa_util.h" /* Track memory allocations to avoid leaks. */ #if PA_TRACK_MEMORY static int numAllocations_ = 0; #endif void *PaUtil_AllocateMemory( long size ) { void *result = malloc( size ); #if PA_TRACK_MEMORY if( result != NULL ) numAllocations_ += 1; #endif return result; } void PaUtil_FreeMemory( void *block ) { if( block != NULL ) { free( block ); #if PA_TRACK_MEMORY numAllocations_ -= 1; #endif } } int PaUtil_CountCurrentlyAllocatedBlocks( void ) { #if PA_TRACK_MEMORY return numAllocations_; #else return 0; #endif } void Pa_Sleep( long msec ) { while( msec > 999 ) /* For OpenBSD and IRIX, argument */ { /* to usleep must be < 1000000. */ usleep( 999000 ); msec -= 999; } usleep( msec * 1000 ); } /* *** NOT USED YET: *** static int usePerformanceCounter_; static double microsecondsPerTick_; */ void PaUtil_InitializeClock( void ) { /* TODO */ } PaTime PaUtil_GetTime( void ) { struct timeval tv; gettimeofday( &tv, NULL ); return (PaTime) tv.tv_usec / 1000000 + (PaTime) tv.tv_sec; } --- NEW FILE: pa_unix_hostapis.c --- /* * $Id: pa_unix_hostapis.c,v 1.3 2004/09/06 20:44:41 millerpuckette Exp $ * Portable Audio I/O Library UNIX initialization table * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 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. * * 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. * * 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. */ #include "pa_hostapi.h" PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaAlsa_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaOSS_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); /* Added for IRIX, Pieter, oct 2, 2003: */ PaError PaSGI_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaUtilHostApiInitializer *paHostApiInitializers[] = { #ifdef PA_USE_OSS PaOSS_Initialize, #endif #ifdef PA_USE_ALSA PaAlsa_Initialize, #endif #ifdef PA_USE_JACK PaJack_Initialize, #endif /* Added for IRIX, Pieter, oct 2, 2003: */ #ifdef PA_USE_SGI PaSGI_Initialize, #endif 0 /* NULL terminated array */ }; int paDefaultHostApiIndex = 0;

1 0

pd/portaudio/pa_unix_oss low_latency_tip.txt,1.2,1.3 pa_unix_oss.c,1.2,1.3 recplay.c,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_unix_oss In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_unix_oss Added Files: low_latency_tip.txt pa_unix_oss.c recplay.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: recplay.c --- /* * recplay.c * Phil Burk * Minimal record and playback test. * */ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #ifndef __STDC__ /* #include <getopt.h> */ #endif /* __STDC__ */ #include <fcntl.h> #ifdef __STDC__ #include <string.h> #else /* __STDC__ */ #include <strings.h> #endif /* __STDC__ */ #include <sys/soundcard.h> #define NUM_BYTES (64*1024) #define BLOCK_SIZE (4*1024) #define AUDIO "/dev/dsp" char buffer[NUM_BYTES]; int audioDev = 0; main (int argc, char *argv[]) { int numLeft; char *ptr; int num; int samplesize; /********** RECORD ********************/ /* Open audio device. */ audioDev = open (AUDIO, O_RDONLY, 0); if (audioDev == -1) { perror (AUDIO); exit (-1); } /* Set to 16 bit samples. */ samplesize = 16; ioctl(audioDev, SNDCTL_DSP_SAMPLESIZE, &samplesize); if (samplesize != 16) { perror("Unable to set the sample size."); exit(-1); } /* Record in blocks */ printf("Begin recording.\n"); numLeft = NUM_BYTES; ptr = buffer; while( numLeft >= BLOCK_SIZE ) { if ( (num = read (audioDev, ptr, BLOCK_SIZE)) < 0 ) { perror (AUDIO); exit (-1); } else { printf("Read %d bytes\n", num); ptr += num; numLeft -= num; } } close( audioDev ); /********** PLAYBACK ********************/ /* Open audio device for writing. */ audioDev = open (AUDIO, O_WRONLY, 0); if (audioDev == -1) { perror (AUDIO); exit (-1); } /* Set to 16 bit samples. */ samplesize = 16; ioctl(audioDev, SNDCTL_DSP_SAMPLESIZE, &samplesize); if (samplesize != 16) { perror("Unable to set the sample size."); exit(-1); } /* Play in blocks */ printf("Begin playing.\n"); numLeft = NUM_BYTES; ptr = buffer; while( numLeft >= BLOCK_SIZE ) { if ( (num = write (audioDev, ptr, BLOCK_SIZE)) < 0 ) { perror (AUDIO); exit (-1); } else { printf("Wrote %d bytes\n", num); ptr += num; numLeft -= num; } } close( audioDev ); } --- NEW FILE: pa_unix_oss.c --- /* * $Id: pa_unix_oss.c,v 1.3 2004/09/06 20:44:41 millerpuckette Exp $ * PortAudio Portable Real-Time Audio Library * Latest Version at: http://www.portaudio.com * OSS implementation by: * Douglas Repetto * Phil Burk * Dominic Mazzoni * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 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: [...1157 lines suppressed...] else return 0; /* TODO: is this right for "don't know"? */ } static signed long GetStreamWriteAvailable( PaStream* s ) { PaOSSStream *stream = (PaOSSStream*)s; audio_buf_info info; if ( ioctl(stream->deviceHandle, SNDCTL_DSP_GETOSPACE, &info) == 0) { int bytesAvailable = info.fragments * info.fragsize; return ( bytesAvailable / 2 / stream->outputChannelCount ); } else return 0; /* TODO: is this right for "don't know"? */ } --- NEW FILE: low_latency_tip.txt --- From: "Benno Senoner" <sbenno(a)gardena.net> To: <music-dsp(a)shoko.calarts.edu> Subject: Re: [music-dsp] coding realtime guitar efx on a "pc" Date: Saturday, June 30, 2001 8:19 AM Andrè, you are solving your problem the wrong way: you need to use a single threaded solution which does this: - set the audio I/O parameters to fragnum=4 fragsize=128 bytes (=32samples) if you use stereo or fragsize=64 bytes (=32 samples) if you use mono. (do not forget to activate fulltuplex with using the _TRIGGER_ stuff) (you need to frist deactivate audio and then start the trigger after the DAC is prefilled (see below)) This will give you a total input to output latency of 4x32 samples = 128 samples which at 44.1kHz correspond to 2.9msec latency. now set your process to SCHED_FIFO (see man sched_setscheduler) after the initialization your code should do more than less this: - write() 4 x 32 samples to the audio fd in order to prefill the DAC. Without this you will get dropouts. while(1) { read() 32 samples from ADC perform_dsp_stuff() on the 32 samples write() 32 samples to DAC } If you use a low latency kernel and pay attention to all the stuff above, then you will get rock solid 3msec latencies (plus eventual converter latencies but these are in the 1-2msec range AFAIK). Using multiple threads , pipes etc, only complicates your life and often makes it impossible to achieve these low latences. Realtime/audio programming is not an easy task , this is why people often fail to get the desired results even if their hardware is low-latency capable. The problem is that the final latency depends on the hardware you use, the application and the operating system. cheers, Benno. http://www.linuxaudiodev.org The Home of Linux Audio Development On Sat, 30 Jun 2001, you wrote: > On 2001-06-29 21:38 +0200, Benno Senoner wrote: > > > OSS/Free refuses to use a low # of frags ? > > > > That's a myth. > > I hope it is. :-) > > The fact is that ioctl(SNDCTL_DSP_SETFRAGMENT) succeeds with > values as low a 0x10007 (one 128-B fragment) but the latency is > still high enough to be clearly noticeable, which suggests that > it's *way* above 2/3 ms. This is on an otherwise idle machine > equipped with a SB PCI 128. > > But maybe it's me who's doing something wrong. I've been careful > to flush stdio buffers or use unbuffered I/O (write(2)) but I > may have let something else through. > > For example, since the signal processing and the I/O are done by > two different vanilla processes communicating via pipes, it may > be a scheduling granularity problem (E.G. the kernel giving the > I/O process a time slice every 20 ms). > > -- > André Majorel <amajorel(a)teaser.fr> > http://www.teaser.fr/~amajorel/ > > dupswapdrop -- the music-dsp mailing list and website: subscription info, > FAQ, source code archive, list archive, book reviews, dsp links > http://shoko.calarts.edu/musicdsp/ -- dupswapdrop -- the music-dsp mailing list and website: subscription info, FAQ, source code archive, list archive, book reviews, dsp links http://shoko.calarts.edu/musicdsp/

1 0

pd/portaudio/pa_win pa_win_hostapis.c,1.2,1.3 pa_win_util.c,1.2,1.3 pa_x86_plain_converters.c,1.2,1.3 pa_x86_plain_converters.h,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_win In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_win Added Files: pa_win_hostapis.c pa_win_util.c pa_x86_plain_converters.c pa_x86_plain_converters.h Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_win_hostapis.c --- /* * $Id: pa_win_hostapis.c,v 1.3 2004/09/06 20:44:41 millerpuckette Exp $ * Portable Audio I/O Library Windows initialization table * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 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. * * 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. * * 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. */ /** @file Win32 host API initialization function table. @todo Consider using PA_USE_WMME etc instead of PA_NO_WMME. This is what the Unix version does, we should consider being consistent. */ #include "pa_hostapi.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ PaError PaSkeleton_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaWinMme_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaWinDs_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaAsio_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); #ifdef __cplusplus } #endif /* __cplusplus */ PaUtilHostApiInitializer *paHostApiInitializers[] = { #ifndef PA_NO_WMME PaWinMme_Initialize, #endif #ifndef PA_NO_DS PaWinDs_Initialize, #endif #ifndef PA_NO_ASIO PaAsio_Initialize, #endif PaSkeleton_Initialize, /* just for testing */ 0 /* NULL terminated array */ }; int paDefaultHostApiIndex = 0; --- NEW FILE: pa_x86_plain_converters.c --- #include "pa_x86_plain_converters.h" #include "pa_converters.h" #include "pa_dither.h" /* plain intel assemby versions of standard pa converter functions. the main reason these versions are faster than the equivalent C versions is that float -> int casting is expensive in C on x86 because the rounding mode needs to be changed for every cast. these versions only set the rounding mode once outside the loop. small additional speed gains are made by the way that clamping is implemented. TODO: o- inline dither code o- implement Dither only (no-clip) versions [...1128 lines suppressed...] } /* -------------------------------------------------------------------------- */ void PaUtil_InitializeX86PlainConverters( void ) { paConverters.Float32_To_Int32 = Float32_To_Int32; paConverters.Float32_To_Int32_Clip = Float32_To_Int32_Clip; paConverters.Float32_To_Int32_DitherClip = Float32_To_Int32_DitherClip; paConverters.Float32_To_Int24 = Float32_To_Int24; paConverters.Float32_To_Int24_Clip = Float32_To_Int24_Clip; paConverters.Float32_To_Int24_DitherClip = Float32_To_Int24_DitherClip; paConverters.Float32_To_Int16 = Float32_To_Int16; paConverters.Float32_To_Int16_Clip = Float32_To_Int16_Clip; paConverters.Float32_To_Int16_DitherClip = Float32_To_Int16_DitherClip; } /* -------------------------------------------------------------------------- */ --- NEW FILE: pa_x86_plain_converters.h --- #ifndef PA_X86_PLAIN_CONVERTERS_H #define PA_X86_PLAIN_CONVERTERS_H #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /** @brief Install optimised converter functions suitable for all IA32 processors */ void PaUtil_InitializeX86PlainConverters( void ); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* PA_X86_PLAIN_CONVERTERS_H */ --- NEW FILE: pa_win_util.c --- /* * $Id: pa_win_util.c,v 1.3 2004/09/06 20:44:41 millerpuckette Exp $ * Portable Audio I/O Library * Win32 platform-specific support functions * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2000 Ross Bencina * * 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. * * 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. * * 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. */ /** @file Win32 platform-specific support functions. @todo Implement workaround for QueryPerformanceCounter() skipping forward bug. (see msdn kb Q274323). */ #include <windows.h> #include <mmsystem.h> /* for timeGetTime() */ #include "pa_util.h" /* Track memory allocations to avoid leaks. */ #if PA_TRACK_MEMORY static int numAllocations_ = 0; #endif void *PaUtil_AllocateMemory( long size ) { void *result = GlobalAlloc( GPTR, size ); #if PA_TRACK_MEMORY if( result != NULL ) numAllocations_ += 1; #endif return result; } void PaUtil_FreeMemory( void *block ) { if( block != NULL ) { GlobalFree( block ); #if PA_TRACK_MEMORY numAllocations_ -= 1; #endif } } int PaUtil_CountCurrentlyAllocatedBlocks( void ) { #if PA_TRACK_MEMORY return numAllocations_; #else return 0; #endif } void Pa_Sleep( long msec ) { Sleep( msec ); } static int usePerformanceCounter_; static double secondsPerTick_; void PaUtil_InitializeClock( void ) { LARGE_INTEGER ticksPerSecond; if( QueryPerformanceFrequency( &ticksPerSecond ) != 0 ) { usePerformanceCounter_ = 1; secondsPerTick_ = 1.0 / (double)ticksPerSecond.QuadPart; } else { usePerformanceCounter_ = 0; } } double PaUtil_GetTime( void ) { LARGE_INTEGER time; if( usePerformanceCounter_ ) { /* FIXME: according to this knowledge-base article, QueryPerformanceCounter can skip forward by seconds! http://support.microsoft.com/default.aspx?scid=KB;EN-US;Q274323& it may be better to use the rtdsc instruction using inline asm, however then a method is needed to calculate a ticks/seconds ratio. */ QueryPerformanceCounter( &time ); return time.QuadPart * secondsPerTick_; } else { return timeGetTime() * .001; } }

1 0

pd/portaudio/pa_sgi pa_sgi.c,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_sgi In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_sgi Added Files: pa_sgi.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_sgi.c --- /* * $Id: pa_sgi.c,v 1.3 2004/09/06 20:44:40 millerpuckette Exp $ * PortAudio Portable Real-Time Audio Library. * Latest Version at: http://www.portaudio.com. * Silicon Graphics (SGI) IRIX implementation by Pieter Suurmond. * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 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. [...1378 lines suppressed...] { return (signed long)alGetFillable(((PaSGIStream*)s)->hostPortBuffOut.port); } /* CVS reminder: To download the 'v19-devel' branch from portaudio's CVS server for the first time, type: cvs -d:pserver:anonymous@www.portaudio.com:/home/cvs checkout -r v19-devel portaudio Then 'cd' to the 'portaudio' directory that should have been created. To commit changes: cvs -d:pserver:pieter@www.portaudio.com:/home/cvs login cvs -d:pserver:pieter@www.portaudio.com:/home/cvs commit -m 'blabla.' -r v19-devel pa_sgi/pa_sgi.c cvs -d:pserver:pieter@www.portaudio.com:/home/cvs logout To see if someone else worked on something: cvs -d:pserver:anonymous@www.portaudio.com:/home/cvs update -r v19-devel To get an older revision of a certain file (without sticky business): cvs -d:pserver:anonymous@www.portaudio.com:/home/cvs update -p -r 1.1.1.1.2.4 pa_tests/patest1.c >pa_tests/patest1.c-OLD To see logs: cvs -d:pserver:anonymous@www.portaudio.com:/home/cvs log pa_common/pa_skeleton.c */

1 0

pd/portaudio/pa_mac_sm pa_mac_sm.c,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_mac_sm In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_mac_sm Added Files: pa_mac_sm.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_mac_sm.c --- /* * $Id: pa_mac_sm.c,v 1.3 2004/09/06 20:44:40 millerpuckette Exp $ * Portable Audio I/O Library for Macintosh * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2000 Phil Burk * * Special thanks to Chris Rolfe for his many helpful suggestions, bug fixes, * and code contributions. * Thanks also to Tue Haste Andersen, Alberto Ricci, Nico Wald, * Roelf Toxopeus and Tom Erbe for testing the code and making * numerous suggestions. * * 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, [...1617 lines suppressed...] playCmd.param1 = 0; playCmd.param2 = (long) &pahsc->pahsc_SoundHeaders[ index ]; error = SndDoCommand (pahsc->pahsc_Channel, &playCmd, true ); if( error != noErr ) goto gotError; /* Ask for a callback when it is done. */ callbackCmd.cmd = callBackCmd; callbackCmd.param1 = index; callbackCmd.param2 = (long)past; error = SndDoCommand (pahsc->pahsc_Channel, &callbackCmd, true ); if( error != noErr ) goto gotError; pahsc->pahsc_NumOutsQueued += 1; return; gotError: sPaHostError = error; done: return; }

1 0

pd/portaudio/pa_mac_core notes.txt,1.2,1.3 pa_mac_core.c,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_mac_core In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_mac_core Added Files: notes.txt pa_mac_core.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: notes.txt --- Notes on Core Audio Implementation of PortAudio by Phil Burk and Darren Gibbs Document last updated March 20, 2002 WHAT WORKS Output with very low latency, <10 msec. Half duplex input or output. Full duplex on the same CoreAudio device. The paFLoat32, paInt16, paInt8, paUInt8 sample formats. Pa_GetCPULoad() Pa_StreamTime() KNOWN BUGS OR LIMITATIONS We do not yet support simultaneous input and output on different devices. Note that some CoreAudio devices like the Roland UH30 look like one device but are actually two different CoreAudio devices. The BuiltIn audio is typically one CoreAudio device. Mono doesn't work. DEVICE MAPPING CoreAudio devices can support both input and output. But the sample rates supported may be different. So we have map one or two PortAudio device to each CoreAudio device depending on whether it supports input, output or both. When we query devices, we first get a list of CoreAudio devices. Then we scan the list and add a PortAudio device for each CoreAudio device that supports input. Then we make a scan for output devices. --- NEW FILE: pa_mac_core.c --- /* * $Id: pa_mac_core.c,v 1.3 2004/09/06 20:44:39 millerpuckette Exp $ * pa_mac_core.c * Implementation of PortAudio for Mac OS X CoreAudio * * PortAudio Portable Real-Time Audio Library * Latest Version at: http://www.portaudio.com * * Authors: Ross Bencina and Phil Burk * Copyright (c) 1999-2000 Ross Bencina and 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. * * 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. * * 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. * */ #include <CoreAudio/CoreAudio.h> #include <AudioToolbox/AudioToolbox.h> #include <stdio.h> #include <stdlib.h> #include <math.h> #include <assert.h> #include "portaudio.h" #include "pa_trace.h" #include "pa_util.h" #include "pa_allocation.h" #include "pa_hostapi.h" #include "pa_stream.h" #include "pa_cpuload.h" #include "pa_process.h" // ===== constants ===== // ===== structs ===== #pragma mark structs // PaMacCoreHostApiRepresentation - host api datastructure specific to this implementation typedef struct PaMacCore_HAR { PaUtilHostApiRepresentation inheritedHostApiRep; PaUtilStreamInterface callbackStreamInterface; PaUtilStreamInterface blockingStreamInterface; PaUtilAllocationGroup *allocations; AudioDeviceID *macCoreDeviceIds; } PaMacCoreHostApiRepresentation; typedef struct PaMacCore_DI { PaDeviceInfo inheritedDeviceInfo; } PaMacCoreDeviceInfo; // PaMacCoreStream - a stream data structure specifically for this implementation typedef struct PaMacCore_S { PaUtilStreamRepresentation streamRepresentation; PaUtilCpuLoadMeasurer cpuLoadMeasurer; PaUtilBufferProcessor bufferProcessor; int primeStreamUsingCallback; AudioDeviceID inputDevice; AudioDeviceID outputDevice; // Processing thread management -------------- // HANDLE abortEvent; // HANDLE processingThread; // DWORD processingThreadId; char throttleProcessingThreadOnOverload; // 0 -> don't throtte, non-0 -> throttle int processingThreadPriority; int highThreadPriority; int throttledThreadPriority; unsigned long throttledSleepMsecs; int isStopped; volatile int isActive; volatile int stopProcessing; // stop thread once existing buffers have been returned volatile int abortProcessing; // stop thread immediately // DWORD allBuffersDurationMs; // used to calculate timeouts } PaMacCoreStream; // Data needed by the CoreAudio callback functions typedef struct PaMacCore_CD { PaMacCoreStream *stream; PaStreamCallback *callback; void *userData; PaUtilConverter *inputConverter; PaUtilConverter *outputConverter; void *inputBuffer; void *outputBuffer; int inputChannelCount; int outputChannelCount; PaSampleFormat inputSampleFormat; PaSampleFormat outputSampleFormat; PaUtilTriangularDitherGenerator *ditherGenerator; } PaMacClientData; // ===== CoreAudio-PortAudio bridge functions ===== #pragma mark CoreAudio-PortAudio bridge functions // Maps CoreAudio OSStatus codes to PortAudio PaError codes static PaError conv_err(OSStatus error) { PaError result; switch (error) { case kAudioHardwareNoError: result = paNoError; break; case kAudioHardwareNotRunningError: result = paInternalError; break; case kAudioHardwareUnspecifiedError: result = paInternalError; break; case kAudioHardwareUnknownPropertyError: result = paInternalError; break; case kAudioHardwareBadPropertySizeError: result = paInternalError; break; case kAudioHardwareIllegalOperationError: result = paInternalError; break; case kAudioHardwareBadDeviceError: result = paInvalidDevice; break; case kAudioHardwareBadStreamError: result = paBadStreamPtr; break; case kAudioHardwareUnsupportedOperationError: result = paInternalError; break; case kAudioDeviceUnsupportedFormatError: result = paSampleFormatNotSupported; break; case kAudioDevicePermissionsError: result = paDeviceUnavailable; break; default: result = paInternalError; } return result; } static AudioStreamBasicDescription *InitializeStreamDescription(const PaStreamParameters *parameters, double sampleRate) { struct AudioStreamBasicDescription *streamDescription = PaUtil_AllocateMemory(sizeof(AudioStreamBasicDescription)); streamDescription->mSampleRate = sampleRate; streamDescription->mFormatID = kAudioFormatLinearPCM; streamDescription->mFormatFlags = 0; streamDescription->mFramesPerPacket = 1; if (parameters->sampleFormat & paNonInterleaved) { streamDescription->mFormatFlags |= kLinearPCMFormatFlagIsNonInterleaved; streamDescription->mChannelsPerFrame = 1; streamDescription->mBytesPerFrame = Pa_GetSampleSize(parameters->sampleFormat); streamDescription->mBytesPerPacket = Pa_GetSampleSize(parameters->sampleFormat); } else { streamDescription->mChannelsPerFrame = parameters->channelCount; } streamDescription->mBytesPerFrame = Pa_GetSampleSize(parameters->sampleFormat) * streamDescription->mChannelsPerFrame; streamDescription->mBytesPerPacket = streamDescription->mBytesPerFrame * streamDescription->mFramesPerPacket; if (parameters->sampleFormat & paFloat32) { streamDescription->mFormatFlags |= kLinearPCMFormatFlagIsFloat; streamDescription->mBitsPerChannel = 32; } else if (parameters->sampleFormat & paInt32) { streamDescription->mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger; streamDescription->mBitsPerChannel = 32; } else if (parameters->sampleFormat & paInt24) { streamDescription->mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger; streamDescription->mBitsPerChannel = 24; } else if (parameters->sampleFormat & paInt16) { streamDescription->mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger; streamDescription->mBitsPerChannel = 16; } else if (parameters->sampleFormat & paInt8) { streamDescription->mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger; streamDescription->mBitsPerChannel = 8; } else if (parameters->sampleFormat & paInt32) { streamDescription->mBitsPerChannel = 8; } return streamDescription; } static PaStreamCallbackTimeInfo *InitializeTimeInfo(const AudioTimeStamp* now, const AudioTimeStamp* inputTime, const AudioTimeStamp* outputTime) { PaStreamCallbackTimeInfo *timeInfo = PaUtil_AllocateMemory(sizeof(PaStreamCallbackTimeInfo)); timeInfo->inputBufferAdcTime = inputTime->mSampleTime; timeInfo->currentTime = now->mSampleTime; timeInfo->outputBufferDacTime = outputTime->mSampleTime; return timeInfo; } // ===== support functions ===== #pragma mark support functions static void CleanUp(PaMacCoreHostApiRepresentation *macCoreHostApi) { if( macCoreHostApi->allocations ) { PaUtil_FreeAllAllocations( macCoreHostApi->allocations ); PaUtil_DestroyAllocationGroup( macCoreHostApi->allocations ); } PaUtil_FreeMemory( macCoreHostApi ); } static PaError GetChannelInfo(PaDeviceInfo *deviceInfo, AudioDeviceID macCoreDeviceId, int isInput) { UInt32 propSize; PaError err = paNoError; UInt32 i; int numChannels = 0; AudioBufferList *buflist; err = conv_err(AudioDeviceGetPropertyInfo(macCoreDeviceId, 0, isInput, kAudioDevicePropertyStreamConfiguration, &propSize, NULL)); buflist = PaUtil_AllocateMemory(propSize); err = conv_err(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyStreamConfiguration, &propSize, buflist)); if (!err) { for (i = 0; i < buflist->mNumberBuffers; ++i) { numChannels += buflist->mBuffers[i].mNumberChannels; } int frameLatency; propSize = sizeof(UInt32); err = conv_err(AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyLatency, &propSize, &frameLatency)); if (!err) { double secondLatency = frameLatency / deviceInfo->defaultSampleRate; if (isInput) { deviceInfo->maxInputChannels = numChannels; deviceInfo->defaultLowInputLatency = secondLatency; deviceInfo->defaultHighInputLatency = secondLatency; } else { deviceInfo->maxOutputChannels = numChannels; deviceInfo->defaultLowOutputLatency = secondLatency; deviceInfo->defaultHighOutputLatency = secondLatency; } } } PaUtil_FreeMemory(buflist); return err; } static PaError InitializeDeviceInfo(PaMacCoreDeviceInfo *macCoreDeviceInfo, AudioDeviceID macCoreDeviceId, PaHostApiIndex hostApiIndex ) { PaDeviceInfo *deviceInfo = &macCoreDeviceInfo->inheritedDeviceInfo; deviceInfo->structVersion = 2; deviceInfo->hostApi = hostApiIndex; PaError err = paNoError; UInt32 propSize; err = conv_err(AudioDeviceGetPropertyInfo(macCoreDeviceId, 0, 0, kAudioDevicePropertyDeviceName, &propSize, NULL)); // FIXME: this allocation should be part of the allocations group char *name = PaUtil_AllocateMemory(propSize); err = conv_err(AudioDeviceGetProperty(macCoreDeviceId, 0, 0, kAudioDevicePropertyDeviceName, &propSize, name)); if (!err) { deviceInfo->name = name; } Float64 sampleRate; propSize = sizeof(Float64); err = conv_err(AudioDeviceGetProperty(macCoreDeviceId, 0, 0, kAudioDevicePropertyNominalSampleRate, &propSize, &sampleRate)); if (!err) { deviceInfo->defaultSampleRate = sampleRate; } // Get channel info err = GetChannelInfo(deviceInfo, macCoreDeviceId, 1); err = GetChannelInfo(deviceInfo, macCoreDeviceId, 0); return err; } static PaError InitializeDeviceInfos( PaMacCoreHostApiRepresentation *macCoreHostApi, PaHostApiIndex hostApiIndex ) { PaError result = paNoError; PaUtilHostApiRepresentation *hostApi; PaMacCoreDeviceInfo *deviceInfoArray; // initialise device counts and default devices under the assumption that there are no devices. These values are incremented below if and when devices are successfully initialized. hostApi = &macCoreHostApi->inheritedHostApiRep; hostApi->info.deviceCount = 0; hostApi->info.defaultInputDevice = paNoDevice; hostApi->info.defaultOutputDevice = paNoDevice; UInt32 propsize; AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propsize, NULL); int numDevices = propsize / sizeof(AudioDeviceID); hostApi->info.deviceCount = numDevices; if (numDevices > 0) { hostApi->deviceInfos = (PaDeviceInfo**)PaUtil_GroupAllocateMemory( macCoreHostApi->allocations, sizeof(PaDeviceInfo*) * numDevices ); if( !hostApi->deviceInfos ) { return paInsufficientMemory; } // allocate all device info structs in a contiguous block deviceInfoArray = (PaMacCoreDeviceInfo*)PaUtil_GroupAllocateMemory( macCoreHostApi->allocations, sizeof(PaMacCoreDeviceInfo) * numDevices ); if( !deviceInfoArray ) { return paInsufficientMemory; } macCoreHostApi->macCoreDeviceIds = PaUtil_GroupAllocateMemory(macCoreHostApi->allocations, propsize); AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propsize, macCoreHostApi->macCoreDeviceIds); AudioDeviceID defaultInputDevice, defaultOutputDevice; propsize = sizeof(AudioDeviceID); AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propsize, &defaultInputDevice); AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &propsize, &defaultOutputDevice); UInt32 i; for (i = 0; i < numDevices; ++i) { if (macCoreHostApi->macCoreDeviceIds[i] == defaultInputDevice) { hostApi->info.defaultInputDevice = i; } if (macCoreHostApi->macCoreDeviceIds[i] == defaultOutputDevice) { hostApi->info.defaultOutputDevice = i; } InitializeDeviceInfo(&deviceInfoArray[i], macCoreHostApi->macCoreDeviceIds[i], hostApiIndex); hostApi->deviceInfos[i] = &(deviceInfoArray[i].inheritedDeviceInfo); } } return result; } static OSStatus CheckFormat(AudioDeviceID macCoreDeviceId, const PaStreamParameters *parameters, double sampleRate, int isInput) { UInt32 propSize = sizeof(AudioStreamBasicDescription); AudioStreamBasicDescription *streamDescription = PaUtil_AllocateMemory(propSize); streamDescription->mSampleRate = sampleRate; streamDescription->mFormatID = 0; streamDescription->mFormatFlags = 0; streamDescription->mBytesPerPacket = 0; streamDescription->mFramesPerPacket = 0; streamDescription->mBytesPerFrame = 0; streamDescription->mChannelsPerFrame = 0; streamDescription->mBitsPerChannel = 0; streamDescription->mReserved = 0; OSStatus result = AudioDeviceGetProperty(macCoreDeviceId, 0, isInput, kAudioDevicePropertyStreamFormatSupported, &propSize, streamDescription); PaUtil_FreeMemory(streamDescription); return result; } static OSStatus CopyInputData(PaMacClientData* destination, const AudioBufferList *source, unsigned long frameCount) { int frameSpacing, channelSpacing; if (destination->inputSampleFormat & paNonInterleaved) { frameSpacing = 1; channelSpacing = destination->inputChannelCount; } else { frameSpacing = destination->inputChannelCount; channelSpacing = 1; } AudioBuffer const *inputBuffer = &source->mBuffers[0]; void *coreAudioBuffer = inputBuffer->mData; void *portAudioBuffer = destination->inputBuffer; UInt32 i, streamNumber, streamChannel; for (i = streamNumber = streamChannel = 0; i < destination->inputChannelCount; ++i, ++streamChannel) { if (streamChannel >= inputBuffer->mNumberChannels) { ++streamNumber; inputBuffer = &source->mBuffers[streamNumber]; coreAudioBuffer = inputBuffer->mData; streamChannel = 0; } destination->inputConverter(portAudioBuffer, frameSpacing, coreAudioBuffer, inputBuffer->mNumberChannels, frameCount, destination->ditherGenerator); coreAudioBuffer += sizeof(Float32); portAudioBuffer += Pa_GetSampleSize(destination->inputSampleFormat) * channelSpacing; } } static OSStatus CopyOutputData(AudioBufferList* destination, PaMacClientData *source, unsigned long frameCount) { int frameSpacing, channelSpacing; if (source->outputSampleFormat & paNonInterleaved) { frameSpacing = 1; channelSpacing = source->outputChannelCount; } else { frameSpacing = source->outputChannelCount; channelSpacing = 1; } AudioBuffer *outputBuffer = &destination->mBuffers[0]; void *coreAudioBuffer = outputBuffer->mData; void *portAudioBuffer = source->outputBuffer; UInt32 i, streamNumber, streamChannel; for (i = streamNumber = streamChannel = 0; i < source->outputChannelCount; ++i, ++streamChannel) { if (streamChannel >= outputBuffer->mNumberChannels) { ++streamNumber; outputBuffer = &destination->mBuffers[streamNumber]; coreAudioBuffer = outputBuffer->mData; streamChannel = 0; } source->outputConverter(coreAudioBuffer, outputBuffer->mNumberChannels, portAudioBuffer, frameSpacing, frameCount, NULL); coreAudioBuffer += sizeof(Float32); portAudioBuffer += Pa_GetSampleSize(source->outputSampleFormat) * channelSpacing; } } static OSStatus AudioIOProc( AudioDeviceID inDevice, const AudioTimeStamp* inNow, const AudioBufferList* inInputData, const AudioTimeStamp* inInputTime, AudioBufferList* outOutputData, const AudioTimeStamp* inOutputTime, void* inClientData) { PaMacClientData *clientData = (PaMacClientData *)inClientData; PaStreamCallbackTimeInfo *timeInfo = InitializeTimeInfo(inNow, inInputTime, inOutputTime); PaUtil_BeginCpuLoadMeasurement( &clientData->stream->cpuLoadMeasurer ); AudioBuffer *outputBuffer = &outOutputData->mBuffers[0]; unsigned long frameCount = outputBuffer->mDataByteSize / (outputBuffer->mNumberChannels * sizeof(Float32)); if (clientData->inputBuffer) { CopyInputData(clientData, inInputData, frameCount); } PaStreamCallbackResult result = clientData->callback(clientData->inputBuffer, clientData->outputBuffer, frameCount, timeInfo, paNoFlag, clientData->userData); if (clientData->outputBuffer) { CopyOutputData(outOutputData, clientData, frameCount); } PaUtil_EndCpuLoadMeasurement( &clientData->stream->cpuLoadMeasurer, frameCount ); if (result == paComplete || result == paAbort) { Pa_StopStream(clientData->stream); } } // This is not for input-only streams, this is for streams where the input device is different from the output device // TODO: This needs to store the output data in a buffer, to be written to the device the next time AudioOutputProc is called static OSStatus AudioInputProc( AudioDeviceID inDevice, const AudioTimeStamp* inNow, const AudioBufferList* inInputData, const AudioTimeStamp* inInputTime, AudioBufferList* outOutputData, const AudioTimeStamp* inOutputTime, void* inClientData) { PaMacClientData *clientData = (PaMacClientData *)inClientData; PaStreamCallbackTimeInfo *timeInfo = InitializeTimeInfo(inNow, inInputTime, inOutputTime); PaUtil_BeginCpuLoadMeasurement( &clientData->stream->cpuLoadMeasurer ); AudioBuffer const *inputBuffer = &inInputData->mBuffers[0]; unsigned long frameCount = inputBuffer->mDataByteSize / (inputBuffer->mNumberChannels * sizeof(Float32)); CopyInputData(clientData, inInputData, frameCount); clientData->callback(clientData->inputBuffer, NULL, frameCount, timeInfo, paNoFlag, clientData->userData); PaUtil_EndCpuLoadMeasurement( &clientData->stream->cpuLoadMeasurer, frameCount ); } // This is not for output-only streams, this is for streams where the input device is different from the output device static OSStatus AudioOutputProc( AudioDeviceID inDevice, const AudioTimeStamp* inNow, const AudioBufferList* inInputData, const AudioTimeStamp* inInputTime, AudioBufferList* outOutputData, const AudioTimeStamp* inOutputTime, void* inClientData) { PaMacClientData *clientData = (PaMacClientData *)inClientData; PaStreamCallbackTimeInfo *timeInfo = InitializeTimeInfo(inNow, inInputTime, inOutputTime); PaUtil_BeginCpuLoadMeasurement( &clientData->stream->cpuLoadMeasurer ); AudioBuffer *outputBuffer = &outOutputData->mBuffers[0]; unsigned long frameCount = outputBuffer->mDataByteSize / (outputBuffer->mNumberChannels * sizeof(Float32)); clientData->callback(NULL, clientData->outputBuffer, frameCount, timeInfo, paNoFlag, clientData->userData); CopyOutputData(outOutputData, clientData, frameCount); PaUtil_EndCpuLoadMeasurement( &clientData->stream->cpuLoadMeasurer, frameCount ); } static PaError SetSampleRate(AudioDeviceID device, double sampleRate, int isInput) { PaError result = paNoError; double actualSampleRate; UInt32 propSize = sizeof(double); result = conv_err(AudioDeviceSetProperty(device, NULL, 0, isInput, kAudioDevicePropertyNominalSampleRate, propSize, &sampleRate)); result = conv_err(AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyNominalSampleRate, &propSize, &actualSampleRate)); if (result == paNoError && actualSampleRate != sampleRate) { result = paInvalidSampleRate; } return result; } static PaError SetFramesPerBuffer(AudioDeviceID device, unsigned long framesPerBuffer, int isInput) { PaError result = paNoError; UInt32 preferredFramesPerBuffer = framesPerBuffer; // while (preferredFramesPerBuffer > UINT32_MAX) { // preferredFramesPerBuffer /= 2; // } UInt32 actualFramesPerBuffer; UInt32 propSize = sizeof(UInt32); result = conv_err(AudioDeviceSetProperty(device, NULL, 0, isInput, kAudioDevicePropertyBufferFrameSize, propSize, &preferredFramesPerBuffer)); result = conv_err(AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyBufferFrameSize, &propSize, &actualFramesPerBuffer)); if (result != paNoError) { // do nothing } else if (actualFramesPerBuffer > framesPerBuffer) { result = paBufferTooSmall; } else if (actualFramesPerBuffer < framesPerBuffer) { result = paBufferTooBig; } return result; } static PaError SetUpUnidirectionalStream(AudioDeviceID device, double sampleRate, unsigned long framesPerBuffer, int isInput) { PaError err = paNoError; err = SetSampleRate(device, sampleRate, isInput); err = SetFramesPerBuffer(device, framesPerBuffer, isInput); } // ===== PortAudio functions ===== #pragma mark PortAudio functions #ifdef __cplusplus extern "C" { #endif // __cplusplus PaError PaMacCore_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); #ifdef __cplusplus } #endif // __cplusplus static void Terminate( struct PaUtilHostApiRepresentation *hostApi ) { PaMacCoreHostApiRepresentation *macCoreHostApi = (PaMacCoreHostApiRepresentation*)hostApi; CleanUp(macCoreHostApi); } static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi, const PaStreamParameters *inputParameters, const PaStreamParameters *outputParameters, double sampleRate ) { PaMacCoreHostApiRepresentation *macCoreHostApi = (PaMacCoreHostApiRepresentation*)hostApi; PaDeviceInfo *deviceInfo; PaError result = paNoError; if (inputParameters) { deviceInfo = macCoreHostApi->inheritedHostApiRep.deviceInfos[inputParameters->device]; if (inputParameters->channelCount > deviceInfo->maxInputChannels) result = paInvalidChannelCount; else if (CheckFormat(macCoreHostApi->macCoreDeviceIds[inputParameters->device], inputParameters, sampleRate, 1) != kAudioHardwareNoError) { result = paInvalidSampleRate; } } if (outputParameters && result == paNoError) { deviceInfo = macCoreHostApi->inheritedHostApiRep.deviceInfos[outputParameters->device]; if (outputParameters->channelCount > deviceInfo->maxOutputChannels) result = paInvalidChannelCount; else if (CheckFormat(macCoreHostApi->macCoreDeviceIds[outputParameters->device], outputParameters, sampleRate, 0) != kAudioHardwareNoError) { result = paInvalidSampleRate; } } return result; } static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi, PaStream** s, const PaStreamParameters *inputParameters, const PaStreamParameters *outputParameters, double sampleRate, unsigned long framesPerBuffer, PaStreamFlags streamFlags, PaStreamCallback *streamCallback, void *userData ) { PaError err = paNoError; PaMacCoreHostApiRepresentation *macCoreHostApi = (PaMacCoreHostApiRepresentation *)hostApi; PaMacCoreStream *stream = PaUtil_AllocateMemory(sizeof(PaMacCoreStream)); stream->isActive = 0; stream->isStopped = 1; stream->inputDevice = kAudioDeviceUnknown; stream->outputDevice = kAudioDeviceUnknown; PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation, ( (streamCallback) ? &macCoreHostApi->callbackStreamInterface : &macCoreHostApi->blockingStreamInterface ), streamCallback, userData ); PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate ); *s = (PaStream*)stream; PaMacClientData *clientData = PaUtil_AllocateMemory(sizeof(PaMacClientData)); clientData->stream = stream; clientData->callback = streamCallback; clientData->userData = userData; clientData->inputBuffer = 0; clientData->outputBuffer = 0; clientData->ditherGenerator = PaUtil_AllocateMemory(sizeof(PaUtilTriangularDitherGenerator)); PaUtil_InitializeTriangularDitherState(clientData->ditherGenerator); if (inputParameters != NULL) { stream->inputDevice = macCoreHostApi->macCoreDeviceIds[inputParameters->device]; clientData->inputConverter = PaUtil_SelectConverter(paFloat32, inputParameters->sampleFormat, streamFlags); clientData->inputBuffer = PaUtil_AllocateMemory(Pa_GetSampleSize(inputParameters->sampleFormat) * framesPerBuffer * inputParameters->channelCount); clientData->inputChannelCount = inputParameters->channelCount; clientData->inputSampleFormat = inputParameters->sampleFormat; err = SetUpUnidirectionalStream(stream->inputDevice, sampleRate, framesPerBuffer, 1); } if (err == paNoError && outputParameters != NULL) { stream->outputDevice = macCoreHostApi->macCoreDeviceIds[outputParameters->device]; clientData->outputConverter = PaUtil_SelectConverter(outputParameters->sampleFormat, paFloat32, streamFlags); clientData->outputBuffer = PaUtil_AllocateMemory(Pa_GetSampleSize(outputParameters->sampleFormat) * framesPerBuffer * outputParameters->channelCount); clientData->outputChannelCount = outputParameters->channelCount; clientData->outputSampleFormat = outputParameters->sampleFormat; err = SetUpUnidirectionalStream(stream->outputDevice, sampleRate, framesPerBuffer, 0); } if (inputParameters == NULL || outputParameters == NULL || stream->inputDevice == stream->outputDevice) { AudioDeviceID device = (inputParameters == NULL) ? stream->outputDevice : stream->inputDevice; AudioDeviceAddIOProc(device, AudioIOProc, clientData); } else { // using different devices for input and output AudioDeviceAddIOProc(stream->inputDevice, AudioInputProc, clientData); AudioDeviceAddIOProc(stream->outputDevice, AudioOutputProc, clientData); } return err; } // Note: When CloseStream() is called, the multi-api layer ensures that the stream has already been stopped or aborted. static PaError CloseStream( PaStream* s ) { PaError err = paNoError; PaMacCoreStream *stream = (PaMacCoreStream*)s; PaUtil_ResetCpuLoadMeasurer( &stream->cpuLoadMeasurer ); if (stream->inputDevice != kAudioDeviceUnknown) { if (stream->outputDevice == kAudioDeviceUnknown || stream->outputDevice == stream->inputDevice) { err = conv_err(AudioDeviceRemoveIOProc(stream->inputDevice, AudioIOProc)); } else { err = conv_err(AudioDeviceRemoveIOProc(stream->inputDevice, AudioInputProc)); err = conv_err(AudioDeviceRemoveIOProc(stream->outputDevice, AudioOutputProc)); } } else { err = conv_err(AudioDeviceRemoveIOProc(stream->outputDevice, AudioIOProc)); } return err; } static PaError StartStream( PaStream *s ) { PaError err = paNoError; PaMacCoreStream *stream = (PaMacCoreStream*)s; if (stream->inputDevice != kAudioDeviceUnknown) { if (stream->outputDevice == kAudioDeviceUnknown || stream->outputDevice == stream->inputDevice) { err = conv_err(AudioDeviceStart(stream->inputDevice, AudioIOProc)); } else { err = conv_err(AudioDeviceStart(stream->inputDevice, AudioInputProc)); err = conv_err(AudioDeviceStart(stream->outputDevice, AudioOutputProc)); } } else { err = conv_err(AudioDeviceStart(stream->outputDevice, AudioIOProc)); } stream->isActive = 1; stream->isStopped = 0; return err; } static PaError AbortStream( PaStream *s ) { PaError err = paNoError; PaMacCoreStream *stream = (PaMacCoreStream*)s; if (stream->inputDevice != kAudioDeviceUnknown) { if (stream->outputDevice == kAudioDeviceUnknown || stream->outputDevice == stream->inputDevice) { err = conv_err(AudioDeviceStop(stream->inputDevice, AudioIOProc)); } else { err = conv_err(AudioDeviceStop(stream->inputDevice, AudioInputProc)); err = conv_err(AudioDeviceStop(stream->outputDevice, AudioOutputProc)); } } else { err = conv_err(AudioDeviceStop(stream->outputDevice, AudioIOProc)); } stream->isActive = 0; stream->isStopped = 1; return err; } static PaError StopStream( PaStream *s ) { // TODO: this should be nicer than abort return AbortStream(s); } static PaError IsStreamStopped( PaStream *s ) { PaMacCoreStream *stream = (PaMacCoreStream*)s; return stream->isStopped; } static PaError IsStreamActive( PaStream *s ) { PaMacCoreStream *stream = (PaMacCoreStream*)s; return stream->isActive; } static PaTime GetStreamTime( PaStream *s ) { OSStatus err; PaTime result; PaMacCoreStream *stream = (PaMacCoreStream*)s; AudioTimeStamp *timeStamp = PaUtil_AllocateMemory(sizeof(AudioTimeStamp)); if (stream->inputDevice != kAudioDeviceUnknown) { err = AudioDeviceGetCurrentTime(stream->inputDevice, timeStamp); } else { err = AudioDeviceGetCurrentTime(stream->outputDevice, timeStamp); } result = err ? 0 : timeStamp->mSampleTime; PaUtil_FreeMemory(timeStamp); return result; } static double GetStreamCpuLoad( PaStream* s ) { PaMacCoreStream *stream = (PaMacCoreStream*)s; return PaUtil_GetCpuLoad( &stream->cpuLoadMeasurer ); } // As separate stream interfaces are used for blocking and callback streams, the following functions can be guaranteed to only be called for blocking streams. static PaError ReadStream( PaStream* s, void *buffer, unsigned long frames ) { return paInternalError; } static PaError WriteStream( PaStream* s, const void *buffer, unsigned long frames ) { return paInternalError; } static signed long GetStreamReadAvailable( PaStream* s ) { return paInternalError; } static signed long GetStreamWriteAvailable( PaStream* s ) { return paInternalError; } // HostAPI-specific initialization function PaError PaMacCore_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex ) { PaError result = paNoError; PaMacCoreHostApiRepresentation *macCoreHostApi = (PaMacCoreHostApiRepresentation *)PaUtil_AllocateMemory( sizeof(PaMacCoreHostApiRepresentation) ); if( !macCoreHostApi ) { result = paInsufficientMemory; goto error; } macCoreHostApi->allocations = PaUtil_CreateAllocationGroup(); if( !macCoreHostApi->allocations ) { result = paInsufficientMemory; goto error; } *hostApi = &macCoreHostApi->inheritedHostApiRep; (*hostApi)->info.structVersion = 1; (*hostApi)->info.type = paCoreAudio; (*hostApi)->info.name = "CoreAudio"; result = InitializeDeviceInfos(macCoreHostApi, hostApiIndex); if (result != paNoError) { goto error; } // Set up the proper callbacks to this HostApi's functions (*hostApi)->Terminate = Terminate; (*hostApi)->OpenStream = OpenStream; (*hostApi)->IsFormatSupported = IsFormatSupported; PaUtil_InitializeStreamInterface( &macCoreHostApi->callbackStreamInterface, CloseStream, StartStream, StopStream, AbortStream, IsStreamStopped, IsStreamActive, GetStreamTime, GetStreamCpuLoad, PaUtil_DummyRead, PaUtil_DummyWrite, PaUtil_DummyGetReadAvailable, PaUtil_DummyGetWriteAvailable ); PaUtil_InitializeStreamInterface( &macCoreHostApi->blockingStreamInterface, CloseStream, StartStream, StopStream, AbortStream, IsStreamStopped, IsStreamActive, GetStreamTime, PaUtil_DummyGetCpuLoad, ReadStream, WriteStream, GetStreamReadAvailable, GetStreamWriteAvailable ); return result; error: if( macCoreHostApi ) { CleanUp(macCoreHostApi); } return result; }

1 0

pd/portaudio/pa_jack pa_jack.c,1.2,1.3
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_jack In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_jack Added Files: pa_jack.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_jack.c --- /* * $Id: pa_jack.c,v 1.3 2004/09/06 20:44:39 millerpuckette Exp $ * PortAudio Portable Real-Time Audio Library * Latest Version at: http://www.portaudio.com * JACK Implementation by Joshua Haberman * * Copyright (c) 2002 Joshua Haberman <joshua(a)haberman.com> * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 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. * * 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. * * 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. */ #include <string.h> #include <regex.h> #include <stdlib.h> #include <stdio.h> #include <jack/types.h> #include <jack/jack.h> #include "pa_util.h" #include "pa_hostapi.h" #include "pa_stream.h" #include "pa_process.h" #include "pa_allocation.h" #include "pa_cpuload.h" PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex ); /* * Functions that directly map to the PortAudio stream interface */ static void Terminate( struct PaUtilHostApiRepresentation *hostApi ); static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi, const PaStreamParameters *inputParameters, const PaStreamParameters *outputParameters, double sampleRate ); static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi, PaStream** s, const PaStreamParameters *inputParameters, const PaStreamParameters *outputParameters, double sampleRate, unsigned long framesPerBuffer, PaStreamFlags streamFlags, PaStreamCallback *streamCallback, void *userData ); static PaError CloseStream( PaStream* stream ); static PaError StartStream( PaStream *stream ); static PaError StopStream( PaStream *stream ); static PaError AbortStream( PaStream *stream ); static PaError IsStreamStopped( PaStream *s ); static PaError IsStreamActive( PaStream *stream ); static PaTime GetStreamInputLatency( PaStream *stream ); static PaTime GetStreamOutputLatency( PaStream *stream ); static PaTime GetStreamTime( PaStream *stream ); static double GetStreamCpuLoad( PaStream* stream ); /* static PaError ReadStream( PaStream* stream, void *buffer, unsigned long frames ); static PaError WriteStream( PaStream* stream, const void *buffer, unsigned long frames ); static signed long GetStreamReadAvailable( PaStream* stream ); static signed long GetStreamWriteAvailable( PaStream* stream ); */ /* * Data specific to this API */ typedef struct { PaUtilHostApiRepresentation commonHostApiRep; PaUtilStreamInterface callbackStreamInterface; PaUtilAllocationGroup *deviceInfoMemory; jack_client_t *jack_client; PaHostApiIndex hostApiIndex; } PaJackHostApiRepresentation; #define MAX_CLIENTS 100 #define TRUE 1 #define FALSE 0 /* * Functions specific to this API */ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi ); static int JackCallback( jack_nframes_t frames, void *userData ); /* * * Implementation * */ /* BuildDeviceList(): * * The process of determining a list of PortAudio "devices" from * JACK's client/port system is fairly involved, so it is separated * into its own routine. */ static PaError BuildDeviceList( PaJackHostApiRepresentation *jackApi ) { /* Utility macros for the repetitive process of allocating memory */ /* ... MALLOC: allocate memory as part of the device list * allocation group */ #define MALLOC(size) \ (PaUtil_GroupAllocateMemory( jackApi->deviceInfoMemory, (size) )) /* ... MEMVERIFY: make sure we didn't get NULL */ #define MEMVERIFY(ptr) \ if( (ptr) == NULL ) return paInsufficientMemory; /* JACK has no concept of a device. To JACK, there are clients * which have an arbitrary number of ports. To make this * intelligible to PortAudio clients, we will group each JACK client * into a device, and make each port of that client a channel */ PaUtilHostApiRepresentation *commonApi = &jackApi->commonHostApiRep; const char **jack_ports; char *client_names[MAX_CLIENTS]; int num_clients = 0; int port_index, client_index, i; double *globalSampleRate; regex_t port_regex; /* since we are rebuilding the list of devices, free all memory * associated with the previous list */ PaUtil_FreeAllAllocations( jackApi->deviceInfoMemory ); /* We can only retrieve the list of clients indirectly, by first * asking for a list of all ports, then parsing the port names * according to the client_name:port_name convention (which is * enforced by jackd) */ jack_ports = jack_get_ports( jackApi->jack_client, "", "", 0 ); if( jack_ports == NULL ) return paUnanticipatedHostError; /* Parse the list of ports, using a regex to grab the client names */ regcomp( &port_regex, "^[^:]*", REG_EXTENDED ); /* Build a list of clients from the list of ports */ for( port_index = 0; jack_ports[port_index] != NULL; port_index++ ) { int client_seen; regmatch_t match_info; char tmp_client_name[100]; /* extract the client name from the port name, using a regex * that parses the clientname:portname syntax */ regexec( &port_regex, jack_ports[port_index], 1, &match_info, 0 ); memcpy( tmp_client_name, &jack_ports[port_index][match_info.rm_so], match_info.rm_eo - match_info.rm_so ); tmp_client_name[ match_info.rm_eo - match_info.rm_so ] = '\0'; /* do we know about this port's client yet? */ client_seen = FALSE; for( i = 0; i < num_clients; i++ ) if( strcmp( tmp_client_name, client_names[i] ) == 0 ) client_seen = TRUE; if( client_seen == FALSE ) { client_names[num_clients] = (char*)MALLOC(strlen(tmp_client_name) + 1); MEMVERIFY( client_names[num_clients] ); /* The alsa_pcm client should go in spot 0. If this * is the alsa_pcm client AND we are NOT about to put * it in spot 0 put it in spot 0 and move whatever * was already in spot 0 to the end. */ if( strcmp( "alsa_pcm", tmp_client_name ) == 0 && num_clients > 0 ) { /* alsa_pcm goes in spot 0 */ strcpy( client_names[ num_clients ], client_names[0] ); strcpy( client_names[0], "alsa_pcm" ); num_clients++; } else { /* put the new client at the end of the client list */ strcpy( client_names[ num_clients ], tmp_client_name ); num_clients++; } } } free( jack_ports ); /* Now we have a list of clients, which will become the list of * PortAudio devices. */ commonApi->info.deviceCount = num_clients; commonApi->info.defaultInputDevice = 0; commonApi->info.defaultOutputDevice = 0; /* there is one global sample rate all clients must conform to */ globalSampleRate = (double*)MALLOC( sizeof(double) ); MEMVERIFY( globalSampleRate ); *globalSampleRate = jack_get_sample_rate( jackApi->jack_client ); commonApi->deviceInfos = (PaDeviceInfo**)MALLOC( sizeof(PaDeviceInfo*) * num_clients ); MEMVERIFY(commonApi->deviceInfos); /* Create a PaDeviceInfo structure for every client */ for( client_index = 0; client_index < num_clients; client_index++ ) { char regex_pattern[100]; PaDeviceInfo *curDevInfo; curDevInfo = (PaDeviceInfo*)MALLOC( sizeof(PaDeviceInfo) ); MEMVERIFY( curDevInfo ); curDevInfo->name = (char*)MALLOC( strlen(client_names[client_index]) + 1 ); MEMVERIFY( curDevInfo->name ); strcpy( (char*)curDevInfo->name, client_names[client_index] ); curDevInfo->structVersion = 2; curDevInfo->hostApi = jackApi->hostApiIndex; /* JACK is very inflexible: there is one sample rate the whole * system must run at, and all clients must speak IEEE float. */ curDevInfo->defaultSampleRate = *globalSampleRate; /* To determine how many input and output channels are available, * we re-query jackd with more specific parameters. */ sprintf( regex_pattern, "%s:.*", client_names[client_index] ); /* ... what are your output ports (that we could input to)? */ jack_ports = jack_get_ports( jackApi->jack_client, regex_pattern, NULL, JackPortIsOutput); curDevInfo->maxInputChannels = 0; for( i = 0; jack_ports[i] != NULL ; i++) { /* The number of ports returned is the number of output channels. * We don't care what they are, we just care how many */ curDevInfo->maxInputChannels++; } free(jack_ports); /* ... what are your input ports (that we could output to)? */ jack_ports = jack_get_ports( jackApi->jack_client, regex_pattern, NULL, JackPortIsInput); curDevInfo->maxOutputChannels = 0; for( i = 0; jack_ports[i] != NULL ; i++) { /* The number of ports returned is the number of input channels. * We don't care what they are, we just care how many */ curDevInfo->maxOutputChannels++; } free(jack_ports); curDevInfo->defaultLowInputLatency = 0.; /* IMPLEMENT ME */ curDevInfo->defaultLowOutputLatency = 0.; /* IMPLEMENT ME */ curDevInfo->defaultHighInputLatency = 0.; /* IMPLEMENT ME */ curDevInfo->defaultHighOutputLatency = 0.; /* IMPLEMENT ME */ /* Add this client to the list of devices */ commonApi->deviceInfos[client_index] = curDevInfo; } #undef MALLOC #undef MEMVERIFY return paNoError; } PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex ) { PaError result = paNoError; PaJackHostApiRepresentation *jackHostApi; jackHostApi = (PaJackHostApiRepresentation*) PaUtil_AllocateMemory( sizeof(PaJackHostApiRepresentation) ); if( !jackHostApi ) { result = paInsufficientMemory; goto error; } jackHostApi->deviceInfoMemory = NULL; /* Try to become a client of the JACK server. If we cannot do * this, than this API cannot be used. */ jackHostApi->jack_client = jack_client_new( "PortAudio client" ); if( jackHostApi->jack_client == 0 ) { /* the V19 development docs say that if an implementation * detects that it cannot be used, it should return a NULL * interface and paNoError */ result = paNoError; *hostApi = NULL; goto error; } jackHostApi->deviceInfoMemory = PaUtil_CreateAllocationGroup(); if( !jackHostApi->deviceInfoMemory ) { result = paInsufficientMemory; goto error; } jackHostApi->hostApiIndex = hostApiIndex; *hostApi = &jackHostApi->commonHostApiRep; (*hostApi)->info.structVersion = 1; (*hostApi)->info.type = paInDevelopment; (*hostApi)->info.name = "JACK Audio Connection Kit"; (*hostApi)->info.defaultInputDevice = paNoDevice; /* set in BuildDeviceList() */ (*hostApi)->info.defaultOutputDevice = paNoDevice; /* set in BuildDeviceList() */ (*hostApi)->info.deviceCount = 0; /* set in BuildDeviceList() */ /* Build a device list by querying the JACK server */ result = BuildDeviceList( jackHostApi ); if( result != paNoError ) goto error; /* Register functions */ (*hostApi)->Terminate = Terminate; (*hostApi)->OpenStream = OpenStream; (*hostApi)->IsFormatSupported = IsFormatSupported; PaUtil_InitializeStreamInterface( &jackHostApi->callbackStreamInterface, CloseStream, StartStream, StopStream, AbortStream, IsStreamStopped, IsStreamActive, GetStreamTime, GetStreamCpuLoad, PaUtil_DummyRead, PaUtil_DummyWrite, PaUtil_DummyGetReadAvailable, PaUtil_DummyGetWriteAvailable ); return result; error: if( jackHostApi ) { if( jackHostApi->deviceInfoMemory ) { PaUtil_FreeAllAllocations( jackHostApi->deviceInfoMemory ); PaUtil_DestroyAllocationGroup( jackHostApi->deviceInfoMemory ); } PaUtil_FreeMemory( jackHostApi ); } return result; } static void Terminate( struct PaUtilHostApiRepresentation *hostApi ) { PaJackHostApiRepresentation *jackHostApi = (PaJackHostApiRepresentation*)hostApi; jack_client_close( jackHostApi->jack_client ); if( jackHostApi->deviceInfoMemory ) { PaUtil_FreeAllAllocations( jackHostApi->deviceInfoMemory ); PaUtil_DestroyAllocationGroup( jackHostApi->deviceInfoMemory ); } PaUtil_FreeMemory( jackHostApi ); } static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi, const PaStreamParameters *inputParameters, const PaStreamParameters *outputParameters, double sampleRate ) { int inputChannelCount, outputChannelCount; PaSampleFormat inputSampleFormat, outputSampleFormat; if( inputParameters ) { inputChannelCount = inputParameters->channelCount; inputSampleFormat = inputParameters->sampleFormat; /* unless alternate device specification is supported, reject the use of paUseHostApiSpecificDeviceSpecification */ if( inputParameters->device == paUseHostApiSpecificDeviceSpecification ) return paInvalidDevice; /* check that input device can support inputChannelCount */ if( inputChannelCount > hostApi->deviceInfos[ inputParameters->device ]->maxInputChannels ) return paInvalidChannelCount; /* validate inputStreamInfo */ if( inputParameters->hostApiSpecificStreamInfo ) return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */ } else { inputChannelCount = 0; } if( outputParameters ) { outputChannelCount = outputParameters->channelCount; outputSampleFormat = outputParameters->sampleFormat; /* unless alternate device specification is supported, reject the use of paUseHostApiSpecificDeviceSpecification */ if( outputParameters->device == paUseHostApiSpecificDeviceSpecification ) return paInvalidDevice; /* check that output device can support inputChannelCount */ if( outputChannelCount > hostApi->deviceInfos[ outputParameters->device ]->maxOutputChannels ) return paInvalidChannelCount; /* validate outputStreamInfo */ if( outputParameters->hostApiSpecificStreamInfo ) return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */ } else { outputChannelCount = 0; } /* The following check is not necessary for JACK. - if a full duplex stream is requested, check that the combination of input and output parameters is supported Because the buffer adapter handles conversion between all standard sample formats, the following checks are only required if paCustomFormat is implemented, or under some other unusual conditions. - check that input device can support inputSampleFormat, or that we have the capability to convert from outputSampleFormat to a native format - check that output device can support outputSampleFormat, or that we have the capability to convert from outputSampleFormat to a native format */ /* check that the device supports sampleRate */ #define ABS(x) ( (x) > 0 ? (x) : -(x) ) if( ABS(sampleRate - hostApi->deviceInfos[0]->defaultSampleRate) > 1 ) return paInvalidSampleRate; #undef ABS return paFormatIsSupported; } /* PaJackStream - a stream data structure specifically for this implementation */ typedef struct PaJackStream { PaUtilStreamRepresentation streamRepresentation; PaUtilBufferProcessor bufferProcessor; PaUtilCpuLoadMeasurer cpuLoadMeasurer; /* our input and output ports */ jack_port_t **local_input_ports; jack_port_t **local_output_ports; /* the input and output ports of the client we are connecting to */ jack_port_t **remote_input_ports; jack_port_t **remote_output_ports; int num_incoming_connections; int num_outgoing_connections; jack_client_t *jack_client; /* The stream is running if it's still producing samples. * The stream is active if samples it produced are still being heard. */ int is_running; int is_active; jack_nframes_t t0; unsigned long total_frames_sent; PaUtilAllocationGroup *stream_memory; } PaJackStream; static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi, PaStream** s, const PaStreamParameters *inputParameters, const PaStreamParameters *outputParameters, double sampleRate, unsigned long framesPerBuffer, PaStreamFlags streamFlags, PaStreamCallback *streamCallback, void *userData ) { PaError result = paNoError; PaJackHostApiRepresentation *jackHostApi = (PaJackHostApiRepresentation*)hostApi; PaJackStream *stream = 0; char port_string[100]; char regex_pattern[100]; const char **jack_ports; int jack_max_buffer_size = jack_get_buffer_size( jackHostApi->jack_client ); int i; int inputChannelCount, outputChannelCount; PaSampleFormat inputSampleFormat, outputSampleFormat; /* the client has no say over the frames per callback */ if( framesPerBuffer == paFramesPerBufferUnspecified ) framesPerBuffer = jack_max_buffer_size; /* Preliminary checks */ if( inputParameters ) { inputChannelCount = inputParameters->channelCount; inputSampleFormat = inputParameters->sampleFormat; /* unless alternate device specification is supported, reject the use of paUseHostApiSpecificDeviceSpecification */ if( inputParameters->device == paUseHostApiSpecificDeviceSpecification ) return paInvalidDevice; /* check that input device can support inputChannelCount */ if( inputChannelCount > hostApi->deviceInfos[ inputParameters->device ]->maxInputChannels ) return paInvalidChannelCount; /* validate inputStreamInfo */ if( inputParameters->hostApiSpecificStreamInfo ) return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */ } else { inputChannelCount = 0; } if( outputParameters ) { outputChannelCount = outputParameters->channelCount; outputSampleFormat = outputParameters->sampleFormat; /* unless alternate device specification is supported, reject the use of paUseHostApiSpecificDeviceSpecification */ if( outputParameters->device == paUseHostApiSpecificDeviceSpecification ) return paInvalidDevice; /* check that output device can support inputChannelCount */ if( outputChannelCount > hostApi->deviceInfos[ outputParameters->device ]->maxOutputChannels ) return paInvalidChannelCount; /* validate outputStreamInfo */ if( outputParameters->hostApiSpecificStreamInfo ) return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */ } else { outputChannelCount = 0; } /* ... check that the sample rate exactly matches the ONE acceptable rate */ #define ABS(x) ( (x) > 0 ? (x) : -(x) ) if( ABS(sampleRate - hostApi->deviceInfos[0]->defaultSampleRate) > 1 ) return paInvalidSampleRate; #undef ABS /* Allocate memory for structuures */ #define MALLOC(size) \ (PaUtil_GroupAllocateMemory( stream->stream_memory, (size) )) #define MEMVERIFY(ptr) \ if( (ptr) == NULL ) \ { \ result = paInsufficientMemory; \ goto error; \ } stream = (PaJackStream*)PaUtil_AllocateMemory( sizeof(PaJackStream) ); MEMVERIFY( stream ); stream->stream_memory = PaUtil_CreateAllocationGroup(); stream->jack_client = jackHostApi->jack_client; PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate ); stream->local_input_ports = (jack_port_t**) MALLOC(sizeof(jack_port_t*) * inputChannelCount ); stream->local_output_ports = (jack_port_t**) MALLOC( sizeof(jack_port_t*) * outputChannelCount ); stream->remote_output_ports = (jack_port_t**) MALLOC( sizeof(jack_port_t*) * inputChannelCount ); stream->remote_input_ports = (jack_port_t**) MALLOC( sizeof(jack_port_t*) * outputChannelCount ); MEMVERIFY( stream->local_input_ports ); MEMVERIFY( stream->local_output_ports ); MEMVERIFY( stream->remote_input_ports ); MEMVERIFY( stream->remote_output_ports ); stream->num_incoming_connections = inputChannelCount; stream->num_outgoing_connections = outputChannelCount; if( streamCallback ) { PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation, &jackHostApi->callbackStreamInterface, streamCallback, userData ); } else { /* we do not support blocking I/O */ return paBadIODeviceCombination; } /* create the JACK ports. We cannot connect them until audio * processing begins */ for( i = 0; i < inputChannelCount; i++ ) { sprintf( port_string, "in_%d", i ); stream->local_input_ports[i] = jack_port_register( jackHostApi->jack_client, port_string, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 ); } for( i = 0; i < outputChannelCount; i++ ) { sprintf( port_string, "out_%d", i ); stream->local_output_ports[i] = jack_port_register( jackHostApi->jack_client, port_string, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); } /* look up the jack_port_t's for the remote ports. We could do * this at stream start time, but doing it here ensures the * name lookup only happens once. */ if( inputChannelCount > 0 ) { /* ... remote output ports (that we input from) */ sprintf( regex_pattern, "%s:.*", hostApi->deviceInfos[ inputParameters->device ]->name ); jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern, NULL, JackPortIsOutput); for( i = 0; i < inputChannelCount && jack_ports[i]; i++ ) { stream->remote_output_ports[i] = jack_port_by_name( jackHostApi->jack_client, jack_ports[i] ); } if( i < inputChannelCount ) { /* we found fewer ports than we expected */ return paInternalError; } free( jack_ports ); // XXX: this doesn't happen if we exit prematurely } if( outputChannelCount > 0 ) { /* ... remote input ports (that we output to) */ sprintf( regex_pattern, "%s:.*", hostApi->deviceInfos[ outputParameters->device ]->name ); jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern, NULL, JackPortIsInput); for( i = 0; i < outputChannelCount && jack_ports[i]; i++ ) { stream->remote_input_ports[i] = jack_port_by_name( jackHostApi->jack_client, jack_ports[i] ); } if( i < outputChannelCount ) { /* we found fewer ports than we expected */ return paInternalError; } free( jack_ports ); // XXX: this doesn't happen if we exit prematurely } result = PaUtil_InitializeBufferProcessor( &stream->bufferProcessor, inputChannelCount, inputSampleFormat, paFloat32, /* hostInputSampleFormat */ outputChannelCount, outputSampleFormat, paFloat32, /* hostOutputSampleFormat */ sampleRate, streamFlags, framesPerBuffer, jack_max_buffer_size, paUtilFixedHostBufferSize, streamCallback, userData ); if( result != paNoError ) goto error; stream->is_running = FALSE; stream->t0 = -1;/* set the first time through the callback*/ stream->total_frames_sent = 0; jack_set_process_callback( jackHostApi->jack_client, JackCallback, stream ); *s = (PaStream*)stream; return result; error: if( stream ) { if( stream->stream_memory ) { PaUtil_FreeAllAllocations( stream->stream_memory ); PaUtil_DestroyAllocationGroup( stream->stream_memory ); } PaUtil_FreeMemory( stream ); } return result; #undef MALLOC #undef MEMVERIFY } static int JackCallback( jack_nframes_t frames, void *userData ) { PaJackStream *stream = (PaJackStream*)userData; PaStreamCallbackTimeInfo timeInfo = {0,0,0}; /* IMPLEMENT ME */ int callbackResult; int chn; int framesProcessed; if( stream->t0 == -1 ) { if( stream->num_outgoing_connections == 0 ) { /* TODO: how to handle stream time for capture-only operation? */ } else { /* the beginning time needs to be initialized */ stream->t0 = jack_frame_time( stream->jack_client ) - jack_frames_since_cycle_start( stream->jack_client) + jack_port_get_total_latency( stream->jack_client, stream->local_output_ports[0] ); } } PaUtil_BeginCpuLoadMeasurement( &stream->cpuLoadMeasurer ); PaUtil_BeginBufferProcessing( &stream->bufferProcessor, &timeInfo, 0 /* @todo pass underflow/overflow flags when necessary */ ); for( chn = 0; chn < stream->num_incoming_connections; chn++ ) { jack_default_audio_sample_t *channel_buf; channel_buf = (jack_default_audio_sample_t*) jack_port_get_buffer( stream->local_input_ports[chn], frames ); PaUtil_SetNonInterleavedInputChannel( &stream->bufferProcessor, chn, channel_buf ); } for( chn = 0; chn < stream->num_outgoing_connections; chn++ ) { jack_default_audio_sample_t *channel_buf; channel_buf = (jack_default_audio_sample_t*) jack_port_get_buffer( stream->local_output_ports[chn], frames ); PaUtil_SetNonInterleavedOutputChannel( &stream->bufferProcessor, chn, channel_buf ); } if( stream->num_incoming_connections > 0 ) PaUtil_SetInputFrameCount( &stream->bufferProcessor, frames ); if( stream->num_outgoing_connections > 0 ) PaUtil_SetOutputFrameCount( &stream->bufferProcessor, frames ); callbackResult = paContinue; framesProcessed = PaUtil_EndBufferProcessing( &stream->bufferProcessor, &callbackResult ); PaUtil_EndCpuLoadMeasurement( &stream->cpuLoadMeasurer, framesProcessed ); stream->total_frames_sent += frames; if( callbackResult == paContinue ) { /* nothing special */ } else if( callbackResult == paAbort ) { /* finish playback immediately */ /* TODO: memset 0 the outgoing samples to "cancel" them */ stream->is_active = FALSE; /* return nonzero so we get deactivated (and the callback won't * get called again) */ return 1; } else { /* User callback has asked us to stop with paComplete or other non-zero value. */ stream->is_active = FALSE; /* return nonzero so we get deactivated (and the callback won't * get called again) */ return 1; } return 0; } /* When CloseStream() is called, the multi-api layer ensures that the stream has already been stopped or aborted. */ static PaError CloseStream( PaStream* s ) { PaError result = paNoError; PaJackStream *stream = (PaJackStream*)s; PaUtil_TerminateStreamRepresentation( &stream->streamRepresentation ); PaUtil_FreeMemory( stream ); return result; } static PaError StartStream( PaStream *s ) { PaError result = paNoError; PaJackStream *stream = (PaJackStream*)s; int i; /* start the audio thread */ jack_activate( stream->jack_client ); /* connect the ports */ /* NOTE: I would rather use jack_port_connect which uses jack_port_t's * instead of port names, but it is not implemented yet. */ if( stream->num_incoming_connections > 0 ) { for( i = 0; i < stream->num_incoming_connections; i++ ) jack_connect( stream->jack_client, jack_port_name(stream->remote_output_ports[i]), jack_port_name(stream->local_input_ports[i] ) ); } if( stream->num_outgoing_connections > 0 ) { for( i = 0; i < stream->num_outgoing_connections; i++ ) jack_connect( stream->jack_client, jack_port_name(stream->local_output_ports[i]), jack_port_name(stream->remote_input_ports[i]) ); } stream->is_running = TRUE; return result; } static PaError StopStream( PaStream *s ) { PaError result = paNoError; PaJackStream *stream = (PaJackStream*)s; /* note: this automatically disconnects all ports, since a deactivated * client is not allowed to have any ports connected */ jack_deactivate( stream->jack_client ); stream->is_running = FALSE; /* TODO: block until playback complete */ stream->is_active = FALSE; return result; } static PaError AbortStream( PaStream *s ) { PaError result = paNoError; PaJackStream *stream = (PaJackStream*)s; /* There's no way to cancel samples already submitted, but we can * return immediately */ /* note: this automatically disconnects all ports, since a deactivated * client is not allowed to have any ports connected */ jack_deactivate( stream->jack_client ); stream->is_running = FALSE; stream->is_active = FALSE; return result; } static PaError IsStreamStopped( PaStream *s ) { PaJackStream *stream = (PaJackStream*)s; return stream->is_running == FALSE; } static PaError IsStreamActive( PaStream *s ) { PaJackStream *stream = (PaJackStream*)s; return stream->is_active == TRUE; } static PaTime GetStreamTime( PaStream *s ) { PaJackStream *stream = (PaJackStream*)s; /* TODO: what if we're recording-only? */ return jack_frame_time( stream->jack_client ) - stream->t0; } static double GetStreamCpuLoad( PaStream* s ) { PaJackStream *stream = (PaJackStream*)s; return PaUtil_GetCpuLoad( &stream->cpuLoadMeasurer ); }

1 0

pd/portaudio/pa_mac pa_mac_hostapis.c,NONE,1.1
by Miller Puckette 06 Sep '04

06 Sep '04

Update of /cvsroot/pure-data/pd/portaudio/pa_mac In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15364/portaudio/pa_mac Added Files: pa_mac_hostapis.c Log Message: ... more changes to try to upload 0.38 test 5 to CVS --- NEW FILE: pa_mac_hostapis.c --- /* * $Id: pa_mac_hostapis.c,v 1.1 2004/09/06 20:44:39 millerpuckette Exp $ * Portable Audio I/O Library Windows initialization table * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 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. * * 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. * * 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. */ /** @file Mac OS host API initialization function table. */ #include "pa_hostapi.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ PaError PaSkeleton_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaMacCore_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaMacSm_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); PaError PaMacAsio_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index ); #ifdef __cplusplus } #endif /* __cplusplus */ PaUtilHostApiInitializer *paHostApiInitializers[] = { #ifdef PA_USE_COREAUDIO PaMacCore_Initialize, #endif #ifdef PA_USE_SM PaMacSm_Initialize, #endif #ifdef PA_USE_JACK PaJack_Initialize, #endif #ifdef PA_USE_ASIO PaMacAsio_Initialize, #endif PaSkeleton_Initialize, /* just for testing */ 0 /* NULL terminated array */ }; int paDefaultHostApiIndex = 0;

1 0

← Newer
1
...
7
8
9
10
11
12
13
14
15
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

Pd-cvs September 2004