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 */