Import SDL release-1.2.15

Change-Id: I505c4aea24325cad475f217db5589814b4c75dbf

1 files changed, 547 insertions, 0 deletions

diff --git a/distrib/sdl-1.2.15/src/audio/ums/SDL_umsaudio.c b/distrib/sdl-1.2.15/src/audio/ums/SDL_umsaudio.c
new file mode 100644
index 0000000..9488911
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/audio/ums/SDL_umsaudio.c
@@ -0,0 +1,547 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 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;
+}
+
+
+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 );
+}
+