[sdl_omap.git] / src / audio / ums / SDL_umsaudio.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Carsten Griwodz
    griff@kom.tu-darmstadt.de

    based on linux/SDL_dspaudio.c by Sam Lantinga
*/
#include "SDL_config.h"

/* Allow access to a raw mixing buffer */

#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/mman.h>

#include "SDL_audio.h"
#include "../SDL_audio_c.h"
#include "../SDL_audiodev_c.h"
#include "SDL_umsaudio.h"

/* The tag name used by UMS audio */
#define UMS_DRIVER_NAME         "ums"

#define DEBUG_AUDIO 1

/* Audio driver functions */
static int UMS_OpenAudio(_THIS, SDL_AudioSpec *spec);
static void UMS_PlayAudio(_THIS);
static Uint8 *UMS_GetAudioBuf(_THIS);
static void UMS_CloseAudio(_THIS);

static UMSAudioDevice_ReturnCode UADOpen(_THIS,  string device, string mode, long flags);
static UMSAudioDevice_ReturnCode UADClose(_THIS);
static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long* bits);
static UMSAudioDevice_ReturnCode UADSetBitsPerSample(_THIS, long bits);
static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate, long* set_rate);
static UMSAudioDevice_ReturnCode UADSetByteOrder(_THIS, string byte_order);
static UMSAudioDevice_ReturnCode UADSetAudioFormatType(_THIS, string fmt);
static UMSAudioDevice_ReturnCode UADSetNumberFormat(_THIS, string fmt);
static UMSAudioDevice_ReturnCode UADInitialize(_THIS);
static UMSAudioDevice_ReturnCode UADStart(_THIS);
static UMSAudioDevice_ReturnCode UADStop(_THIS);
static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS,  UMSAudioTypes_TimeFormat fmt );
static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS,  long* buff_size );
static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS,  long* buff_size );
static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS,  long* buff_size );
static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS,  long bytes, long* bytes_ret );
static UMSAudioDevice_ReturnCode UADSetVolume(_THIS,  long volume );
static UMSAudioDevice_ReturnCode UADSetBalance(_THIS,  long balance );
static UMSAudioDevice_ReturnCode UADSetChannels(_THIS,  long channels );
static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS,  boolean block );
static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS,  string output, long* left_gain, long* right_gain);
static UMSAudioDevice_ReturnCode UADWrite(_THIS,  UMSAudioTypes_Buffer* buff, long samples, long* samples_written);

/* Audio driver bootstrap functions */
static int Audio_Available(void)
{
    return 1;
}

static void Audio_DeleteDevice(_THIS)
{
    if(this->hidden->playbuf._buffer) SDL_free(this->hidden->playbuf._buffer);
    if(this->hidden->fillbuf._buffer) SDL_free(this->hidden->fillbuf._buffer);
    _somFree( this->hidden->umsdev );
    SDL_free(this->hidden);
    SDL_free(this);
}

static SDL_AudioDevice *Audio_CreateDevice(int devindex)
{
    SDL_AudioDevice *this;

    /*
     * Allocate and initialize management storage and private management
     * storage for this SDL-using library.
     */
    this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
    if ( this ) {
        SDL_memset(this, 0, (sizeof *this));
        this->hidden = (struct SDL_PrivateAudioData *)SDL_malloc((sizeof *this->hidden));
    }
    if ( (this == NULL) || (this->hidden == NULL) ) {
        SDL_OutOfMemory();
        if ( this ) {
            SDL_free(this);
        }
        return(0);
    }
    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
#ifdef DEBUG_AUDIO
    fprintf(stderr, "Creating UMS Audio device\n");
#endif

    /*
     * Calls for UMS env initialization and audio object construction.
     */
    this->hidden->ev     = somGetGlobalEnvironment();
    this->hidden->umsdev = UMSAudioDeviceNew();

    /*
     * Set the function pointers.
     */
    this->OpenAudio   = UMS_OpenAudio;
    this->WaitAudio   = NULL;           /* we do blocking output */
    this->PlayAudio   = UMS_PlayAudio;
    this->GetAudioBuf = UMS_GetAudioBuf;
    this->CloseAudio  = UMS_CloseAudio;
    this->free        = Audio_DeleteDevice;

#ifdef DEBUG_AUDIO
    fprintf(stderr, "done\n");
#endif
    return this;
}

AudioBootStrap UMS_bootstrap = {
	UMS_DRIVER_NAME, "AIX UMS audio",
	Audio_Available, Audio_CreateDevice
};

