/**
** Type member function to read from the module
**
** @param buf Buffer to write data to
** @param len Length of the buffer
**
** @return Number of bytes read
*/
int CSampleMikModStream::Read(void *buf, int len)
{
int read;
// fill up the buffer
read = 0;
while (this->Len < SOUND_BUFFER_SIZE / 2 && Player_Active()) {
memcpy(this->Buffer, this->Buffer + this->Pos, this->Len);
this->Pos = 0;
CurrentFile = this->Data.MikModFile;
read = VC_WriteBytes((SBYTE *)this->Buffer + this->Pos,
SOUND_BUFFER_SIZE - (this->Pos + this->Len));
this->Len += read;
}
if (this->Len < len) {
// EOF
len = this->Len;
}
memcpy(buf, this->Buffer + this->Pos, len);
this->Len -= len;
this->Pos += len;
return len;
}
static void NS_Update(void)
{
#ifndef SDL_MIXER_ONLY
if (zerobuf)
VC_WriteBytes(zerobuf,ZEROLEN);
#endif
}
static void DS_Update(void)
{
LPVOID block;
DWORD bBytes;
/* Do first update in DS_Update() to be consistent with other
non threaded drivers. */
if (do_update && pSoundBuffer) {
do_update = 0;
if (pSoundBuffer->lpVtbl->Lock (pSoundBuffer, 0, fragsize,
&block, &bBytes, NULL, NULL, 0)
== DSERR_BUFFERLOST) {
pSoundBuffer->lpVtbl->Restore (pSoundBuffer);
pSoundBuffer->lpVtbl->Lock (pSoundBuffer, 0, fragsize,
&block, &bBytes, NULL, NULL, 0);
}
if (Player_Paused_internal()) {
VC_SilenceBytes ((SBYTE *)block, (ULONG)bBytes);
} else {
VC_WriteBytes ((SBYTE *)block, (ULONG)bBytes);
}
pSoundBuffer->lpVtbl->Unlock (pSoundBuffer, block, bBytes, NULL, 0);
pSoundBuffer->lpVtbl->SetCurrentPosition(pSoundBuffer, 0);
pSoundBuffer->lpVtbl->Play(pSoundBuffer, 0, 0, DSBPLAY_LOOPING);
threadInUse=1;
ResumeThread (updateBufferHandle);
}
}
static void ALSA_Update(void)
{
int err;
{
if (bytes_written == 0 || bytes_played == bytes_written)
{
bytes_written = VC_WriteBytes(audiobuffer,buffer_size_in_frames * global_frame_size);
bytes_played = 0;
}
while (bytes_played < bytes_written)
{
err = alsa_pcm_writei(pcm_h, &audiobuffer[bytes_played], (bytes_written - bytes_played) / global_frame_size);
if (err == -EAGAIN)
{
continue;
}
if (err < 0) {
if ((err = xrun_recovery(pcm_h, err)) < 0) {
printf("Write error: %s\n", alsa_strerror(err));
exit(-1);
}
break;
}
bytes_played += err * global_frame_size;
}
}
}
static void ALSA_Update(void)
{
int err;
if (!enabled) return;
if (bytes_written == 0 || bytes_played == bytes_written) {
bytes_written = VC_WriteBytes(audiobuffer,period_size * global_frame_size);
bytes_played = 0;
}
while (bytes_played < bytes_written)
{
err = alsa_pcm_writei(pcm_h, &audiobuffer[bytes_played], (bytes_written - bytes_played) / global_frame_size);
if (err == -EAGAIN)
continue;
if (err < 0) {
if ((err = xrun_recovery(pcm_h, err)) < 0) {
_mm_errno = MMERR_ALSA_PCM_RECOVER;
enabled = 0;
dbgprint(stderr, "Write error: %s\n", alsa_strerror(err));
}
break;
}
bytes_played += err * global_frame_size;
}
}
static DWORD WINAPI UpdateBufferProc(LPVOID lpParameter) {
while (threadInUse) {
while (1) {
XAUDIO2_VOICE_STATE state;
XAUDIO2_BUFFER audio_buf;
#if !defined(DRV_XAUDIO28)
IXAudio2SourceVoice_GetState(pSourceVoice, &state);
#else
IXAudio2SourceVoice_GetState(pSourceVoice, &state, XAUDIO2_VOICE_NOSAMPLESPLAYED);
#endif
if (state.BuffersQueued >= XAUDIO2_NUM_BUFFERS - 1)
break;
MUTEX_LOCK(vars);
if (Player_Paused_internal())
VC_SilenceBytes((SBYTE *) buffers[current_buf], (ULONG) XAUDIO2_BUFFER_SIZE);
else
VC_WriteBytes((SBYTE *) buffers[current_buf], (ULONG) XAUDIO2_BUFFER_SIZE);
MUTEX_UNLOCK(vars);
memset(&audio_buf, 0, sizeof(XAUDIO2_BUFFER));
audio_buf.AudioBytes = XAUDIO2_BUFFER_SIZE;
audio_buf.pAudioData = buffers[current_buf];
IXAudio2SourceVoice_SubmitSourceBuffer(pSourceVoice, &audio_buf, NULL);
current_buf++;
current_buf %= XAUDIO2_NUM_BUFFERS;
}
WaitForSingleObject(hBufferEvent, INFINITE);
}
return 0;
}
static void XAudio2_Update(void) {
if (do_update && pSourceVoice) {
do_update = 0;
while (1) {
XAUDIO2_VOICE_STATE state;
XAUDIO2_BUFFER audio_buf;
#if !defined(DRV_XAUDIO28)
IXAudio2SourceVoice_GetState(pSourceVoice, &state);
#else
IXAudio2SourceVoice_GetState(pSourceVoice, &state, XAUDIO2_VOICE_NOSAMPLESPLAYED);
#endif
if (state.BuffersQueued > 0)
break;
current_buf %= XAUDIO2_NUM_BUFFERS;
if (Player_Paused_internal())
VC_SilenceBytes((SBYTE *) buffers[current_buf], (ULONG) XAUDIO2_BUFFER_SIZE);
else
VC_WriteBytes((SBYTE *) buffers[current_buf], (ULONG) XAUDIO2_BUFFER_SIZE);
memset(&audio_buf, 0, sizeof(XAUDIO2_BUFFER));
audio_buf.AudioBytes = XAUDIO2_BUFFER_SIZE;
audio_buf.pAudioData = buffers[current_buf];
IXAudio2SourceVoice_SubmitSourceBuffer(pSourceVoice, &audio_buf, NULL);
current_buf++;
current_buf %= XAUDIO2_NUM_BUFFERS;
}
IXAudio2SourceVoice_Start(pSourceVoice, 0, 0);
threadInUse = 1;
ResumeThread(UpdateBufferHandle);
}
}
static void ALSA_Update(void)
{
snd_pcm_playback_status_t status;
int total, count;
if (alsa_pcm_playback_status(pcm_h, &status) >= 0) {
/* Update md_mixfreq if necessary */
if (md_mixfreq != status.rate)
md_mixfreq = status.rate;
/* Using status.count would cause clicks, as this is always less than
the freespace in the buffer - so compute how many bytes we can
afford */
total = status.fragments * status.fragment_size - status.queue;
if (total < fragmentsize)
total = fragmentsize;
} else
total = fragmentsize;
/* Don't send data if ALSA is too busy */
while (total) {
count = fragmentsize > total ? total : fragmentsize;
total -= count;
alsa_pcm_write(pcm_h,audiobuffer,VC_WriteBytes(audiobuffer,count));
}
}
static DWORD WINAPI updateBufferProc(LPVOID lpParameter)
{
LPVOID pBlock1 = NULL, pBlock2 = NULL;
DWORD soundBufferCurrentPosition, blockBytes1, blockBytes2;
DWORD start;
while (threadInUse) {
if (WaitForSingleObject(notifyUpdateHandle,INFINITE)==WAIT_OBJECT_0) {
if (!threadInUse) break;
pSoundBuffer->lpVtbl->GetCurrentPosition
(pSoundBuffer,&soundBufferCurrentPosition,NULL);
if (soundBufferCurrentPosition < fragsize)
start = fragsize;
else
start = 0;
if (pSoundBuffer->lpVtbl->Lock
(pSoundBuffer,start,fragsize,&pBlock1,&blockBytes1,
&pBlock2,&blockBytes2,0)==DSERR_BUFFERLOST) {
pSoundBuffer->lpVtbl->Restore(pSoundBuffer);
pSoundBuffer->lpVtbl->Lock
(pSoundBuffer,start,fragsize,&pBlock1,&blockBytes1,
&pBlock2,&blockBytes2,0);
}
MUTEX_LOCK(vars);
if (Player_Paused_internal()) {
VC_SilenceBytes((SBYTE*)pBlock1,(ULONG)blockBytes1);
if (pBlock2)
VC_SilenceBytes((SBYTE*)pBlock2,(ULONG)blockBytes2);
} else {
VC_WriteBytes((SBYTE*)pBlock1,(ULONG)blockBytes1);
if (pBlock2)
VC_WriteBytes((SBYTE*)pBlock2,(ULONG)blockBytes2);
}
MUTEX_UNLOCK(vars);
pSoundBuffer->lpVtbl->Unlock
(pSoundBuffer,pBlock1,blockBytes1,pBlock2,blockBytes2);
}
}
return 0;
}
static void Sun_Update(void)
{
int done;
done = VC_WriteBytes((char *)audiobuffer, fragsize);
if (play_encoding == AUDIO_ENCODING_ULAW)
unsignedtoulaw(audiobuffer, done);
write(sndfd, audiobuffer, done);
}
static void stdout_Update(void)
{
#ifdef WIN32
_write
#else
write
#endif
(1,audiobuffer,VC_WriteBytes((SBYTE*)audiobuffer,BUFFERSIZE));
}
static void
moda_mmout_Update (void)
{
written = 0;
if (!buffer || bufsize == 0)
return;
written = VC_WriteBytes (buffer, bufsize);
}
static void WAV_Update(void)
{
ULONG done;
done=VC_WriteBytes(audiobuffer,BUFFERSIZE);
if (md_mode & DMODE_FLOAT) {
/* O.S. - assuming same endian model for integer vs fp values */
_mm_write_I_ULONGS((ULONG *) audiobuffer,done>>2,wavout);
}
int mod_decode(OutputBuffer * cb, DecoderControl * dc, char * path) {
mod_Data * data;
float time = 0.0;
int ret;
float secPerByte;
if(mod_initMikMod() < 0) return -1;
if(!(data = mod_open(path))) {
ERROR("failed to open mod: %s\n", path);
MikMod_Exit();
return -1;
}
dc->audioFormat.bits = 16;
dc->audioFormat.sampleRate = 44100;
dc->audioFormat.channels = 2;
getOutputAudioFormat(&(dc->audioFormat),&(cb->audioFormat));
secPerByte = 1.0/((dc->audioFormat.bits*dc->audioFormat.channels/8.0)*
(float)dc->audioFormat.sampleRate);
dc->state = DECODE_STATE_DECODE;
while(1) {
if(dc->seek) {
dc->seekError = 1;
dc->seek = 0;
}
if(dc->stop) break;
if(!Player_Active()) break;
ret = VC_WriteBytes(data->audio_buffer, MIKMOD_FRAME_SIZE);
time += ret*secPerByte;
sendDataToOutputBuffer(cb, NULL, dc, 0,
(char *)data->audio_buffer, ret, time,
0, NULL);
}
flushOutputBuffer(cb);
mod_close(data);
MikMod_Exit();
if(dc->stop) {
dc->state = DECODE_STATE_STOP;
dc->stop = 0;
}
else dc->state = DECODE_STATE_STOP;
return 0;
}
static void sound_callback(void *buf, unsigned int reqn, void *pdata)
{
(void)pdata;
if (playing)
{
VC_WriteBytes(buf, reqn*4);
}
else
{
memset(buf, 0, reqn*4);
}
}
static void GP32_Update(void) {
unsigned long bytesread;
#ifdef GP32_DEBUG
/* gp_debug( 1, "Read bytes" );*/
#endif
bytesread = VC_WriteBytes(GP32_buffer, GP32_buffersize);
#ifdef GP32_DEBUG
/* gp_debug(1, "Read %d bytes", bytesread);*/
#endif
if (!bytesread) return; /* exit if a whole buffer hasn't been read */
gp_addRingsegment((unsigned short*)GP32_buffer);
}
static void WIN_Update(void)
{
ULONG done;
while (buffersout<NUMBUFFERS) {
done=VC_WriteBytes(buffer[nextbuffer],buffersize);
if (!done) break;
header[nextbuffer].dwBufferLength=done;
waveOutWrite(hwaveout,&header[nextbuffer],sizeof(WAVEHDR));
if (++nextbuffer>=NUMBUFFERS) nextbuffer%=NUMBUFFERS;
++buffersout;
}
}
static Uint32 mm_mix_data(struct audio_stream *a_src, Sint32 *buffer,
Uint32 len)
{
struct mikmod_stream *mm_stream = (struct mikmod_stream *)a_src;
Uint32 read_wanted = mm_stream->s.allocated_data_length -
mm_stream->s.stream_offset;
Uint8 *read_buffer = (Uint8 *)mm_stream->s.output_data +
mm_stream->s.stream_offset;
VC_WriteBytes((SBYTE*)read_buffer, read_wanted);
sampled_mix_data((struct sampled_stream *)mm_stream, buffer, len);
return 0;
}
static void ANDROID_Update(void)
{
if (playing)
{
VC_WriteBytes(mikmod_sndbuf, count * 2);
}
else
{
// memset(mikmod_sndbuf, 0, BUFFERSIZE * 4);
}
// boostSound(mikmod_sndbuf, BUFFERSIZE);
}
int oslAudioCallback_AudioCallback_MOD(unsigned int i, void* buf, unsigned int length) {
//Set up playback
//md_mixfreq = osl_modFrequency;
//md_mixshift = osl_modShift;
if (osl_modPlaying)
VC_WriteBytes(buf, length << 2);
else
memset(buf, 0, length << 2);
//Fin de la chanson ^^
if (!Player_Active())
return 0;
return 1;
}
static void OSLES_Update(void)
{
unsigned long done = 1;
while (buffersout < NUMBUFFERS) {
done=VC_WriteBytes(buffer[nextbuffer],buffersize);
if (!done) break;
SLresult result;
// enqueue another buffer
result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, buffer[nextbuffer], done);
if(SL_RESULT_SUCCESS != result)
break;
if (++nextbuffer>=NUMBUFFERS) nextbuffer%=NUMBUFFERS;
++buffersout;
}
}
static BOOL NDS_SW_PlayStart(void)
{
if(VC_PlayStart())
return 1;
Player_SetPosition(0);
ipc->prevTimer = 0;
ipc->writeCursor = 0;
ipc->readCursor = 0;
int written = VC_WriteBytes(ipc->buffer, ipc->bufferSize);
unsignedtosigned(ipc->buffer, written);
DC_FlushRange(ipc, sizeof(*ipc));
MikMod9_SendCommand(NDS_SW_CMD_START << 28);
return 0;
}
static int dc_update(void)
{
int n;
int buffer[512];
/* Number of bytes in fifo */
n = fifo_free() << 2;
if (n < 0) {
return INP_DECODE_ERROR;
}
if (!n) {
return 0;
}
/* Not to much please. */
if (n > (int)sizeof(buffer)) {
n = sizeof(buffer);
}
n = VC_WriteBytes((void*)buffer, n);
if (n < 0) {
return INP_DECODE_ERROR;
}
if (!n) {
/* $$$ ben: no more data ? probably the end ! */
return INP_DECODE_END;
}
/* Get it back to sample */
n >>= 2;
if (fifo_write(buffer, n) != n) {
/* This should not happen since we check the fifo above and no other
thread fill it. */
return INP_DECODE_ERROR;
}
return INP_DECODE_CONT;
}
/* ARGSUSED */
void OS2_UpdateBufferThread(void *dummy)
{
/* Run at timecritical priority */
DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, PRTYD_MAXIMUM - 1, 0);
while (!FinishPlayback) {
ULONG count;
static ULONG NextBuffer = 0; /* next fragment to be filled */
/* wait for play enable */
DosWaitEventSem(Play, SEM_INDEFINITE_WAIT);
/* wait for timer event */
DosWaitEventSem(Update, SEM_INDEFINITE_WAIT);
/* reset timer semaphore */
DosResetEventSem(Update, &count);
/* fill all free buffers */
while (PlayList[NextBuffer].ulOperand3 >=
PlayList[NextBuffer].ulOperand2) {
MUTEX_LOCK(vars);
if (Player_Paused_internal())
PlayList[NextBuffer].ulOperand2 =
VC_SilenceBytes((SBYTE *)PlayList[NextBuffer].ulOperand1,
BufferSize);
else
PlayList[NextBuffer].ulOperand2 =
VC_WriteBytes((SBYTE *)PlayList[NextBuffer].ulOperand1,
BufferSize);
MUTEX_UNLOCK(vars);
/* Reset play offset, although it seems MMOS2 does it
automagically */
PlayList[NextBuffer].ulOperand3 = 0;
NextBuffer = (NextBuffer + 1) % FRAGMENTS;
}
}
/* Tell main thread we're done */
ThreadID = 0;
}
static void NDS_SW_Update(void)
{
DC_InvalidateRange(&ipc->readCursor, sizeof(ipc->readCursor));
while(ipc->readCursor != ipc->writeCursor)
{
int todo = ipc->readCursor - ipc->writeCursor;
if(todo < 0)
todo = ipc->bufferSize - ipc->writeCursor;
int written = VC_WriteBytes(ipc->buffer + ipc->writeCursor, todo);
unsignedtosigned(ipc->buffer + ipc->writeCursor, written);
int newCursor = ipc->writeCursor + written;
if(ipc->writeCursor >= ipc->bufferSize)
newCursor -= ipc->bufferSize;
ipc->writeCursor = newCursor;
}
DC_FlushRange(&ipc->writeCursor, sizeof(ipc->writeCursor));
// we send this afterwards to give arm7 as much time as possible
// to update
MikMod9_SendCommand(NDS_SW_CMD_UPDATE << 28);
}
/* Buffer update thread (created and called by DART)
This is a high-priority thread used to compute and update the audio stream,
automatically created by the DART subsystem. We compute the next audio
buffer and feed it to the waveaudio device. */
static LONG APIENTRY Dart_UpdateBuffers(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer, ULONG ulFlags)
{
/* sanity check */
if (!pBuffer)
return TRUE;
/* if we have finished a buffer, we're ready to play a new one */
if ((ulFlags == MIX_WRITE_COMPLETE) ||
((ulFlags == (MIX_WRITE_COMPLETE | MIX_STREAM_ERROR)) &&
(ulStatus == ERROR_DEVICE_UNDERRUN))) {
/* refill this audio buffer and feed it again */
MUTEX_LOCK(vars);
if (Player_Paused_internal())
pBuffer->ulBufferLength =
VC_SilenceBytes(pBuffer->pBuffer, BufferSize);
else
pBuffer->ulBufferLength =
VC_WriteBytes(pBuffer->pBuffer, BufferSize);
MUTEX_UNLOCK(vars);
MixSetupParms.pmixWrite(MixSetupParms.ulMixHandle, pBuffer, 1);
}
return TRUE;
}
/**
** Load MikMod.
**
** @param name Filename of the module.
** @param flags Unused.
**
** @return Returns the loaded sample.
*/
CSample *LoadMikMod(const char *name, int flags)
{
CSample *sample;
MikModData *data;
MODULE *module;
CFile *f;
char s[256];
static int registered = 0;
md_mode |= DMODE_STEREO | DMODE_INTERP | DMODE_SURROUND | DMODE_HQMIXER;
MikMod_RegisterDriver(&drv_nos);
if (!registered) {
MikMod_RegisterAllLoaders();
registered = 1;
}
strcpy_s(s, sizeof(s), name);
f = new CFile;
if (f->open(name, CL_OPEN_READ) == -1) {
delete f;
return NULL;
}
CurrentFile = f;
MikMod_Init("");
module = Player_LoadGeneric(&MReader, 64, 0);
if (!module) {
MikMod_Exit();
f->close();
delete f;
return NULL;
}
if (flags & PlayAudioStream) {
sample = new CSampleMikModStream;
data = &((CSampleMikModStream *)sample)->Data;
} else {
sample = new CSampleMikMod;
data = &((CSampleMikMod *)sample)->Data;
}
data->MikModFile = f;
data->MikModModule = module;
sample->Channels = 2;
sample->SampleSize = 16;
sample->Frequency = 44100;
sample->Pos = 0;
if (flags & PlayAudioStream) {
sample->Len = 0;
sample->Buffer = new unsigned char[SOUND_BUFFER_SIZE];
Player_Start(data->MikModModule);
} else {
int read;
int pos;
// FIXME: need to find the correct length
sample->Len = 55000000;
sample->Buffer = new unsigned char[sample->Len];
pos = 0;
Player_Start(data->MikModModule);
while (Player_Active()) {
read = VC_WriteBytes((SBYTE *)sample->Buffer + pos,
sample->Len - pos);
pos += read;
}
Player_Stop();
Player_Free(data->MikModModule);
MikMod_Exit();
data->MikModFile->close();
delete data->MikModFile;
}
return sample;
}
static void NS_Update(void)
{
if (zerobuf)
VC_WriteBytes(zerobuf,ZEROLEN);
}
/* SDY_Update - read data into buffer, called by Player_Update() from inside MikMod. */
static void SDY_Update(void)
{
g_dwReaded = VC_WriteBytes(g_lpbyBuffer, g_dwReadBytes);
}
static void HP_Update(void)
{
write(fd,audiobuffer,VC_WriteBytes(audiobuffer,buffersize));
}
