Subversion Repositories Kolibri OS

Compare Revisions

No changes between revisions

Regard whitespace Rev 8209 → Rev 8210

/contrib/sdk/sources/SDL-1.2.2_newlib/src/audio/SDL_kolibri_audio.c
0,0 → 1,297
#include "SDL_audio.h"
#include <menuet/os.h>
#include <stdlib.h>
#include <string.h>
#include <sound.h>
#include <stdio.h>
 
static void GetNotify(__u32* event)
{
__asm__("int $0x40" :: "a"(68),"b"(14),"c"(event));
}
static int CreateThread(void* fn, char* p_stack)
{
int res;
__asm__("int $0x40" : "=a"(res) : "a"(51),"b"(1),"c"(fn),"d"(p_stack));
return res;
}
static char pinfo[1024];
static int GetProcessInfo(int slot)
{
int res;
__asm__("int $0x40" : "=a"(res) : "a"(9),"b"(pinfo),"c"(slot));
return res;
}
static void ActivateWnd(int slot)
{
__asm__("int $0x40" :: "a"(18),"b"(3),"c"(slot));
}
static void Yield(void)
{
__asm__("int $0x40" :: "a"(68),"b"(1));
}
 
static int bInitialized=0;
static SNDBUF hBuff=0;
static char* data=NULL;
static int audio_tid=0;
static int main_slot;
static __u32 main_tid;
static char audio_thread_stack[40960];
static __u32 used_format=0;
static volatile int mix_size=0;
 
static void (*callback)(void* userdata, Uint8* stream, int len);
static void* userdata;
 
int SDL_AudioInit(const char* driver_name)
{
if (bInitialized)
{
SDL_SetError("audio already initialized");
return -1;
}
int ver;
if (InitSound(&ver))
{
SDL_printf("Warning: cannot load drivers, sound output will be disabled\n");
return 0;
}
bInitialized = 1;
return 0;
}
 
void SDL_AudioQuit(void)
{
}
 
char* SDL_AudioDriverName(char* namebuf, int maxlen)
{
if (!bInitialized)
return NULL;
strncpy(namebuf,"KolibriAudio",maxlen);
return namebuf;
}
 
#define AUDIO_SUSPEND 1
#define AUDIO_RESUME 2
#define AUDIO_DIE 3
static volatile int audio_command=0,audio_response=0,bLocked=0,bInCallback=0;
static void audio_thread(void)
{
SDL_printf("audio_thread created\n");
int bPaused;
__u32 event[6];
// initialize
if (CreateBuffer(used_format|PCM_RING, 0, &hBuff))
{
audio_response=1;
__menuet__sys_exit();
}
GetBufferSize(hBuff, &mix_size);
SDL_printf("buffer created, size is %d\n",mix_size);
mix_size >>= 1;
data = malloc(mix_size);
audio_response=1;
if (!data) __menuet__sys_exit();
// wait for resume
while (audio_command!=AUDIO_RESUME)
Yield();
// initialize
/* bInCallback=1;
callback(userdata,data,mix_size);
SetBuffer(hBuff,data,0,mix_size);
callback(userdata,data,mix_size);
SetBuffer(hBuff,data,mix_size,mix_size);
bInCallback=0;*/
audio_command=0;
bPaused=0;
audio_response=1;
PlayBuffer(hBuff,0);
// main loop
for (;;)
{
if (audio_command==AUDIO_RESUME)
{
PlayBuffer(hBuff,0);
audio_command = 0;
bPaused = 0;
audio_response = 1;
}
else if (audio_command==AUDIO_SUSPEND)
{
StopBuffer(hBuff);
audio_command = 0;
bPaused = 1;
audio_response = 1;
}
else if (audio_command==AUDIO_DIE)
{
audio_response = 1;
StopBuffer(hBuff);
DestroyBuffer(hBuff);
__menuet__sys_exit();
}
else
{
GetProcessInfo(main_slot);
if (pinfo[0x32]==9 || *(__u32*)(pinfo+0x1E)!=main_tid)
{
audio_command = AUDIO_DIE;
continue;
}
}
if (bPaused)
__menuet__delay100(5);
else
{
GetNotify(event);
if (event[0] != 0xFF000001)
continue;
while (bLocked)
Yield();
bInCallback=1;
callback(userdata,data,mix_size);
bInCallback=0;
SetBuffer(hBuff,data,event[3],mix_size);
}
}
}
 