static Uint8 *UMS_GetAudioBuf(_THIS)
{
#ifdef DEBUG_AUDIO
    fprintf(stderr, "enter UMS_GetAudioBuf\n");
#endif
    return this->hidden->fillbuf._buffer;
/*
    long                      bufSize;
    UMSAudioDevice_ReturnCode rc;

    rc = UADSetTimeFormat(this, UMSAudioTypes_Bytes );
    rc = UADWriteBuffSize(this,  bufSize );
*/
}

static void UMS_CloseAudio(_THIS)
{
    UMSAudioDevice_ReturnCode rc;

#ifdef DEBUG_AUDIO
    fprintf(stderr, "enter UMS_CloseAudio\n");
#endif
    rc = UADPlayRemainingData(this, TRUE);
    rc = UADStop(this);
    rc = UADClose(this);
}

static void UMS_PlayAudio(_THIS)
{
    UMSAudioDevice_ReturnCode rc;
    long                      samplesToWrite;
    long                      samplesWritten;
    UMSAudioTypes_Buffer      swpbuf;

#ifdef DEBUG_AUDIO
    fprintf(stderr, "enter UMS_PlayAudio\n");
#endif
    samplesToWrite = this->hidden->playbuf._length/this->hidden->bytesPerSample;
    do
    {
        rc = UADWrite(this,  &this->hidden->playbuf,
		       samplesToWrite,
	               &samplesWritten );
	samplesToWrite -= samplesWritten;

	/* rc values: UMSAudioDevice_Success
	 *            UMSAudioDevice_Failure
	 *            UMSAudioDevice_Preempted
	 *            UMSAudioDevice_Interrupted
	 *            UMSAudioDevice_DeviceError
	 */
	if ( rc == UMSAudioDevice_DeviceError ) {
#ifdef DEBUG_AUDIO
	    fprintf(stderr, "Returning from PlayAudio with devices error\n");
#endif
	    return;
	}
    }
    while(samplesToWrite>0);

    SDL_LockAudio();
    SDL_memcpy( &swpbuf,                &this->hidden->playbuf, sizeof(UMSAudioTypes_Buffer) );
    SDL_memcpy( &this->hidden->playbuf, &this->hidden->fillbuf, sizeof(UMSAudioTypes_Buffer) );
    SDL_memcpy( &this->hidden->fillbuf, &swpbuf,                sizeof(UMSAudioTypes_Buffer) );
    SDL_UnlockAudio();

#ifdef DEBUG_AUDIO
    fprintf(stderr, "Wrote audio data and swapped buffer\n");
#endif
}

#if 0
// 	/* Set the DSP frequency */
// 	value = spec->freq;
// 	if ( ioctl(this->hidden->audio_fd, SOUND_PCM_WRITE_RATE, &value) < 0 ) {
// 		SDL_SetError("Couldn't set audio frequency");
// 		return(-1);
// 	}
// 	spec->freq = value;
#endif

