diff options
Diffstat (limited to 'distrib/sdl-1.2.12/src/audio/amigaos/SDL_ahiaudio.c')
-rw-r--r-- | distrib/sdl-1.2.12/src/audio/amigaos/SDL_ahiaudio.c | 337 |
1 files changed, 337 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.12/src/audio/amigaos/SDL_ahiaudio.c b/distrib/sdl-1.2.12/src/audio/amigaos/SDL_ahiaudio.c new file mode 100644 index 0000000..c9a4c1a --- /dev/null +++ b/distrib/sdl-1.2.12/src/audio/amigaos/SDL_ahiaudio.c @@ -0,0 +1,337 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2006 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 + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +/* Allow access to a raw mixing buffer (for AmigaOS) */ + +#include "SDL_audio.h" +#include "../SDL_audio_c.h" +#include "SDL_ahiaudio.h" + +/* Audio driver functions */ +static int AHI_OpenAudio(_THIS, SDL_AudioSpec *spec); +static void AHI_WaitAudio(_THIS); +static void AHI_PlayAudio(_THIS); +static Uint8 *AHI_GetAudioBuf(_THIS); +static void AHI_CloseAudio(_THIS); + +#ifndef __SASC + #define mymalloc(x) AllocVec(x,MEMF_PUBLIC) + #define myfree FreeVec +#else + #define mymalloc malloc + #define myfree free +#endif + +/* Audio driver bootstrap functions */ + +static int Audio_Available(void) +{ + int ok=0; + struct MsgPort *p; + struct AHIRequest *req; + + if(p=CreateMsgPort()) + { + if(req=(struct AHIRequest *)CreateIORequest(p,sizeof(struct AHIRequest))) + { + req->ahir_Version=4; + + if(!OpenDevice(AHINAME,0,(struct IORequest *)req,NULL)) + { + D(bug("AHI available.\n")); + ok=1; + CloseDevice((struct IORequest *)req); + } + DeleteIORequest((struct IORequest *)req); + } + DeleteMsgPort(p); + } + + D(if(!ok) bug("AHI not available\n")); + return ok; +} + +static void Audio_DeleteDevice(SDL_AudioDevice *device) +{ + SDL_free(device->hidden); + SDL_free(device); +} + +static SDL_AudioDevice *Audio_CreateDevice(int devindex) +{ + SDL_AudioDevice *this; + +#ifndef NO_AMIGADEBUG + D(bug("AHI created...\n")); +#endif + + /* Initialize all variables that we clean on shutdown */ + 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)); + + /* Set the function pointers */ + this->OpenAudio = AHI_OpenAudio; + this->WaitAudio = AHI_WaitAudio; + this->PlayAudio = AHI_PlayAudio; + this->GetAudioBuf = AHI_GetAudioBuf; + this->CloseAudio = AHI_CloseAudio; + + this->free = Audio_DeleteDevice; + + return this; +} + +AudioBootStrap AHI_bootstrap = { + "AHI", Audio_Available, Audio_CreateDevice +}; + + +void static AHI_WaitAudio(_THIS) +{ + if(!CheckIO((struct IORequest *)audio_req[current_buffer])) + { + WaitIO((struct IORequest *)audio_req[current_buffer]); +// AbortIO((struct IORequest *)audio_req[current_buffer]); + } +} + +static void AHI_PlayAudio(_THIS) +{ + if(playing>1) + WaitIO((struct IORequest *)audio_req[current_buffer]); + + /* Write the audio data out */ + audio_req[current_buffer] -> ahir_Std. io_Message.mn_Node.ln_Pri = 60; + audio_req[current_buffer] -> ahir_Std. io_Data = mixbuf[current_buffer]; + audio_req[current_buffer] -> ahir_Std. io_Length = this->hidden->size; + audio_req[current_buffer] -> ahir_Std. io_Offset = 0; + audio_req[current_buffer] -> ahir_Std . io_Command = CMD_WRITE; + audio_req[current_buffer] -> ahir_Frequency = this->hidden->freq; + audio_req[current_buffer] -> ahir_Volume = 0x10000; + audio_req[current_buffer] -> ahir_Type = this->hidden->type; + audio_req[current_buffer] -> ahir_Position = 0x8000; + audio_req[current_buffer] -> ahir_Link = (playing>0 ? audio_req[current_buffer^1] : NULL); + + SendIO((struct IORequest *)audio_req[current_buffer]); + current_buffer^=1; + + playing++; +} + +static Uint8 *AHI_GetAudioBuf(_THIS) +{ + return(mixbuf[current_buffer]); +} + +static void AHI_CloseAudio(_THIS) +{ + D(bug("Closing audio...\n")); + + playing=0; + + if(audio_req[0]) + { + if(audio_req[1]) + { + D(bug("Break req[1]...\n")); + + AbortIO((struct IORequest *)audio_req[1]); + WaitIO((struct IORequest *)audio_req[1]); + } + + D(bug("Break req[0]...\n")); + + AbortIO((struct IORequest *)audio_req[0]); + WaitIO((struct IORequest *)audio_req[0]); + + if(audio_req[1]) + { + D(bug("Break AGAIN req[1]...\n")); + AbortIO((struct IORequest *)audio_req[1]); + WaitIO((struct IORequest *)audio_req[1]); + } +// Double abort to be sure to break the dbuffering process. + + SDL_Delay(200); + + D(bug("Reqs breaked, closing device...\n")); + CloseDevice((struct IORequest *)audio_req[0]); + D(bug("Device closed, freeing memory...\n")); + myfree(audio_req[1]); + D(bug("Memory freed, deleting IOReq...\n")); + DeleteIORequest((struct IORequest *)audio_req[0]); + audio_req[0]=audio_req[1]=NULL; + } + + D(bug("Freeing mixbuf[0]...\n")); + if ( mixbuf[0] != NULL ) { + myfree(mixbuf[0]); +// SDL_FreeAudioMem(mixbuf[0]); + mixbuf[0] = NULL; + } + + D(bug("Freeing mixbuf[1]...\n")); + if ( mixbuf[1] != NULL ) { + myfree(mixbuf[1]); +// SDL_FreeAudioMem(mixbuf[1]); + mixbuf[1] = NULL; + } + + D(bug("Freeing audio_port...\n")); + + if ( audio_port != NULL ) { + DeleteMsgPort(audio_port); + audio_port = NULL; + } + D(bug("...done!\n")); +} + +static int AHI_OpenAudio(_THIS, SDL_AudioSpec *spec) +{ +// int width; + + D(bug("AHI opening...\n")); + + /* Determine the audio parameters from the AudioSpec */ + switch ( spec->format & 0xFF ) { + + case 8: { /* Signed 8 bit audio data */ + D(bug("Samples a 8 bit...\n")); + spec->format = AUDIO_S8; + this->hidden->bytespersample=1; + if(spec->channels<2) + this->hidden->type = AHIST_M8S; + else + this->hidden->type = AHIST_S8S; + } + break; + + case 16: { /* Signed 16 bit audio data */ + D(bug("Samples a 16 bit...\n")); + spec->format = AUDIO_S16MSB; + this->hidden->bytespersample=2; + if(spec->channels<2) + this->hidden->type = AHIST_M16S; + else + this->hidden->type = AHIST_S16S; + } + break; + + default: { + SDL_SetError("Unsupported audio format"); + return(-1); + } + } + + if(spec->channels!=1 && spec->channels!=2) + { + D(bug("Wrong channel number!\n")); + SDL_SetError("Channel number non supported"); + return -1; + } + + D(bug("Before CalculateAudioSpec\n")); + /* Update the fragment size as size in bytes */ + SDL_CalculateAudioSpec(spec); + + D(bug("Before CreateMsgPort\n")); + + if(!(audio_port=CreateMsgPort())) + { + SDL_SetError("Unable to create a MsgPort"); + return -1; + } + + D(bug("Before CreateIORequest\n")); + + if(!(audio_req[0]=(struct AHIRequest *)CreateIORequest(audio_port,sizeof(struct AHIRequest)))) + { + SDL_SetError("Unable to create an AHIRequest"); + DeleteMsgPort(audio_port); + return -1; + } + + audio_req[0]->ahir_Version = 4; + + if(OpenDevice(AHINAME,0,(struct IORequest *)audio_req[0],NULL)) + { + SDL_SetError("Unable to open AHI device!\n"); + DeleteIORequest((struct IORequest *)audio_req[0]); + DeleteMsgPort(audio_port); + return -1; + } + + D(bug("AFTER opendevice\n")); + + /* Set output frequency and size */ + this->hidden->freq = spec->freq; + this->hidden->size = spec->size; + + D(bug("Before buffer allocation\n")); + + /* Allocate mixing buffer */ + mixbuf[0] = (Uint8 *)mymalloc(spec->size); + mixbuf[1] = (Uint8 *)mymalloc(spec->size); + + D(bug("Before audio_req allocation\n")); + + if(!(audio_req[1]=mymalloc(sizeof(struct AHIRequest)))) + { + SDL_OutOfMemory(); + return(-1); + } + + D(bug("Before audio_req memcpy\n")); + + SDL_memcpy(audio_req[1],audio_req[0],sizeof(struct AHIRequest)); + + if ( mixbuf[0] == NULL || mixbuf[1] == NULL ) { + SDL_OutOfMemory(); + return(-1); + } + + D(bug("Before mixbuf memset\n")); + + SDL_memset(mixbuf[0], spec->silence, spec->size); + SDL_memset(mixbuf[1], spec->silence, spec->size); + + current_buffer=0; + playing=0; + + D(bug("AHI opened: freq:%ld mixbuf:%lx/%lx buflen:%ld bits:%ld channels:%ld\n",spec->freq,mixbuf[0],mixbuf[1],spec->size,this->hidden->bytespersample*8,spec->channels)); + + /* We're ready to rock and roll. :-) */ + return(0); +} |