int SDL_OpenAudio(SDL_AudioSpec* desired, SDL_AudioSpec* obtained)
{
if (!bInitialized)
{
SDL_SetError("Audio device was not initialized");
return -1;
}
if (!obtained)
{
SDL_SetError("Audio format: software emulation is not supported");
return -1;
}
if (used_format)
{
SDL_SetError("Audio device was already opened");
return -1;
}
memcpy(obtained,desired,sizeof(SDL_AudioSpec));
switch (desired->freq)
{
 
#define HANDLE_FREQ(freq,symb) \
case freq: \
switch (desired->channels) \
{ \
case 1: \
switch (desired->format) \
{ \
case AUDIO_U8: \
case AUDIO_S8: \
used_format = PCM_1_8_##symb; \
break; \
case AUDIO_U16SYS: \
case AUDIO_S16SYS: \
used_format = PCM_1_16_##symb; \
break; \
} \
break; \
case 2: \
switch (desired->format) \
{ \
case AUDIO_U8: \
case AUDIO_S8: \
used_format = PCM_2_8_##symb; \
break; \
case AUDIO_U16SYS: \
case AUDIO_S16SYS: \
used_format = PCM_2_16_##symb; \
break; \
} \
break; \
} \
break;
 
HANDLE_FREQ(48000,48);
HANDLE_FREQ(44100,44);
HANDLE_FREQ(32000,32);
HANDLE_FREQ(24000,24);
HANDLE_FREQ(22050,22);
HANDLE_FREQ(16000,16);
HANDLE_FREQ(12000,12);
HANDLE_FREQ(11025,11);
HANDLE_FREQ(8000,8);
}
if (!used_format)
{
SDL_SetError("Unknown audio format");
return -1;
}
callback=desired->callback;
userdata=desired->userdata;
GetProcessInfo(-1);
main_tid = *(__u32*)(pinfo+0x1E);
for (main_slot=0;;main_slot++)
{
GetProcessInfo(main_slot);
if (pinfo[0x32]!=9 && *(__u32*)(pinfo+0x1E)==main_tid)
break;
}
audio_tid=CreateThread(audio_thread,audio_thread_stack+40960);
if (audio_tid<0)
{
SDL_SetError("Cannot create audio thread");
return -1;
}
ActivateWnd(main_slot);
while (!audio_response)
Yield();
if (!hBuff)
{
SDL_SetError("Cannot create audio buffer");
return -1;
}
if (!data)
{
SDL_SetError("Cannot allocate audio buffer");
return -1;
}
obtained->silence = (desired->format == AUDIO_U8 ? 0x80 : 0);
obtained->size = mix_size;
obtained->samples = obtained->size / obtained->channels;
if (desired->format == AUDIO_U16SYS || desired->format == AUDIO_S16SYS)
obtained->samples /= 2;
SDL_printf("obtained size is %d, samples %d\n",obtained->size,
obtained->samples);
return 0;
}
void SDL_CloseAudio(void)
{
if (!audio_tid) return;
audio_response = 0;
audio_command = AUDIO_DIE;
while (!audio_response)
Yield();
free(data);
used_format = 0;
}
 
void SDL_PauseAudio(int pause_on)
{
if (!audio_tid) return;
audio_response = 0;
audio_command = pause_on?AUDIO_SUSPEND:AUDIO_RESUME;
while (!audio_response)
Yield();
}
void SDL_LockAudio(void)
{
if (!audio_tid) return;
bLocked = 1;
while (bInCallback)
Yield();
}
void SDL_UnlockAudio(void)
{
bLocked = 0;
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property