static int UMS_OpenAudio(_THIS, SDL_AudioSpec *spec)
{
    char*  audiodev = "/dev/paud0";
    long   lgain;
    long   rgain;
    long   outRate;
    long   outBufSize;
    long   bitsPerSample;
    long   samplesPerSec;
    long   success;
    Uint16 test_format;
    int    frag_spec;
    UMSAudioDevice_ReturnCode rc;

#ifdef DEBUG_AUDIO
    fprintf(stderr, "enter UMS_OpenAudio\n");
#endif
    rc = UADOpen(this, audiodev,"PLAY", UMSAudioDevice_BlockingIO);
    if ( rc != UMSAudioDevice_Success ) {
	SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
	return -1;
    }
 
    rc = UADSetAudioFormatType(this, "PCM"); 

    success = 0;
    test_format = SDL_FirstAudioFormat(spec->format);
    do
    {
#ifdef DEBUG_AUDIO
        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
#endif
        switch ( test_format )
        {
        case AUDIO_U8:
/* from the mac code: better ? */
/* sample_bits = spec->size / spec->samples / spec->channels * 8; */
	    success       = 1;
            bitsPerSample = 8;
            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
            rc = UADSetByteOrder(this, "MSB");       /* irrelevant */
            rc = UADSetNumberFormat(this, "UNSIGNED");
            break;
        case AUDIO_S8:
	    success       = 1;
            bitsPerSample = 8;
            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
            rc = UADSetByteOrder(this, "MSB");       /* irrelevant */
            rc = UADSetNumberFormat(this, "SIGNED");
            break;
        case AUDIO_S16LSB:
	    success       = 1;
            bitsPerSample = 16;
            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
            rc = UADSetByteOrder(this, "LSB");
            rc = UADSetNumberFormat(this, "SIGNED");
            break;
        case AUDIO_S16MSB:
	    success       = 1;
            bitsPerSample = 16;
            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
            rc = UADSetByteOrder(this, "MSB");
            rc = UADSetNumberFormat(this, "SIGNED");
            break;
        case AUDIO_U16LSB:
	    success       = 1;
            bitsPerSample = 16;
            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
            rc = UADSetByteOrder(this, "LSB");
            rc = UADSetNumberFormat(this, "UNSIGNED");
            break;
        case AUDIO_U16MSB:
	    success       = 1;
            bitsPerSample = 16;
            rc = UADSetSampleRate(this,  spec->freq << 16, &outRate );
            rc = UADSetByteOrder(this, "MSB");
            rc = UADSetNumberFormat(this, "UNSIGNED");
            break;
        default:
            break;
        }
        if ( ! success ) {
            test_format = SDL_NextAudioFormat();
        }
    }
    while ( ! success && test_format );

    if ( success == 0 ) {
        SDL_SetError("Couldn't find any hardware audio formats");
        return -1;
    }

    spec->format = test_format;

    for ( frag_spec = 0; (0x01<<frag_spec) < spec->size; ++frag_spec );
    if ( (0x01<<frag_spec) != spec->size ) {
        SDL_SetError("Fragment size must be a power of two");
        return -1;
    }
    if ( frag_spec > 2048 ) frag_spec = 2048;

    this->hidden->bytesPerSample   = (bitsPerSample / 8) * spec->channels;
    samplesPerSec                  = this->hidden->bytesPerSample * outRate;

    this->hidden->playbuf._length  = 0;
    this->hidden->playbuf._maximum = spec->size;
    this->hidden->playbuf._buffer  = (unsigned char*)SDL_malloc(spec->size);
    this->hidden->fillbuf._length  = 0;
    this->hidden->fillbuf._maximum = spec->size;
    this->hidden->fillbuf._buffer  = (unsigned char*)SDL_malloc(spec->size);

    rc = UADSetBitsPerSample(this,  bitsPerSample );
    rc = UADSetDMABufferSize(this,  frag_spec, &outBufSize );
    rc = UADSetChannels(this, spec->channels);      /* functions reduces to mono or stereo */

    lgain = 100; /*maximum left input gain*/
    rgain = 100; /*maimum right input gain*/
    rc = UADEnableOutput(this, "LINE_OUT",&lgain,&rgain);
    rc = UADInitialize(this);
    rc = UADStart(this);
    rc = UADSetVolume(this, 100);
    rc = UADSetBalance(this, 0);

    /* We're ready to rock and roll. :-) */
    return 0;
}

\f
static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long* bits)
{
    return UMSAudioDevice_get_bits_per_sample( this->hidden->umsdev,
					       this->hidden->ev,
					       bits );
}

static UMSAudioDevice_ReturnCode UADSetBitsPerSample(_THIS, long bits)
{
    return UMSAudioDevice_set_bits_per_sample( this->hidden->umsdev,
					       this->hidden->ev,
					       bits );
}

static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate, long* set_rate)
{
    /* from the mac code: sample rate = spec->freq << 16; */
    return UMSAudioDevice_set_sample_rate( this->hidden->umsdev,
					   this->hidden->ev,
					   rate,
					   set_rate );
}

static UMSAudioDevice_ReturnCode UADSetByteOrder(_THIS, string byte_order)
{
    return UMSAudioDevice_set_byte_order( this->hidden->umsdev,
					  this->hidden->ev,
					  byte_order );
}

static UMSAudioDevice_ReturnCode UADSetAudioFormatType(_THIS, string fmt)
{
    /* possible PCM, A_LAW or MU_LAW */
    return UMSAudioDevice_set_audio_format_type( this->hidden->umsdev,
						 this->hidden->ev,
						 fmt );
}

static UMSAudioDevice_ReturnCode UADSetNumberFormat(_THIS, string fmt)
{
    /* possible SIGNED, UNSIGNED, or TWOS_COMPLEMENT */
    return UMSAudioDevice_set_number_format( this->hidden->umsdev,
					     this->hidden->ev,
					     fmt );
}

static UMSAudioDevice_ReturnCode UADInitialize(_THIS)
{
    return UMSAudioDevice_initialize( this->hidden->umsdev,
				      this->hidden->ev );
}

static UMSAudioDevice_ReturnCode UADStart(_THIS)
{
    return UMSAudioDevice_start( this->hidden->umsdev,
				 this->hidden->ev );
}

