int playerStart(char *path,pMalloc extern_malloc,pFree extern_free, int(*callback)(int)){
int ret,ch;MODFILE mod;
if(!extern_malloc || !extern_free)return -1;
if((ch=sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL,PSP_AUDIO_SAMPLE_ALIGN(768),PSP_AUDIO_FORMAT_STEREO))<0)return ch;
myMalloc=extern_malloc;
myFree =extern_free;
MODFILE_Init(&mod);
if((ret=MODFILE_Load(path, &mod))<0)return ret;
mod.musicvolume = 255;
mod.sfxvolume = 255;
mod.callback = NULL;//callback;
MODFILE_Start(&mod);
MODFILE_SetFormat(&mod, 44100, 2,16,1/*unsigned*/);
SceCtrlData pad;
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(1);
for(int i=0;;i++){
sceCtrlReadBufferPositive(&pad,1);
if(pad.Buttons&PSP_CTRL_START)break;
mod.mixingbuf =(void*)out[i%2];
mod.mixingbuflen = 768*2*2;
MODFILE_Player(&mod);
sceAudioOutputBlocking(ch, PSP_AUDIO_VOLUME_MAX,out[i%2]);
}
MODFILE_Stop(&mod);
MODFILE_Free(&mod);
sceAudioChRelease(ch);
return 0;
}
static int
PSPAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
{
int format, mixlen, i;
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc(sizeof(*this->hidden));
if (this->hidden == NULL) {
return SDL_OutOfMemory();
}
SDL_zerop(this->hidden);
switch (this->spec.format & 0xff) {
case 8:
case 16:
this->spec.format = AUDIO_S16LSB;
break;
default:
return SDL_SetError("Unsupported audio format");
}
/* The sample count must be a multiple of 64. */
this->spec.samples = PSP_AUDIO_SAMPLE_ALIGN(this->spec.samples);
this->spec.freq = 44100;
/* Update the fragment size as size in bytes. */
SDL_CalculateAudioSpec(&this->spec);
/* Allocate the mixing buffer. Its size and starting address must
be a multiple of 64 bytes. Our sample count is already a multiple of
64, so spec->size should be a multiple of 64 as well. */
mixlen = this->spec.size * NUM_BUFFERS;
this->hidden->rawbuf = (Uint8 *) memalign(64, mixlen);
if (this->hidden->rawbuf == NULL) {
return SDL_SetError("Couldn't allocate mixing buffer");
}
/* Setup the hardware channel. */
if (this->spec.channels == 1) {
format = PSP_AUDIO_FORMAT_MONO;
} else {
format = PSP_AUDIO_FORMAT_STEREO;
}
this->hidden->channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, this->spec.samples, format);
if (this->hidden->channel < 0) {
free(this->hidden->rawbuf);
this->hidden->rawbuf = NULL;
return SDL_SetError("Couldn't reserve hardware channel");
}
memset(this->hidden->rawbuf, 0, mixlen);
for (i = 0; i < NUM_BUFFERS; i++) {
this->hidden->mixbufs[i] = &this->hidden->rawbuf[i * this->spec.size];
}
this->hidden->next_buffer = 0;
return 0;
}
bool PspAudio::open(uint32 freq, uint32 numOfChannels, uint32 numOfSamples, callbackFunc callback, void *userData) {
DEBUG_ENTER_FUNC();
if (_init) {
PSP_ERROR("audio device already initialized\n");
return true;
}
PSP_DEBUG_PRINT("freq[%d], numOfChannels[%d], numOfSamples[%d], callback[%p], userData[%x]\n",
freq, numOfChannels, numOfSamples, callback, (uint32)userData);
numOfSamples = PSP_AUDIO_SAMPLE_ALIGN(numOfSamples);
uint32 bufLen = numOfSamples * numOfChannels * NUM_BUFFERS * sizeof(uint16);
PSP_DEBUG_PRINT("total buffer size[%d]\n", bufLen);
_buffers[0] = (byte *)memalign(64, bufLen);
if (!_buffers[0]) {
PSP_ERROR("failed to allocate memory for audio buffers\n");
return false;
}
memset(_buffers[0], 0, bufLen); // clean the buffer
// Fill in the rest of the buffer pointers
byte *pBuffer = _buffers[0];
for (int i = 1; i < NUM_BUFFERS; i++) {
pBuffer += numOfSamples * numOfChannels * sizeof(uint16);
_buffers[i] = pBuffer;
}
// Reserve a HW channel for our audio
_pspChannel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, numOfSamples, numOfChannels == 2 ? PSP_AUDIO_FORMAT_STEREO : PSP_AUDIO_FORMAT_MONO);
if (_pspChannel < 0) {
PSP_ERROR("failed to reserve audio channel\n");
return false;
}
PSP_DEBUG_PRINT("reserved channel[%d] for audio\n", _pspChannel);
// Save our data
_numOfChannels = numOfChannels;
_numOfSamples = numOfSamples;
_bufferSize = numOfSamples * numOfChannels * sizeof(uint16); // should be the right size to send the app
_callback = callback;
_userData = userData;
_bufferToFill = 0;
_bufferToPlay = 0;
_init = true;
_paused = true; // start in paused mode
threadCreateAndStart("audioThread", PRIORITY_AUDIO_THREAD, STACK_AUDIO_THREAD); // start the consumer thread
return true;
}
static int SoundThread()
{
int err=0;
int sample_count;
int chan;
int realSampleCount;
int buf = 0;
//For SMS, we need tighter timings
if (menuConfig.sound.perfectSynchro && gblMachineType == EM_SMS)
sample_count = 128;
else
sample_count = snd.sample_rate/snd.fps;
sample_count = PSP_AUDIO_SAMPLE_ALIGN(sample_count);
realSampleCount = sample_count / (44100 / snd.sample_rate);
chan = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, sample_count, PSP_AUDIO_FORMAT_STEREO);
if(chan > 0 && sample_count > 0 && sample_count <= 2048)
{
for(; soundRunning; )
{
if (soundPause)
memset(audioOut[buf], 0, sample_count * sizeof(sample_t));
else
StandardSoundProcess();
//Game Boy: réglage du son ne fonctionne pas!
AudioGet(audioOut[buf], sample_count, realSampleCount);
sceAudioOutputBlocking(chan, PSP_AUDIO_VOLUME_MAX, (void*)audioOut[buf]);
if (menuConfig.sound.perfectSynchro)
buf = 1 - buf;
}
sceAudioChRelease(chan);
}
soundRunning = -1;
sceKernelExitDeleteThread(0);
}