"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1993 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic2' }"

"{ NameSpace: Smalltalk }"

FileStream subclass:#SoundStream

	instanceVariableNames:'sampleRate numberOfChannels bitsPerSample audioFormat handle1

		handle2 bufferOffset bufferSize lastErrorString fragmentSize

		openMode openAttributes'

	classVariableNames:'IsInitialized UnsupportedOperationSignal ConcreteClass'

	poolDictionaries:''

	category:'Streams-External'

!

SoundStream subclass:#DevAudio

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:SoundStream

!

SoundStream subclass:#IRISAudio

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:SoundStream

!

SoundStream subclass:#JackAudio

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:SoundStream

!

SoundStream subclass:#PortAudio

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:SoundStream

!

SoundStream subclass:#Win32DirectSound

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:SoundStream

!

SoundStream subclass:#Win32WaveSound

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:SoundStream

!

!SoundStream primitiveDefinitions!

%{

#include "stxOSDefs.h"

#ifndef NO_SOUND

# ifdef __win32__

#  define xxxSUPPORT_WIN32_DIRECTSOUND

#  ifndef SUPPORT_WIN32_WAVESOUND

#   define SUPPORT_WIN32_WAVESOUND

#  endif

# endif /* __win32__ */

# ifdef __iris__

#  ifndef IRIX5

#   ifndef SUPPORT_IRIS_AUDIO

#    define SUPPORT_IRIS_AUDIO

#   endif

#  endif

# endif // __iris__

# ifndef SUPPORT_IRIS_AUDIO

#  ifndef SUPPORT_ALSA_AUDIO

#   ifdef LINUX

#    ifndef SUPPORT_DEV_AUDIO

#     define SUPPORT_DEV_AUDIO

#    endif

#   endif // LINUX

#  endif

# endif // SUPPORT_IRIS_AUDIO

# ifdef __osx__

#  ifndef SUPPORT_PORTAUDIO

#   define xxxSUPPORT_PORTAUDIO 	// def comes from config file

#  endif

# endif // __osx__

#endif /* NO_SOUND */

#ifdef SUPPORT_IRIS_AUDIO

# include <audio.h>

# define __ALportVal(o)  (ALport)(__externalAddressVal(o))

# define alPort handle1

#endif

#ifdef SUPPORT_ALSA_AUDIO

# ifdef LINUX

#  include <alsa/asoundlib.h>

#  define MAX_NR_OF_CHANNELS 8

#  define DEBUG_SOUND

#  define readHandle handle1

#  define writeHandle handle2

# endif

#endif

#ifdef SUPPORT_DEV_AUDIO

# ifdef LINUX

#  include <stdio.h>

#  include <errno.h>

#  include <signal.h>

#  include <sys/ioctl.h>

#  include <sys/soundcard.h>

#  define DEV_AUDIO_DEFAULT_FREQ (8000)

#  define DEV_AUDIO_DEFAULT_BUFFERSIZE (16384)

# endif

# ifdef FREEBSD

#  include <stdio.h>

#  include <sys/time.h>

#  include <sys/ioctl.h>

#  include <machine/pcaudioio.h>

#  define DEV_AUDIO_DEFAULT_FREQ (8000)

#  define DEV_AUDIO_DEFAULT_BUFFERSIZE (16384)

# endif

# if defined(sunos) || defined(solaris)

#  include <stdio.h>

#  ifdef solaris

#   include <sys/audioio.h>

#  else

#   include <sun/audioio.h>

#  endif

#  define DEV_AUDIO_DEFAULT_FREQ (8000)

#  define DEV_AUDIO_DEFAULT_BUFFERSIZE (16384)

# endif

# if defined(hpux)

#  include <stdio.h>

#  include <sys/ioctl.h>

#  include <sys/inode.h>

#  include <sys/audio.h>

#  include <sys/time.h>

#  include <unistd.h>

#  define DEV_AUDIO_DEFAULT_FREQ (22050)

#  define DEV_AUDIO_DEFAULT_BUFFERSIZE (16384)

# endif

#endif /* SUPPORT_DEV_AUDIO */

#ifdef SUPPORT_PORTAUDIO

// # include "pthread.h"

# include "portaudio.h"

# define PORTAUDIO_DEFAULT_FREQ (44100)

# define PORTAUDIO_DEFAULT_BUFFERSIZE (16384)

# define xINITLOCK(lk)    { pthread_mutex_init(&(lk), NULL); }

# define xRELEASELOCK(lk) { pthread_mutex_destroy(&(lk)); }

# define xLOCK(lk)        { pthread_mutex_lock(&(lk)); }

# define xUNLOCK(lk)      { pthread_mutex_unlock(&(lk)); }

# define xMUTEX            pthread_mutex_t

# define INITLOCK(lk)    { (lk) = 0; }

# define RELEASELOCK(lk) { (lk) = 0; }

# define LOCK(lk)        { while ((lk)) ; (lk) = 1; }

# define UNLOCK(lk)      { (lk) = 0; }

# define MUTEX           int

#endif // SUPPORT_PORTAUDIO

#ifdef SUPPORT_JACKAUDIO

# include "jack/jack.h"

#endif // SUPPORT_JACKAUDIO

#ifdef __win32__

# define _WIN32

# undef INT

# undef Array

# undef Number

# undef Method

# undef Point

# undef Rectangle

# undef Block

# undef String

# undef Message

# undef Object

# undef Context

# undef Time

# undef Date

# undef Process

# undef Processor

# undef Set

# undef Signal

# undef Delay

/* # include <stdarg.h> /* */

# include <stdio.h> /* */

# include <windows.h>

# ifdef SUPPORT_WIN32_DIRECTSOUND

#  define CINTERFACE

#  include "dsound.h"

#  define __DirectSoundVal(o) (LPDIRECTSOUND)(__externalAddressVal(o))

#  define __DSBufferVal(o)    (LPDIRECTSOUNDBUFFER)(__externalAddressVal(o))

#  define RT_BUFFER_SIZE 4096

#  define NBUFS          4

#  define pDirectSound handle1

#  define pDSBuffer    handle2

# else /* USE WAVE... */

#  ifdef SUPPORT_WIN32_WAVESOUND

#   define __WaveHandleVal(o)    (HWAVEOUT)(__externalAddressVal(o))

#   define MAXBUF      10        /* Maximum number of buffers */

#   define DATALEN     2048      /* Size of wave data buffer */

struct buf {

    WAVEHDR hdr;                /* Wave data header */

    char data[DATALEN];         /* Actual wave data */

    struct buf *next;           /* Next buffer in free list */

};

static struct buf *free_list = NULL;      /* List of available buffers */

static CRITICAL_SECTION free_list_lock;

static int free_buffers = 0;             /* Number of buffers in free list */

static int total_buffers = 0;            /* Total number of buffers allocated */

static HANDLE free_buffer_event;         /* Automatic-reset event triggered whenever */

#   define waveHandle handle1

#  endif /* SUPPORT_WIN32_WAVESOUND */

# endif /* SUPPORT_WIN32_DIRECTSOUND */

# ifdef __DEF_Array

#  define Array __DEF_Array

# endif

# ifdef __DEF_Number

#  define Number __DEF_Number

# endif

# ifdef __DEF_Method

#  define Method __DEF_Method

# endif

# ifdef __DEF_Point

#  define Point __DEF_Point

# endif

# ifdef __DEF_Block

#  define Block __DEF_Block

# endif

# ifdef __DEF_String

#  define String __DEF_String

# endif

# ifdef __DEF_Message

#  define Message __DEF_Message

# endif

# ifdef __DEF_Object

#  define Object __DEF_Object

# endif

# ifdef __DEF_Context

#  define Context __DEF_Context

# endif

# ifdef __DEF_Time

#  define Time __DEF_Time

# endif

# ifdef __DEF_Date

#  define Date __DEF_Date

# endif

#ifdef __DEF_Process

# define Process __DEF_Process

#endif

#ifdef __DEF_Processor

# define Processor __DEF_Processor

#endif

#ifdef __DEF_Set

# define Set __DEF_Set

#endif

#ifdef __DEF_Signal

# define Signal __DEF_Signal

#endif

#ifdef __DEF_Delay

# define Delay __DEF_Delay

#endif

# define INT  STX_INT

# define UINT STX_UINT

#endif /* __win32__ */

#ifdef DEBUG_SOUND

# define DPRINTF(x) console_printf x

#else

# define DPRINTF(x) /* as nothing */

#endif

%}