static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS,  UMSAudioTypes_TimeFormat fmt )
{
    /*
     * Switches the time format to the new format, immediately.
     * possible UMSAudioTypes_Msecs, UMSAudioTypes_Bytes or UMSAudioTypes_Samples
     */
    return UMSAudioDevice_set_time_format( this->hidden->umsdev,
					   this->hidden->ev,
					   fmt );
}

static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS,  long* buff_size )
{
    /*
     * returns write buffer size in the current time format
     */
    return UMSAudioDevice_write_buff_size( this->hidden->umsdev,
                                           this->hidden->ev,
					   buff_size );
}

static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS,  long* buff_size )
{
    /*
     * returns amount of available space in the write buffer
     * in the current time format
     */
    return UMSAudioDevice_write_buff_remain( this->hidden->umsdev,
                                             this->hidden->ev,
					     buff_size );
}

static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS,  long* buff_size )
{
    /*
     * returns amount of filled space in the write buffer
     * in the current time format
     */
    return UMSAudioDevice_write_buff_used( this->hidden->umsdev,
                                           this->hidden->ev,
					   buff_size );
}

static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS,  long bytes, long* bytes_ret )
{
    /*
     * Request a new DMA buffer size, maximum requested size 2048.
     * Takes effect with next initialize() call.
     * Devices may or may not support DMA.
     */
    return UMSAudioDevice_set_DMA_buffer_size( this->hidden->umsdev,
					       this->hidden->ev,
					       bytes,
					       bytes_ret );
}

static UMSAudioDevice_ReturnCode UADSetVolume(_THIS,  long volume )
{
    /*
     * Set the volume.
     * Takes effect immediately.
     */
    return UMSAudioDevice_set_volume( this->hidden->umsdev,
				      this->hidden->ev,
				      volume );
}

static UMSAudioDevice_ReturnCode UADSetBalance(_THIS,  long balance )
{
    /*
     * Set the balance.
     * Takes effect immediately.
     */
    return UMSAudioDevice_set_balance( this->hidden->umsdev,
				       this->hidden->ev,
				       balance );
}

static UMSAudioDevice_ReturnCode UADSetChannels(_THIS,  long channels )
{
    /*
     * Set mono or stereo.
     * Takes effect with next initialize() call.
     */
    if ( channels != 1 ) channels = 2;
    return UMSAudioDevice_set_number_of_channels( this->hidden->umsdev,
				                  this->hidden->ev,
				                  channels );
}

static UMSAudioDevice_ReturnCode UADOpen(_THIS,  string device, string mode, long flags)
{
    return UMSAudioDevice_open( this->hidden->umsdev,
				this->hidden->ev,
				device,
				mode,
				flags );
}

static UMSAudioDevice_ReturnCode UADWrite(_THIS,  UMSAudioTypes_Buffer* buff,
                                           long samples,
					   long* samples_written)
{
    return UMSAudioDevice_write( this->hidden->umsdev,
				 this->hidden->ev,
				 buff,
				 samples,
				 samples_written );
}

static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS,  boolean block )
{
    return UMSAudioDevice_play_remaining_data( this->hidden->umsdev,
					       this->hidden->ev,
					       block);
}

static UMSAudioDevice_ReturnCode UADStop(_THIS)
{
    return UMSAudioDevice_stop( this->hidden->umsdev,
				this->hidden->ev );
}

static UMSAudioDevice_ReturnCode UADClose(_THIS)
{
    return UMSAudioDevice_close( this->hidden->umsdev,
				 this->hidden->ev );
}

static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS,  string output, long* left_gain, long* right_gain)
{
    return UMSAudioDevice_enable_output( this->hidden->umsdev,
					 this->hidden->ev,
					 output,
					 left_gain,
					 right_gain );
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Carsten Griwodz
	20	griff@kom.tu-darmstadt.de
	21
	22	based on linux/SDL_dspaudio.c by Sam Lantinga
	23	*/
	24	#include "SDL_config.h"
	25
	26	/* Allow access to a raw mixing buffer */
	27
	28	#include <errno.h>
	29	#include <unistd.h>
	30	#include <fcntl.h>
	31	#include <sys/types.h>
	32	#include <sys/time.h>
	33	#include <sys/ioctl.h>
	34	#include <sys/stat.h>
	35	#include <sys/mman.h>
	36
	37	#include "SDL_audio.h"
	38	#include "../SDL_audio_c.h"
	39	#include "../SDL_audiodev_c.h"
	40	#include "SDL_umsaudio.h"
	41
	42	/* The tag name used by UMS audio */
	43	#define UMS_DRIVER_NAME "ums"
	44
	45	#define DEBUG_AUDIO 1
	46
	47	/* Audio driver functions */
	48	static int UMS_OpenAudio(_THIS, SDL_AudioSpec *spec);
	49	static void UMS_PlayAudio(_THIS);
	50	static Uint8 *UMS_GetAudioBuf(_THIS);
	51	static void UMS_CloseAudio(_THIS);
	52
	53	static UMSAudioDevice_ReturnCode UADOpen(_THIS, string device, string mode, long flags);
	54	static UMSAudioDevice_ReturnCode UADClose(_THIS);
	55	static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long* bits);
	56	static UMSAudioDevice_ReturnCode UADSetBitsPerSample(_THIS, long bits);
	57	static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate, long* set_rate);
	58	static UMSAudioDevice_ReturnCode UADSetByteOrder(_THIS, string byte_order);
	59	static UMSAudioDevice_ReturnCode UADSetAudioFormatType(_THIS, string fmt);
	60	static UMSAudioDevice_ReturnCode UADSetNumberFormat(_THIS, string fmt);
	61	static UMSAudioDevice_ReturnCode UADInitialize(_THIS);
	62	static UMSAudioDevice_ReturnCode UADStart(_THIS);
	63	static UMSAudioDevice_ReturnCode UADStop(_THIS);
	64	static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS, UMSAudioTypes_TimeFormat fmt );
