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; }
// The real thread function void PspAudio::threadFunction() { assert(_callback); PSP_DEBUG_PRINT_FUNC("audio thread started\n"); while (_init) { // Keep looping so long as we haven't been told to stop if (_paused) PSP_DEBUG_PRINT("audio thread paused\n"); while (_paused) { // delay until we stop pausing PspThread::delayMicros(100000); // 100ms if (!_paused) PSP_DEBUG_PRINT("audio thread unpaused\n"); } PSP_DEBUG_PRINT("remaining samples[%d]\n", _remainingSamples); PSP_DEBUG_PRINT("filling buffer[%d]\n", _bufferToFill); _callback(_userData, _buffers[_bufferToFill], _bufferSize); // ask mixer to fill in data nextBuffer(_bufferToFill); PSP_DEBUG_PRINT("playing buffer[%d].\n", _bufferToPlay); playBuffer(); nextBuffer(_bufferToPlay); } // while _init // destroy everything free(_buffers[0]); sceAudioChRelease(_pspChannel); PSP_DEBUG_PRINT("audio thread exiting. ****************************\n"); }
static void CleanUp(){ if ( mp3_audio_thread >= 0 ) { sceKernelDeleteThread(mp3_audio_thread); mp3_audio_thread = -1; } if ( mp3_audio_channel >= 0 ) { sceAudioChRelease(mp3_audio_channel); mp3_audio_channel = -1; } if ( !mp3_file_handle ) { sceIoClose(mp3_file_handle); mp3_file_handle = 0; } mp3_data_start = 0; mp3_output_buffers = 0; mp3_play = 0; mp3_pause = 0; if ( mp3_codec_flag ) { sceAudiocodecReleaseEDRAM(mp3_codec_buffer); mp3_codec_flag = 0; } }
/** * stop_channel: Stop playback from the given playback buffer. * * [Parameters] * buffer_desc: Playback buffer descriptor * [Return value] * None */ void stop_channel(PSPSoundBufferDesc *buffer_desc) { if (!buffer_desc) { DMSG("buffer_desc == NULL"); return; } if (!buffer_desc->started) { DMSG("Buffer has not been started!"); return; } /* Signal the thread to stop, then wait for it (if we try to stop the * thread in the middle of an audio write, we won't be able to free * the hardware channel) */ buffer_desc->stop = 1; int tries; for (tries = (1000 * (2*BUFFER_SIZE)/PLAYBACK_RATE); tries > 0; tries--) { if (sys_delete_thread_if_stopped(buffer_desc->thread, NULL)) { break; } sceKernelDelayThread(1000); // Wait for 1ms before trying again } if (!tries) { /* The thread didn't stop on its own, so terminate it with * extreme prejudice */ sceKernelTerminateDeleteThread(buffer_desc->thread); sceAudioChRelease(buffer_desc->channel); memset(buffer_desc, 0, sizeof(*buffer_desc)); } }
void pmp_play_close(struct pmp_play_struct *p, int usePos, int pspType) { if (!(p->audio_reserved < 0)) { while(sceAudioGetChannelRestLen(0) > 0 ); sceAudioChRelease(0); } cooleyesAudioSetFrequency(sceKernelDevkitVersion(), 44100); if (!(p->semaphore_can_get < 0)) sceKernelDeleteSema(p->semaphore_can_get); if (!(p->semaphore_can_put < 0)) sceKernelDeleteSema(p->semaphore_can_put); if (!(p->semaphore_can_show < 0)) sceKernelDeleteSema(p->semaphore_can_show); if (!(p->semaphore_show_done < 0)) sceKernelDeleteSema(p->semaphore_show_done); if (!(p->output_thread < 0)) sceKernelDeleteThread(p->output_thread); if (!(p->show_thread < 0)) sceKernelDeleteThread(p->show_thread); pmp_decode_close(&p->decoder, pspType); int i = 0; for (i=0; i<p->subtitle_count; i++) subtitle_parse_close( &subtitle_parser[i] ); //if (usePos) pmp_stat_save( p ); pmp_stat_save( p ); pmp_play_safe_constructor(p); }
int pspAudioInit() { int i,ret; int failed=0; char str[32]; audio_terminate=0; audio_ready=0; for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) { AudioStatus[i].handle = -1; AudioStatus[i].threadhandle = -1; AudioStatus[i].volumeright = PSP_VOLUME_MAX; AudioStatus[i].volumeleft = PSP_VOLUME_MAX; AudioStatus[i].callback = 0; AudioStatus[i].pdata = 0; } for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) { if ((AudioStatus[i].handle = sceAudioChReserve(-1,PSP_NUM_AUDIO_SAMPLES,0))<0) failed=1; } if (failed) { for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) { if (AudioStatus[i].handle != -1) sceAudioChRelease(AudioStatus[i].handle); AudioStatus[i].handle = -1; } return -1; } audio_ready = 1; strcpy(str,"audiot0"); for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) { str[6]='0'+i; AudioStatus[i].threadhandle = sceKernelCreateThread(str,(void*)&AudioChannelThread,0x12,0x10000,0,NULL); if (AudioStatus[i].threadhandle < 0) { AudioStatus[i].threadhandle = -1; failed=1; break; } ret=sceKernelStartThread(AudioStatus[i].threadhandle,sizeof(i),&i); if (ret!=0) { failed=1; break; } } if (failed) { audio_terminate=1; for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) { if (AudioStatus[i].threadhandle != -1) { //sceKernelWaitThreadEnd(AudioStatus[i].threadhandle,NULL); sceKernelDeleteThread(AudioStatus[i].threadhandle); } AudioStatus[i].threadhandle = -1; } audio_ready=0; return -1; } return 0; }
static void PSPAUDIO_CloseDevice(_THIS) { if (this->hidden->channel >= 0) { sceAudioChRelease(this->hidden->channel); } free(this->hidden->rawbuf); /* this uses memalign(), not SDL_malloc(). */ SDL_free(this->hidden); }
void OSPC_StopPlay(){ if (OSPC_thread<0) return; OSPC_exit=1; sceKernelWaitThreadEnd( OSPC_thread, NULL ); sceKernelDeleteThread( OSPC_thread ); OSPC_thread=-1; sceAudioChRelease( OSPC_sound_fd ); OSPC_Stop(); OSPC_Close(); if (OSPC_id) free(OSPC_id); }
/* digi_psp_exit: * Shuts down the sound driver. */ static void digi_psp_exit(int input) { if (input) return; psp_audio_on = FALSE; sceKernelDeleteThread(audio_thread_UID); sceAudioChRelease(hw_channel); _mixer_exit(); }
void psp_audio_end() { psp_audio_term = 1; if (psp_audio_thid != -1) { sceKernelDeleteThread( psp_audio_thid ); psp_audio_thid = -1; } if (psp_cdaudio_thid != -1) { sceKernelDeleteThread( psp_cdaudio_thid ); psp_cdaudio_thid = -1; } if (psp_audio_chid != -1) { sceAudioChRelease( psp_audio_chid ); psp_audio_chid = -1; } if (psp_cdaudio_chid != -1) { sceAudioChRelease( psp_cdaudio_chid ); psp_cdaudio_chid = -1; } }
static void PSPAUD_CloseDevice(_THIS) { if (this->hidden->channel >= 0) { sceAudioChRelease(this->hidden->channel); this->hidden->channel = -1; } if (this->hidden->rawbuf != NULL) { free(this->hidden->rawbuf); this->hidden->rawbuf = NULL; } }
void OSPC_PlayBuffer(char *buff,int len,int release,int vol) { int i,j,pollcpt; char str[256]; SPC_ID666 *id; char *emulator[3]={"Unknown","Zsnes","Snes9x"}; uint8 *scr; OSPC_Init(); if (i=OSPC_LoadBuffer(buff,len)) { sprintf(str,"Error at SPC loading, code : %d",i); msgBoxLines(str,60); //gp32_pause(); //GpAppExit(); return; } OSPC_id=OSPC_GetID666(spc_data); OSPC_sound_fd = sceAudioChReserve( -1, 1024, 0 ); OSPC_exit=0; OSPC_volume=vol; OSPC_thread = sceKernelCreateThread( "OSPC Thread", (SceKernelThreadEntry)OSPC_PlayThread, 0x8, 256*1024, 0, 0 ); if (OSPC_thread<0) { msgBoxLines("Cannot create OSPC playback thread",60); } else { //init start time sceKernelLibcGettimeofday( &OSPC_start_time, 0 ); sceKernelStartThread( OSPC_thread, 0, 0 ); if (release) return; for (;;) { pgWaitV(); if (get_pad()) break; } OSPC_exit=1; sceKernelWaitThreadEnd( OSPC_thread, NULL ); sceKernelDeleteThread( OSPC_thread ); OSPC_thread=-1; } sceAudioChRelease( OSPC_sound_fd ); OSPC_Stop(); OSPC_Close(); if (OSPC_id) free(OSPC_id); }
/** * start_channel: Allocate a new channel and starts playback. * * [Parameters] * buffer_desc: Playback buffer descriptor * [Return value] * Nonzero on success, zero on error */ static int start_channel(PSPSoundBufferDesc *buffer_desc) { if (!buffer_desc) { DMSG("buffer_desc == NULL"); return 0; } if (buffer_desc->started) { DMSG("Buffer is already started!"); return 0; } /* Allocate a hardware channel */ buffer_desc->channel = sceAudioChReserve( PSP_AUDIO_NEXT_CHANNEL, BUFFER_SIZE, PSP_AUDIO_FORMAT_STEREO ); if (buffer_desc->channel < 0) { DMSG("Failed to allocate channel: %s", psp_strerror(buffer_desc->channel)); return 0; } /* Initialize the ring buffer */ buffer_desc->cur_play = NUM_BUFFERS - 1; buffer_desc->next_play = 0; buffer_desc->next_write = 0; int i; for (i = 0; i < NUM_BUFFERS; i++) { buffer_desc->write_ready[i] = 1; } buffer_desc->stop = 0; /* Also write everything out of the cache so it's ready for the ME */ sceKernelDcacheWritebackAll(); /* Start the playback thread */ char thname[100]; snprintf(thname, sizeof(thname), "YabauseSoundCh%d", buffer_desc->channel); SceUID handle = sys_start_thread(thname, playback_thread, THREADPRI_SOUND, 0x1000, sizeof(buffer_desc), &buffer_desc); if (handle < 0) { DMSG("Failed to create thread: %s", psp_strerror(handle)); sceAudioChRelease(buffer_desc->channel); return 0; } buffer_desc->thread = handle; /* Success */ buffer_desc->started = 1; return 1; }
SceInt32 CPMFPlayer::ShutdownAudio() { sceAudioChRelease(Audio.m_AudioChannel); //Human-Behind sceKernelDeleteThread(Audio.m_ThreadID); sceKernelDeleteSema(Audio.m_SemaphoreStart); sceKernelDeleteSema(Audio.m_SemaphoreLock); for(int i = 0; i < Audio.m_iNumBuffers; i++) free(Audio.m_pAudioBuffer[i]); return 0; }
triVoid triAt3Free() { triAt3Stop(); AT3_Loaded = 0; sceKernelDelayThread(50000); sceAudioChRelease(AT3_Channel); sceAudiocodecReleaseEDRAM(AT3_Codec_Buffer); sceKernelWaitThreadEnd(AT3_ThreadID, NULL); sceKernelTerminateDeleteThread(AT3_ThreadID); if(Tune) triFree(Tune); }
/** * playback_thread: Sound playback thread. Continually sends the ring * buffer data to the OS until signaled to stop. * * [Parameters] * args: Thread argument size * argp: Thread argument pointer * [Return value] * Always zero */ static int playback_thread(SceSize args, void *argp) { PSPSoundBufferDesc * const buffer_desc = *(PSPSoundBufferDesc **)argp; /* Temporary buffer for dummy audio data when the emulator falls behind * real time (filled with the last sample sent to avoid clicks). This * thread is only launched once, so "static" is safe. */ static uint32_t dummy_buffer[BUFFER_SIZE]; // 1 stereo sample = 32 bits static uint32_t last_sample; // Last stereo sample played while (!buffer_desc->stop) { const unsigned int next_play = buffer_desc->next_play; //static int x;int now=sceKernelGetSystemTimeLow();if(now-x>100000){printf("--- audio stat: %u %u %u %u cp=%u np=%u nw=%u\n",UNCACHED(buffer_desc->write_ready[0]),UNCACHED(buffer_desc->write_ready[1]),UNCACHED(buffer_desc->write_ready[2]),UNCACHED(buffer_desc->write_ready[3]),buffer_desc->cur_play,next_play,UNCACHED(buffer_desc->next_write));x=now;} if (!UNCACHED(buffer_desc->write_ready[next_play])) { // i.e., ready for playback const void *buffer = buffer_desc->buffer[next_play]; last_sample = ((const uint32_t *)buffer)[BUFFER_SIZE - 1]; sceAudioOutputBlocking(buffer_desc->channel, muted ? 0 : 0x8000, buffer); #ifdef DUMP_AUDIO sceIoWrite(dump_fd, buffer, BUFFER_SIZE*4); #endif UNCACHED(buffer_desc->write_ready[buffer_desc->cur_play]) = 1; buffer_desc->cur_play = next_play; buffer_desc->next_play = (next_play + 1) % NUM_BUFFERS; } else { const uint32_t sample = last_sample; // Help out optimizer uint32_t *ptr32 = dummy_buffer; unsigned int i; for (i = 0; i < BUFFER_SIZE; i += 8) { ptr32[i+0] = sample; ptr32[i+1] = sample; ptr32[i+2] = sample; ptr32[i+3] = sample; ptr32[i+4] = sample; ptr32[i+5] = sample; ptr32[i+6] = sample; ptr32[i+7] = sample; } sceAudioOutputBlocking(buffer_desc->channel, muted ? 0 : 0x8000, dummy_buffer); } } sceAudioChRelease(buffer_desc->channel); memset(buffer_desc, 0, sizeof(*buffer_desc)); return 0; }
void mp3_thread_stop(void) { if (mp3_thread >= 0) { mp3_active = 0; mp3_stop(); sceKernelWakeupThread(mp3_thread); sceKernelWaitThreadEnd(mp3_thread, NULL); sceKernelDeleteThread(mp3_thread); mp3_thread = -1; sceAudioChRelease(mp3_handle); mp3_handle = -1; } }
int FreeHardwareChannel(int channel) { int i; for (i=0;i<8;i++) { if (hardwareChannels[i]==channel) { while (AalibGetStatus(channel)!=PSPAALIB_STATUS_STOPPED) { sceKernelDelayThread(10); } sceAudioChRelease(i); hardwareChannels[i]=PSPAALIB_CHANNEL_NONE; return TRUE; } } return FALSE; }
void audio_Term(void) { int i; audio_ready = 0; audio_terminate = 1; for (i=0; i<CHANNELS; i++) { if (audio_thread_handle[i] != -1) { sceKernelWaitThreadEnd(audio_thread_handle[i], NULL); sceKernelDeleteThread(audio_thread_handle[i]); } audio_thread_handle[i] = -1; } for (i=0; i<CHANNELS; i++) { if (audio_handles[i] != -1) { sceAudioChRelease(audio_handles[i]); audio_handles[i] = -1; } } }
void pspAudioEnd() { int i; audio_ready=0; audio_terminate=1; for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) { if (AudioStatus[i].threadhandle != -1) { //sceKernelWaitThreadEnd(AudioStatus[i].threadhandle,NULL); sceKernelDeleteThread(AudioStatus[i].threadhandle); } AudioStatus[i].threadhandle = -1; } for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) { if (AudioStatus[i].handle != -1) { sceAudioChRelease(AudioStatus[i].handle); AudioStatus[i].handle = -1; } } }
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); }
int mp3_thread_start(void) { mp3_handle = -1; mp3_thread = -1; mp3_active = 0; mp3_status = MP3_STOP; mp3_running = 0; mp3_sleep = 0; mp3_newfile = 0; mp3_volume = 0; memset(mp3_out[0], 0, MP3_BUFFER_SIZE); memset(mp3_out[1], 0, MP3_BUFFER_SIZE); mp3_handle = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, MP3_SAMPLES, PSP_AUDIO_FORMAT_STEREO); if (mp3_handle < 0) { fatalerror(TEXT(COULD_NOT_RESERVE_AUDIO_CHANNEL_FOR_MP3)); return 0; } mp3_active = 1; mp3_thread = sceKernelCreateThread("MP3 thread", MP3Thread, 0x8, 0x40000, 0, NULL); if (mp3_thread < 0) { fatalerror(TEXT(COULD_NOT_START_MP3_THREAD)); sceAudioChRelease(mp3_handle); return 0; } sceKernelStartThread(mp3_thread, 0, 0); return 1; }
int audio_Init(void) { int i, ret; int failed = 0; char str[32]; audio_terminate=0; audio_ready=0; for(i=0; i<CHANNELS; i++) { audio_handles[i] = -1; audio_thread_handle[i] = -1; audio_ChannelCallback[i] = 0; audio_volumes[i][0] = MAXVOLUME; audio_volumes[i][1] = MAXVOLUME; } for(i=0; i<CHANNELS; i++) if((audio_handles[i] = sceAudioChReserve(-1, SAMPLES, 0)) < 0) failed = 1; if(failed) { for(i=0; i<CHANNELS; i++) { if(audio_handles[i] != -1) sceAudioChRelease(audio_handles[i]); audio_handles[i] = -1; } return -1; } audio_ready = 1; strcpy(str,"Sound Thread"); for(i=0; i<CHANNELS; i++) { str[6] = '0' + i; audio_thread_handle[i] = sceKernelCreateThread(str, audio_ChannelThread, 0x8, 0x10000, PSP_THREAD_ATTR_USER, NULL); if(audio_thread_handle[i] < 0) { audio_thread_handle[i] = -1; failed = 1; break; } ret = sceKernelStartThread(audio_thread_handle[i], sizeof(i), &i); if(ret != 0) { failed = 1; break; } } if(failed) { audio_terminate = 1; for(i=0; i<CHANNELS; i++) { if(audio_thread_handle[i] != -1) { sceKernelWaitThreadEnd(audio_thread_handle[i],NULL); sceKernelDeleteThread(audio_thread_handle[i]); } audio_thread_handle[i] = -1; } audio_ready = 0; return -1; } audio_SetChannelCallback(0, audio_UpdateCallback); return 0; }
SceInt32 CPMFPlayer::InitAudio() { int i = 0, fail = 0; Audio.m_AudioChannel = sceAudioChReserve(-1, 512, PSP_AUDIO_FORMAT_STEREO); if(Audio.m_AudioChannel < 0) { sprintf(m_LastError, "sceAudioChReserve() failed: 0x%08X", (int)Audio.m_AudioChannel); return -1; } sceAudioSetChannelDataLen(Audio.m_AudioChannel, m_MpegAtracOutSize / 4); Audio.m_ThreadID = sceKernelCreateThread("audio_thread", T_Audio, 0x3D, 0x10000, PSP_THREAD_ATTR_USER, NULL); if(Audio.m_ThreadID < 0) { sprintf(m_LastError, "sceKernelCreateThread() failed: 0x%08X", (int)Audio.m_ThreadID); goto exit0; } Audio.m_SemaphoreStart = sceKernelCreateSema("audio_start_sema", 0, 0, 1, NULL); if(Audio.m_SemaphoreStart < 0) { sprintf(m_LastError, "sceKernelCreateSema() failed: 0x%08X", (int)Audio.m_SemaphoreStart); goto exit1; } Audio.m_SemaphoreLock = sceKernelCreateSema("audio_lock_sema", 0, 1, 1, NULL); if(Audio.m_SemaphoreLock < 0 ) { sprintf(m_LastError, "sceKernelCreateSema() failed: 0x%08X", (int)Audio.m_SemaphoreLock); goto exit2; } Audio.m_iNumBuffers = 4; Audio.m_iFullBuffers = 0; Audio.m_iPlayBuffer = 1; Audio.m_iDecodeBuffer = 0; Audio.m_iAbort = 0; Audio.m_LastError = m_LastError; for(i = 0; i < Audio.m_iNumBuffers; i++) { Audio.m_pAudioBuffer[i] = NULL; Audio.m_iBufferTimeStamp[i] = 0; } for(i = 0; i < Audio.m_iNumBuffers; i++) { Audio.m_pAudioBuffer[i] = memalign(64, m_MpegAtracOutSize); if(Audio.m_pAudioBuffer[i] < 0) fail++; } if(fail > 0) { for(i = 0; i < Audio.m_iNumBuffers; i++) { if(Audio.m_pAudioBuffer[i] != NULL) free(Audio.m_pAudioBuffer[i]); } sprintf(m_LastError, "malloc() failed!"); goto exit3; } return 0; exit3: sceKernelDeleteSema(Audio.m_SemaphoreLock); exit2: sceKernelDeleteSema(Audio.m_SemaphoreStart); exit1: sceKernelDeleteThread(Audio.m_ThreadID); exit0: sceAudioChRelease(Audio.m_AudioChannel); return -1; }
int main(int argc, char *argv[]) { char *at3_data; int at3_size; char *decode_data; int decode_size; int n; FILE *file; int atracID; int maxSamples = 0; int result; int channel; u32 puiPosition; u32 puiDataByte; if ((file = fopen("sample.at3", "rb")) != NULL) { fseek(file, 0, SEEK_END); at3_size = ftell(file); fseek(file, 0, SEEK_SET); at3_data = malloc(at3_size); decode_data = malloc(decode_size = 512 * 1024); memset(at3_data, 0, at3_size); memset(decode_data, 0, decode_size); fread(at3_data, at3_size, 1, file); fclose(file); } pspSdkLoadStartModule("flash0:/kd/audiocodec.prx", PSP_MEMORY_PARTITION_KERNEL); pspSdkLoadStartModule("flash0:/kd/libatrac3plus.prx", PSP_MEMORY_PARTITION_KERNEL); printf("at3: %08X, %08X\n", (unsigned int)at3_data, at3_size); printf("Header: %s\n", (char *)at3_data); atracID = sceAtracSetDataAndGetID(at3_data, at3_size); result = sceAtracSetLoopNum(atracID, 2); printf("sceAtracSetLoopNum: %08X\n", result); printf("sceAtracSetDataAndGetID: %08X\n", atracID); result = sceAtracGetMaxSample(atracID, &maxSamples); printf("sceAtracGetMaxSample: %08X, %d\n", result, maxSamples); channel = sceAudioChReserve(0, maxSamples, PSP_AUDIO_FORMAT_STEREO); result = sceAtracGetSecondBufferInfo(atracID, &puiPosition, &puiDataByte); printf("sceAtracGetSecondBufferInfo: %08X, %u, %u\n", result, (unsigned int)puiPosition, (unsigned int)puiDataByte); int end = 0; int steps = 0; while (!end) { //int remainFrame = -1; int remainFrame = 0; //int decodeBufferPosition = 0; int samples = 0; int nextSample = 0; u32 nextPosition = 0; if (steps < 4) { result = sceAtracGetNextSample(atracID, &nextSample); printf("sceAtracGetNextSample(%d): %d\n", result, nextSample); result = sceAtracGetNextDecodePosition(atracID, &nextPosition); printf("sceAtracGetNextDecodePosition(%d): %u\n", result, (unsigned int)nextPosition); } result = sceAtracDecodeData(atracID, (u16 *)decode_data, &samples, &end, &remainFrame); if (steps < 4) { } sceAudioSetChannelDataLen(channel, samples); sceAudioOutputBlocking(channel, 0x8000, decode_data); result = sceAtracGetRemainFrame(atracID, &remainFrame); if (steps < 4) { printf("sceAtracDecodeData: %08X, at3_size: %d, decode_size: %d, samples: %d, end: %d, remainFrame: %d\n\n", result, at3_size, decode_size, samples, end, remainFrame); if (steps == 1) { for (n = 0; n < 32; n++) printf("%04X ", (u16)decode_data[n]); } printf("sceAtracGetRemainFrame: %08X\n", result); } steps++; } sceAudioChRelease(channel); result = sceAtracReleaseAtracID(atracID); printf("sceAtracGetRemainFrame: %08X\n", result); return 0; }
void OSPC_Play(char *fname,int release,int vol) { u16 *menu_bg; u16 *dst,*src; int i,j,pollcpt; char str[256]; char *emulator[3]={"Unknown","Zsnes","Snes9x"}; uint8 *scr; OSPC_Init(); if (i=OSPC_Load(fname)) { sprintf(str,"Error at SPC loading, code : %d",i); msgBoxLines(str,60); //gp32_pause(); //GpAppExit(); return; } OSPC_id=OSPC_GetID666(spc_data); OSPC_sound_fd = sceAudioChReserve( -1, 1024, 0 ); OSPC_exit=0; OSPC_volume=vol; OSPC_thread = sceKernelCreateThread( "OSPC Thread", (SceKernelThreadEntry)OSPC_PlayThread, 0x8, 256*1024, 0, 0 ); if (OSPC_thread<0) { msgBoxLines("Cannot create OSPC playback thread",60); } else { //init start time scePowerSetClockFrequency(266,266,133); sceKernelLibcGettimeofday( &OSPC_start_time, 0 ); sceKernelStartThread( OSPC_thread, 0, 0 ); if (release) return; //init bg menu_bg=(u16*)malloc_64(480*272*2); dst=menu_bg; show_background(bg_img_mul,(os9x_lowbat?0x600000:0)); for (i=0;i<272;i++) { src = (u16*)pgGetVramAddr(0,i); memcpy(dst,src,480*2); dst+=480; } //init fx fx_init(); for (;;) { //show bg OSPC_show_bg(menu_bg); //show bg fx fx_main(pgGetVramAddr(0,0)); //batt infos show_batteryinfo(); //music info //draw frame pgDrawFrame(14,14,20+230+5+1,75+1,12|(12<<5)|(12<<10)); pgDrawFrame(13,13,20+230+5+2,75+2,30|(30<<5)|(30<<10)); pgDrawFrame(12,12,20+230+5+3,75+3,12|(12<<5)|(12<<10)); pgFillBoxHalfer(15,15,20+230+5,75); // if (strlen(OSPC_id->gametitle)) sprintf(str,"Game : %s",OSPC_id->gametitle); else sprintf(str,"Game : unknown"); mh_print(20,20,(char*)str,30|(30<<5)|(30<<10)); if (strlen(OSPC_id->songname)) sprintf(str,"Song : %s",OSPC_id->songname); else sprintf(str,"Song : unknown"); mh_print(20,30,(char*)str,30|(30<<5)|(30<<10)); if (strlen(OSPC_id->dumper)) sprintf(str,"Dumper : %s",OSPC_id->dumper); else sprintf(str,"Dumper : unknown"); mh_print(20,40,(char*)str,30|(30<<5)|(30<<10)); if (strlen(OSPC_id->comments)) sprintf(str,"Comments : %s",OSPC_id->comments); else sprintf(str,"Comments : unknown"); mh_print(20,50,(char*)str,30|(30<<5)|(30<<10)); if (strlen(OSPC_id->author)) sprintf(str,"Author : %s",OSPC_id->author); else sprintf(str,"Author : unknown"); mh_print(20,60,(char*)str,30|(30<<5)|(30<<10)); //time infos //draw frame //draw frame pgDrawFrame(14,94,20+65+5+1,116,8|(8<<5)|(16<<10)); pgDrawFrame(13,93,20+65+5+2,117,28|(28<<5)|(31<<10)); pgDrawFrame(12,92,20+65+5+3,118,8|(8<<5)|(16<<10)); pgFillBoxHalfer(15,95,20+65+5,115); sceKernelLibcGettimeofday( &OSPC_cur_time, 0 ); i=(OSPC_cur_time.tv_sec-OSPC_start_time.tv_sec)+(OSPC_cur_time.tv_usec-OSPC_start_time.tv_usec)/1000000; sprintf(str,"%2d%c%.2d / %2d:%.2d",i/60,((i&1)?':':' '),i%60,OSPC_id->playtime/60,OSPC_id->playtime%60); mh_print(20,100,(char*)str,(20)|(31<<5)|(18<<10)); if (get_pad()) break; pgScreenFlip(); } OSPC_exit=1; sceKernelWaitThreadEnd( OSPC_thread, NULL ); sceKernelDeleteThread( OSPC_thread ); OSPC_thread=-1; free(menu_bg); fx_close(); } sceAudioChRelease( OSPC_sound_fd ); OSPC_Stop(); OSPC_Close(); if (OSPC_id) free(OSPC_id); }
int MP3_Load (const char *name){ if ( !mp3_codec_flag ) return -1; mp3_file_handle = sceIoOpen(name, PSP_O_RDONLY, 0777); if ( !mp3_file_handle ) return -1; if ( sceIoRead( mp3_file_handle, mp3_header_buffer, 4 ) != 4 ) { sceIoClose(mp3_file_handle); return -2; } while(1) { if ( mp3_header_buffer[0] == 'I' && mp3_header_buffer[1] == 'D' && mp3_header_buffer[2] == '3' ) { unsigned char id3v2_buffer[6]; if ( sceIoRead( mp3_file_handle, id3v2_buffer, 6 ) != 6 ) { sceIoClose(mp3_file_handle); return -2; } int id3v2_size = (int)(id3v2_buffer[2] & 0x7F) << 21 | (int)(id3v2_buffer[3] & 0x7F) << 14 | (int)(id3v2_buffer[4] & 0x7F) << 7 | (int)(id3v2_buffer[5] & 0x7F); sceIoLseek32(mp3_file_handle, id3v2_size, PSP_SEEK_CUR); if ( sceIoRead( mp3_file_handle, mp3_header_buffer, 4 ) != 4 ) { sceIoClose(mp3_file_handle); return -2; } continue; } unsigned int mp3_header = mp3_header_buffer[0]; mp3_header = (mp3_header<<8) | mp3_header_buffer[1]; mp3_header = (mp3_header<<8) | mp3_header_buffer[2]; mp3_header = (mp3_header<<8) | mp3_header_buffer[3]; if ( (mp3_header & 0xFFFE0000) != 0xFFFA0000) { sceIoLseek32(mp3_file_handle, -3, PSP_SEEK_CUR); if ( sceIoRead( mp3_file_handle, mp3_header_buffer, 4 ) != 4 ) { sceIoClose(mp3_file_handle); return -2; } continue; } mp3_samplerate = (mp3_header & 0x0C00) >> 10; if ( mp3_samplerate != 0 && mp3_samplerate != 1 ) { sceIoClose(mp3_file_handle); return -3; } mp3_samplerate = (mp3_samplerate == 0)?44100:48000; mp3_channels = (mp3_header & 0x00C0) >> 6; mp3_channels = (mp3_channels == 3)?1:2; mp3_data_start = sceIoLseek32(mp3_file_handle, -4, PSP_SEEK_CUR); break; } mp3_audio_channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, MP3_SAMPLE_COUNT, PSP_AUDIO_FORMAT_STEREO); if ( mp3_audio_channel < 0 ) { sceIoClose(mp3_file_handle); return -4; } mp3_audio_thread = sceKernelCreateThread("mp3_audio_thread",MP3OutputThread,0x12,0x10000,0,NULL); if ( mp3_audio_thread < 0 ) { sceAudioChRelease(mp3_audio_channel); sceIoClose(mp3_file_handle); return -5; } return 1; }