int
nist_open (SF_PRIVATE *psf)
{ int error ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = nist_read_header (psf)))
return error ;
} ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ if (psf->is_pipe)
return SFE_NO_PIPE_WRITE ;
if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_NIST)
return SFE_BAD_OPEN_FORMAT ;
psf->endian = SF_ENDIAN (psf->sf.format) ;
if (psf->endian == 0 || psf->endian == SF_ENDIAN_CPU)
psf->endian = (CPU_IS_BIG_ENDIAN) ? SF_ENDIAN_BIG : SF_ENDIAN_LITTLE ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
psf->sf.frames = 0 ;
if ((error = nist_write_header (psf, SF_FALSE)))
return error ;
psf->write_header = nist_write_header ;
} ;
psf->container_close = nist_close ;
switch (SF_CODEC (psf->sf.format))
{ case SF_FORMAT_PCM_S8 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_PCM_16 :
case SF_FORMAT_PCM_24 :
case SF_FORMAT_PCM_32 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_ULAW :
error = ulaw_init (psf) ;
break ;
case SF_FORMAT_ALAW :
error = alaw_init (psf) ;
break ;
default :
error = SFE_UNIMPLEMENTED ;
break ;
} ;
return error ;
} /* nist_open */
int
nist_open (SF_PRIVATE *psf)
{ int subformat, error ;
if (psf->mode == SFM_READ || (psf->mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = nist_read_header (psf)))
return error ;
} ;
subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
{ if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_NIST)
return SFE_BAD_OPEN_FORMAT ;
psf->endian = psf->sf.format & SF_FORMAT_ENDMASK ;
if (psf->endian == 0 || psf->endian == SF_ENDIAN_CPU)
psf->endian = (CPU_IS_BIG_ENDIAN) ? SF_ENDIAN_BIG : SF_ENDIAN_LITTLE ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
if ((error = nist_write_header (psf, SF_FALSE)))
return error ;
psf->write_header = nist_write_header ;
} ;
psf->close = nist_close ;
switch (psf->sf.format & SF_FORMAT_SUBMASK)
{ case SF_FORMAT_PCM_S8 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_PCM_16 :
case SF_FORMAT_PCM_24 :
case SF_FORMAT_PCM_32 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_ULAW :
error = ulaw_init (psf) ;
break ;
case SF_FORMAT_ALAW :
error = alaw_init (psf) ;
break ;
default : error = SFE_UNIMPLEMENTED ;
break ;
} ;
return error ;
} /* nist_open */
void pcm_set_16bits(int b)
{
int open = wout ? 1 : 0;
pcm_close();
bits = b;
if (open) pcm_init();
}
void pcm_set_samplerate(int rate)
{
int open = wout ? 1 : 0;
pcm_close();
samplerate = rate;
if (open) pcm_init();
}
void pcm_set_stereo(int stereomode)
{
int open = wout ? 1 : 0;
pcm_close();
stereo = stereomode;
if (open) pcm_init();
}
jstring Java_com_ingogo_android_cardreader_helpers_Swipe_decodeSquareSwipe(JNIEnv *environment, jobject thiz, jshortArray jArray, int length) {
jshort *jSamples;
jstring returnString;
short *samples;
jSamples = (*environment)->GetShortArrayElements(environment, jArray, NULL);
if (jSamples == NULL) {
return (*environment)->NewStringUTF(environment, "");
}
samples = jSamples;
PcmData *pcm = pcm_init(samples, length, false);
(*environment)->ReleaseShortArrayElements(environment, jArray, jSamples, JNI_ABORT);
SquareDecoder *decoder = square_init(pcm);
square_decode_swipe(decoder);
if (decoder->lastError == SwipeError_Success) {
returnString = (*environment)->NewStringUTF(environment, decoder->cardString);
} else {
char errorCode[8];
sprintf(errorCode, "%d", decoder->lastError);
returnString = (*environment)->NewStringUTF(environment, errorCode);
}
pcm_free(pcm);
square_free(decoder);
return returnString;
}
int
avr_open (SF_PRIVATE *psf)
{ int subformat ;
int error = 0 ;
if (psf->mode == SFM_READ || (psf->mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = avr_read_header (psf)))
return error ;
} ;
if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_AVR)
return SFE_BAD_OPEN_FORMAT ;
subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
{ psf->endian = psf->sf.format & SF_FORMAT_ENDMASK ;
psf->endian = SF_ENDIAN_BIG ;
if (avr_write_header (psf, SF_FALSE))
return psf->error ;
psf->write_header = avr_write_header ;
} ;
psf->close = avr_close ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
error = pcm_init (psf) ;
return error ;
} /* avr_open */
int gbcInitialize(int rate)
{
vid_init();
pcm_init(rate);
return 1;
}
int
avr_open (SF_PRIVATE *psf)
{ int error = 0 ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = avr_read_header (psf)))
return error ;
} ;
if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_AVR)
return SFE_BAD_OPEN_FORMAT ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ psf->endian = SF_ENDIAN (psf->sf.format) ;
psf->endian = SF_ENDIAN_BIG ;
if (avr_write_header (psf, SF_FALSE))
return psf->error ;
psf->write_header = avr_write_header ;
} ;
psf->container_close = avr_close ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
error = pcm_init (psf) ;
return error ;
} /* avr_open */
extern "C" DLL_EXPORT void CDECL_CALL EmuMain(char *rom)
{
int i;
char *s;
/* If we have special perms, drop them ASAP! */
vid_preinit();
init_exports();
s = strdup(".");
sys_sanitize(s);
sys_initpath(s);
for (i = 0; defaultconfig[i]; i++)
rc_command(defaultconfig[i]);
/* FIXME - make interface modules responsible for atexit() */
atexit(shutdown);
catch_signals();
vid_init();
pcm_init();
rom = strdup(rom);
sys_sanitize(rom);
loader_init(rom);
emu_reset();
emu_run();
}
void pcm_set_buffer_count(int count)
{
int open = wout ? 1 : 0;
pcm_close();
buffers = count;
if (open) pcm_init();
}
void *dspio_init(void)
{
struct dspio_state *state;
state = malloc(sizeof(struct dspio_state));
if (!state)
return NULL;
memset(&state->dma, 0, sizeof(struct dspio_dma));
state->input_running = state->pcm_input_running =
state->lin_input_running = state->mic_input_running =
state->output_running = state->dac_running = state->speaker = 0;
state->dma.dsp_fifo_enabled = 1;
rng_init(&state->fifo_in, DSP_FIFO_SIZE, 2);
rng_init(&state->fifo_out, DSP_FIFO_SIZE, 2);
rng_init(&state->midi_fifo_in, MIDI_FIFO_SIZE, 1);
rng_init(&state->midi_fifo_out, MIDI_FIFO_SIZE, 1);
state->i_handle = pcm_register_player(&player, state);
pcm_init();
pcm_set_volume_cb(dspio_get_volume);
pcm_set_connected_cb(dspio_is_connected);
state->dac_strm = pcm_allocate_stream(1, "SB DAC", (void*)MC_VOICE);
pcm_set_flag(state->dac_strm, PCM_FLAG_RAW);
state->dma_strm = pcm_allocate_stream(2, "SB DMA", (void*)MC_VOICE);
pcm_set_flag(state->dma_strm, PCM_FLAG_SLTS);
midi_init();
return state;
}
int init_smt(struct s_smc *smc, u_char *mac_addr)
{
int p ;
#if defined(DEBUG) && !defined(DEBUG_BRD)
debug.d_smt = 0 ;
debug.d_smtf = 0 ;
debug.d_rmt = 0 ;
debug.d_ecm = 0 ;
debug.d_pcm = 0 ;
debug.d_cfm = 0 ;
debug.d_plc = 0 ;
#ifdef ESS
debug.d_ess = 0 ;
#endif
#ifdef SBA
debug.d_sba = 0 ;
#endif
#endif
for ( p = 0; p < NUMPHYS; p ++ ) {
smc->y[p].mib = & smc->mib.p[p] ;
}
set_oem_spec_val(smc) ;
(void) smt_set_mac_opvalues(smc) ;
init_fddi_driver(smc,mac_addr) ;
smt_fixup_mib(smc) ;
ev_init(smc) ;
#ifndef SLIM_SMT
smt_init_evc(smc) ;
#endif
smt_timer_init(smc) ;
smt_agent_init(smc) ;
pcm_init(smc) ;
ecm_init(smc) ;
cfm_init(smc) ;
rmt_init(smc) ;
for (p = 0 ; p < NUMPHYS ; p++) {
pcm(smc,p,0) ;
}
ecm(smc,0) ;
cfm(smc,0) ;
rmt(smc,0) ;
smt_agent_task(smc) ;
PNMI_INIT(smc) ;
return(0) ;
}
/*
* Init SMT
*/
int init_smt(struct s_smc *smc, u_char *mac_addr)
/* u_char *mac_addr; canonical address or NULL */
{
int p ;
#if defined(DEBUG) && !defined(DEBUG_BRD)
debug.d_smt = 0 ;
debug.d_smtf = 0 ;
debug.d_rmt = 0 ;
debug.d_ecm = 0 ;
debug.d_pcm = 0 ;
debug.d_cfm = 0 ;
debug.d_plc = 0 ;
#ifdef ESS
debug.d_ess = 0 ;
#endif
#ifdef SBA
debug.d_sba = 0 ;
#endif
#endif /* DEBUG && !DEBUG_BRD */
/* First initialize the ports mib->pointers */
for ( p = 0; p < NUMPHYS; p ++ ) {
smc->y[p].mib = & smc->mib.p[p] ;
}
set_oem_spec_val(smc) ;
(void) smt_set_mac_opvalues(smc) ;
init_fddi_driver(smc,mac_addr) ; /* HW driver */
smt_fixup_mib(smc) ; /* update values that depend on s.sas */
ev_init(smc) ; /* event queue */
#ifndef SLIM_SMT
smt_init_evc(smc) ; /* evcs in MIB */
#endif /* no SLIM_SMT */
smt_timer_init(smc) ; /* timer package */
smt_agent_init(smc) ; /* SMT frame manager */
pcm_init(smc) ; /* PCM state machine */
ecm_init(smc) ; /* ECM state machine */
cfm_init(smc) ; /* CFM state machine */
rmt_init(smc) ; /* RMT state machine */
for (p = 0 ; p < NUMPHYS ; p++) {
pcm(smc,p,0) ; /* PCM A state machine */
}
ecm(smc,0) ; /* ECM state machine */
cfm(smc,0) ; /* CFM state machine */
rmt(smc,0) ; /* RMT state machine */
smt_agent_task(smc) ; /* NIF FSM etc */
PNMI_INIT(smc) ; /* PNMI initialization */
return(0) ;
}
int
mat4_open (SF_PRIVATE *psf)
{ int subformat, error = 0 ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = mat4_read_header (psf)))
return error ;
} ;
if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_MAT4)
return SFE_BAD_OPEN_FORMAT ;
subformat = SF_CODEC (psf->sf.format) ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ if (psf->is_pipe)
return SFE_NO_PIPE_WRITE ;
psf->endian = SF_ENDIAN (psf->sf.format) ;
if (CPU_IS_LITTLE_ENDIAN && (psf->endian == SF_ENDIAN_CPU || psf->endian == 0))
psf->endian = SF_ENDIAN_LITTLE ;
else if (CPU_IS_BIG_ENDIAN && (psf->endian == SF_ENDIAN_CPU || psf->endian == 0))
psf->endian = SF_ENDIAN_BIG ;
if ((error = mat4_write_header (psf, SF_FALSE)))
return error ;
psf->write_header = mat4_write_header ;
} ;
psf->container_close = mat4_close ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
switch (subformat)
{ case SF_FORMAT_PCM_16 :
case SF_FORMAT_PCM_32 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_FLOAT :
error = float32_init (psf) ;
break ;
case SF_FORMAT_DOUBLE :
error = double64_init (psf) ;
break ;
default : break ;
} ;
if (error)
return error ;
return error ;
} /* mat4_open */
int
ircam_open (SF_PRIVATE *psf)
{ int subformat ;
int error = SFE_NO_ERROR ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = ircam_read_header (psf)))
return error ;
} ;
subformat = SF_CODEC (psf->sf.format) ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_IRCAM)
return SFE_BAD_OPEN_FORMAT ;
psf->endian = SF_ENDIAN (psf->sf.format) ;
if (psf->endian == 0 || psf->endian == SF_ENDIAN_CPU)
psf->endian = (CPU_IS_BIG_ENDIAN) ? SF_ENDIAN_BIG : SF_ENDIAN_LITTLE ;
psf->dataoffset = IRCAM_DATA_OFFSET ;
if ((error = ircam_write_header (psf, SF_FALSE)))
return error ;
psf->write_header = ircam_write_header ;
} ;
psf->container_close = ircam_close ;
switch (subformat)
{ case SF_FORMAT_ULAW : /* 8-bit Ulaw encoding. */
error = ulaw_init (psf) ;
break ;
case SF_FORMAT_ALAW : /* 8-bit Alaw encoding. */
error = alaw_init (psf) ;
break ;
case SF_FORMAT_PCM_16 : /* 16-bit linear PCM. */
case SF_FORMAT_PCM_32 : /* 32-bit linear PCM. */
error = pcm_init (psf) ;
break ;
case SF_FORMAT_FLOAT : /* 32-bit linear PCM. */
error = float32_init (psf) ;
break ;
default :
break ;
} ;
return error ;
} /* ircam_open */
int
voc_open (SF_PRIVATE *psf)
{ int subformat, error = 0 ;
if (psf->is_pipe)
return SFE_VOC_NO_PIPE ;
if (psf->mode == SFM_READ || (psf->mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = voc_read_header (psf)))
return error ;
} ;
subformat = SF_CODEC (psf->sf.format) ;
if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
{ if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_VOC)
return SFE_BAD_OPEN_FORMAT ;
psf->endian = SF_ENDIAN_LITTLE ;
if ((error = voc_write_header (psf, SF_FALSE)))
return error ;
psf->write_header = voc_write_header ;
} ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
psf->container_close = voc_close ;
switch (subformat)
{
case SF_FORMAT_PCM_U8 :
case SF_FORMAT_PCM_16 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_ALAW :
error = alaw_init (psf) ;
break ;
case SF_FORMAT_ULAW :
error = ulaw_init (psf) ;
break ;
default :
return SFE_UNIMPLEMENTED ;
} ;
return error ;
} /* voc_open */
void emu_init(int game_id)
{
vid_init();
pcm_init();
vid_preinit();
// load ROM & load palette
bitbox_rom_load(game_id);
emu_reset();
vid_begin();
lcd_begin();
emu_started = 1; // at the end , start line blitting
}
void audio_set_rate(int samplerate, double framerate)
{
/* Number of M-cycles executed per second. */
/* All emulated chips are kept in sync by using a common oscillator (MCLOCK) */
/* */
/* The original console would run exactly 53693175 M-cycles per sec (53203424 for PAL), */
/* 3420 M-cycles per line and 262 (313 for PAL) lines per frame, which gives an exact */
/* framerate of 59.92 (49.70 for PAL) frames per second. */
/* */
/* Since audio samples are generated at the end of the frame, to prevent audio skipping */
/* or lag between emulated frames, number of samples rendered per frame must be set to */
/* output samplerate (number of samples played per second) divided by input framerate */
/* (number of frames emulated per seconds). */
/* */
/* On some systems, we may want to achieve 100% smooth video rendering by synchronizing */
/* frame emulation with VSYNC, which frequency is generally not exactly those values. */
/* In that case, input framerate (number of frames emulated per seconds) is the same as */
/* output framerate (number of frames rendered per seconds) by the host video hardware. */
/* */
/* When no framerate is specified, base clock is set to original master clock value. */
/* Otherwise, it is set to number of M-cycles emulated per line (fixed) multiplied by */
/* number of lines per frame (VDP mode specific) multiplied by input framerate. */
/* */
double mclk = framerate ? (MCYCLES_PER_LINE * (vdp_pal ? 313 : 262) * framerate) : system_clock;
/* For maximal accuracy, sound chips are running at their original rate using common */
/* master clock timebase so they remain perfectly synchronized together, while still */
/* being synchronized with 68K and Z80 CPUs as well. Mixed sound chip output is then */
/* resampled to desired rate at the end of each frame, using Blip Buffer. */
blip_set_rates(snd.blips[0], mclk, samplerate);
/* Mega CD sound hardware */
if (system_hw == SYSTEM_MCD)
{
/* number of SCD master clocks run per second */
mclk = (mclk / system_clock) * SCD_CLOCK;
/* PCM core */
pcm_init(mclk, samplerate);
/* CDD core */
cdd_init(samplerate);
}
/* Reinitialize internal rates */
snd.sample_rate = samplerate;
snd.frame_rate = framerate;
}
int
htk_open (SF_PRIVATE *psf)
{ int subformat ;
int error = 0 ;
if (psf->is_pipe)
return SFE_HTK_NO_PIPE ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = htk_read_header (psf)))
return error ;
} ;
subformat = SF_CODEC (psf->sf.format) ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_HTK)
return SFE_BAD_OPEN_FORMAT ;
psf->endian = SF_ENDIAN_BIG ;
if (htk_write_header (psf, SF_FALSE))
return psf->error ;
psf->write_header = htk_write_header ;
} ;
psf->container_close = htk_close ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
switch (subformat)
{
case SF_FORMAT_PCM_16 : /* 16-bit linear PCM. */
error = pcm_init (psf) ;
break ;
default :
break ;
} ;
return error ;
} /* htk_open */
static int gnuboy_main(const char *rom)
{
rb->lcd_puts(0,0,"Init video");
vid_init();
rb->lcd_puts(0,1,"Init sound");
pcm_init();
rb->lcd_puts(0,2,"Loading rom");
loader_init(rom);
if(shut)
return PLUGIN_ERROR;
rb->lcd_puts(0,3,"Emu reset");
emu_reset();
rb->lcd_puts(0,4,"Emu run");
rb->lcd_clear_display();
rb->lcd_update();
emu_run();
/* never reached */
return PLUGIN_OK;
}
void emu_init()
{
vid_init();
pcm_init();
emu_reset();
}
int
w64_open (SF_PRIVATE *psf)
{ WAV_PRIVATE * wpriv ;
int subformat, error, blockalign = 0, framesperblock = 0 ;
if ((wpriv = calloc (1, sizeof (WAV_PRIVATE))) == NULL)
return SFE_MALLOC_FAILED ;
psf->container_data = wpriv ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR &&psf->filelength > 0))
{ if ((error = w64_read_header (psf, &blockalign, &framesperblock)))
return error ;
} ;
if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_W64)
return SFE_BAD_OPEN_FORMAT ;
subformat = SF_CODEC (psf->sf.format) ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ if (psf->is_pipe)
return SFE_NO_PIPE_WRITE ;
psf->endian = SF_ENDIAN_LITTLE ; /* All W64 files are little endian. */
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
if (subformat == SF_FORMAT_IMA_ADPCM || subformat == SF_FORMAT_MS_ADPCM)
{ blockalign = wav_w64_srate2blocksize (psf->sf.samplerate * psf->sf.channels) ;
framesperblock = -1 ;
/*
** At this point we don't know the file length so set it stupidly high, but not
** so high that it triggers undefined behaviour whan something is added to it.
*/
psf->filelength = SF_COUNT_MAX - 10000 ;
psf->datalength = psf->filelength ;
if (psf->sf.frames <= 0)
psf->sf.frames = (psf->blockwidth) ? psf->filelength / psf->blockwidth : psf->filelength ;
} ;
if ((error = w64_write_header (psf, SF_FALSE)))
return error ;
psf->write_header = w64_write_header ;
} ;
psf->container_close = w64_close ;
switch (subformat)
{ case SF_FORMAT_PCM_U8 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_PCM_16 :
case SF_FORMAT_PCM_24 :
case SF_FORMAT_PCM_32 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_ULAW :
error = ulaw_init (psf) ;
break ;
case SF_FORMAT_ALAW :
error = alaw_init (psf) ;
break ;
/* Lite remove start */
case SF_FORMAT_FLOAT :
error = float32_init (psf) ;
break ;
case SF_FORMAT_DOUBLE :
error = double64_init (psf) ;
break ;
case SF_FORMAT_IMA_ADPCM :
error = wav_w64_ima_init (psf, blockalign, framesperblock) ;
break ;
case SF_FORMAT_MS_ADPCM :
error = wav_w64_msadpcm_init (psf, blockalign, framesperblock) ;
break ;
/* Lite remove end */
case SF_FORMAT_GSM610 :
error = gsm610_init (psf) ;
break ;
default : return SFE_UNIMPLEMENTED ;
} ;
return error ;
} /* w64_open */
int
au_open (SF_PRIVATE *psf)
{ int subformat ;
int error = 0 ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = au_read_header (psf)))
return error ;
} ;
if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_AU)
return SFE_BAD_OPEN_FORMAT ;
subformat = SF_CODEC (psf->sf.format) ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ psf->endian = SF_ENDIAN (psf->sf.format) ;
if (CPU_IS_LITTLE_ENDIAN && psf->endian == SF_ENDIAN_CPU)
psf->endian = SF_ENDIAN_LITTLE ;
else if (psf->endian != SF_ENDIAN_LITTLE)
psf->endian = SF_ENDIAN_BIG ;
if (au_write_header (psf, SF_FALSE))
return psf->error ;
psf->write_header = au_write_header ;
} ;
psf->container_close = au_close ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
switch (subformat)
{ case SF_FORMAT_ULAW : /* 8-bit Ulaw encoding. */
ulaw_init (psf) ;
break ;
case SF_FORMAT_PCM_S8 : /* 8-bit linear PCM. */
error = pcm_init (psf) ;
break ;
case SF_FORMAT_PCM_16 : /* 16-bit linear PCM. */
case SF_FORMAT_PCM_24 : /* 24-bit linear PCM */
case SF_FORMAT_PCM_32 : /* 32-bit linear PCM. */
error = pcm_init (psf) ;
break ;
case SF_FORMAT_ALAW : /* 8-bit Alaw encoding. */
alaw_init (psf) ;
break ;
/* Lite remove start */
case SF_FORMAT_FLOAT : /* 32-bit floats. */
error = float32_init (psf) ;
break ;
case SF_FORMAT_DOUBLE : /* 64-bit double precision floats. */
error = double64_init (psf) ;
break ;
case SF_FORMAT_G721_32 :
error = g72x_init (psf) ;
psf->sf.seekable = SF_FALSE ;
break ;
case SF_FORMAT_G723_24 :
error = g72x_init (psf) ;
psf->sf.seekable = SF_FALSE ;
break ;
case SF_FORMAT_G723_40 :
error = g72x_init (psf) ;
psf->sf.seekable = SF_FALSE ;
break ;
/* Lite remove end */
default : break ;
} ;
return error ;
} /* au_open */
int
raw_open (SF_PRIVATE *psf)
{ int subformat, error = SFE_NO_ERROR ;
subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
psf->endian = psf->sf.format & SF_FORMAT_ENDMASK ;
if (CPU_IS_BIG_ENDIAN && (psf->endian == 0 || psf->endian == SF_ENDIAN_CPU))
psf->endian = SF_ENDIAN_BIG ;
else if (CPU_IS_LITTLE_ENDIAN && (psf->endian == 0 || psf->endian == SF_ENDIAN_CPU))
psf->endian = SF_ENDIAN_LITTLE ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
psf->dataoffset = 0 ;
psf->datalength = psf->filelength ;
switch (subformat)
{ case SF_FORMAT_PCM_S8 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_PCM_U8 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_PCM_16 :
case SF_FORMAT_PCM_24 :
case SF_FORMAT_PCM_32 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_ULAW :
error = ulaw_init (psf) ;
break ;
case SF_FORMAT_ALAW :
error = alaw_init (psf) ;
break ;
case SF_FORMAT_GSM610 :
error = gsm610_init (psf) ;
break ;
/* Lite remove start */
case SF_FORMAT_FLOAT :
error = float32_init (psf) ;
break ;
case SF_FORMAT_DOUBLE :
error = double64_init (psf) ;
break ;
case SF_FORMAT_DWVW_12 :
error = dwvw_init (psf, 12) ;
break ;
case SF_FORMAT_DWVW_16 :
error = dwvw_init (psf, 16) ;
break ;
case SF_FORMAT_DWVW_24 :
error = dwvw_init (psf, 24) ;
break ;
case SF_FORMAT_VOX_ADPCM :
error = vox_adpcm_init (psf) ;
break ;
/* Lite remove end */
default : return SFE_BAD_OPEN_FORMAT ;
} ;
return error ;
} /* raw_open */
int
sd2_open (SF_PRIVATE *psf)
{ int marker, software, rsrc_offset, len ;
int rsrc_data_offset, rsrc_map_offset, rsrc_data_length, rsrc_map_length ;
char slen ;
float srate ;
/* Read only so far. */
psf_binheader_readf (psf, "Epmmj", 0x41, &marker, &software, 14) ;
if (marker != Sd2f_MARKER)
{ printf ("Whoops!!!\n") ;
puts (psf->logbuffer) ;
exit (1) ;
} ;
psf_log_printf (psf, "Marker : %M\n"
"Software : %M\n",
marker, software) ;
/* This seems to be a constant for binhex files. */
psf->dataoffset = 0x80 ;
/* All SD2 files are big endian. */
psf->endian= SF_ENDIAN_BIG ;
/*
** Resource header info from:
** http://developer.apple.com/techpubs/mac/MoreToolbox/MoreToolbox-99.html
*/
rsrc_offset = psf->datalength + psf->dataoffset ;
if (rsrc_offset & 0x7F)
rsrc_offset = rsrc_offset - (rsrc_offset & 0x7F) + psf->dataoffset ;
psf_log_printf (psf, "Resource offset : 0x%X\n", rsrc_offset) ;
/* Jump to the rsrc_offset fork section. */
psf_binheader_readf (psf, "Ep", rsrc_offset) ;
psf_binheader_readf (psf, "E4444", &rsrc_data_offset, &rsrc_map_offset, &rsrc_data_length, &rsrc_map_length) ;
rsrc_data_offset += rsrc_offset ;
rsrc_map_offset += rsrc_offset ;
psf_log_printf (psf, " data offset : 0x%X\n"
" map offset : 0x%X\n"
" data length : 0x%X\n"
" map length : 0x%X\n",
rsrc_data_offset, rsrc_map_offset, rsrc_data_length, rsrc_map_length) ;
if (rsrc_data_offset + rsrc_data_length > rsrc_map_offset || rsrc_map_offset + rsrc_map_length > psf->filelength)
{ puts ("##############################") ;
puts (psf->logbuffer) ;
puts ("##############################") ;
exit (1) ;
} ;
memset (psf->buffer, 0, sizeof (psf->buffer)) ;
psf_binheader_readf (psf, "Ep41", rsrc_data_offset, &len, &slen) ;
if (slen + 1 == len)
{ psf_binheader_readf (psf, "Eb", psf->buffer, len - 1) ;
((char*) psf->buffer) [len - 1] = 0 ;
if (sscanf ((char*) psf->buffer, "%d", &len) == 1)
psf->bytewidth = len ;
} ;
psf_binheader_readf (psf, "E41", &len, &slen) ;
if (slen + 1 == len)
{ psf_binheader_readf (psf, "Eb", psf->buffer, len - 1) ;
((char*) psf->buffer) [len - 1] = 0 ;
if (sscanf ((char*) psf->buffer, "%f", &srate) == 1)
psf->sf.samplerate = srate ;
} ;
psf_binheader_readf (psf, "E41", &len, &slen) ;
if (slen + 1 == len)
{ psf_binheader_readf (psf, "Eb", psf->buffer, len - 1) ;
((char*) psf->buffer) [len - 1] = 0 ;
if (sscanf ((char*) psf->buffer, "%d", &len) == 1)
psf->sf.channels = len ;
} ;
psf_log_printf (psf, " byte width : %d\n", psf->bytewidth) ;
psf_log_printf (psf, " sample rate : %d\n", psf->sf.samplerate) ;
psf_log_printf (psf, " channels : %d\n", psf->sf.channels) ;
if (psf->bytewidth == 2)
{ psf->sf.format = SF_FORMAT_SD2 | SF_FORMAT_PCM_16 ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
psf->sf.frames = psf->datalength / psf->blockwidth ;
} ;
pcm_init (psf) ;
psf_fseek (psf->filedes, psf->dataoffset, SEEK_SET) ;
psf->close = sd2_close ;
return 0 ;
} /* sd2_open */
/*
* do_user_menu - create the user menu on the screen.
*
* Returns USER_MENU_QUIT if the user selected "quit", otherwise
* returns zero.
*/
int do_user_menu(void) {
bool done=false;
int selected=0, ret=0;
int result;
int time = 0;
#if CONFIG_RTC
time = rb->mktime(rb->get_time());
#endif
#if defined(HAVE_LCD_MODES) && (HAVE_LCD_MODES & LCD_MODE_PAL256)
rb->lcd_set_mode(LCD_MODE_RGB565);
#endif
/* Clean out the button Queue */
while (rb->button_get(false) != BUTTON_NONE)
rb->yield();
MENUITEM_STRINGLIST(menu, "Rockboy Menu", NULL,
"Load Game", "Save Game",
"Options", "Quit");
pcm_init();
while(!done)
{
result = rb->do_menu(&menu, &selected, NULL, false);
switch (result)
{
case 0: /* Load Game */
do_slot_menu(true);
break;
case 1: /* Save Game */
do_slot_menu(false);
break;
case 2: /* Options */
do_opt_menu();
break;
case 3: /* Quit */
ret = USER_MENU_QUIT;
done=true;
break;
default:
done=true;
break;
}
}
rb->lcd_setfont(0); /* Reset the font */
rb->lcd_clear_display(); /* Clear display for screen size changes */
/* Keep the RTC in sync */
#if CONFIG_RTC
time = (rb->mktime(rb->get_time()) - time) * 60;
#endif
while (time-- > 0) rtc_tick();
#if defined(HAVE_LCD_MODES) && (HAVE_LCD_MODES & LCD_MODE_PAL256)
rb->lcd_set_mode(LCD_MODE_PAL256);
#endif
return ret;
}
int main(int argc, char *argv[])
{
int i;
char *opt, *arg, *cmd, *s, *rom = 0;
/* Avoid initializing video if we don't have to */
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "--help"))
help(base(argv[0]));
else if (!strcmp(argv[i], "--version"))
version(base(argv[0]));
else if (!strcmp(argv[i], "--copying"))
copying();
else if (!strcmp(argv[i], "--bind")) i += 2;
else if (!strcmp(argv[i], "--source")) i++;
else if (!strcmp(argv[i], "--showvars"))
{
show_exports();
exit(0);
}
else if (argv[i][0] == '-' && argv[i][1] == '-');
else if (argv[i][0] == '-' && argv[i][1]);
else rom = argv[i];
}
if (!rom) usage(base(argv[0]));
/* If we have special perms, drop them ASAP! */
vid_preinit();
init_exports();
s = strdup(argv[0]);
sys_sanitize(s);
sys_initpath(s);
for (i = 0; defaultconfig[i]; i++)
rc_command(defaultconfig[i]);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "--bind"))
{
if (i + 2 >= argc) die("missing arguments to bind\n");
cmd = malloc(strlen(argv[i+1]) + strlen(argv[i+2]) + 9);
sprintf(cmd, "bind %s \"%s\"", argv[i+1], argv[i+2]);
rc_command(cmd);
free(cmd);
i += 2;
}
else if (!strcmp(argv[i], "--source"))
{
if (i + 1 >= argc) die("missing argument to source\n");
cmd = malloc(strlen(argv[i+1]) + 6);
sprintf(cmd, "source %s", argv[++i]);
rc_command(cmd);
free(cmd);
}
else if (!strncmp(argv[i], "--no-", 5))
{
opt = strdup(argv[i]+5);
while ((s = strchr(opt, '-'))) *s = '_';
cmd = malloc(strlen(opt) + 7);
sprintf(cmd, "set %s 0", opt);
rc_command(cmd);
free(cmd);
free(opt);
}
else if (argv[i][0] == '-' && argv[i][1] == '-')
{
opt = strdup(argv[i]+2);
if ((s = strchr(opt, '=')))
{
*s = 0;
arg = s+1;
}
else arg = "1";
while ((s = strchr(opt, '-'))) *s = '_';
while ((s = strchr(arg, ','))) *s = ' ';
cmd = malloc(strlen(opt) + strlen(arg) + 6);
sprintf(cmd, "set %s %s", opt, arg);
rc_command(cmd);
free(cmd);
free(opt);
}
/* short options not yet implemented */
else if (argv[i][0] == '-' && argv[i][1]);
}
/* FIXME - make interface modules responsible for atexit() */
atexit(shutdown);
catch_signals();
vid_init();
pcm_init();
rom = strdup(rom);
sys_sanitize(rom);
loader_init(rom);
emu_reset();
emu_run();
/* never reached */
return 0;
}
int
sd2_open (SF_PRIVATE *psf)
{ int subformat, error = 0, valid ;
/* SD2 is always big endian. */
psf->endian = SF_ENDIAN_BIG ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->rsrclength > 0))
{ psf_use_rsrc (psf, SF_TRUE) ;
valid = psf_file_valid (psf) ;
psf_use_rsrc (psf, SF_FALSE) ;
if (! valid)
{ psf_log_printf (psf, "sd2_open : psf->rsrc.filedes < 0\n") ;
return SFE_SD2_BAD_RSRC ;
} ;
error = sd2_parse_rsrc_fork (psf) ;
if (error)
goto error_cleanup ;
} ;
if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_SD2)
{ error = SFE_BAD_OPEN_FORMAT ;
goto error_cleanup ;
} ;
subformat = SF_CODEC (psf->sf.format) ;
psf->dataoffset = 0 ;
/* Only open and write the resource in RDWR mode is its current length is zero. */
if (psf->file.mode == SFM_WRITE || (psf->file.mode == SFM_RDWR && psf->rsrclength == 0))
{ psf->rsrc.mode = psf->file.mode ;
psf_open_rsrc (psf) ;
error = sd2_write_rsrc_fork (psf, SF_FALSE) ;
if (error)
goto error_cleanup ;
/* Not needed. */
psf->write_header = NULL ;
} ;
psf->container_close = sd2_close ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
switch (subformat)
{ case SF_FORMAT_PCM_S8 : /* 8-bit linear PCM. */
case SF_FORMAT_PCM_16 : /* 16-bit linear PCM. */
case SF_FORMAT_PCM_24 : /* 24-bit linear PCM */
case SF_FORMAT_PCM_32 : /* 32-bit linear PCM */
error = pcm_init (psf) ;
break ;
default :
error = SFE_UNIMPLEMENTED ;
break ;
} ;
psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
error_cleanup:
/* Close the resource fork regardless. We won't need it again. */
psf_close_rsrc (psf) ;
return error ;
} /* sd2_open */
int
caf_open (SF_PRIVATE *psf)
{ CAF_PRIVATE * pcaf ;
int subformat, format, error = 0 ;
if ((psf->container_data = calloc (1, sizeof (CAF_PRIVATE))) == NULL)
return SFE_MALLOC_FAILED ;
pcaf = psf->container_data ;
if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
{ if ((error = caf_read_header (psf)))
return error ;
psf->next_chunk_iterator = caf_next_chunk_iterator ;
psf->get_chunk_size = caf_get_chunk_size ;
psf->get_chunk_data = caf_get_chunk_data ;
} ;
subformat = SF_CODEC (psf->sf.format) ;
if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
{ if (psf->is_pipe)
return SFE_NO_PIPE_WRITE ;
format = SF_CONTAINER (psf->sf.format) ;
if (format != SF_FORMAT_CAF)
return SFE_BAD_OPEN_FORMAT ;
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
if (psf->file.mode != SFM_RDWR || psf->filelength < 44)
{ psf->filelength = 0 ;
psf->datalength = 0 ;
psf->dataoffset = 0 ;
psf->sf.frames = 0 ;
} ;
psf->strings.flags = SF_STR_ALLOW_START | SF_STR_ALLOW_END ;
/*
** By default, add the peak chunk to floating point files. Default behaviour
** can be switched off using sf_command (SFC_SET_PEAK_CHUNK, SF_FALSE).
*/
if (psf->file.mode == SFM_WRITE && (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE))
{ if ((psf->peak_info = peak_info_calloc (psf->sf.channels)) == NULL)
return SFE_MALLOC_FAILED ;
psf->peak_info->peak_loc = SF_PEAK_START ;
} ;
if ((error = caf_write_header (psf, SF_FALSE)) != 0)
return error ;
psf->write_header = caf_write_header ;
psf->set_chunk = caf_set_chunk ;
} ;
psf->container_close = caf_close ;
psf->command = caf_command ;
switch (subformat)
{ case SF_FORMAT_PCM_S8 :
case SF_FORMAT_PCM_16 :
case SF_FORMAT_PCM_24 :
case SF_FORMAT_PCM_32 :
error = pcm_init (psf) ;
break ;
case SF_FORMAT_ULAW :
error = ulaw_init (psf) ;
break ;
case SF_FORMAT_ALAW :
error = alaw_init (psf) ;
break ;
/* Lite remove start */
case SF_FORMAT_FLOAT :
error = float32_init (psf) ;
break ;
case SF_FORMAT_DOUBLE :
error = double64_init (psf) ;
break ;
case SF_FORMAT_ALAC_16 :
case SF_FORMAT_ALAC_20 :
case SF_FORMAT_ALAC_24 :
case SF_FORMAT_ALAC_32 :
if (psf->file.mode == SFM_READ)
/* Only pass the ALAC_DECODER_INFO in read mode. */
error = alac_init (psf, &pcaf->alac) ;
else
error = alac_init (psf, NULL) ;
break ;
/* Lite remove end */
default :
return SFE_UNSUPPORTED_ENCODING ;
} ;
return error ;
} /* caf_open */