65	static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS, long* buff_size );
66	static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS, long* buff_size );
67	static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS, long* buff_size );
68	static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS, long bytes, long* bytes_ret );
69	static UMSAudioDevice_ReturnCode UADSetVolume(_THIS, long volume );
70	static UMSAudioDevice_ReturnCode UADSetBalance(_THIS, long balance );
71	static UMSAudioDevice_ReturnCode UADSetChannels(_THIS, long channels );
72	static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS, boolean block );
73	static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS, string output, long* left_gain, long* right_gain);
74	static UMSAudioDevice_ReturnCode UADWrite(_THIS, UMSAudioTypes_Buffer* buff, long samples, long* samples_written);
75
76	/* Audio driver bootstrap functions */
77	static int Audio_Available(void)
78	{
79	return 1;
80	}
81
82	static void Audio_DeleteDevice(_THIS)
83	{
84	if(this->hidden->playbuf._buffer) SDL_free(this->hidden->playbuf._buffer);
85	if(this->hidden->fillbuf._buffer) SDL_free(this->hidden->fillbuf._buffer);
86	_somFree( this->hidden->umsdev );
87	SDL_free(this->hidden);
88	SDL_free(this);
89	}
90
91	static SDL_AudioDevice *Audio_CreateDevice(int devindex)
92	{
93	SDL_AudioDevice *this;
94
95	/*
96	* Allocate and initialize management storage and private management
97	* storage for this SDL-using library.
98	*/
99	this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
100	if ( this ) {
101	SDL_memset(this, 0, (sizeof *this));
102	this->hidden = (struct SDL_PrivateAudioData )SDL_malloc((sizeof this->hidden));
103	}
104	if ( (this == NULL) \|\| (this->hidden == NULL) ) {
105	SDL_OutOfMemory();
106	if ( this ) {
107	SDL_free(this);
108	}
109	return(0);
110	}
111	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
112	#ifdef DEBUG_AUDIO
113	fprintf(stderr, "Creating UMS Audio device\n");
114	#endif
115
116	/*
117	* Calls for UMS env initialization and audio object construction.
118	*/
119	this->hidden->ev = somGetGlobalEnvironment();
120	this->hidden->umsdev = UMSAudioDeviceNew();
121
122	/*
123	* Set the function pointers.
124	*/
125	this->OpenAudio = UMS_OpenAudio;
126	this->WaitAudio = NULL; /* we do blocking output */
127	this->PlayAudio = UMS_PlayAudio;
128	this->GetAudioBuf = UMS_GetAudioBuf;
129	this->CloseAudio = UMS_CloseAudio;
130	this->free = Audio_DeleteDevice;
131
132	#ifdef DEBUG_AUDIO
133	fprintf(stderr, "done\n");
134	#endif
135	return this;
136	}
137
138	AudioBootStrap UMS_bootstrap = {
139	UMS_DRIVER_NAME, "AIX UMS audio",
140	Audio_Available, Audio_CreateDevice
141	};
142
143	static Uint8 *UMS_GetAudioBuf(_THIS)
144	{
145	#ifdef DEBUG_AUDIO
146	fprintf(stderr, "enter UMS_GetAudioBuf\n");
147	#endif
148	return this->hidden->fillbuf._buffer;
149	/*
150	long bufSize;
151	UMSAudioDevice_ReturnCode rc;
152
153	rc = UADSetTimeFormat(this, UMSAudioTypes_Bytes );
154	rc = UADWriteBuffSize(this, bufSize );
155	*/
156	}
157
158	static void UMS_CloseAudio(_THIS)
159	{
160	UMSAudioDevice_ReturnCode rc;
161
162	#ifdef DEBUG_AUDIO
163	fprintf(stderr, "enter UMS_CloseAudio\n");
164	#endif
165	rc = UADPlayRemainingData(this, TRUE);
166	rc = UADStop(this);
167	rc = UADClose(this);
168	}
169
170	static void UMS_PlayAudio(_THIS)
171	{
172	UMSAudioDevice_ReturnCode rc;
173	long samplesToWrite;
174	long samplesWritten;
175	UMSAudioTypes_Buffer swpbuf;
176
177	#ifdef DEBUG_AUDIO
178	fprintf(stderr, "enter UMS_PlayAudio\n");
179	#endif
180	samplesToWrite = this->hidden->playbuf._length/this->hidden->bytesPerSample;
181	do
182	{
183	rc = UADWrite(this, &this->hidden->playbuf,
184	samplesToWrite,
185	&samplesWritten );
186	samplesToWrite -= samplesWritten;
187
188	/* rc values: UMSAudioDevice_Success
189	* UMSAudioDevice_Failure
190	* UMSAudioDevice_Preempted
191	* UMSAudioDevice_Interrupted
192	* UMSAudioDevice_DeviceError
193	*/
194	if ( rc == UMSAudioDevice_DeviceError ) {
195	#ifdef DEBUG_AUDIO
196	fprintf(stderr, "Returning from PlayAudio with devices error\n");
197	#endif
198	return;
199	}
200	}
201	while(samplesToWrite>0);
202
203	SDL_LockAudio();
204	SDL_memcpy( &swpbuf, &this->hidden->playbuf, sizeof(UMSAudioTypes_Buffer) );
205	SDL_memcpy( &this->hidden->playbuf, &this->hidden->fillbuf, sizeof(UMSAudioTypes_Buffer) );
206	SDL_memcpy( &this->hidden->fillbuf, &swpbuf, sizeof(UMSAudioTypes_Buffer) );
207	SDL_UnlockAudio();
208
209	#ifdef DEBUG_AUDIO
210	fprintf(stderr, "Wrote audio data and swapped buffer\n");
211	#endif
212	}
213
214	#if 0
215	// /* Set the DSP frequency */
216	// value = spec->freq;
217	// if ( ioctl(this->hidden->audio_fd, SOUND_PCM_WRITE_RATE, &value) < 0 ) {
218	// SDL_SetError("Couldn't set audio frequency");
219	// return(-1);
220	// }
221	// spec->freq = value;
222	#endif
223
224	static int UMS_OpenAudio(_THIS, SDL_AudioSpec *spec)
225	{
226	char* audiodev = "/dev/paud0";
227	long lgain;
228	long rgain;
229	long outRate;
230	long outBufSize;
231	long bitsPerSample;
232	long samplesPerSec;
233	long success;
234	Uint16 test_format;
235	int frag_spec;
236	UMSAudioDevice_ReturnCode rc;
237
238	#ifdef DEBUG_AUDIO
239	fprintf(stderr, "enter UMS_OpenAudio\n");
240	#endif
241	rc = UADOpen(this, audiodev,"PLAY", UMSAudioDevice_BlockingIO);
242	if ( rc != UMSAudioDevice_Success ) {
243	SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
244	return -1;
245	}
246
247	rc = UADSetAudioFormatType(this, "PCM");
248
249	success = 0;
250	test_format = SDL_FirstAudioFormat(spec->format);
251	do
252	{
253	#ifdef DEBUG_AUDIO
254	fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
255	#endif
256	switch ( test_format )
257	{
258	case AUDIO_U8:
259	/* from the mac code: better ? */
260	/* sample_bits = spec->size / spec->samples / spec->channels * 8; */
261	success = 1;
262	bitsPerSample = 8;
263	rc = UADSetSampleRate(this, spec->freq << 16, &outRate );
264	rc = UADSetByteOrder(this, "MSB"); /* irrelevant */
265	rc = UADSetNumberFormat(this, "UNSIGNED");
266	break;
267	case AUDIO_S8:
268	success = 1;
269	bitsPerSample = 8;
270	rc = UADSetSampleRate(this, spec->freq << 16, &outRate );
271	rc = UADSetByteOrder(this, "MSB"); /* irrelevant */
272	rc = UADSetNumberFormat(this, "SIGNED");
273	break;
274	case AUDIO_S16LSB:
275	success = 1;
276	bitsPerSample = 16;
277	rc = UADSetSampleRate(this, spec->freq << 16, &outRate );
278	rc = UADSetByteOrder(this, "LSB");
279	rc = UADSetNumberFormat(this, "SIGNED");
280	break;
281	case AUDIO_S16MSB:
282	success = 1;
283	bitsPerSample = 16;
284	rc = UADSetSampleRate(this, spec->freq << 16, &outRate );
285	rc = UADSetByteOrder(this, "MSB");
286	rc = UADSetNumberFormat(this, "SIGNED");
287	break;
288	case AUDIO_U16LSB:
289	success = 1;
290	bitsPerSample = 16;
291	rc = UADSetSampleRate(this, spec->freq << 16, &outRate );
292	rc = UADSetByteOrder(this, "LSB");
293	rc = UADSetNumberFormat(this, "UNSIGNED");
294	break;
295	case AUDIO_U16MSB:
296	success = 1;
297	bitsPerSample = 16;
298	rc = UADSetSampleRate(this, spec->freq << 16, &outRate );
299	rc = UADSetByteOrder(this, "MSB");
300	rc = UADSetNumberFormat(this, "UNSIGNED");
301	break;
302	default:
303	break;
304	}
305	if ( ! success ) {
306	test_format = SDL_NextAudioFormat();
307	}
308	}
309	while ( ! success && test_format );
310
311	if ( success == 0 ) {
312	SDL_SetError("Couldn't find any hardware audio formats");
313	return -1;
314	}
315
316	spec->format = test_format;
317
318	for ( frag_spec = 0; (0x01<<frag_spec) < spec->size; ++frag_spec );
319	if ( (0x01<<frag_spec) != spec->size ) {
320	SDL_SetError("Fragment size must be a power of two");
321	return -1;
322	}
323	if ( frag_spec > 2048 ) frag_spec = 2048;
324
325	this->hidden->bytesPerSample = (bitsPerSample / 8) * spec->channels;
326	samplesPerSec = this->hidden->bytesPerSample * outRate;
327
328	this->hidden->playbuf._length = 0;
329	this->hidden->playbuf._maximum = spec->size;
330	this->hidden->playbuf._buffer = (unsigned char*)SDL_malloc(spec->size);
331	this->hidden->fillbuf._length = 0;
332	this->hidden->fillbuf._maximum = spec->size;
333	this->hidden->fillbuf._buffer = (unsigned char*)SDL_malloc(spec->size);
334
335	rc = UADSetBitsPerSample(this, bitsPerSample );
336	rc = UADSetDMABufferSize(this, frag_spec, &outBufSize );
337	rc = UADSetChannels(this, spec->channels); /* functions reduces to mono or stereo */
338
339	lgain = 100; /maximum left input gain/
340	rgain = 100; /maimum right input gain/
341	rc = UADEnableOutput(this, "LINE_OUT",&lgain,&rgain);
342	rc = UADInitialize(this);
343	rc = UADStart(this);
344	rc = UADSetVolume(this, 100);
345	rc = UADSetBalance(this, 0);
346
347	/* We're ready to rock and roll. :-) */
348	return 0;
349	}
350
351	\f
352	static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long* bits)
353	{
354	return UMSAudioDevice_get_bits_per_sample( this->hidden->umsdev,
355	this->hidden->ev,
356	bits );
357	}
358
359	static UMSAudioDevice_ReturnCode UADSetBitsPerSample(_THIS, long bits)
360	{
361	return UMSAudioDevice_set_bits_per_sample( this->hidden->umsdev,
362	this->hidden->ev,
363	bits );
364	}
365
366	static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate, long* set_rate)
367	{
368	/* from the mac code: sample rate = spec->freq << 16; */
369	return UMSAudioDevice_set_sample_rate( this->hidden->umsdev,
370	this->hidden->ev,
371	rate,
372	set_rate );
373	}
374
375	static UMSAudioDevice_ReturnCode UADSetByteOrder(_THIS, string byte_order)
376	{
377	return UMSAudioDevice_set_byte_order( this->hidden->umsdev,
378	this->hidden->ev,
379	byte_order );
380	}
381
382	static UMSAudioDevice_ReturnCode UADSetAudioFormatType(_THIS, string fmt)
383	{
384	/* possible PCM, A_LAW or MU_LAW */
385	return UMSAudioDevice_set_audio_format_type( this->hidden->umsdev,
386	this->hidden->ev,
387	fmt );
388	}
389
390	static UMSAudioDevice_ReturnCode UADSetNumberFormat(_THIS, string fmt)
391	{
392	/* possible SIGNED, UNSIGNED, or TWOS_COMPLEMENT */
393	return UMSAudioDevice_set_number_format( this->hidden->umsdev,
394	this->hidden->ev,
395	fmt );
396	}
397
398	static UMSAudioDevice_ReturnCode UADInitialize(_THIS)
399	{
400	return UMSAudioDevice_initialize( this->hidden->umsdev,
401	this->hidden->ev );
402	}
403
404	static UMSAudioDevice_ReturnCode UADStart(_THIS)
405	{
406	return UMSAudioDevice_start( this->hidden->umsdev,
407	this->hidden->ev );
408	}
409
410	static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS, UMSAudioTypes_TimeFormat fmt )
411	{
412	/*
413	* Switches the time format to the new format, immediately.
414	* possible UMSAudioTypes_Msecs, UMSAudioTypes_Bytes or UMSAudioTypes_Samples
415	*/
416	return UMSAudioDevice_set_time_format( this->hidden->umsdev,
417	this->hidden->ev,
418	fmt );
419	}
420
421	static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS, long* buff_size )
422	{
423	/*
424	* returns write buffer size in the current time format
425	*/
426	return UMSAudioDevice_write_buff_size( this->hidden->umsdev,
427	this->hidden->ev,
428	buff_size );
429	}
430
431	static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS, long* buff_size )
432	{
433	/*
434	* returns amount of available space in the write buffer
435	* in the current time format
436	*/
437	return UMSAudioDevice_write_buff_remain( this->hidden->umsdev,
438	this->hidden->ev,
439	buff_size );
440	}
441
442	static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS, long* buff_size )
443	{
444	/*
445	* returns amount of filled space in the write buffer
446	* in the current time format
447	*/
448	return UMSAudioDevice_write_buff_used( this->hidden->umsdev,
449	this->hidden->ev,
450	buff_size );
451	}
452
453	static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS, long bytes, long* bytes_ret )
454	{
455	/*
456	* Request a new DMA buffer size, maximum requested size 2048.
457	* Takes effect with next initialize() call.
458	* Devices may or may not support DMA.
459	*/
460	return UMSAudioDevice_set_DMA_buffer_size( this->hidden->umsdev,
461	this->hidden->ev,
462	bytes,
463	bytes_ret );
464	}
465
466	static UMSAudioDevice_ReturnCode UADSetVolume(_THIS, long volume )
467	{
468	/*
469	* Set the volume.
470	* Takes effect immediately.
471	*/
472	return UMSAudioDevice_set_volume( this->hidden->umsdev,
473	this->hidden->ev,
474	volume );
475	}
476
477	static UMSAudioDevice_ReturnCode UADSetBalance(_THIS, long balance )
478	{
479	/*
480	* Set the balance.
481	* Takes effect immediately.
482	*/
483	return UMSAudioDevice_set_balance( this->hidden->umsdev,
484	this->hidden->ev,
485	balance );
486	}
487
488	static UMSAudioDevice_ReturnCode UADSetChannels(_THIS, long channels )
489	{
490	/*
491	* Set mono or stereo.
492	* Takes effect with next initialize() call.
493	*/
494	if ( channels != 1 ) channels = 2;
495	return UMSAudioDevice_set_number_of_channels( this->hidden->umsdev,
496	this->hidden->ev,
497	channels );
498	}
499
500	static UMSAudioDevice_ReturnCode UADOpen(_THIS, string device, string mode, long flags)
501	{
502	return UMSAudioDevice_open( this->hidden->umsdev,
503	this->hidden->ev,
504	device,
505	mode,
506	flags );
507	}
508
509	static UMSAudioDevice_ReturnCode UADWrite(_THIS, UMSAudioTypes_Buffer* buff,
510	long samples,
511	long* samples_written)
512	{
513	return UMSAudioDevice_write( this->hidden->umsdev,
514	this->hidden->ev,
515	buff,
516	samples,
517	samples_written );
518	}
519
520	static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS, boolean block )
521	{
522	return UMSAudioDevice_play_remaining_data( this->hidden->umsdev,
523	this->hidden->ev,
524	block);
525	}
526
527	static UMSAudioDevice_ReturnCode UADStop(_THIS)
528	{
529	return UMSAudioDevice_stop( this->hidden->umsdev,
530	this->hidden->ev );
531	}
532
533	static UMSAudioDevice_ReturnCode UADClose(_THIS)
534	{
535	return UMSAudioDevice_close( this->hidden->umsdev,
536	this->hidden->ev );
537	}
538
539	static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS, string output, long* left_gain, long* right_gain)
540	{
541	return UMSAudioDevice_enable_output( this->hidden->umsdev,
542	this->hidden->ev,
543	output,
544	left_gain,
545	right_gain );
546	}
547