! !

!SoundStream primitiveVariables!

%{

static int DEBUGGING = 0;

%}

! !

!SoundStream primitiveFunctions!

%{

#ifdef SUPPORT_WIN32_WAVESOUND

/*

 * This routine will be called by windows when audio is needed.

 * It may called at interrupt level and by a separate thread, so don't do anything

 * that could mess up the system like calling malloc() or free().

 */

static void CALLBACK

waveCallBack(HWAVE waveHandle, UINT msg, DWORD_PTR inst, DWORD_PTR p1, DWORD_PTR p2)

{

    if (msg == MM_WOM_DONE) {

        struct buf *bp = (struct buf *)p1;

        EnterCriticalSection(&free_list_lock);

        bp->next = free_list;

        free_list = bp;

        free_buffers++;

        SetEvent(free_buffer_event);

        LeaveCriticalSection(&free_list_lock);

    }

}

#endif /* SUPPORT_WIN32_WAVESOUND */

#ifdef SUPPORT_PORTAUDIO

struct paBuffer {

    void* sampleData;

    int bufferSize;

    struct paBuffer* nextBuffer;

};

struct paStreamData {

    PaStream *stream;

    MUTEX lock;

    int readOffset;

    int bytesPerSample;     // bytesPerSample (1, 2 or 4)

    int nChannels;          // num channels (1 or 2)

    int hasFinished;

    struct paBuffer* currentBuffer;

    struct paBuffer* lastBuffer;

    struct paBuffer* freeList;

};

/*

 * This routine will be called by the PortAudio engine when audio is needed.

 * It may called at interrupt level on some machines, so don't do anything

 * that could mess up the system like calling malloc() or free().

 */

static int

paCallback( const void *inputBuffer, void *outputBuffer,

            unsigned long framesPerBuffer,

            const PaStreamCallbackTimeInfo* timeInfo,

            PaStreamCallbackFlags statusFlags,

            void *userData )

{

    struct paStreamData *streamData = (struct paStreamData *)userData;

    struct paBuffer *buffer = streamData->currentBuffer;

    int nBytesToOutput = streamData->bytesPerSample * streamData->nChannels * framesPerBuffer;

    int nBytesLeftInBuffer;

    int readOffset;

    int writeOffset = 0;

    int nSent;

    int retVal = paContinue;

    readOffset = streamData->readOffset;

  again:

    if (buffer != NULL) {

        nBytesLeftInBuffer = buffer->bufferSize - readOffset;

        if (DEBUGGING) {

            fprintf(stderr, "pa: %d from %p[%d] to [%d]; next: %p last: %p)\n",

                        nBytesLeftInBuffer, buffer, readOffset, writeOffset,

                        buffer->nextBuffer, streamData->lastBuffer);

        }

    } else {

        nBytesLeftInBuffer = 0;

    }

    if (nBytesLeftInBuffer >= nBytesToOutput) {

        memcpy(outputBuffer+writeOffset, buffer->sampleData+readOffset, nBytesToOutput);

        nSent = nBytesToOutput;

        if (DEBUGGING) {

            fprintf(stderr, "pa: %d from buffer\n", nSent);

        }

        nBytesToOutput = 0;

        readOffset += nSent;

    } else {

        nSent = nBytesLeftInBuffer;

        if (nSent > 0) {

            memcpy(outputBuffer+writeOffset, buffer->sampleData+readOffset, nBytesLeftInBuffer);

            if (DEBUGGING) {

                fprintf(stderr, "pa: %d from buffer\n", nBytesLeftInBuffer);

            }

            nBytesToOutput -= nSent;

            readOffset += nBytesLeftInBuffer;

        }

    }

    if (buffer != NULL) {

        streamData->readOffset = readOffset;

        if (readOffset >= buffer->bufferSize) {

            LOCK(streamData->lock);

            // next buffer

            streamData->currentBuffer = buffer->nextBuffer;

            streamData->readOffset = readOffset = 0;

            // this buffer onto freeList

            buffer->nextBuffer = streamData->freeList;

            streamData->freeList = buffer;

            if (DEBUGGING) {

                fprintf(stderr, "pa: put on freelist: %p\n", buffer);

            }

            if (streamData->currentBuffer == NULL) {

                if (DEBUGGING) {

                    fprintf(stderr, "pa: done with last buffer\n");

                }

                streamData->lastBuffer = NULL;

                retVal = paComplete;

            }

            UNLOCK(streamData->lock);

            if (nBytesToOutput > 0) {

                writeOffset += nSent;

                if (streamData->currentBuffer == NULL) {

                    memset(outputBuffer+writeOffset, 0, nBytesToOutput);

                } else {

                    buffer = streamData->currentBuffer;

                    readOffset = 0;

                    if (DEBUGGING) {

                        fprintf(stderr, "pa: %d more\n", nBytesToOutput);

                    }

                    goto again;

                }

            }

        }

    }

    return paContinue;

}

/*

 * This routine is called by portaudio when playback is done.

 */

static void

paStreamFinished( void* userData )

{

    struct paStreamData *streamData = (struct paStreamData *)userData;

    streamData->hasFinished = 1;

    if (DEBUGGING) {

        fprintf(stderr, "pa: Stream Completed\n" );

    }

}

#endif /* SUPPORT_PORTAUDIO */

#ifdef SUPPORT_JACKAUDIO

struct jackBuffer {

    void* sampleData;

    int bufferSize;

    struct jackBuffer* nextBuffer;

};

struct jackStreamData {

    jack_port_t *jack_input_port;

    jack_port_t *jack_output_port;

    jack_client_t *jack_client;