├── FBACache_windows.zip
├── FBAcapex_src
    ├── COPYING
    ├── GFX
    │   ├── gfx_BG.bmp
    │   ├── gfx_BG.h
    │   ├── gfx_CAPEX.bmp
    │   ├── gfx_CAPEX.h
    │   ├── gfx_FONT.bmp
    │   ├── gfx_FONT.h
    │   ├── gfx_SELECTEUR.bmp
    │   └── gfx_SELECTEUR.h
    ├── Makefile
    ├── Makefile.debug
    ├── README-FBACAPEX
    ├── capex.c
    ├── capex.cfg
    ├── capex.h
    ├── capex_pixel.h
    ├── capex_read.h
    ├── capex_tri.h
    ├── capex_write.h
    ├── fba_splash.png
    ├── gamelist.py
    ├── gamelist.txt
    ├── gfx_FONT.bmp
    ├── keyconstants.h
    ├── rominfo.fba
    ├── skin
    │   ├── capex_bg.bmp
    │   ├── capex_selector.bmp
    │   ├── capex_title.bmp
    │   ├── fba_splash.png
    │   └── gfx_FONT.bmp
    └── zipname.fba
├── Makefile
├── Makefile.debug
├── Makefile.gp2x
├── burn
    ├── ay8910.c
    ├── ay8910.h
    ├── bitswap.h
    ├── burn.cpp
    ├── burn.h
    ├── burn_sound.cpp
    ├── burn_sound.h
    ├── burn_sound_c.cpp
    ├── burn_ym2151.cpp
    ├── burn_ym2151.h
    ├── burn_ym2203.cpp
    ├── burn_ym2203.h
    ├── burn_ym2608.cpp
    ├── burn_ym2608.h
    ├── burn_ym2610.cpp
    ├── burn_ym2610.h
    ├── burn_ym3812.cpp
    ├── burn_ym3812.h
    ├── burn_ymf278b.cpp
    ├── burn_ymf278b.h
    ├── burnint.h
    ├── capcom
    │   ├── cps.cpp
    │   ├── cps.h
    │   ├── cps2_crpt.cpp
    │   ├── cps_draw.cpp
    │   ├── cps_mem.cpp
    │   ├── cps_obj.cpp
    │   ├── cps_pal.cpp
    │   ├── cps_run.cpp
    │   ├── cps_rw.cpp
    │   ├── cps_scr.cpp
    │   ├── cpsr.cpp
    │   ├── cpsrd.cpp
    │   ├── cpst.cpp
    │   ├── ctv.cpp
    │   ├── ctv.h
    │   ├── ctv_do.h
    │   ├── ctv_make.cpp
    │   ├── dc_1941.cpp
    │   ├── dc_1944.cpp
    │   ├── dc_19xx.cpp
    │   ├── dc_3wonders.cpp
    │   ├── dc_armwar.cpp
    │   ├── dc_avsp.cpp
    │   ├── dc_batcir.cpp
    │   ├── dc_captcomm.cpp
    │   ├── dc_cawing.cpp
    │   ├── dc_choko.cpp
    │   ├── dc_csclub.cpp
    │   ├── dc_cworld2j.cpp
    │   ├── dc_cyb.cpp
    │   ├── dc_ddsom.cpp
    │   ├── dc_ddtod.cpp
    │   ├── dc_dimahoo.cpp
    │   ├── dc_dino.cpp
    │   ├── dc_dstlk.cpp
    │   ├── dc_dw.cpp
    │   ├── dc_ecofghtr.cpp
    │   ├── dc_ffight.cpp
    │   ├── dc_forgottn.cpp
    │   ├── dc_ghouls.cpp
    │   ├── dc_gigawing.cpp
    │   ├── dc_hsf2.cpp
    │   ├── dc_input.cpp
    │   ├── dc_jyangoku.cpp
    │   ├── dc_knights.cpp
    │   ├── dc_kod.cpp
    │   ├── dc_megaman.cpp
    │   ├── dc_megaman2.cpp
    │   ├── dc_mercs.cpp
    │   ├── dc_mmatrix.cpp
    │   ├── dc_mpang.cpp
    │   ├── dc_msh.cpp
    │   ├── dc_mshvsf.cpp
    │   ├── dc_msword.cpp
    │   ├── dc_mtwins.cpp
    │   ├── dc_mvsc.cpp
    │   ├── dc_nemo.cpp
    │   ├── dc_nwarr.cpp
    │   ├── dc_pang3.cpp
    │   ├── dc_pnickj.cpp
    │   ├── dc_progear.cpp
    │   ├── dc_punisher.cpp
    │   ├── dc_pzloop2.cpp
    │   ├── dc_qad.cpp
    │   ├── dc_qnd.cpp
    │   ├── dc_qtono2.cpp
    │   ├── dc_ringdest.cpp
    │   ├── dc_sf2.cpp
    │   ├── dc_sf2t.cpp
    │   ├── dc_sfa.cpp
    │   ├── dc_sfa2.cpp
    │   ├── dc_sfa3.cpp
    │   ├── dc_sfzch.cpp
    │   ├── dc_sgemf.cpp
    │   ├── dc_slammast.cpp
    │   ├── dc_spf.cpp
    │   ├── dc_ssf2.cpp
    │   ├── dc_ssf2t.cpp
    │   ├── dc_strider.cpp
    │   ├── dc_unsquad.cpp
    │   ├── dc_varth.cpp
    │   ├── dc_vhunt2.cpp
    │   ├── dc_vsav.cpp
    │   ├── dc_vsav2.cpp
    │   ├── dc_willow.cpp
    │   ├── dc_wof.cpp
    │   ├── dc_xmcota.cpp
    │   ├── dc_xmvsf.cpp
    │   ├── kabuki.cpp
    │   ├── ps.cpp
    │   ├── ps_m.cpp
    │   ├── ps_z.cpp
    │   ├── qs.cpp
    │   ├── qs_c.cpp
    │   └── qs_z.cpp
    ├── cave
    │   ├── cave.cpp
    │   ├── cave.h
    │   ├── cave_palette.cpp
    │   ├── cave_sprite.cpp
    │   ├── cave_sprite_func.h
    │   ├── cave_sprite_func_table.h
    │   ├── cave_sprite_render.h
    │   ├── cave_sprite_render_zoom.h
    │   ├── cave_tile.cpp
    │   ├── cave_tile_func.h
    │   ├── cave_tile_func_table.h
    │   ├── cave_tile_render.h
    │   ├── d_dodonpachi.cpp
    │   ├── d_donpachi.cpp
    │   ├── d_esprade.cpp
    │   ├── d_feversos.cpp
    │   ├── d_gaia.cpp
    │   ├── d_guwange.cpp
    │   ├── d_hotdogst.cpp
    │   ├── d_mazinger.cpp
    │   ├── d_metmqstr.cpp
    │   ├── d_pwrinst2.cpp
    │   ├── d_sailormn.cpp
    │   └── d_uopoko.cpp
    ├── cheat.cpp
    ├── cheat.h
    ├── cps3
    │   ├── cps3.h
    │   ├── cps3run.cpp
    │   ├── cps3snd.cpp
    │   ├── d_cps3.cpp
    │   ├── d_psikyosh.cpp
    │   └── d_suprnova.cpp
    ├── driver.h
    ├── driverlist.h
    ├── eeprom_93cxx.cpp
    ├── eeprom_93cxx.h
    ├── fm.c
    ├── fm.h
    ├── fmopl.c
    ├── fmopl.h
    ├── load.cpp
    ├── misc
    │   ├── d_1945kiii.cpp
    │   ├── d_aerofgt.cpp
    │   ├── d_biomtoy.cpp
    │   ├── d_bombjack.cpp
    │   ├── d_esd16.cpp
    │   ├── d_fstarfrc.cpp
    │   ├── d_gaiden.cpp
    │   ├── d_galpanic.cpp
    │   ├── d_hyperpac.cpp
    │   ├── d_kaneko16.cpp
    │   ├── d_m92.cpp
    │   ├── d_madgear.cpp
    │   ├── d_news.cpp
    │   ├── d_ohmygod.cpp
    │   ├── d_parent.cpp
    │   ├── d_powerins.cpp
    │   ├── d_prehisle.cpp
    │   ├── d_shadfrce.cpp
    │   ├── d_solomon.cpp
    │   ├── d_tigerheli.cpp
    │   ├── d_tmnt.cpp
    │   ├── d_tumbleb.cpp
    │   ├── d_unico.cpp
    │   ├── d_wc90.cpp
    │   ├── d_wwfwfest.cpp
    │   ├── kanekotb.h
    │   ├── taito_68k
    │   │   ├── d_opwolf.cpp
    │   │   ├── d_rainbow.cpp
    │   │   ├── d_rastan.cpp
    │   │   ├── d_superman.cpp
    │   │   ├── d_twinhawk.cpp
    │   │   ├── rain_chip.cpp
    │   │   ├── rain_chip.h
    │   │   ├── snd_tc0140.cpp
    │   │   ├── snd_tc0140.h
    │   │   ├── taito.h
    │   │   ├── taito_gfx.cpp
    │   │   ├── taito_gfx.h
    │   │   ├── vid_pc080sn.cpp
    │   │   ├── vid_pc080sn.h
    │   │   ├── vid_pc090oj.cpp
    │   │   ├── vid_pc090oj.h
    │   │   ├── vid_sysx.cpp
    │   │   └── vid_sysx.h
    │   ├── tiles_generic.cpp
    │   └── tiles_generic.h
    ├── msm5205.cpp
    ├── msm5205.h
    ├── msm6295.cpp
    ├── msm6295.h
    ├── neogeo
    │   ├── d_neogeo.cpp
    │   ├── neo_decrypt.cpp
    │   ├── neo_palette.cpp
    │   ├── neo_run.cpp
    │   ├── neo_sprite.cpp
    │   ├── neo_sprite_func.h
    │   ├── neo_sprite_func_table.h
    │   ├── neo_sprite_render.h
    │   ├── neo_text.cpp
    │   ├── neo_text_render.h
    │   ├── neo_upd4990a.cpp
    │   ├── neogeo.cpp
    │   └── neogeo.h
    ├── pgm
    │   ├── d_pgm.cpp
    │   ├── pgm.h
    │   ├── pgm_crypt.cpp
    │   ├── pgm_draw.cpp
    │   ├── pgm_prot.cpp
    │   ├── pgm_run.cpp
    │   ├── pgm_snd.cpp
    │   └── pgmy2ks.h
    ├── psikyo
    │   ├── d_psikyo.cpp
    │   ├── psikyo.h
    │   ├── psikyo_palette.cpp
    │   ├── psikyo_render.h
    │   ├── psikyo_sprite.cpp
    │   ├── psikyo_sprite_func.h
    │   └── psikyo_tile.cpp
    ├── sega
    │   ├── d_hangon.cpp
    │   ├── d_outrun.cpp
    │   ├── d_sys16a.cpp
    │   ├── d_sys16b.cpp
    │   ├── d_xbrd.cpp
    │   ├── d_ybrd.cpp
    │   ├── fd1089.cpp
    │   ├── fd1094.cpp
    │   ├── fd1094.h
    │   ├── mc8123.cpp
    │   ├── sys16.h
    │   ├── sys16_fd1094.cpp
    │   ├── sys16_gfx.cpp
    │   ├── sys16_pcm.cpp
    │   ├── sys16_ppi.cpp
    │   └── sys16_run.cpp
    ├── sek.cpp
    ├── sek.h
    ├── sekdebug.h
    ├── state.h
    ├── stdfunc.h
    ├── tchar.h
    ├── timer.cpp
    ├── timer.h
    ├── toaplan
    │   ├── d_batrider.cpp
    │   ├── d_batsugun.cpp
    │   ├── d_battleg.cpp
    │   ├── d_bbakraid.cpp
    │   ├── d_dogyuun.cpp
    │   ├── d_hellfire.cpp
    │   ├── d_kbash.cpp
    │   ├── d_mahoudai.cpp
    │   ├── d_outzone.cpp
    │   ├── d_shippumd.cpp
    │   ├── d_snowbro2.cpp
    │   ├── d_tekipaki.cpp
    │   ├── d_truxton.cpp
    │   ├── d_truxton2.cpp
    │   ├── d_vfive.cpp
    │   ├── d_zerowing.cpp
    │   ├── toa_bcu2.cpp
    │   ├── toa_extratext.cpp
    │   ├── toa_extratext.h
    │   ├── toa_gp9001.cpp
    │   ├── toa_gp9001_func.h
    │   ├── toa_gp9001_func_table.h
    │   ├── toa_gp9001_render.h
    │   ├── toa_palette.cpp
    │   ├── toaplan.cpp
    │   ├── toaplan.h
    │   └── toaplan1.cpp
    ├── version.h
    ├── vez.cpp
    ├── vez.h
    ├── ym2151.c
    ├── ym2151.h
    ├── ymdeltat.c
    ├── ymdeltat.h
    ├── ymf278b.c
    ├── ymf278b.h
    ├── ymz280b.cpp
    ├── ymz280b.h
    ├── zet.cpp
    └── zet.h
├── capex.cfg.template
├── cpu
    ├── a68k
    │   └── fba_make68k.c
    ├── cyclone
    │   ├── Cyclone.txt
    │   ├── cyclone.h
    │   └── cyclone.s
    ├── cz80
    │   ├── cz80.c
    │   ├── cz80.h
    │   ├── cz80_op.c
    │   ├── cz80_opCB.c
    │   ├── cz80_opED.c
    │   ├── cz80_opXY.c
    │   ├── cz80_opXYCB.c
    │   ├── cz80jmp.c
    │   └── readme.txt
    ├── doze
    │   ├── dam.cpp
    │   ├── dam.h
    │   ├── dama.cpp
    │   ├── damc.cpp
    │   ├── dame.cpp
    │   ├── damf.cpp
    │   ├── damj.cpp
    │   ├── damm.cpp
    │   ├── damo.cpp
    │   ├── damt.cpp
    │   ├── doze.cpp
    │   └── doze.h
    ├── drz80
    │   ├── DrZ80.h
    │   ├── DrZ80.org.s
    │   ├── DrZ80.s
    │   ├── DrZ80.txt
    │   └── gpl.txt
    ├── m68k
    │   ├── m68k.h
    │   ├── m68k_in.c
    │   ├── m68kconf.h
    │   ├── m68kcpu.c
    │   ├── m68kcpu.h
    │   ├── m68kdasm.c
    │   └── m68kmake.c
    ├── nec
    │   ├── nec.cpp
    │   ├── nec.h
    │   ├── necea.h
    │   ├── necinstr.h
    │   ├── necintrf.h
    │   └── necmodrm.h
    ├── sh2
    │   ├── mksh2.cpp
    │   ├── sh2.cpp
    │   └── sh2.h
    └── z80
    │   ├── z80.cpp
    │   ├── z80.h
    │   ├── z80daisy.cpp
    │   └── z80daisy.h
├── fba2x.cfg.template
├── fba_029671_clrmame_dat.zip
├── install.sh
├── readme.txt
├── rominfo.fba
├── rpi
    ├── boolean.h
    ├── burner.h
    ├── bzip.cpp
    ├── cache.cpp
    ├── cache.h
    ├── config.h
    ├── configfile.h
    ├── drv.cpp
    ├── fba_player.cpp
    ├── fba_player.h
    ├── fifo_buffer.c
    ├── fifo_buffer.h
    ├── font.cpp
    ├── font.h
    ├── gamewidget.cpp
    ├── gamewidget.h
    ├── gles2.cpp
    ├── gp2xsdk.cpp
    ├── gp2xsdk.h
    ├── input.cpp
    ├── main.cpp
    ├── main.h
    ├── moose.h
    ├── run.cpp
    ├── snd.cpp
    ├── snd.h
    ├── state.cpp
    ├── statec.cpp
    ├── thread.c
    ├── thread.h
    ├── unzip.c
    ├── unzip.h
    ├── zconf.h
    ├── zipfn.cpp
    └── zlib.h
├── skin
    ├── capex_bg.bmp
    ├── capex_selector.bmp
    ├── capex_title.bmp
    └── gfx_FONT.bmp
├── zipit
└── zipname.fba


/FBACache_windows.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBACache_windows.zip


--------------------------------------------------------------------------------
/FBAcapex_src/GFX/gfx_BG.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/GFX/gfx_BG.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/GFX/gfx_CAPEX.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/GFX/gfx_CAPEX.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/GFX/gfx_FONT.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/GFX/gfx_FONT.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/GFX/gfx_SELECTEUR.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/GFX/gfx_SELECTEUR.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/Makefile:
--------------------------------------------------------------------------------
 1 | # Comilation file for RPI
 2 | PROG_NAME = ../fbacapex
 3 | OBJS = capex.o
 4 | LDFLAGS = 
 5 | 
 6 | CC = gcc
 7 | CXX = g++
 8 | STRIP = strip
 9 | 
10 | # output from sdl-config
11 | SDL_FLAGS=-I/usr/include/SDL -I/usr/include/glib-2.0 -I/usr/lib/arm-linux-gnueabihf/glib-2.0/include \
12 | 	-I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads \
13 |     -I/opt/vc/include/interface/vmcs_host/linux
14 | SDL_LIBS=-lSDL -lm -ldl -lglib-2.0
15 | 
16 | CFLAGS = $(SDL_FLAGS) -O2 -funroll-loops -Wextra -Werror
17 | CXXFLAGS = $(SDL_FLAGS) -O2 -funroll-loops -Wall
18 | LIBS = $(SDL_LIBS)  -L/opt/vc/lib -lbcm_host -lbrcmGLESv2 -lrt
19 | 
20 | TARGET = $(PROG_NAME)
21 | 
22 | all : $(TARGET)
23 | 
24 | $(TARGET) : $(OBJS)
25 | 	$(CXX) $(LDFLAGS) -o $(TARGET) $(OBJS) $(LIBS)
26 | #	$(STRIP) $(TARGET)
27 | 
28 | clean:
29 | 	/bin/rm -rf *~ *.o $(TARGET)
30 | 


--------------------------------------------------------------------------------
/FBAcapex_src/Makefile.debug:
--------------------------------------------------------------------------------
 1 | # Comilation file for RPI
 2 | PROG_NAME = ../fbacapex.debug
 3 | OBJS = capex.o
 4 | LDFLAGS = -g
 5 | 
 6 | CC = gcc
 7 | CXX = g++
 8 | STRIP = strip
 9 | 
10 | # output from sdl-config
11 | SDL_FLAGS=-I/usr/include/SDL -I/usr/include/glib-2.0 -I/usr/lib/arm-linux-gnueabihf/glib-2.0/include \
12 | 	-I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads \
13 |     -I/opt/vc/include/interface/vmcs_host/linux
14 | SDL_LIBS=-lSDL -lm -ldl -lglib-2.0
15 | 
16 | CFLAGS = $(SDL_FLAGS) -g -funroll-loops -Wextra -Werror
17 | CXXFLAGS = $(SDL_FLAGS) -g -funroll-loops -Wall
18 | LIBS = $(SDL_LIBS)  -L/opt/vc/lib -lbcm_host -lbrcmGLESv2
19 | 
20 | TARGET = $(PROG_NAME)
21 | 
22 | all : $(TARGET)
23 | 
24 | $(TARGET) : $(OBJS)
25 | 	$(CXX) $(LDFLAGS) -o $(TARGET) $(OBJS) $(LIBS)
26 | #	$(STRIP) $(TARGET)
27 | 
28 | clean:
29 | 	/bin/rm -rf *~ *.o $(TARGET)
30 | 


--------------------------------------------------------------------------------
/FBAcapex_src/README-FBACAPEX:
--------------------------------------------------------------------------------
 1 | CAPEX frontend by JYCET and Juanvvc
 2 | for Fireburn Alpha emulator by Headoverheels
 3 | 
 4 | UP/DOWN/LEFT/RIGHT = scroll in the list
 5 | A = Launch a rom (all except RED)
 6 | X = help screen
 7 | SELECT = options window
 8 | START (double) = quit
 9 | 
10 | ROMS COLOR:
11 | RED = missing
12 | ORANGE = clone rom detected
13 | YELLOW = parent rom detected or clone rom detected & parent rom detected
14 | GREEN = clone rom detected & parent rom detected & cache detected
15 | BLUE = parent rom detected & cache detected
16 | 
17 | Extract all in your Fba2x folder and launch fbacapex.gpe !
18 | FBACAPEX.GPE need:
19 | -emulator fba2x in the same folder
20 | -file zipname.fba
21 | -file rominfo.fba
22 | -folder ./preview/ (empty if you want)
23 | -folder ./conf/
24 | Optional
25 | -file fbacapex.png (icon)
26 | -file README and COPYING (this file)
27 | -folder and files ./skin/... (but better :) )
28 | 
29 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
30 | 
31 | v0.7b3:
32 | - first adaptation from capex 0.6 for CPS2emu by JYCET
33 | - beta testers: Dullyboy, Haohmaru, Headoverheels, Jurk anv Rivroner.
34 | 


--------------------------------------------------------------------------------
/FBAcapex_src/capex.cfg:
--------------------------------------------------------------------------------
 1 | # CAPEX config file v1.1
 2 | 
 3 | # FBA2X OPTIONS
 4 | 
 5 | fba2x_sound 1
 6 | fba2x_samplerate 44100
 7 | fba2x_showfps 0
 8 | fba2x_hiscore 1
 9 | 
10 | # CAPEX OPTIONS
11 | 
12 | capex_list 0
13 | capex_sely 239
14 | capex_selnum 0
15 | capex_seloffset_num 0
16 | 


--------------------------------------------------------------------------------
/FBAcapex_src/capex_pixel.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/capex_pixel.h


--------------------------------------------------------------------------------
/FBAcapex_src/capex_tri.h:
--------------------------------------------------------------------------------
 1 | /*  CAPEX for GP2X
 2 | 
 3 |     Copyright (C) 2007  JyCet
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License
16 |     along with this program; if not, write to the Free Software
17 |     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18 | */
19 | 
20 | //algo de tri alphabetique
21 | void tri_alphabeticAZ(unsigned int minimun, unsigned int maximum)
22 | {
23 | 	//unsigned int longueur;
24 | 	unsigned int tampon,ligne1,ligne2;
25 | 	unsigned int min;
26 | 	
27 | 	//tri des dossiers en premier	
28 | 	for (ligne1=minimun;ligne1<maximum-1;++ligne1){
29 | 		min=ligne1;
30 | 		for (ligne2=ligne1+1;ligne2<maximum;++ligne2){
31 | 			if (strcmp( data.name[listing_tri[0][ligne2]] , data.name[listing_tri[0][min]] ) <0 ) {
32 | 				min=ligne2;
33 | 			}
34 | 		}
35 | 		if (min!=ligne1){
36 | 			tampon=listing_tri[0][ligne1];
37 | 			listing_tri[0][ligne1]=listing_tri[0][min];
38 | 			listing_tri[0][min]=tampon;
39 | 		}
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/FBAcapex_src/capex_write.h:
--------------------------------------------------------------------------------
 1 | /*  CAPEX for GP2X
 2 | 
 3 |     Copyright (C) 2007  JyCet
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License
16 |     along with this program; if not, write to the Free Software
17 |     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18 | */
19 | 
20 | void write_cfg()
21 | {
22 | 	FILE *fp;
23 | 
24 | 	fp = fopen("capex.cfg", "w");
25 | 
26 | 	fputs("# CAPEX config file v1.1\n",fp);
27 | 	fputs("\n",fp);
28 | 	
29 | 	fputs("# FBA2X OPTIONS\n",fp);
30 | 	fputs("\n",fp);
31 | 	sprintf((char*)g_string, "fba2x_sound %d\n",options.sound);
32 | 	fputs(g_string,fp);
33 | 	sprintf((char*)g_string, "fba2x_samplerate %d\n",options.samplerate);
34 | 	fputs(g_string,fp);
35 | //	sprintf((char*)g_string, "fba2x_rescale %d\n",options.rescale);
36 | //	fputs(g_string,fp);
37 | 	sprintf((char*)g_string, "fba2x_showfps %d\n",options.showfps);
38 | 	fputs(g_string,fp);
39 | 
40 | 	fputs("\n",fp);
41 | 	
42 | 	fputs("# CAPEX OPTIONS\n",fp);
43 | 	fputs("\n",fp);
44 | 	sprintf((char*)g_string, "capex_list %d\n",capex.list);
45 | 	fputs(g_string,fp);
46 | 	sprintf((char*)g_string, "capex_sely %d\n",capex.sely);
47 | 	fputs(g_string,fp);
48 | 	sprintf((char*)g_string, "capex_selnum %d\n",capex.selnum);
49 | 	fputs(g_string,fp);
50 | 	sprintf((char*)g_string, "capex_seloffset_num %d\n",capex.seloffset_num);
51 | 	fputs(g_string,fp);
52 | 
53 | 	fclose(fp);
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/FBAcapex_src/fba_splash.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/fba_splash.png


--------------------------------------------------------------------------------
/FBAcapex_src/gamelist.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python
 2 | # -*- coding: utf-8 -*-
 3 | # 
 4 | # Takes gamelist.txt (output from the compilation of fba) and generates
 5 | # zipname.fba and rominfo.fba for capex for fba2x
 6 | #
 7 | # Copyright (C) 2007 Juanvi juanvvc@hotmail,com
 8 | # This program is free software; you can redistribute it and/or modify
 9 | # it under the terms of the GNU General Public License as published by
10 | # the Free Software Foundation; either version 2 of the License, or
11 | # (at your option) any later version.
12 | #
13 | # This program is distributed in the hope that it will be useful,
14 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 | # GNU General Public License for more details.
17 | #
18 | # You should have received a copy of the GNU General Public License along
19 | # with this program; if not, write to the Free Software Foundation, Inc.,
20 | # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 | 
22 | import re
23 | 
24 | gl = open('gamelist.txt','r')
25 | zn = open('zipname.fba','w')
26 | ri = open('rominfo.fba','w')
27 | 
28 | started = False
29 | for l in gl:
30 | 	if l.startswith('+-----'):
31 | 		started = not started
32 | 		if started:
33 | 			print 'Gamelist starts'
34 | 		else:
35 | 			print 'Gamelist ends'
36 | 		continue
37 | 	if started:
38 | 		fields = l.split('|')
39 | 		# removes first field (always empty since line starts with |)
40 | 		fields.pop(0)
41 | 		# remove leading and trailing spaces in fields
42 | 		for i in range(0, len(fields)): fields[i] = fields[i].strip(' \t')
43 | 		print 'Data for ' + fields[2].replace(',','')
44 | 		# save data if the rom works (no info in second column)
45 | 		if not fields[1]:
46 | 			zn.write('%s,%s,%s %s\n'%(fields[0], fields[2].replace(',',''), fields[4], fields[5]))
47 | 			parent='fba'
48 | 			if fields[3]: parent=fields[3]
49 | 			ri.write('FILENAME( %s %s %s "%s" )\n'%(fields[0], parent, fields[4], fields[5]))
50 | 
51 | gl.close()
52 | zn.close()
53 | ri.close()
54 | 


--------------------------------------------------------------------------------
/FBAcapex_src/gfx_FONT.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/gfx_FONT.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/keyconstants.h:
--------------------------------------------------------------------------------
 1 | 
 2 | // Default key and joystick mappings
 3 | 
 4 | enum {
 5 |     GP2X_UP=0x1,
 6 |     GP2X_UP_LEFT=1<<1,
 7 |     GP2X_LEFT=1<<2,
 8 |     GP2X_DOWN_LEFT=1<<3,
 9 |     GP2X_DOWN=1<<4,
10 |     GP2X_DOWN_RIGHT=1<<5,
11 |     GP2X_RIGHT=1<<6,
12 |     GP2X_UP_RIGHT=1<<7,
13 |     GP2X_START=1<<8,
14 |     GP2X_SELECT=1<<9,
15 |     GP2X_L=1<<10,
16 |     GP2X_R=1<<11,
17 |     GP2X_A=1<<12,
18 |     GP2X_B=1<<13,
19 |     GP2X_X=1<<14,
20 |     GP2X_Y=1<<15,
21 |     GP2X_ESCAPE=1<<16
22 | };
23 | 
24 | #define RPI_KEY_A       SDLK_LCTRL
25 | #define RPI_KEY_B       SDLK_SPACE
26 | #define RPI_KEY_X       SDLK_LALT
27 | #define RPI_KEY_Y       SDLK_LSHIFT
28 | #define RPI_KEY_L       SDLK_z
29 | #define RPI_KEY_R       SDLK_x
30 | #define RPI_KEY_START   SDLK_RETURN
31 | #define RPI_KEY_SELECT  SDLK_TAB
32 | #define RPI_KEY_LEFT    SDLK_LEFT
33 | #define RPI_KEY_RIGHT   SDLK_RIGHT
34 | #define RPI_KEY_UP      SDLK_UP
35 | #define RPI_KEY_DOWN    SDLK_DOWN
36 | #define RPI_KEY_QUIT    SDLK_ESCAPE
37 | #define RPI_KEY_ACCEL   SDLK_BACKSPACE
38 | 
39 | #define RPI_JOY_A       3
40 | #define RPI_JOY_B       2
41 | #define RPI_JOY_X       1
42 | #define RPI_JOY_Y       0
43 | #define RPI_JOY_L       4
44 | #define RPI_JOY_R       6
45 | #define RPI_JOY_START   9
46 | #define RPI_JOY_SELECT  8
47 | #define RPI_JOY_QUIT    5
48 | #define RPI_JOY_ACCEL   7
49 | #define RPI_JOY_QLOAD   10
50 | #define RPI_JOY_QSAVE   11
51 | 
52 | #define A_1 0
53 | #define B_1 1
54 | #define X_1 2
55 | #define Y_1 3
56 | #define L_1 4
57 | #define R_1 5
58 | #define A_2 6
59 | #define B_2 7
60 | #define X_2 8
61 | #define Y_2 9
62 | #define L_2 10
63 | #define R_2 11
64 | #define START_1 12
65 | #define SELECT_1 13
66 | #define START_2 14
67 | #define SELECT_2 15
68 | #define UP_1 16
69 | #define DOWN_1 17
70 | #define LEFT_1 18
71 | #define RIGHT_1 19
72 | #define UP_2 20
73 | #define DOWN_2 21
74 | #define LEFT_2 22
75 | #define RIGHT_2 23
76 | #define LU_2 24
77 | #define LD_2 25
78 | #define RU_2 26
79 | #define RD_2 27
80 | 
81 | #define ACCEL 50
82 | #define QUIT 51
83 | #define HELP 52
84 | 
85 | #define QLOAD 55
86 | #define QSAVE 56
87 | 
88 | #define SHIFTL 30
89 | #define SHIFTR 31
90 | #define CTRLL 32
91 | #define CTRLR 33
92 | 
93 | // Axis positions
94 | #define CENTER  0
95 | #define LEFT    1
96 | #define RIGHT   2
97 | #define UP      1
98 | #define DOWN    2
99 | 


--------------------------------------------------------------------------------
/FBAcapex_src/skin/capex_bg.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/skin/capex_bg.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/skin/capex_selector.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/skin/capex_selector.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/skin/capex_title.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/skin/capex_title.bmp


--------------------------------------------------------------------------------
/FBAcapex_src/skin/fba_splash.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/skin/fba_splash.png


--------------------------------------------------------------------------------
/FBAcapex_src/skin/gfx_FONT.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/FBAcapex_src/skin/gfx_FONT.bmp


--------------------------------------------------------------------------------
/burn/ay8910.h:
--------------------------------------------------------------------------------
 1 | #ifndef AY8910_H
 2 | #define AY8910_H
 3 | 
 4 | #define MAX_8910 5
 5 | #define ALL_8910_CHANNELS -1
 6 | 
 7 | struct AY8910interface
 8 | {
 9 | 	int num;	/* total number of 8910 in the machine */
10 | 	int baseclock;
11 | 	int mixing_level[MAX_8910];
12 |     read8_handler portAread[MAX_8910];
13 |     read8_handler portBread[MAX_8910];
14 |     write8_handler portAwrite[MAX_8910];
15 |     write8_handler portBwrite[MAX_8910];
16 | 	void (*handler[MAX_8910])(int irq);	/* IRQ handler for the YM2203 */
17 | };
18 | 
19 | extern int ay8910_index_ym;
20 | 
21 | void AY8910_set_clock(int chip, int clock);
22 | void AY8910Reset(int chip);
23 | 
24 | void AY8910Update(int chip, INT16** buffer, int length);
25 | 
26 | void AY8910Write(int chip, int a, int data);
27 | int AY8910Read(int chip);
28 | 
29 | void AY8910Reset(int chip);
30 | void AY8910Exit(int chip);
31 | int AY8910Init(int chip, int clock, int sample_rate,
32 | 		read8_handler portAread, read8_handler portBread,
33 | 		write8_handler portAwrite, write8_handler portBwrite);
34 | 
35 | int AY8910InitYM(int chip, int clock, int sample_rate,
36 | 		read8_handler portAread, read8_handler portBread,
37 | 		write8_handler portAwrite, write8_handler portBwrite,
38 | 		void (*update_callback)(void));
39 | 
40 | int AY8910Scan(int nAction, int* pnMin);
41 | 
42 | #endif
43 | 


--------------------------------------------------------------------------------
/burn/burn_sound.cpp:
--------------------------------------------------------------------------------
 1 | #include "burnint.h"
 2 | #include "burn_sound.h"
 3 | 
 4 | short Precalc[4096 *4];
 5 | 
 6 | // Routine used to precalculate the table used for interpolation
 7 | int cmc_4p_Precalc()
 8 | {
 9 | 	int a, x, x2, x3;
10 | 
11 | 	for (a = 0; a < 4096; a++) {
12 | 		x  = a  * 4;			// x = 0..16384
13 | 		x2 = x  * x / 16384;	// pow(x, 2);
14 | 		x3 = x2 * x / 16384;	// pow(x, 3);
15 | 
16 | 		Precalc[a * 4 + 0] = (short)(-x / 3 + x2 / 2 - x3 / 6);
17 | 		Precalc[a * 4 + 1] = (short)(-x / 2 - x2     + x3 / 2 + 16384);
18 | 		Precalc[a * 4 + 2] = (short)( x     + x2 / 2 - x3 / 2);
19 | 		Precalc[a * 4 + 3] = (short)(-x / 6 + x3 / 6);
20 | 	}
21 | 
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/burn/burn_sound.h:
--------------------------------------------------------------------------------
 1 | // burn_sound.h - General sound support functions
 2 | // based on code by Daniel Moreno (ComaC) < comac2k@teleline.es >
 3 | 
 4 | extern "C" {
 5 | 	int __cdecl ChannelMix_QS_A(int* Dest, int nLen,
 6 | 								char* Sample, int LoopEnd,
 7 | 								int* Pos,
 8 | 								int VolL, int VolR,
 9 | 								int LoopLen,
10 | 								int IncPos,
11 | 								char* EndBuff);
12 | 
13 | 	void __cdecl BurnSoundCopyClamp_A(int* Src, short* Dest, int Len);
14 | 	void __cdecl BurnSoundCopyClamp_Add_A(int* Src, short* Dest, int Len);
15 | 
16 | 	void __cdecl BurnSoundCopyClamp_Mono_A(int* Src, short* Dest, int Len);
17 | 	void __cdecl BurnSoundCopyClamp_Mono_Add_A(int* Src, short* Dest, int Len);
18 | 
19 | 	void __cdecl BurnSoundCopy_FM_A(short* SrcL, short* SrcR, short* Dest, int Len, int VolL, int VolR);
20 | 	void __cdecl BurnSoundCopy_FM_Add_A(short* SrcL, short* SrcR, short* Dest, int Len, int VolL, int VolR);
21 | 
22 | 	/* SrcOPN should have left channel data at SrcOPN, right channel at SrcOPN + 4096, SrcPSG should have all summed channels */
23 | 	void __cdecl BurnSoundCopy_FM_OPN_A(short* SrcOPN, int* SrcPSG, short* Dest, int Len, int VolPSGL, int VolPSGR);
24 | }
25 | 
26 | void BurnSoundCopyClamp_C(int* Src, short* Dest, int Len);
27 | void BurnSoundCopyClamp_Add_C(int* Src, short* Dest, int Len);
28 | void BurnSoundCopyClamp_Mono_C(int* Src, short* Dest, int Len);
29 | void BurnSoundCopyClamp_Mono_Add_C(int* Src, short* Dest, int Len);
30 | void BurnSoundCopyClamp_MonoMono_C(int* Src, short* Dest, int Len);
31 | void BurnSoundCopyClamp_MonoMono_Add_C(int* Src, short* Dest, int Len);
32 | 
33 | extern int cmc_4p_Precalc();
34 | 
35 | #ifdef __ELF__
36 |  #define Precalc _Precalc
37 | #endif
38 | 
39 | extern "C" short Precalc[];
40 | 
41 | #define INTERPOLATE4PS_8BIT(fp, sN, s0, s1, s2)      (((int)((sN) * Precalc[(int)(fp) * 4 + 0]) + (int)((s0) * Precalc[(int)(fp) * 4 + 1]) + (int)((s1) * Precalc[(int)(fp) * 4 + 2]) + (int)((s2) * Precalc[(int)(fp) * 4 + 3])) / 64)
42 | #define INTERPOLATE4PS_16BIT(fp, sN, s0, s1, s2)     (((int)((sN) * Precalc[(int)(fp) * 4 + 0]) + (int)((s0) * Precalc[(int)(fp) * 4 + 1]) + (int)((s1) * Precalc[(int)(fp) * 4 + 2]) + (int)((s2) * Precalc[(int)(fp) * 4 + 3])) / 16384)
43 | #define INTERPOLATE4PS_CUSTOM(fp, sN, s0, s1, s2, v) (((int)((sN) * Precalc[(int)(fp) * 4 + 0]) + (int)((s0) * Precalc[(int)(fp) * 4 + 1]) + (int)((s1) * Precalc[(int)(fp) * 4 + 2]) + (int)((s2) * Precalc[(int)(fp) * 4 + 3])) / (int)(v))
44 | 
45 | #define INTERPOLATE4PU_8BIT(fp, sN, s0, s1, s2)      (((unsigned int)((sN) * Precalc[(int)(fp) * 4 + 0]) + (unsigned int)((s0) * Precalc[(int)(fp) * 4 + 1]) + (unsigned int)((s1) * Precalc[(int)(fp) * 4 + 2]) + (unsigned int)((s2) * Precalc[(int)(fp) * 4 + 3])) / 64)
46 | #define INTERPOLATE4PU_16BIT(fp, sN, s0, s1, s2)     (((unsigned int)((sN) * Precalc[(int)(fp) * 4 + 0]) + (unsigned int)((s0) * Precalc[(int)(fp) * 4 + 1]) + (unsigned int)((s1) * Precalc[(int)(fp) * 4 + 2]) + (unsigned int)((s2) * Precalc[(int)(fp) * 4 + 3])) / 16384)
47 | #define INTERPOLATE4PU_CUSTOM(fp, sN, s0, s1, s2, v) (((unsigned int)((sN) * Precalc[(int)(fp) * 4 + 0]) + (unsigned int)((s0) * Precalc[(int)(fp) * 4 + 1]) + (unsigned int)((s1) * Precalc[(int)(fp) * 4 + 2]) + (unsigned int)((s2) * Precalc[(int)(fp) * 4 + 3])) / (unsigned int)(v))
48 | 
49 | #ifdef USE_IWMMXT
50 | // ----- Intel xScale iwMMXt optimize by OopsWare -------
51 | extern "C" {
52 | 	void BurnSoundCopyClamp_iwMMXt(int* Src, short* Dest, int Len);
53 | 	void BurnSoundCopyClamp_Add_iwMMXt(int* Src, short* Dest, int Len);
54 | 
55 | 	void BurnSoundCopyClamp_Mono_iwMMXt(int* Src, short* Dest, int Len);
56 | 	void BurnSoundCopyClamp_Mono_Add_iwMMXt(int* Src, short* Dest, int Len);
57 | 	
58 | 	void BurnSoundCopy_FM_iwMMXt(short ** Src, short* Dest, int Len, int Vol);
59 | 	
60 | 	void BurnSoundCopy_FM_OPN_iwMMXt(short* SrcOPN, short* Dest, int Len);
61 | 
62 | };
63 | #endif
64 | 
65 | 


--------------------------------------------------------------------------------
/burn/burn_sound_c.cpp:
--------------------------------------------------------------------------------
 1 | #include "burnint.h"
 2 | #include "burn_sound.h"
 3 | 
 4 | #define CLIP(A) ((A) < -0x8000 ? -0x8000 : (A) > 0x7fff ? 0x7fff : (A))
 5 | 
 6 | void BurnSoundCopyClamp_C(int *Src, short *Dest, int Len)
 7 | {
 8 | 	Len *= 2;
 9 | 	while (Len--) {
10 | 		*Dest = CLIP((*Src >> 8));
11 | 		Src++;
12 | 		Dest++;
13 | 	}
14 | }
15 | 
16 | void BurnSoundCopyClamp_Add_C(int *Src, short *Dest, int Len)
17 | {
18 | 	Len *= 2;
19 | 	while (Len--) {
20 | 		*Dest = CLIP((*Src >> 8) + *Dest);
21 | 		Src++;
22 | 		Dest++;
23 | 	}
24 | }
25 | 
26 | void BurnSoundCopyClamp_Mono_C(int *Src, short *Dest, int Len)
27 | {
28 | 	while (Len--) {
29 | 		Dest[0] = CLIP((*Src >> 8));
30 | 		Dest[1] = CLIP((*Src >> 8));
31 | 		Src++;
32 | 		Dest += 2;
33 | 	}
34 | }
35 | 
36 | void BurnSoundCopyClamp_Mono_Add_C(int *Src, short *Dest, int Len)
37 | {
38 | 	while (Len--) {
39 | 		Dest[0] = CLIP((*Src >> 8) + Dest[0]);
40 | 		Dest[1] = CLIP((*Src >> 8) + Dest[1]);
41 | 		Src++;
42 | 		Dest += 2;
43 | 	}
44 | }
45 | 
46 | #undef CLIP
47 | 


--------------------------------------------------------------------------------
/burn/burn_ym2151.h:
--------------------------------------------------------------------------------
 1 | // burn_ym2151.h
 2 | #include "driver.h"
 3 | extern "C" {
 4 |  #include "ym2151.h"
 5 | }
 6 | 
 7 | int BurnYM2151Init(int nClockFrequency, float nVolume);
 8 | void BurnYM2151Reset();
 9 | void BurnYM2151Exit();
10 | extern void (*BurnYM2151Render)(short* pSoundBuf, int nSegmentLength);
11 | void BurnYM2151Scan(int nAction);
12 | 
13 | static inline void BurnYM2151SelectRegister(const unsigned char nRegister)
14 | {
15 | 	extern unsigned int nBurnCurrentYM2151Register;
16 | 
17 | 	nBurnCurrentYM2151Register = nRegister;
18 | }
19 | 
20 | static inline void BurnYM2151WriteRegister(const unsigned char nValue)
21 | {
22 | 	extern unsigned int nBurnCurrentYM2151Register;
23 | 	extern unsigned char BurnYM2151Registers[0x0100];
24 | 
25 | 	BurnYM2151Registers[nBurnCurrentYM2151Register] = nValue;
26 | 	YM2151WriteReg(0, nBurnCurrentYM2151Register, nValue);
27 | }
28 | 
29 | #define BurnYM2151ReadStatus() YM2151ReadStatus(0)
30 | #define BurnYM2151SetIrqHandler(h) YM2151SetIrqHandler(0, h)
31 | #define BurnYM2151SetPortHandler(h) YM2151SetPortWriteHandler(0, h)
32 | 
33 | 


--------------------------------------------------------------------------------
/burn/burn_ym2203.h:
--------------------------------------------------------------------------------
 1 | // burn_ym2203.h
 2 | #include "driver.h"
 3 | extern "C" {
 4 |  #include "ay8910.h"
 5 |  #include "fm.h"
 6 | }
 7 | #include "timer.h"
 8 | 
 9 | extern "C" void BurnYM2203UpdateRequest();
10 | 
11 | int BurnYM2203Init(int num, int nClockFrequency, FM_IRQHANDLER IRQCallback, int (*StreamCallback)(int), double (*GetTimeCallback)(), int bAddSignal);
12 | void BurnYM2203Reset();
13 | void BurnYM2203Exit();
14 | extern void (*BurnYM2203Update)(short* pSoundBuf, int nSegmentEnd);
15 | void BurnYM2203Scan(int nAction, int* pnMin);
16 | 
17 | #define BurnYM2203Write(i, a, n) YM2203Write(i, a, n)
18 | #define BurnYM2203Read(i, a) YM2203Read(i, a)
19 | 
20 | 


--------------------------------------------------------------------------------
/burn/burn_ym2608.h:
--------------------------------------------------------------------------------
 1 | // burn_ym2608.h
 2 | #include "driver.h"
 3 | extern "C" {
 4 |  #include "ay8910.h"
 5 |  #include "fm.h"
 6 | }
 7 | #include "timer.h"
 8 | 
 9 | extern "C" void BurnYM2608UpdateRequest();
10 | 
11 | int BurnYM2608Init(int nClockFrequency, unsigned char* YM2608ADPCMROM, int* nYM2608ADPCMSize, FM_IRQHANDLER IRQCallback, int (*StreamCallback)(int), double (*GetTimeCallback)());
12 | void BurnYM2608Reset();
13 | void BurnYM2608Exit();
14 | extern void (*BurnYM2608Update)(int nSegmentEnd);
15 | void BurnYM2608Scan(int nAction, int* pnMin);
16 | 
17 | #define BurnYM2608Write(a, n) YM2608Write(0, a, n)
18 | #define BurnYM2608Read(a) YM2608Read(0, a)
19 | 
20 | 


--------------------------------------------------------------------------------
/burn/burn_ym2610.h:
--------------------------------------------------------------------------------
 1 | // burn_ym2610.h
 2 | #include "driver.h"
 3 | extern "C" {
 4 |  #include "ay8910.h"
 5 |  #include "fm.h"
 6 | }
 7 | #include "timer.h"
 8 | 
 9 | extern "C" void BurnYM2610UpdateRequest();
10 | 
11 | int BurnYM2610Init(int nClockFrequency, unsigned char* YM2610ADPCMAROM, int* nYM2610ADPCMASize, unsigned char* YM2610ADPCMBROM, int* nYM2610ADPCMBSize, FM_IRQHANDLER IRQCallback, int (*StreamCallback)(int), double (*GetTimeCallback)());
12 | void BurnYM2610Reset();
13 | void BurnYM2610Exit();
14 | extern void (*BurnYM2610Update)(int nSegmentEnd);
15 | void BurnYM2610Scan(int nAction, int* pnMin);
16 | 
17 | #define BurnYM2610Write(a, n) YM2610Write(0, a, n)
18 | #define BurnYM2610Read(a) YM2610Read(0, a)
19 | 
20 | 


--------------------------------------------------------------------------------
/burn/burn_ym3812.h:
--------------------------------------------------------------------------------
 1 | #include "driver.h"
 2 | extern "C" {
 3 |  #include "fmopl.h"
 4 | }
 5 | #include "timer.h"
 6 | 
 7 | extern "C" void BurnYM3812UpdateRequest();
 8 | 
 9 | int BurnYM3812Init(int nClockFrequency, OPL_IRQHANDLER IRQCallback, int (*StreamCallback)(int));
10 | void BurnYM3812Reset();
11 | void BurnYM3812Exit();
12 | extern void (*BurnYM3812Update)(int nSegmentEnd);
13 | void BurnYM3812Scan(int nAction, int* pnMin);
14 | 
15 | #define BurnYM3812Write(a, n) YM3812Write(0, a, n)
16 | #define BurnYM3812Read(a) YM3812Read(0, a)
17 | 


--------------------------------------------------------------------------------
/burn/burn_ymf278b.h:
--------------------------------------------------------------------------------
 1 | #include "driver.h"
 2 | extern "C" {
 3 |  #include "ymf278b.h"
 4 | }
 5 | 
 6 | #include "timer.h"
 7 | 
 8 | void BurnYMF278BSelectRegister(int nRegister, unsigned char nValue);
 9 | void BurnYMF278BWriteRegister(int nRegister, unsigned char nValue);
10 | unsigned char BurnYMF278BReadStatus();
11 | unsigned char BurnYMF278BReadData();
12 | 
13 | int BurnYMF278BInit(int nClockFrequency, unsigned char* YMF278BROM, void (*IRQCallback)(int, int), int (*StreamCallback)(int));
14 | void BurnYMF278BReset();
15 | void BurnYMF278BExit();
16 | void BurnYMF278BUpdate(int nSegmentEnd);
17 | void BurnYMF278BScan(int nAction, int* pnMin);
18 | 
19 | 
20 | 


--------------------------------------------------------------------------------
/burn/burnint.h:
--------------------------------------------------------------------------------
 1 | // Burn - Arcade emulator library - internal code
 2 | 
 3 | // Standard headers
 4 | #include <stdarg.h>
 5 | #include <stdio.h>
 6 | #include <stdlib.h>
 7 | #include <string.h>
 8 | #include <assert.h>
 9 | 
10 | #include "tchar.h"
11 | #include "burn.h"
12 | 
13 | #ifndef MAX_PATH
14 |  #define MAX_PATH (260)
15 | #endif
16 | 
17 | // ---------------------------------------------------------------------------
18 | // CPU emulation interfaces
19 | 
20 | // sek.cpp
21 | #include "sek.h"
22 | 
23 | // zet.cpp
24 | #include "zet.h"
25 | 
26 | //sq #include "czet.h"
27 | // ---------------------------------------------------------------------------
28 | // Driver information
29 | 
30 | struct BurnDriver {
31 | 	char* szShortName;			// The filename of the zip file (without extension)
32 | 	char* szParent;				// The filename of the parent (without extension, NULL if not applicable)
33 | 	char* szBoardROM;			// The filename of the board ROMs (without extension, NULL if not applicable)
34 | 	char* szDate;
35 | 
36 | 	// szFullNameA, szCommentA, szManufacturerA and szSystemA should always contain valid info
37 | 	// szFullNameW, szCommentW, szManufacturerW and szSystemW should be used only if characters or scripts are needed that ASCII can't handle
38 | 	char*    szFullNameA; char*    szCommentA; char*    szManufacturerA; char*    szSystemA;
39 | 	wchar_t* szFullNameW; wchar_t* szCommentW; wchar_t* szManufacturerW; wchar_t* szSystemW;
40 | 
41 | 	int flags;			// See burn.h
42 | 	int players;		// Max number of players a game supports (so we can remove single player games from netplay)
43 | 	int hardware;		// Which type of hardware the game runs on
44 | 	int (*GetZipName)(char** pszName, unsigned int i);				// Function to get possible zip names
45 | 	int (*GetRomInfo)(struct BurnRomInfo* pri,unsigned int i);		// Function to get the length and crc of each rom
46 | 	int (*GetRomName)(char** pszName, unsigned int i, int nAka);	// Function to get the possible names for each rom
47 | 	int (*GetInputInfo)(struct BurnInputInfo* pii, unsigned int i);	// Function to get the input info for the game
48 | 	int (*GetDIPInfo)(struct BurnDIPInfo* pdi, unsigned int i);		// Function to get the input info for the game
49 | 	int (*Init)(); int (*Exit)(); int (*Frame)(); int (*Redraw)(); int (*AreaScan)(int nAction, int* pnMin);
50 | 	unsigned char* pRecalcPal;										// Set to 1 if the palette needs to be fully re-calculated
51 | 	int nWidth, nHeight; int nXAspect, nYAspect;					// Screen width, height, x/y aspect
52 | };
53 | 
54 | #define BurnDriverD BurnDriver		// Debug status
55 | #define BurnDriverX BurnDriver		// Exclude from build
56 | 
57 | // Standard functions for dealing with ROM and input info structures
58 | #include "stdfunc.h"
59 | 
60 | // ---------------------------------------------------------------------------
61 | 
62 | // burn.cpp
63 | int BurnSetRefreshRate(double dRefreshRate);
64 | int BurnByteswap(UINT8* pm,int nLen);
65 | int BurnClearScreen();
66 | 
67 | // load.cpp
68 | int BurnLoadRom(UINT8* Dest,int i, int nGap);
69 | int BurnXorRom(UINT8* Dest,int i, int nGap);
70 | int BurnLoadBitField(UINT8* pDest, UINT8* pSrc, int nField, int nSrcLen);
71 | 
72 | // ---------------------------------------------------------------------------
73 | // Colour-depth independant image transfer
74 | 
75 | extern unsigned short* pTransDraw;
76 | 
77 | void BurnTransferClear();
78 | int BurnTransferCopy(unsigned int* pPalette);
79 | void BurnTransferExit();
80 | int BurnTransferInit();
81 | 
82 | // ---------------------------------------------------------------------------
83 | // Plotting pixels
84 | 
85 | inline static void PutPix(UINT8* pPix, UINT32 c)
86 | {
87 | 	if (nBurnBpp >= 4) {
88 | 		*((UINT32*)pPix) = c;
89 | 	} else {
90 | 		if (nBurnBpp == 2) {
91 | 			*((UINT16*)pPix) = (UINT16)c;
92 | 		} else {
93 | 			pPix[0] = (UINT8)(c >>  0);
94 | 			pPix[1] = (UINT8)(c >>  8);
95 | 			pPix[2] = (UINT8)(c >> 16);
96 | 		}
97 | 	}
98 | }
99 | 


--------------------------------------------------------------------------------
/burn/capcom/cps_draw.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/burn/capcom/cps_draw.cpp


--------------------------------------------------------------------------------
/burn/capcom/ctv.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | // CPS Tile Variants
 4 | // horizontal/vertical clip rolls
 5 | unsigned int nCtvRollX=0,nCtvRollY=0;
 6 | // Add 0x7fff after each pixel/line
 7 | // If nRollX/Y&0x20004000 both == 0, you can draw the pixel
 8 | 
 9 | unsigned char *pCtvTile=NULL; // Pointer to tile data
10 | int nCtvTileAdd=0; // Amount to add after each tile line
11 | unsigned char *pCtvLine=NULL; // Pointer to output bitmap
12 | 
13 | // Include all tile variants:
14 | #include "ctv.h"
15 | 
16 | static int nLastBpp=0;
17 | int CtvReady()
18 | {
19 |   // Set up the CtvDoX functions to point to the correct bpp functions.
20 |   // Must be called before calling CpstOne
21 |   if (nBurnBpp!=nLastBpp)
22 |   {
23 | 	  if (nBurnBpp==2) {
24 | 		memcpy(CtvDoX,CtvDo2,sizeof(CtvDoX));
25 | 		memcpy(CtvDoXM,CtvDo2m,sizeof(CtvDoXM));
26 | 		memcpy(CtvDoXB,CtvDo2b,sizeof(CtvDoXB));
27 | 	  }
28 | 	  else if (nBurnBpp==3) {
29 | 		memcpy(CtvDoX,CtvDo3,sizeof(CtvDoX));
30 | 		memcpy(CtvDoXM,CtvDo3m,sizeof(CtvDoXM));
31 | 		memcpy(CtvDoXB,CtvDo3b,sizeof(CtvDoXB));
32 | 	  }
33 | 	  else if (nBurnBpp==4) {
34 | 		memcpy(CtvDoX,CtvDo4,sizeof(CtvDoX));
35 | 		memcpy(CtvDoXM,CtvDo4m,sizeof(CtvDoXM));
36 | 		memcpy(CtvDoXB,CtvDo4b,sizeof(CtvDoXB));
37 | 	  }
38 |   }
39 |   nLastBpp=nBurnBpp;
40 |   return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/burn/capcom/ctv_make.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | 
  3 | // Create the ctv.h header file
  4 | // which includes all combinations of the cps tile drawing functions
  5 | 
  6 | int main()
  7 | {
  8 |   int nCuMask=0;
  9 |   int nCuBpp=0;
 10 |   int nCuSize=0;
 11 |   int nCuRows=0;
 12 |   int nCuCare=0;
 13 |   int nCuFlipX=0;
 14 | 
 15 |   for (nCuMask=0; nCuMask<=2; nCuMask++)
 16 |   {
 17 |     printf ("#define CU_MASK  (%d)\n\n",nCuMask);
 18 |     for (nCuBpp=2; nCuBpp<=4; nCuBpp++)
 19 | 	{
 20 |       printf ("#define CU_BPP   (%d)\n\n",nCuBpp);
 21 |       for (nCuSize=8; nCuSize<=32; nCuSize<<=1)
 22 | 	  {
 23 |         printf ("#define CU_SIZE  (%d)\n\n",nCuSize);
 24 |         for (nCuRows=0; nCuRows<2; nCuRows++)
 25 | 		{
 26 |           printf ("#define CU_ROWS  (%d)\n\n",nCuRows);
 27 |           for (nCuCare=0; nCuCare<2; nCuCare++)
 28 | 		  {
 29 |             printf ("#define CU_CARE  (%d)\n",nCuCare);
 30 |             for (nCuFlipX=0; nCuFlipX<2; nCuFlipX++)
 31 | 			{
 32 |               printf ("#define CU_FLIPX (%d)\n",nCuFlipX);
 33 | 
 34 | 			  if ((nCuRows && (nCuSize != 16) || (nCuRows && nCuMask))) {
 35 | 				  printf("// Invalid combination of capabilities.\n");
 36 | 			  }	else {
 37 | 				printf ("static int ");
 38 | 				printf ("CtvDo");
 39 | 				printf ("%d",nCuBpp);
 40 | 				printf ("%.2d",nCuSize);
 41 | 					 if (nCuRows)  printf ("r"); else printf ("_");
 42 | 					 if (nCuCare)  printf ("c"); else printf ("_");
 43 | 					 if (nCuFlipX) printf ("f"); else printf ("_");
 44 | 					 if (nCuMask==1)  printf ("m()\n#include \"ctv_do.h\"\n");
 45 | 			    else if (nCuMask==2)  printf ("b()\n#include \"ctv_do.h\"\n");
 46 | 			    else                  printf ("_()\n#include \"ctv_do.h\"\n");
 47 | 			  }
 48 | 
 49 | 
 50 | 
 51 |               printf ("#undef  CU_FLIPX\n");
 52 | 			}
 53 |             printf ("#undef  CU_CARE\n\n");
 54 | 		  }
 55 |           printf ("#undef  CU_ROWS\n\n");
 56 | 		}
 57 |         printf ("#undef  CU_SIZE\n\n");
 58 | 	  }
 59 |       printf ("#undef  CU_BPP\n\n");
 60 | 	}
 61 | 	printf ("#undef  CU_MASK\n\n");
 62 |   }
 63 | 
 64 |   printf ("\n\n");
 65 | 
 66 |   printf ("// Filler function\n");
 67 |   printf ("static int CtvDo_______() { return 0; }\n\n\n\n");
 68 | 
 69 |   for (nCuMask=0; nCuMask<=2; nCuMask++)
 70 |   {
 71 |     for (nCuBpp=2; nCuBpp<=4; nCuBpp++)
 72 | 	{
 73 |       int i=0;
 74 | 
 75 |       if (nCuMask==1)
 76 |       {
 77 | 	     printf ("// Lookup table for %d bpp with Sprite Masking\n",nCuBpp);
 78 | 	     printf ("static CtvDoFn CtvDo%dm[0x20]={\n",nCuBpp);
 79 |       }
 80 |       else if (nCuMask==2)
 81 |       {
 82 | 	     printf ("// Lookup table for %d bpp with BgHi\n",nCuBpp);
 83 |          printf ("static CtvDoFn CtvDo%db[0x20]={\n",nCuBpp);
 84 |       }
 85 |       else
 86 |       {
 87 | 	     printf ("// Lookup table for %d bpp\n",nCuBpp);
 88 |          printf ("static CtvDoFn CtvDo%d[0x20]={\n",nCuBpp);
 89 |       }
 90 | 
 91 |       for (i=0;i<0x20;i++)
 92 | 	  {
 93 |         int s;
 94 |         printf ("CtvDo");
 95 | 
 96 |         s=(i&24)+8;
 97 |         if (s!=8 && s!=16 && s!=32) { printf ("_______"); goto End; }
 98 | 		if ((i&4) && (s!=16)) { printf ("_______"); goto End; }
 99 | 		if ((i&4) && nCuMask) { printf ("_______"); goto End; }
100 |         printf ("%d",nCuBpp);
101 |         printf ("%.2d",s);
102 |         if (i&4)     printf ("r"); else printf ("_");
103 |         if (i&2)     printf ("c"); else printf ("_");
104 |         if (i&1)     printf ("f"); else printf ("_");
105 | 		if (nCuMask==1) printf ("m");
106 |    else if (nCuMask==2) printf ("b");
107 |    else                 printf ("_");
108 | 
109 |       End:
110 |         printf (",");
111 |         if (((i+1)&3)==0) printf("\n");
112 | 	  }
113 |       printf ("};\n");
114 | 	}
115 |   }
116 | 
117 |   printf ("\n\n");
118 |   printf ("// Current BPP:\n");
119 |   printf ("CtvDoFn CtvDoX[0x20];\n");
120 |   printf ("CtvDoFn CtvDoXM[0x20];\n");
121 |   printf ("CtvDoFn CtvDoXB[0x20];\n");
122 |   printf ("\n\n");
123 | 
124 |   return 0;
125 | }
126 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_choko.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | static struct BurnInputInfo DrvInputList[] =
 4 | {
 5 | 	{"P1 Coin"       , BIT_DIGITAL, CpsInp020+4, "p1 coin"},
 6 | 	{"P1 Start"      , BIT_DIGITAL, CpsInp020+0, "p1 start"},
 7 | 	{"P1 Up"         , BIT_DIGITAL, CpsInp001+3, "p1 up"},
 8 | 	{"P1 Down"       , BIT_DIGITAL, CpsInp001+2, "p1 down"},
 9 | 	{"P1 Left"       , BIT_DIGITAL, CpsInp001+1, "p1 left"},
10 | 	{"P1 Right"      , BIT_DIGITAL, CpsInp001+0, "p1 right"},
11 | 	{"P1 Shot1"      , BIT_DIGITAL, CpsInp001+4, "p1 fire 1"},
12 | 	{"P1 Shot2"      , BIT_DIGITAL, CpsInp001+5, "p1 fire 2"},
13 | 	{"P1 Shot3"      , BIT_DIGITAL, CpsInp001+6, "p1 fire 3"},
14 | 
15 | 	{"P2 Coin"       , BIT_DIGITAL, CpsInp020+5, "p2 coin"},
16 | 
17 | 	{"Reset"         , BIT_DIGITAL, &CpsReset  , "reset"},
18 | 	{"Diagnostic"    , BIT_DIGITAL, CpsInp021+1, "diag"},
19 | 	{"Service"       , BIT_DIGITAL, CpsInp021+2, "service"},
20 | };
21 | 
22 | STDINPUTINFO(Drv);
23 | 
24 | static struct BurnRomInfo chokoRomDesc[] = {
25 | 	{ "tkoj.03",       0x080000, 0x11f5452f,  1 | BRF_ESS | BRF_PRG },
26 | 	{ "tkoj.04",       0x080000, 0x68655378,  1 | BRF_ESS | BRF_PRG },
27 | 
28 | 	{ "tkoj1_d.simm1", 0x200000, 0x6933377d, 11 | BRF_GRA },
29 | 	{ "tkoj1_c.simm1", 0x200000, 0x7f668950, 11 | BRF_GRA },
30 | 	{ "tkoj1_b.simm1", 0x200000, 0xcfb68ca9, 11 | BRF_GRA },
31 | 	{ "tkoj1_a.simm1", 0x200000, 0x437e21c5, 11 | BRF_GRA },
32 | 	{ "tkoj3_d.simm3", 0x200000, 0xa9e32b57, 11 | BRF_GRA },
33 | 	{ "tkoj3_c.simm3", 0x200000, 0xb7ab9338, 11 | BRF_GRA },
34 | 	{ "tkoj3_b.simm3", 0x200000, 0x4d3f919a, 11 | BRF_GRA },
35 | 	{ "tkoj3_a.simm3", 0x200000, 0xcfef17ab, 11 | BRF_GRA },
36 | 	
37 | 	{ "tko.01",        0x020000, 0x6eda50c2,  4 | BRF_ESS | BRF_PRG },
38 | 
39 | 	{ "tkoj5_a.simm5", 0x200000, 0xab45d509, 15 | BRF_SND },	
40 | 	{ "tkoj5_b.simm5", 0x200000, 0xfa905c3d, 15 | BRF_SND },	
41 | };
42 | 
43 | 
44 | STD_ROM_PICK(choko) STD_ROM_FN(choko)
45 | 
46 | struct BurnDriver BurnDrvCpsChoko = {
47 | 	"choko", NULL, NULL, "2001",
48 | 	"Choko (010820 Japan)\0", NULL, "Mitchell", "CPS2",
49 | 	L"\u9577\u6C5F (Choko 010820 Japan)\0", NULL, NULL, NULL,
50 | 	BDF_GAME_WORKING, 2, HARDWARE_CAPCOM_CPS2 | HARDWARE_CAPCOM_CPS2_SIMM,
51 | 	NULL, chokoRomInfo, chokoRomName, DrvInputInfo, NULL,
52 | 	Cps2Init,CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
53 | 	&CpsRecalcPal,384,224,4,3
54 | };
55 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_hsf2.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | STDINPUTINFOSPEC(Drv, CpsFsi);
 4 | 
 5 | static int DrvInit()
 6 | {
 7 | 	Ssf2t = 1;
 8 | 	
 9 | 	if (Cps2Init()) {
10 | 		return 1;
11 | 	}
12 | 
13 | 	nCpsGfxScroll[3] = 0;
14 | 
15 | 	return 0;
16 | }
17 | 
18 | static int DrvExit()
19 | {
20 | 	Ssf2t = 0;
21 | 
22 | 	return CpsExit();
23 | }
24 | 
25 | static struct BurnRomInfo hsf2RomDesc[] = {
26 | 	{ "hs2a.03",     0x080000, 0xd50a17e0, 1 | BRF_ESS | BRF_PRG },
27 | 	{ "hs2a.04",     0x080000, 0xa27f42de, 1 | BRF_ESS | BRF_PRG },
28 | 	{ "hs2.05",      0x080000, 0xdde34a35, 1 | BRF_ESS | BRF_PRG },
29 | 	{ "hs2.06",      0x080000, 0xf4e56dda, 1 | BRF_ESS | BRF_PRG },
30 | 	{ "hs2a.07",     0x080000, 0xee4420fc, 1 | BRF_ESS | BRF_PRG },
31 | 	{ "hs2.08",      0x080000, 0xc9441533, 1 | BRF_ESS | BRF_PRG },
32 | 	{ "hs2.09",      0x080000, 0x3fc638a8, 1 | BRF_ESS | BRF_PRG },
33 | 	{ "hs2.10",      0x080000, 0x20d0f9e4, 1 | BRF_ESS | BRF_PRG },
34 | 
35 | 	{ "hs2.13m",     0x800000, 0xa6ecab17, 3 | BRF_GRA },
36 | 	{ "hs2.15m",     0x800000, 0x10a0ae4d, 3 | BRF_GRA },
37 | 	{ "hs2.17m",     0x800000, 0xadfa7726, 3 | BRF_GRA },
38 | 	{ "hs2.19m",     0x800000, 0xbb3ae322, 3 | BRF_GRA },
39 | 
40 | 	{ "hs2.01",      0x020000, 0xc1a13786, 4 | BRF_ESS | BRF_PRG },
41 | 	{ "hs2.02",      0x020000, 0x2d8794aa, 4 | BRF_ESS | BRF_PRG },
42 | 
43 | 	{ "hs2.11m",     0x800000, 0x0e15c359, 5 | BRF_SND },
44 | };
45 | 
46 | 
47 | STD_ROM_PICK(hsf2) STD_ROM_FN(hsf2)
48 | 
49 | static struct BurnRomInfo hsf2jRomDesc[] = {
50 | 	{ "hs2j.03",     0x080000, 0x00738f73, 1 | BRF_ESS | BRF_PRG },
51 | 	{ "hs2j.04",     0x080000, 0x40072c4a, 1 | BRF_ESS | BRF_PRG },
52 | 	{ "hs2.05",      0x080000, 0xdde34a35, 1 | BRF_ESS | BRF_PRG },
53 | 	{ "hs2.06",      0x080000, 0xf4e56dda, 1 | BRF_ESS | BRF_PRG },
54 | 	{ "hs2j.07",     0x080000, 0x09fe85b4, 1 | BRF_ESS | BRF_PRG },
55 | 	{ "hs2.08",      0x080000, 0xc9441533, 1 | BRF_ESS | BRF_PRG },
56 | 	{ "hs2.09",      0x080000, 0x3fc638a8, 1 | BRF_ESS | BRF_PRG },
57 | 	{ "hs2.10",      0x080000, 0x20d0f9e4, 1 | BRF_ESS | BRF_PRG },
58 | 
59 | 	{ "hs2.13m" ,    0x800000, 0xa6ecab17, 3 | BRF_GRA },
60 | 	{ "hs2.15m",     0x800000, 0x10a0ae4d, 3 | BRF_GRA },
61 | 	{ "hs2.17m",     0x800000, 0xadfa7726, 3 | BRF_GRA },
62 | 	{ "hs2.19m",     0x800000, 0xbb3ae322, 3 | BRF_GRA },
63 | 
64 | 	{ "hs2.01",      0x020000, 0xc1a13786, 4 | BRF_ESS | BRF_PRG },
65 | 	{ "hs2.02",      0x020000, 0x2d8794aa, 4 | BRF_ESS | BRF_PRG },
66 | 
67 | 	{ "hs2.11m",     0x800000, 0x0e15c359, 5 | BRF_SND },
68 | };
69 | 
70 | 
71 | STD_ROM_PICK(hsf2j) STD_ROM_FN(hsf2j)
72 | 
73 | struct BurnDriver BurnDrvCpsHsf2 = {
74 | 	"hsf2", NULL, NULL, "2004",
75 | 	"Hyper Street Fighter 2: The Anniversary Edition (040202 Asia)\0", NULL, "Capcom", "CPS2",
76 | 	NULL, NULL, NULL, NULL,
77 | 	BDF_GAME_WORKING,2,HARDWARE_CAPCOM_CPS2,
78 | 	NULL, hsf2RomInfo, hsf2RomName, DrvInputInfo, NULL,
79 | 	DrvInit, DrvExit,Cps2Frame,CpsRedraw,CpsAreaScan,
80 | 	&CpsRecalcPal,384,224,4,3
81 | };
82 | 
83 | struct BurnDriver BurnDrvCpsHsf2j = {
84 | 	"hsf2j", "hsf2", NULL, "2004",
85 | 	"Hyper Street Fighter 2: The Anniversary Edition (031222 Japan)\0", NULL, "Capcom", "CPS2",
86 | 	NULL, NULL, NULL, NULL,
87 | 	BDF_GAME_WORKING | BDF_CLONE,2,HARDWARE_CAPCOM_CPS2,
88 | 	NULL, hsf2jRomInfo, hsf2jRomName, DrvInputInfo, NULL,
89 | 	DrvInit, DrvExit,Cps2Frame,CpsRedraw,CpsAreaScan,
90 | 	&CpsRecalcPal,384,224,4,3
91 | };
92 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_input.cpp:
--------------------------------------------------------------------------------
 1 | // Inputs common to all Cps2 Fighter Style games (3 x Punch,3 x Kick)
 2 | 
 3 | #include "cps.h"
 4 | 
 5 | struct BurnInputInfo CpsFsi[] = {
 6 |   {"P1 Coin",			BIT_DIGITAL, CpsInp020+4, "p1 coin"},	// 0x00
 7 |   {"P1 Start",			BIT_DIGITAL, CpsInp020+0, "p1 start"},
 8 | 
 9 |   {"P1 Up",				BIT_DIGITAL, CpsInp001+3, "p1 up"},		// 0x02
10 |   {"P1 Down",			BIT_DIGITAL, CpsInp001+2, "p1 down"},
11 |   {"P1 Left",			BIT_DIGITAL, CpsInp001+1, "p1 left"},
12 |   {"P1 Right",			BIT_DIGITAL, CpsInp001+0, "p1 right"},
13 | 
14 |   {"P1 Weak punch",		BIT_DIGITAL, CpsInp001+4, "p1 fire 1"},	// 0x06
15 |   {"P1 Medium punch",	BIT_DIGITAL, CpsInp001+5, "p1 fire 2"},
16 |   {"P1 Strong punch",	BIT_DIGITAL, CpsInp001+6, "p1 fire 3"},
17 |   {"P1 Weak kick",		BIT_DIGITAL, CpsInp011+0, "p1 fire 4"},
18 |   {"P1 Medium kick",	BIT_DIGITAL, CpsInp011+1, "p1 fire 5"},
19 |   {"P1 Strong kick",	BIT_DIGITAL, CpsInp011+2, "p1 fire 6"},
20 | 
21 |   {"P2 Coin",			BIT_DIGITAL, CpsInp020+5, "p2 coin"},	// 0x0C
22 |   {"P2 Start",			BIT_DIGITAL, CpsInp020+1, "p2 start"},
23 | 
24 |   {"P2 Up",				BIT_DIGITAL, CpsInp000+3, "p2 up"},		// 0x0E
25 |   {"P2 Down",			BIT_DIGITAL, CpsInp000+2, "p2 down"},
26 |   {"P2 Left",			BIT_DIGITAL, CpsInp000+1, "p2 left"},
27 |   {"P2 Right",			BIT_DIGITAL, CpsInp000+0, "p2 right"},
28 | 
29 |   {"P2 Weak punch",		BIT_DIGITAL, CpsInp000+4, "p2 fire 1"},	// 0x12
30 |   {"P2 Medium punch",	BIT_DIGITAL, CpsInp000+5, "p2 fire 2"},
31 |   {"P2 Strong Punch",	BIT_DIGITAL, CpsInp000+6, "p2 fire 3"},
32 |   {"P2 Weak kick",		BIT_DIGITAL, CpsInp011+4, "p2 fire 4"},
33 |   {"P2 Medium kick",	BIT_DIGITAL, CpsInp011+5, "p2 fire 5"},
34 |   {"P2 Strong kick",	BIT_DIGITAL, CpsInp020+6, "p2 fire 6"},
35 | 
36 |   {"Reset",				BIT_DIGITAL, &CpsReset  , "reset"},		// 0x18
37 |   {"Diagnostic",		BIT_DIGITAL, CpsInp021+1, "diag"},
38 |   {"Service",			BIT_DIGITAL, CpsInp021+2, "service"},
39 | };
40 | 
41 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_jyangoku.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | static struct BurnInputInfo DrvInputList[] =
 4 | {
 5 | 	{"P1 Coin"       , BIT_DIGITAL, CpsInp020+4, "p1 coin"},
 6 | 	{"P1 Start"      , BIT_DIGITAL, CpsInp020+0, "p1 start"},
 7 | 	{"P1 Up"         , BIT_DIGITAL, CpsInp001+3, "p1 up"},
 8 | 	{"P1 Down"       , BIT_DIGITAL, CpsInp001+2, "p1 down"},
 9 | 	{"P1 Left"       , BIT_DIGITAL, CpsInp001+1, "p1 left"},
10 | 	{"P1 Right"      , BIT_DIGITAL, CpsInp001+0, "p1 right"},
11 | 	{"P1 Shot1"      , BIT_DIGITAL, CpsInp001+4, "p1 fire 1"},
12 | 	{"P1 Shot2"      , BIT_DIGITAL, CpsInp001+5, "p1 fire 2"},
13 | 
14 | 	{"Reset"         , BIT_DIGITAL, &CpsReset  , "reset"},
15 | 	{"Diagnostic"    , BIT_DIGITAL, CpsInp021+1, "diag"},
16 | 	{"Service"       , BIT_DIGITAL, CpsInp021+2, "service"},
17 | };
18 | 
19 | STDINPUTINFO(Drv);
20 | 
21 | static struct BurnRomInfo jyangokuRomDesc[] = {
22 | 	{ "maj_j03.6a",   0x080000, 0x4614a3b2,  1 | BRF_ESS | BRF_PRG },
23 | 
24 | 	{ "maj1_d.simm1", 0x200000, 0xba0fe27b, 11 | BRF_GRA },
25 | 	{ "maj1_c.simm1", 0x200000, 0x2cd141bf, 11 | BRF_GRA },
26 | 	{ "maj1_b.simm1", 0x200000, 0xe29e4c26, 11 | BRF_GRA },
27 | 	{ "maj1_a.simm1", 0x200000, 0x7f68b88a, 11 | BRF_GRA },
28 | 	{ "maj3_d.simm3", 0x200000, 0x3aaeb90b, 11 | BRF_GRA },
29 | 	{ "maj3_c.simm3", 0x200000, 0x97894cea, 11 | BRF_GRA },
30 | 	{ "maj3_b.simm3", 0x200000, 0xec737d9d, 11 | BRF_GRA },
31 | 	{ "maj3_a.simm3", 0x200000, 0xc23b6f22, 11 | BRF_GRA },
32 | 	
33 | 	{ "maj_01.1a",    0x020000, 0x1fe8c213,  4 | BRF_ESS | BRF_PRG },
34 | 
35 | 	{ "maj5_a.simm5", 0x200000, 0x5ad9ee53, 15 | BRF_SND },	
36 | 	{ "maj5_b.simm5", 0x200000, 0xefb3dbfb, 15 | BRF_SND },	
37 | };
38 | 
39 | 
40 | STD_ROM_PICK(jyangoku) STD_ROM_FN(jyangoku)
41 | 
42 | struct BurnDriver BurnDrvCpsJyangoku = {
43 | 	"jyangoku", NULL, NULL, "1999",
44 | 	"Jyangokushi  -Haoh no Saihai- (990527 Japan)\0", NULL, "Mitchell", "CPS2",
45 | 	L"\u96C0\u570B\u5FD7 -\u8987\u738B\u306E\u91C7\u724C- (Jyangokushi 990527 Japan)\0", NULL, NULL, NULL,
46 | 	BDF_GAME_WORKING, 2, HARDWARE_CAPCOM_CPS2 | HARDWARE_CAPCOM_CPS2_SIMM,
47 | 	NULL, jyangokuRomInfo, jyangokuRomName, DrvInputInfo, NULL,
48 | 	Cps2Init,CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
49 | 	&CpsRecalcPal,384,224,4,3
50 | };
51 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_mpang.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | static struct BurnInputInfo DrvInputList[] =
 4 | {
 5 | 	{"P1 Coin"       , BIT_DIGITAL, CpsInp020+4, "p1 coin"},
 6 | 	{"P1 Start"      , BIT_DIGITAL, CpsInp020+0, "p1 start"},
 7 | 	{"P1 Up"         , BIT_DIGITAL, CpsInp001+3, "p1 up"},
 8 | 	{"P1 Down"       , BIT_DIGITAL, CpsInp001+2, "p1 down"},
 9 | 	{"P1 Left"       , BIT_DIGITAL, CpsInp001+1, "p1 left"},
10 | 	{"P1 Right"      , BIT_DIGITAL, CpsInp001+0, "p1 right"},
11 | 	{"P1 Shot1"      , BIT_DIGITAL, CpsInp001+4, "p1 fire 1"},
12 | 	{"P1 Shot2"      , BIT_DIGITAL, CpsInp001+5, "p1 fire 2"},
13 | 
14 | 	{"P2 Coin"       , BIT_DIGITAL, CpsInp020+5, "p2 coin"},
15 | 	{"P2 Start"      , BIT_DIGITAL, CpsInp020+1, "p2 start"},
16 | 	{"P2 Up"         , BIT_DIGITAL, CpsInp000+3, "p2 up"},
17 | 	{"P2 Down"       , BIT_DIGITAL, CpsInp000+2, "p2 down"},
18 | 	{"P2 Left"       , BIT_DIGITAL, CpsInp000+1, "p2 left"},
19 | 	{"P2 Right"      , BIT_DIGITAL, CpsInp000+0, "p2 right"},
20 | 	{"P2 Shot1"      , BIT_DIGITAL, CpsInp000+4, "p2 fire 1"},
21 | 	{"P2 Shot2"      , BIT_DIGITAL, CpsInp000+5, "p2 fire 2"},
22 | 
23 | 	{"Reset"         , BIT_DIGITAL, &CpsReset  , "reset"},
24 | 	{"Diagnostic"    , BIT_DIGITAL, CpsInp021+1, "diag"},
25 | 	{"Service"       , BIT_DIGITAL, CpsInp021+2, "service"},
26 | };
27 | 
28 | STDINPUTINFO(Drv);
29 | 
30 | static struct BurnRomInfo mpangRomDesc[] = {
31 | 	{ "mpn.03",       0x080000, 0x6e7ed03c,  1 | BRF_ESS | BRF_PRG },
32 | 	{ "mpn.04",       0x080000, 0xde079131,  1 | BRF_ESS | BRF_PRG },
33 | 
34 | 	{ "mpn.13m",      0x200000, 0xc5f123dc, 3 | BRF_GRA },
35 | 	{ "mpn.15m",      0x200000, 0x8e033265, 3 | BRF_GRA },
36 | 	{ "mpn.17m",      0x200000, 0xcfcd73d2, 3 | BRF_GRA },
37 | 	{ "mpn.19m",      0x200000, 0x2db1ffbc, 3 | BRF_GRA },
38 | 	
39 | 	{ "mpn.01",       0x020000, 0x90C7ADB6,  4 | BRF_ESS | BRF_PRG },
40 | 
41 | 	{ "mpn.q1",       0x100000, 0xd21c1f5a, 5 | BRF_SND },	
42 | 	{ "mpn.q2",       0x100000, 0xd22090b1, 5 | BRF_SND },	
43 | 	{ "mpn.q3",       0x100000, 0x60aa5ef2, 5 | BRF_SND },	
44 | 	{ "mpn.q4",       0x100000, 0x3a67d203, 5 | BRF_SND },	
45 | };
46 | 
47 | 
48 | STD_ROM_PICK(mpang) STD_ROM_FN(mpang)
49 | 
50 | static struct BurnRomInfo mpangjRomDesc[] = {
51 | 	{ "mpnj.03a",     0x080000, 0xBF597b1C,  1 | BRF_ESS | BRF_PRG },
52 | 	{ "mpnj.04a",     0x080000, 0xF4A3AB0F,  1 | BRF_ESS | BRF_PRG },
53 | 
54 | 	{ "mpn-simm.01c", 0x200000, 0x388DB66B, 11 | BRF_GRA },
55 | 	{ "mpn-simm.01d", 0x200000, 0xAFF1B494, 11 | BRF_GRA },
56 | 	{ "mpn-simm.01a", 0x200000, 0xA9C4857B, 11 | BRF_GRA },
57 | 	{ "mpn-simm.01b", 0x200000, 0xF759DF22, 11 | BRF_GRA },
58 | 	{ "mpn-simm.03c", 0x200000, 0xDEC6B720, 11 | BRF_GRA },
59 | 	{ "mpn-simm.03d", 0x200000, 0xF8774C18, 11 | BRF_GRA },
60 | 	{ "mpn-simm.03a", 0x200000, 0xC2AEA4EC, 11 | BRF_GRA },
61 | 	{ "mpn-simm.03b", 0x200000, 0x84D6DC33, 11 | BRF_GRA },
62 | 
63 | 	{ "mpn.01",       0x020000, 0x90C7ADB6,  4 | BRF_ESS | BRF_PRG },
64 | 
65 | 	{ "mpn-simm.05a", 0x200000, 0x318A2E21, 13 | BRF_SND },
66 | 	{ "mpn-simm.05b", 0x200000, 0x5462F4E8, 13 | BRF_SND },
67 | };
68 | 
69 | 
70 | STD_ROM_PICK(mpangj) STD_ROM_FN(mpangj)
71 | 
72 | struct BurnDriver BurnDrvCpsMPang = {
73 | 	"mpang", NULL, NULL, "2000",
74 | 	"Mighty! Pang (001010 USA)\0", NULL, "Mitchell", "CPS2",
75 | 	NULL, NULL, NULL, NULL,
76 | 	BDF_GAME_WORKING, 2, HARDWARE_CAPCOM_CPS2,
77 | 	NULL, mpangRomInfo, mpangRomName, DrvInputInfo, NULL,
78 | 	Cps2Init,CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
79 | 	&CpsRecalcPal,384,224,4,3
80 | };
81 | 
82 | struct BurnDriver BurnDrvCpsMPangj = {
83 | 	"mpangj", "mpang", NULL, "2000",
84 | 	"Mighty! Pang (001011 Japan)\0", NULL, "Mitchell", "CPS2",
85 | 	NULL, NULL, NULL, NULL,
86 | 	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_CAPCOM_CPS2 | HARDWARE_CAPCOM_CPS2_SIMM,
87 | 	NULL, mpangjRomInfo, mpangjRomName, DrvInputInfo, NULL,
88 | 	Cps2Init,CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
89 | 	&CpsRecalcPal,384,224,4,3
90 | };
91 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_qnd.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | static struct BurnInputInfo DrvInputList[] =
 4 | {
 5 |   {"P1 Coin"       , BIT_DIGITAL, CpsInp020+4, "p1 coin"},
 6 |   {"P1 Start"      , BIT_DIGITAL, CpsInp020+0, "p1 start"},
 7 |   {"P1 Answer 1"   , BIT_DIGITAL, CpsInp001+4, "p1 fire 1"},
 8 |   {"P1 Answer 2"   , BIT_DIGITAL, CpsInp001+5, "p1 fire 2"},
 9 |   {"P1 Answer 3"   , BIT_DIGITAL, CpsInp001+6, "p1 fire 3"},
10 |   {"P1 Answer 4"   , BIT_DIGITAL, CpsInp001+7, "p1 fire 4"},
11 | 
12 |   {"P2 Coin"       , BIT_DIGITAL, CpsInp020+5, "p2 coin"},
13 |   {"P2 Start"      , BIT_DIGITAL, CpsInp020+1, "p2 start"},
14 |   {"P2 Answer 1"   , BIT_DIGITAL, CpsInp000+4, "p2 fire 1"},
15 |   {"P2 Answer 2"   , BIT_DIGITAL, CpsInp000+5, "p2 fire 2"},
16 |   {"P2 Answer 3"   , BIT_DIGITAL, CpsInp000+6, "p2 fire 3"},
17 |   {"P2 Answer 4"   , BIT_DIGITAL, CpsInp000+7, "p2 fire 4"},
18 | 
19 |   {"Reset"         , BIT_DIGITAL, &CpsReset,   "reset"},
20 |   {"Diagnostic"    , BIT_DIGITAL, CpsInp021+1, "diag"},
21 |   {"Service"       , BIT_DIGITAL, CpsInp021+2, "service"},
22 | };
23 | 
24 | STDINPUTINFO(Drv);
25 | 
26 | static struct BurnRomInfo DrvRomDesc[] = {
27 | 	{ "tqzj.03a",      0x80000, 0x7acf3e30, 1 | BRF_ESS | BRF_PRG }, // 68000 code (encrypted)
28 | 	{ "tqzj.04",       0x80000, 0xf1044a87, 1 | BRF_ESS | BRF_PRG },
29 | 	{ "tqzj.05",       0x80000, 0x4105ba0e, 1 | BRF_ESS | BRF_PRG },
30 | 	{ "tqzj.06",       0x80000, 0xc371e8a5, 1 | BRF_ESS | BRF_PRG },
31 | 
32 | 	{ "tqz.14m",      0x200000, 0x98af88a2, 3 | BRF_GRA },			 //  5
33 | 	{ "tqz.16m",      0x200000, 0xdf82d491, 3 | BRF_GRA },
34 | 	{ "tqz.18m",      0x200000, 0x42f132ff, 3 | BRF_GRA },
35 | 	{ "tqz.20m",      0x200000, 0xb2e128a3, 3 | BRF_GRA },
36 | 
37 | 	{ "tqz.01",       0x020000, 0xe9ce9d0a, 4 | BRF_ESS | BRF_PRG }, //  9
38 | 
39 | 	{ "tqz.11m",      0x200000, 0x78e7884f, 5 | BRF_SND },			 // 10
40 | 	{ "tqz.12m",      0x200000, 0x2e049b13, 5 | BRF_SND },
41 | };
42 | 
43 | 
44 | STD_ROM_PICK(Drv) STD_ROM_FN(Drv)
45 | 
46 | struct BurnDriver BurnDrvCpsQndream = {
47 | 	"qndream", NULL, NULL, "1996",
48 | 	"Quiz Nanairo Dreams - nijiirochou no kiseki (nanairo dreams 960826 Japan)\0", NULL, "Capcom", "CPS2",
49 | 	L"Quiz \u306A\u306A\u3044\u308D Dreams - \u8679\u8272\u753A\u306E\u5947\u8DE1 (Nanairo Dreams 960826 Japan)\0Quiz Nanairo Dreams - nijiirochou no kiseki\0", NULL, NULL, NULL,
50 | 	BDF_GAME_WORKING,2,HARDWARE_CAPCOM_CPS2,
51 | 	NULL, DrvRomInfo, DrvRomName, DrvInputInfo, NULL,
52 | 	Cps2Init, CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
53 | 	&CpsRecalcPal,384,224,4,3
54 | };
55 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_vhunt2.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | STDINPUTINFOSPEC(Drv, CpsFsi);
 4 | 
 5 | static struct BurnRomInfo Vhunt2RomDesc[] = {
 6 | 	{ "vh2j.03a",     0x080000, 0x9ae8f186, 1 | BRF_ESS | BRF_PRG },
 7 | 	{ "vh2j.04a",     0x080000, 0xe2fabf53, 1 | BRF_ESS | BRF_PRG },
 8 | 	{ "vh2j.05",      0x080000, 0xde34f624, 1 | BRF_ESS | BRF_PRG },
 9 | 	{ "vh2j.06",      0x080000, 0x6a3b9897, 1 | BRF_ESS | BRF_PRG },
10 | 	{ "vh2j.07",      0x080000, 0xb021c029, 1 | BRF_ESS | BRF_PRG },
11 | 	{ "vh2j.08",      0x080000, 0xac873dff, 1 | BRF_ESS | BRF_PRG },
12 | 	{ "vh2j.09",      0x080000, 0xeaefce9c, 1 | BRF_ESS | BRF_PRG },
13 | 	{ "vh2j.10",      0x080000, 0x11730952, 1 | BRF_ESS | BRF_PRG },
14 | 
15 | 	{ "vh2.13m",      0x400000, 0x3b02ddaa, 3 | BRF_GRA },
16 | 	{ "vh2.15m",      0x400000, 0x4e40de66, 3 | BRF_GRA },
17 | 	{ "vh2.17m",      0x400000, 0xb31d00c9, 3 | BRF_GRA },
18 | 	{ "vh2.19m",      0x400000, 0x149be3ab, 3 | BRF_GRA },
19 | 	{ "vh2.14m",      0x400000, 0xcd09bd63, 3 | BRF_GRA },
20 | 	{ "vh2.16m",      0x400000, 0xe0182c15, 3 | BRF_GRA },
21 | 	{ "vh2.18m",      0x400000, 0x778dc4f6, 3 | BRF_GRA },
22 | 	{ "vh2.20m",      0x400000, 0x605d9d1d, 3 | BRF_GRA },
23 | 
24 | 	{ "vh2.01",       0x020000, 0x67b9f779, 4 | BRF_ESS | BRF_PRG },
25 | 	{ "vh2.02",       0x020000, 0xaaf15fcb, 4 | BRF_ESS | BRF_PRG },
26 | 
27 | 	{ "vh2.11m",      0x400000, 0x38922efd, 5 | BRF_SND },
28 | 	{ "vh2.12m",      0x400000, 0x6e2430af, 5 | BRF_SND },
29 | };
30 | 
31 | 
32 | STD_ROM_PICK(Vhunt2) STD_ROM_FN(Vhunt2)
33 | 
34 | static struct BurnRomInfo Vhunt2r1RomDesc[] = {
35 | 	{ "vh2j.03",      0x080000, 0x1a5feb13, 1 | BRF_ESS | BRF_PRG },
36 | 	{ "vh2j.04",      0x080000, 0x434611a5, 1 | BRF_ESS | BRF_PRG },
37 | 	{ "vh2j.05",      0x080000, 0xde34f624, 1 | BRF_ESS | BRF_PRG },
38 | 	{ "vh2j.06",      0x080000, 0x6a3b9897, 1 | BRF_ESS | BRF_PRG },
39 | 	{ "vh2j.07",      0x080000, 0xb021c029, 1 | BRF_ESS | BRF_PRG },
40 | 	{ "vh2j.08",      0x080000, 0xac873dff, 1 | BRF_ESS | BRF_PRG },
41 | 	{ "vh2j.09",      0x080000, 0xeaefce9c, 1 | BRF_ESS | BRF_PRG },
42 | 	{ "vh2j.10",      0x080000, 0x11730952, 1 | BRF_ESS | BRF_PRG },
43 | 
44 | 	{ "vh2.13m",      0x400000, 0x3b02ddaa, 3 | BRF_GRA },
45 | 	{ "vh2.15m",      0x400000, 0x4e40de66, 3 | BRF_GRA },
46 | 	{ "vh2.17m",      0x400000, 0xb31d00c9, 3 | BRF_GRA },
47 | 	{ "vh2.19m",      0x400000, 0x149be3ab, 3 | BRF_GRA },
48 | 	{ "vh2.14m",      0x400000, 0xcd09bd63, 3 | BRF_GRA },
49 | 	{ "vh2.16m",      0x400000, 0xe0182c15, 3 | BRF_GRA },
50 | 	{ "vh2.18m",      0x400000, 0x778dc4f6, 3 | BRF_GRA },
51 | 	{ "vh2.20m",      0x400000, 0x605d9d1d, 3 | BRF_GRA },
52 | 
53 | 	{ "vh2.01",       0x020000, 0x67b9f779, 4 | BRF_ESS | BRF_PRG },
54 | 	{ "vh2.02",       0x020000, 0xaaf15fcb, 4 | BRF_ESS | BRF_PRG },
55 | 
56 | 	{ "vh2.11m",      0x400000, 0x38922efd, 5 | BRF_SND },
57 | 	{ "vh2.12m",      0x400000, 0x6e2430af, 5 | BRF_SND },
58 | };
59 | 
60 | 
61 | STD_ROM_PICK(Vhunt2r1) STD_ROM_FN(Vhunt2r1)
62 | 
63 | struct BurnDriver BurnDrvCpsVhunt2 = {
64 | 	"vhunt2", NULL, NULL, "1997",
65 | 	"Vampire Hunter 2 - darkstalkers revenge (970929 Japan)\0", NULL, "Capcom", "CPS2",
66 | 	NULL, NULL, NULL, NULL,
67 | 	BDF_GAME_WORKING,2,HARDWARE_CAPCOM_CPS2,
68 | 	NULL, Vhunt2RomInfo, Vhunt2RomName, DrvInputInfo, NULL,
69 | 	Cps2Init, CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
70 | 	&CpsRecalcPal,384,224,4,3
71 | };
72 | 
73 | struct BurnDriver BurnDrvCpsVhunt2r1 = {
74 | 	"vhunt2r1", "vhunt2", NULL, "1997",
75 | 	"Vampire Hunter 2 - darkstalkers revenge (970913 Japan)\0", NULL, "Capcom", "CPS2",
76 | 	NULL, NULL, NULL, NULL,
77 | 	BDF_GAME_WORKING | BDF_CLONE,2,HARDWARE_CAPCOM_CPS2,
78 | 	NULL, Vhunt2r1RomInfo, Vhunt2r1RomName, DrvInputInfo, NULL,
79 | 	Cps2Init, CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
80 | 	&CpsRecalcPal,384,224,4,3
81 | };
82 | 


--------------------------------------------------------------------------------
/burn/capcom/dc_vsav2.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | 
 3 | STDINPUTINFOSPEC(Drv, CpsFsi);
 4 | 
 5 | static struct BurnRomInfo Vsav2RomDesc[] = {
 6 | 	{ "vs2j.03",       0x80000, 0x89fd86b4, 1 | BRF_ESS | BRF_PRG },
 7 | 	{ "vs2j.04",       0x80000, 0x107c091b, 1 | BRF_ESS | BRF_PRG },
 8 | 	{ "vs2j.05",       0x80000, 0x61979638, 1 | BRF_ESS | BRF_PRG },
 9 | 	{ "vs2j.06",       0x80000, 0xf37c5bc2, 1 | BRF_ESS | BRF_PRG },
10 | 	{ "vs2j.07",       0x80000, 0x8f885809, 1 | BRF_ESS | BRF_PRG },
11 | 	{ "vs2j.08",       0x80000, 0x2018c120, 1 | BRF_ESS | BRF_PRG },
12 | 	{ "vs2j.09",       0x80000, 0xfac3c217, 1 | BRF_ESS | BRF_PRG },
13 | 	{ "vs2j.10",       0x80000, 0xeb490213, 1 | BRF_ESS | BRF_PRG },
14 | 
15 | 	{ "vs2.13m",      0x400000, 0x5c852f52, 3 | BRF_GRA },
16 | 	{ "vs2.15m",      0x400000, 0xa20f58af, 3 | BRF_GRA },
17 | 	{ "vs2.17m",      0x400000, 0x39db59ad, 3 | BRF_GRA },
18 | 	{ "vs2.19m",      0x400000, 0x00c763a7, 3 | BRF_GRA },
19 | 	{ "vs2.14m",      0x400000, 0xcd09bd63, 3 | BRF_GRA },
20 | 	{ "vs2.16m",      0x400000, 0xe0182c15, 3 | BRF_GRA },
21 | 	{ "vs2.18m",      0x400000, 0x778dc4f6, 3 | BRF_GRA },
22 | 	{ "vs2.20m",      0x400000, 0x605d9d1d, 3 | BRF_GRA },
23 | 
24 | 	{ "vs2.01",       0x020000, 0x35190139, 4 | BRF_ESS | BRF_PRG },
25 | 	{ "vs2.02",       0x020000, 0xc32dba09, 4 | BRF_ESS | BRF_PRG },
26 | 
27 | 	{ "vs2.11m",      0x400000, 0xd67e47b7, 5 | BRF_SND },
28 | 	{ "vs2.12m",      0x400000, 0x6d020a14, 5 | BRF_SND },
29 | };
30 | 
31 | 
32 | STD_ROM_PICK(Vsav2) STD_ROM_FN(Vsav2)
33 | 
34 | struct BurnDriver BurnDrvCpsVsav2 = {
35 | 	"vsav2", NULL, NULL, "1997",
36 | 	"Vampire Savior 2 - the lord of vampire (970913 Japan)\0", NULL, "Capcom", "CPS2",
37 | 	NULL, NULL, NULL, NULL,
38 | 	BDF_GAME_WORKING,2,HARDWARE_CAPCOM_CPS2,
39 | 	NULL, Vsav2RomInfo, Vsav2RomName, DrvInputInfo, NULL,
40 | 	Cps2Init, CpsExit,Cps2Frame,CpsRedraw,CpsAreaScan,
41 | 	&CpsRecalcPal,384,224,4,3
42 | };
43 | 


--------------------------------------------------------------------------------
/burn/capcom/ps.cpp:
--------------------------------------------------------------------------------
 1 | // PSound (CPS1 sound)
 2 | #include "cps.h"
 3 | #include "driver.h"
 4 | extern "C" {
 5 |  #include "ym2151.h"
 6 | }
 7 | 
 8 | unsigned char PsndCode, PsndFade;						// Sound code/fade sent to the z80 program
 9 | 
10 | static int nSyncPeriod;
11 | static int nSyncNext;
12 | 
13 | static int nCyclesDone;
14 | 
15 | static void drvYM2151IRQHandler(int nStatus)
16 | {
17 | 	if (nStatus) {
18 | 		ZetSetIRQLine(0xFF, ZET_IRQSTATUS_ACK);
19 | 		ZetRun(0x0800);
20 | 	} else {
21 | 		ZetSetIRQLine(0,    ZET_IRQSTATUS_NONE);
22 | 	}
23 | }
24 | 
25 | int PsndInit()
26 | {
27 | 	nCpsZ80Cycles = 3200000 * 100 / nBurnFPS;
28 | 	nSyncPeriod = nCpsZ80Cycles / 8 /*/ 32*/;
29 | 
30 | 	// Init PSound z80
31 | 	if (PsndZInit()!= 0) {
32 | 		return 1;
33 | 	}
34 | 
35 | 	// Init PSound mixing (not critical if it fails)
36 | 	PsmInit();
37 | 
38 | 	YM2151SetIrqHandler(0, &drvYM2151IRQHandler);
39 | 
40 | 	PsndCode = 0; PsndFade = 0;
41 | 
42 | 	nCyclesDone = 0;
43 | 
44 | 	return 0;
45 | }
46 | 
47 | int PsndExit()
48 | {
49 | 	PsmExit();
50 | 	PsndZExit();
51 | 
52 | 	return 0;
53 | }
54 | 
55 | int PsndScan(int nAction)
56 | {
57 | 	if (nAction & ACB_DRIVER_DATA) {
58 | 		SCAN_VAR(nCyclesDone); SCAN_VAR(nSyncNext);
59 | 		PsndZScan(nAction);							// Scan Z80
60 | 		SCAN_VAR(PsndCode); SCAN_VAR(PsndFade);		// Scan sound info
61 | 	}
62 | 	return 0;
63 | }
64 | 
65 | void PsndNewFrame()
66 | {
67 | 	ZetNewFrame();
68 | 	PsmNewFrame();
69 | 	nSyncNext = nSyncPeriod;
70 | 
71 | 	ZetIdle(nCyclesDone % nCpsZ80Cycles);
72 | 	nCyclesDone = 0;
73 | }
74 | 
75 | int PsndSyncZ80(int nCycles)
76 | {
77 | 	while (nSyncNext < nCycles) {
78 | 		PsmUpdate(nSyncNext * nBurnSoundLen / nCpsZ80Cycles);
79 | 		ZetRun(nSyncNext - ZetTotalCycles());
80 | 		nSyncNext += nSyncPeriod;
81 | 	}
82 | 
83 | 	nCyclesDone = ZetRun(nCycles - ZetTotalCycles());
84 | 
85 | 	return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/burn/capcom/ps_m.cpp:
--------------------------------------------------------------------------------
 1 | #include "cps.h"
 2 | #include "burn_ym2151.h"
 3 | 
 4 | // CPS1 sound Mixing
 5 | 
 6 | int bPsmOkay = 0;										// 1 if the module is okay
 7 | static short* WaveBuf = NULL;
 8 | 
 9 | static int nPos;
10 | 
11 | int PsmInit()
12 | {
13 | 	int nMemLen, nRate, nRet;
14 | 	bPsmOkay = 0;										// not OK yet
15 | 
16 | 	if (nBurnSoundRate > 0) {
17 | 		nRate = nBurnSoundRate;
18 | 	} else {
19 | 		nRate = 11025;
20 | 	}
21 | 
22 | 	if (BurnYM2151Init(3579540, 50.0)) {				// Init FM sound chip
23 | 		return 1;
24 | 	}
25 | 
26 | 	// Allocate a buffer for the intermediate sound (between YM2151 and pBurnSoundOut)
27 | 	nMemLen = nBurnSoundLen * 2 * sizeof(short);
28 | 	WaveBuf = (short*)malloc(nMemLen);
29 | 	if (WaveBuf == NULL) {
30 | 		PsmExit();
31 | 		return 1;
32 | 	}
33 | 	memset(WaveBuf, 0, nMemLen);						// Init to silence
34 | 
35 | 	// Init ADPCM
36 | 	MSM6295ROM = CpsAd;
37 | 	if (Forgottn) {
38 | 		nRet = MSM6295Init(0, 6061, 21.5, 1);
39 | 	} else {
40 | 		nRet = MSM6295Init(0, 7576, 21.5, 1);
41 | 	}
42 | 
43 | 	if (nRet!=0) {
44 | 		PsmExit(); return 1;
45 | 	}
46 | 
47 | 	bPsmOkay = 1;										// OK
48 | 
49 | 	return 0;
50 | }
51 | 
52 | int PsmExit()
53 | {
54 | 	bPsmOkay = 0;
55 | 
56 | 	MSM6295Exit(0);
57 | 
58 | 	free(WaveBuf);
59 | 	WaveBuf = NULL;
60 | 
61 | 	BurnYM2151Exit();									// Exit FM sound chip
62 | 	return 0;
63 | }
64 | 
65 | void PsmNewFrame()
66 | {
67 | 	nPos = 0;
68 | }
69 | 
70 | int PsmUpdate(int nEnd)
71 | {
72 | 	if (bPsmOkay == 0 || pBurnSoundOut == NULL) {
73 | 		return 1;
74 | 	}
75 | 
76 | 	if (nEnd <= nPos) {
77 | 		return 0;
78 | 	}
79 | 	if (nEnd > nBurnSoundLen) {
80 | 		nEnd = nBurnSoundLen;
81 | 	}
82 | 
83 | 	// Render FM
84 | 	BurnYM2151Render(pBurnSoundOut + (nPos << 1), nEnd - nPos);
85 | 
86 | 	// Render ADPCM
87 | //sq	MSM6295Render(0, pBurnSoundOut + (nPos << 1), nEnd - nPos);
88 | 
89 | 	nPos = nEnd;
90 | 
91 | 	return 0;
92 | }
93 | 


--------------------------------------------------------------------------------
/burn/capcom/qs.cpp:
--------------------------------------------------------------------------------
  1 | #include "cps.h"
  2 | // QSound
  3 | 
  4 | static int nQsndCyclesExtra;
  5 | 
  6 | static int qsndTimerOver(int, int)
  7 | {
  8 | //	bprintf(PRINT_NORMAL, _T("  - IRQ -> 1.\n"));
  9 | 	ZetSetIRQLine(0xFF, ZET_IRQSTATUS_AUTO);
 10 | 
 11 | 	return 0;
 12 | }
 13 | 
 14 | int QsndInit()
 15 | {
 16 | 	int nVolumeShift;
 17 | 	int nRate;
 18 | 
 19 | 	// Init QSound z80
 20 | 	if (QsndZInit()) {
 21 | 		return 1;
 22 | 	}
 23 | 	BurnTimerInit(qsndTimerOver, NULL);
 24 | 
 25 | 	if (Cps1Qs == 1) {
 26 | 		nCpsZ80Cycles = 6000000 * 100 / nBurnFPS;
 27 | 		BurnTimerAttachZet(6000000);
 28 | 	} else {
 29 | 		nCpsZ80Cycles = 8000000 * 100 / nBurnFPS;
 30 | 		BurnTimerAttachZet(8000000);
 31 | 	}
 32 | 
 33 | 	if (nBurnSoundRate >= 0) {
 34 | 		nRate = nBurnSoundRate;
 35 | 	} else {
 36 | 		nRate = 11025;
 37 | 	}
 38 | 
 39 | 	nVolumeShift = 0;
 40 | 
 41 | 	// These games are too soft at normal volumes
 42 | 	if (strncmp(BurnDrvGetTextA(DRV_NAME), "csclub", 6) == 0) {
 43 | 		nVolumeShift = -1;
 44 | 	}
 45 | #if 0
 46 | 	// These games are loud at normal volumes (no clipping)
 47 | 	if (strncmp(BurnDrvGetTextA(DRV_NAME), "1944",	  4) == 0 ||
 48 | 		strcmp( BurnDrvGetTextA(DRV_NAME), "dimahoo"  ) == 0 ||
 49 | 		strcmp( BurnDrvGetTextA(DRV_NAME), "gmahoo"   ) == 0)
 50 | 	{
 51 | 		nVolumeShift = 1;
 52 | 	}
 53 | #endif
 54 | 	// These games are too loud at normal volumes (no clipping)
 55 | 	if (strncmp(BurnDrvGetTextA(DRV_NAME), "sgemf",  5) == 0 ||
 56 | 		strncmp(BurnDrvGetTextA(DRV_NAME), "pfght",  5) == 0 ||
 57 | 		strncmp(BurnDrvGetTextA(DRV_NAME), "mpang",  5) == 0 ||
 58 | 		strncmp(BurnDrvGetTextA(DRV_NAME), "spf2",   4) == 0 ||
 59 | 		strncmp(BurnDrvGetTextA(DRV_NAME), "sfa2",   4) == 0 ||
 60 | 		strncmp(BurnDrvGetTextA(DRV_NAME), "sfa2",   4) == 0)
 61 | 	{
 62 | 		nVolumeShift = 1;
 63 | 	}
 64 | 	// These games are too loud at normal volumes (clipping)
 65 | 	if (strncmp(BurnDrvGetTextA(DRV_NAME), "19xx",   4) == 0 ||
 66 | 		strncmp(BurnDrvGetTextA(DRV_NAME), "ddtod",  5) == 0)
 67 | 	{
 68 | 		nVolumeShift = 2;
 69 | 	}
 70 | 
 71 | 	QscInit(nRate, nVolumeShift);		// Init QSound chip
 72 | 
 73 | 	return 0;
 74 | }
 75 | 
 76 | void QsndReset()
 77 | {
 78 | 	BurnTimerReset();
 79 | 	BurnTimerSetRetrig(0, 1.0 / 252.0);
 80 | 
 81 | 	nQsndCyclesExtra = 0;
 82 | }
 83 | 
 84 | void QsndExit()
 85 | {
 86 | 	QscExit();							// Exit QSound chip
 87 | 	QsndZExit();
 88 | }
 89 | 
 90 | int QsndScan(int nAction)
 91 | {
 92 | 	if (nAction & ACB_DRIVER_DATA) {
 93 | 		QsndZScan(nAction);				// Scan Z80
 94 | 		QscScan(nAction);				// Scan QSound Chip
 95 | 	}
 96 | 
 97 | 	return 0;
 98 | }
 99 | 
100 | void QsndNewFrame()
101 | {
102 | 	ZetNewFrame();
103 | 
104 | 	ZetIdle(nQsndCyclesExtra);
105 | 
106 | 	QscNewFrame();
107 | }
108 | 
109 | void QsndEndFrame()
110 | {
111 | 	BurnTimerEndFrame(nCpsZ80Cycles);
112 | 	if (pBurnSoundOut) QscUpdate(nBurnSoundLen);
113 | 
114 | 	nQsndCyclesExtra = ZetTotalCycles() - nCpsZ80Cycles;
115 | }
116 | 
117 | void QsndSyncZ80()
118 | {
119 | 	int nCycles = (long long)SekTotalCycles() * nCpsZ80Cycles / nCpsCycles;
120 | 
121 | 	if (nCycles <= ZetTotalCycles()) {
122 | 		return;
123 | 	}
124 | 
125 | 	BurnTimerUpdate(nCycles);
126 | }
127 | 


--------------------------------------------------------------------------------
/burn/capcom/qs_z.cpp:
--------------------------------------------------------------------------------
  1 | #include "cps.h"
  2 | // QSound - Z80
  3 | 
  4 | static int nQsndZBank = 0;
  5 | 
  6 | // Map in the memory for the current 0x8000-0xc000 music bank
  7 | static int QsndZBankMap()
  8 | {
  9 | 	unsigned int nOff;
 10 | 	unsigned char* Bank;
 11 | 	nOff = nQsndZBank << 14;
 12 | 	nOff += 0x8000;
 13 | 
 14 | 	if (Cps1Qs == 0) {
 15 | 		if (nOff + 0x4000 > nCpsZRomLen) {			// End of bank is out of range
 16 | 			nOff = 0;
 17 | 		}
 18 | 		Bank = CpsZRom + nOff;
 19 | 	} else {
 20 | 		if (nOff + 0x4000 > (nCpsZRomLen / 2)) {
 21 | 			nOff = 0;
 22 | 		}
 23 | 		Bank = CpsZRom - (nCpsZRomLen / 2) + nOff;
 24 | 	}
 25 | 
 26 | 	// Read and fetch the bank
 27 | 	ZetMapArea(0x8000, 0xbfff, 0, Bank);
 28 | 	if (Cps1Qs == 0) {
 29 | 		ZetMapArea(0x8000, 0xbfff, 2, Bank, CpsZRom + nOff);
 30 | 	} else {
 31 | 		ZetMapArea(0x8000, 0xbfff, 2, Bank);
 32 | 	}
 33 | 
 34 | 	return 0;
 35 | }
 36 | 
 37 | static unsigned char QscCmd[2] = {0, 0};
 38 | 
 39 | void __fastcall QsndZWrite(unsigned short a, unsigned char d)
 40 | {
 41 | 	if (a == 0xd000) {
 42 | 		QscCmd[0] = d;
 43 | 		return;
 44 | 	}
 45 | 	if (a == 0xd001) {
 46 | 		QscCmd[1] = d;
 47 | 		return;
 48 | 	}
 49 | 	if (a == 0xd002) {
 50 | 		QscWrite(d, (QscCmd[0] << 8) | QscCmd[1]);
 51 | //		bprintf(PRINT_NORMAL, "QSound command %02X %04X sent.\n", d, (QscCmd[0] << 8) | QscCmd[1]);
 52 | 		return;
 53 | 	}
 54 | 	if (a == 0xd003) {
 55 | 		int nNewBank = d & 0x0f;
 56 | 		if (nQsndZBank != nNewBank) {
 57 | 			nQsndZBank = nNewBank;
 58 | 			QsndZBankMap();
 59 | 		}
 60 | 	}
 61 | }
 62 | 
 63 | unsigned char __fastcall QsndZRead(unsigned short a)
 64 | {
 65 | 	if (a == 0xd007) {						// return ready all the time
 66 | 		return 0x80;
 67 | 	}
 68 | 	return 0;
 69 | }
 70 | 
 71 | int QsndZInit()
 72 | {
 73 | 	if (nCpsZRomLen < 0x8000) {				// Not enough Z80 Data
 74 | 		return 1;
 75 | 	}
 76 | 	if (CpsZRom == NULL) {
 77 | 		return 1;
 78 | 	}
 79 | 
 80 | 	ZetInit(1);
 81 | 
 82 | 	ZetSetReadHandler(QsndZRead);
 83 | 	ZetSetWriteHandler(QsndZWrite);
 84 | 
 85 | 	// Read and fetch first 0x8000 of Rom
 86 | 	if (Cps1Qs) {
 87 | 		ZetMapArea(0x0000, 0x7FFF, 0, CpsZRom - (nCpsZRomLen / 2));
 88 | 		ZetMapArea(0x0000, 0x7FFF, 2, CpsZRom, CpsZRom - (nCpsZRomLen / 2));	// If it tries to fetch this area
 89 | 	} else {
 90 | 		ZetMapArea(0x0000, 0x7FFF, 0 ,CpsZRom);
 91 | 		ZetMapArea(0x0000, 0x7FFF, 2, CpsZRom);
 92 | 	}
 93 | 
 94 | 	// Map first Bank of Rom
 95 | 	nQsndZBank = 0;
 96 | 	QsndZBankMap();
 97 | 
 98 | 	ZetMapArea(0xC000, 0xCFFF, 0, CpsZRamC0);
 99 | 	ZetMapArea(0xC000, 0xCFFF, 1, CpsZRamC0);
100 | 	ZetMapArea(0xC000, 0xCFFF, 2, CpsZRamC0);
101 | 
102 | 	ZetMemCallback(0xD000, 0xEFFF, 0);
103 | 	ZetMemCallback(0xD000, 0xEFFF, 1);
104 | 
105 | 	if (Cps1Qs) {
106 | 		ZetMapArea(0xD000, 0xEFFF, 2, CpsZRom, CpsZRom - (nCpsZRomLen / 2));	// If it tries to fetch this area
107 | 	} else {
108 | 		ZetMapArea(0xD000, 0xEFFF, 2, CpsZRom);
109 | 	}
110 | 
111 | 	ZetMapArea(0xF000, 0xFFFF, 0, CpsZRamF0);
112 | 	ZetMapArea(0xF000, 0xFFFF, 1, CpsZRamF0);
113 | 	ZetMapArea(0xF000, 0xFFFF, 2, CpsZRamF0);
114 | 
115 | 	ZetMemEnd();
116 | 
117 | 	return 0;
118 | }
119 | 
120 | int QsndZExit()
121 | {
122 | 	ZetClose();
123 | 	ZetExit();
124 | 	return 0;
125 | }
126 | 
127 | // Scan the current QSound z80 state
128 | int QsndZScan(int nAction)
129 | {
130 | 	ZetScan(nAction);					// Scan Z80
131 | 	SCAN_VAR(nQsndZBank);
132 | 
133 | 	if (nAction & ACB_WRITE) {			// If write, bank could have changed
134 | 		QsndZBankMap();
135 | 	}
136 | 
137 | 	return 0;
138 | }
139 | 


--------------------------------------------------------------------------------
/burn/cave/cave.cpp:
--------------------------------------------------------------------------------
 1 | #include "cave.h"
 2 | 
 3 | int nCaveXSize = 0, nCaveYSize = 0;
 4 | int nCaveXOffset = 0, nCaveYOffset = 0;
 5 | int nCaveExtraXOffset = 0, nCaveExtraYOffset = 0;
 6 | int nCaveRowModeOffset = 0;
 7 | 
 8 | int CaveScanGraphics()
 9 | {
10 | 	SCAN_VAR(nCaveXOffset);
11 | 	SCAN_VAR(nCaveYOffset);
12 | 
13 | 	SCAN_VAR(nCaveTileBank);
14 | 
15 | 	SCAN_VAR(nCaveSpriteBank);
16 | 	SCAN_VAR(nCaveSpriteBankDelay);
17 | 
18 | 	for (int i = 0; i < 4; i++) {
19 | 		SCAN_VAR(CaveTileReg[i][0]);
20 | 		SCAN_VAR(CaveTileReg[i][1]);
21 | 		SCAN_VAR(CaveTileReg[i][2]);
22 | 	}
23 | 
24 | 	return 0;
25 | }
26 | 
27 | // This function fills the screen with the background colour
28 | void CaveClearScreen(unsigned int nColour)
29 | {
30 | 	if (nColour) {
31 | 		unsigned int* pClear = (unsigned int*)pBurnDraw;
32 | 		nColour = nColour | (nColour << 16);
33 | 		for (int i = nCaveXSize * nCaveYSize / 16; i > 0 ; i--) {
34 | 			*pClear++ = nColour;
35 | 			*pClear++ = nColour;
36 | 			*pClear++ = nColour;
37 | 			*pClear++ = nColour;
38 | 			*pClear++ = nColour;
39 | 			*pClear++ = nColour;
40 | 			*pClear++ = nColour;
41 | 			*pClear++ = nColour;
42 | 		}
43 | 	} else {
44 | 		memset(pBurnDraw, 0, nCaveXSize * nCaveYSize * sizeof(short));
45 | 	}
46 | }
47 | 
48 | 


--------------------------------------------------------------------------------
/burn/cave/cave.h:
--------------------------------------------------------------------------------
 1 | #include "burnint.h"
 2 | #include "eeprom_93cxx.h"
 3 | 
 4 | #define CAVE_REFRESHRATE (15625.0 / 271.5)
 5 | 
 6 | inline static void CaveClearOpposites(unsigned short* nJoystickInputs)
 7 | {
 8 | 	if ((*nJoystickInputs & 0x0003) == 0x0003) {
 9 | 		*nJoystickInputs &= ~0x0003;
10 | 	}
11 | 	if ((*nJoystickInputs & 0x000C) == 0x000C) {
12 | 		*nJoystickInputs &= ~0x000C;
13 | 	}
14 | }
15 | 
16 | // cave.cpp
17 | extern int nCaveXSize, nCaveYSize;
18 | extern int nCaveXOffset, nCaveYOffset;
19 | extern int nCaveExtraXOffset, nCaveExtraYOffset;
20 | extern int nCaveRowModeOffset;
21 | 
22 | int CaveScanGraphics();
23 | void CaveClearScreen(unsigned int nColour);
24 | 
25 | // cave_palette.cpp
26 | extern unsigned int* CavePalette;
27 | 
28 | extern unsigned char* CavePalSrc;
29 | extern unsigned char CaveRecalcPalette;
30 | 
31 | int CavePalInit(int nPalSize);
32 | int CavePalExit();
33 | int CavePalUpdate4Bit(int nOffset, int nNumPalettes);
34 | int CavePalUpdate8Bit(int nOffset, int nNumPalettes);
35 | 
36 | void CavePalWriteByte(unsigned int nAddress, unsigned char byteValue);
37 | void CavePalWriteWord(unsigned int nAddress, unsigned short wordValue);
38 | 
39 | // cave_tiles.cpp
40 | extern unsigned char* CaveTileROM[4];
41 | extern unsigned char* CaveTileRAM[4];
42 | 
43 | extern unsigned int CaveTileReg[4][3];
44 | extern int nCaveTileBank;
45 | 
46 | int CaveTileRender(int nMode);
47 | void CaveTileExit();
48 | int CaveTileInit();
49 | int CaveTileInitLayer(int nLayer, int nROMSize, int nBitdepth, int nOffset);
50 | 
51 | // cave_sprite.cpp
52 | extern int CaveSpriteVisibleXOffset;
53 | 
54 | extern unsigned char* CaveSpriteROM;
55 | extern unsigned char* CaveSpriteRAM;
56 | 
57 | extern int nCaveSpriteBank;
58 | extern int nCaveSpriteBankDelay;
59 | 
60 | extern int (*CaveSpriteBuffer)();
61 | extern int CaveSpriteRender(int nLowPriority, int nHighPriority);
62 | void CaveSpriteExit();
63 | int CaveSpriteInit(int nType, int nROMSize);
64 | 
65 | 
66 | 


--------------------------------------------------------------------------------
/burn/cave/cave_palette.cpp:
--------------------------------------------------------------------------------
  1 | #include "cave.h"
  2 | 
  3 | unsigned char* CavePalSrc;
  4 | unsigned char CaveRecalcPalette;	// Set to 1 to force recalculation of the entire palette
  5 | 
  6 | unsigned int* CavePalette = NULL;
  7 | static unsigned short* CavePalCopy = NULL;
  8 | 
  9 | int CavePalInit(int nPalSize)
 10 | {
 11 | 	CavePalette = (unsigned int*)malloc(nPalSize * sizeof(int));
 12 | 	memset(CavePalette, 0, nPalSize * sizeof(int));
 13 | 
 14 | 	CavePalCopy = (unsigned short*)malloc(nPalSize * sizeof(short));
 15 | 	memset(CavePalCopy, 0, nPalSize * sizeof(short));
 16 | 
 17 | 	return 0;
 18 | }
 19 | 
 20 | int CavePalExit()
 21 | {
 22 | 	free(CavePalette);
 23 | 	CavePalette = NULL;
 24 | 	free(CavePalCopy);
 25 | 	CavePalCopy = NULL;
 26 | 
 27 | 	return 0;
 28 | }
 29 | 
 30 | inline static unsigned int CalcCol(unsigned short nColour)
 31 | {
 32 | 	int r, g, b;
 33 | 
 34 | 	r = (nColour & 0x03E0) >> 2;	// Red
 35 | 	r |= r >> 5;
 36 | 	g = (nColour & 0x7C00) >> 7;  	// Green
 37 | 	g |= g >> 5;
 38 | 	b = (nColour & 0x001F) << 3;	// Blue
 39 | 	b |= b >> 5;
 40 | 
 41 | 	return BurnHighCol(r, g, b, 0);
 42 | }
 43 | 
 44 | int CavePalUpdate4Bit(int nOffset, int nNumPalettes)
 45 | {
 46 | 	int i, j;
 47 | 
 48 | 	unsigned short* ps = (unsigned short*)CavePalSrc + nOffset;
 49 | 	unsigned short* pc;
 50 | 	unsigned int* pd;
 51 | 
 52 | 	unsigned short c;
 53 | 
 54 | 	if (CaveRecalcPalette) {
 55 | 
 56 | 		for (i = 0; i < 0 + nNumPalettes; i++) {
 57 | 
 58 | 			pc = CavePalCopy + (i << 8);
 59 | 			pd = CavePalette + (i << 8);
 60 | 
 61 | 			for (j = 0; j < 16; j++, ps++, pc++, pd++) {
 62 | 
 63 | 				c = *ps;
 64 | 				*pc = c;
 65 | 				*pd = CalcCol(c);
 66 | 
 67 | 			}
 68 | 		}
 69 | 
 70 | 		CaveRecalcPalette = 0;
 71 | 		return 0;
 72 | 	}
 73 | 
 74 | 
 75 | 	for (i = 0; i < 0 + nNumPalettes; i++) {
 76 | 
 77 | 		pc = CavePalCopy + (i << 8);
 78 | 		pd = CavePalette + (i << 8);
 79 | 
 80 | 		for (j = 0; j < 16; j++, ps++, pc++, pd++) {
 81 | 
 82 | 			c = *ps;
 83 | 			if (*pc != c) {
 84 | 				*pc = c;
 85 | 				*pd = CalcCol(c);
 86 | 			}
 87 | 
 88 | 		}
 89 | 	}
 90 | 
 91 | 	return 0;
 92 | }
 93 | 
 94 | int CavePalUpdate8Bit(int nOffset, int nNumPalettes)
 95 | {
 96 | 	if (CaveRecalcPalette) {
 97 | 		int i, j;
 98 | 
 99 | 		unsigned short* ps = (unsigned short*)CavePalSrc + nOffset;
100 | 		unsigned short* pc;
101 | 		unsigned int* pd;
102 | 
103 | 		unsigned short c;
104 | 
105 | 		for (i = 0; i < nNumPalettes; i++) {
106 | 
107 | 			pc = CavePalCopy + nOffset + (i << 8);
108 | 			pd = CavePalette + nOffset + (i << 8);
109 | 
110 | 			for (j = 0; j < 256; j++, ps++, pc++, pd++) {
111 | 
112 | 				c = *ps;
113 | 				*pc = c;
114 | 				*pd = CalcCol(c);
115 | 
116 | 			}
117 | 		}
118 | 
119 | 		CaveRecalcPalette = 0;
120 | 	}
121 | 
122 | 	return 0;
123 | }
124 | 
125 | // Update the PC copy of the palette on writes to the palette memory
126 | void CavePalWriteByte(unsigned int nAddress, unsigned char byteValue)
127 | {
128 | 	nAddress ^= 1;
129 | 	CavePalSrc[nAddress] = byteValue;							// write byte
130 | 
131 | 	if (*((unsigned char*)(CavePalCopy + nAddress)) != byteValue) {
132 | 		*((unsigned char*)(CavePalCopy + nAddress)) = byteValue;
133 | 		CavePalette[nAddress >> 1] = CalcCol(*(unsigned short*)(CavePalSrc + (nAddress & ~0x01)));
134 | 	}
135 | }
136 | 
137 | void CavePalWriteWord(unsigned int nAddress, unsigned short wordValue)
138 | {
139 | 	nAddress >>= 1;
140 | 
141 | 	((unsigned short*)CavePalSrc)[nAddress] = wordValue;		// write word
142 | 
143 | 	if (CavePalCopy[nAddress] != wordValue) {
144 | 		CavePalCopy[nAddress] = wordValue;
145 | 		CavePalette[nAddress] = CalcCol(wordValue);
146 | 	}
147 | }
148 | 
149 | 


--------------------------------------------------------------------------------
/burn/cave/cave_sprite_func.h:
--------------------------------------------------------------------------------
  1 | #define EIGHTBIT 1
  2 | #define ROT 0
  3 | 
  4 | #define BPP 16
  5 | #define XSIZE 320
  6 | #define ZOOM 0
  7 | #define XFLIP 0
  8 | #define ZBUFFER 0
  9 | #include "cave_sprite_render.h"
 10 | #undef ZBUFFER
 11 | #define ZBUFFER 1
 12 | #include "cave_sprite_render.h"
 13 | #undef ZBUFFER
 14 | #define ZBUFFER 2
 15 | #include "cave_sprite_render.h"
 16 | #undef ZBUFFER
 17 | #define ZBUFFER 3
 18 | #include "cave_sprite_render.h"
 19 | #undef ZBUFFER
 20 | #undef XFLIP
 21 | #define XFLIP 1
 22 | #define ZBUFFER 0
 23 | #include "cave_sprite_render.h"
 24 | #undef ZBUFFER
 25 | #define ZBUFFER 1
 26 | #include "cave_sprite_render.h"
 27 | #undef ZBUFFER
 28 | #define ZBUFFER 2
 29 | #include "cave_sprite_render.h"
 30 | #undef ZBUFFER
 31 | #define ZBUFFER 3
 32 | #include "cave_sprite_render.h"
 33 | #undef ZBUFFER
 34 | #undef XFLIP
 35 | #undef ZOOM
 36 | 
 37 | #define XFLIP 0
 38 | #define ZOOM 1
 39 | #define ZBUFFER 0
 40 | #include "cave_sprite_render_zoom.h"
 41 | #undef ZBUFFER
 42 | #define ZBUFFER 1
 43 | #include "cave_sprite_render_zoom.h"
 44 | #undef ZBUFFER
 45 | #define ZBUFFER 2
 46 | #include "cave_sprite_render_zoom.h"
 47 | #undef ZBUFFER
 48 | #define ZBUFFER 3
 49 | #include "cave_sprite_render_zoom.h"
 50 | #undef ZBUFFER
 51 | #undef ZOOM
 52 | 
 53 | #define ZOOM 2
 54 | #define ZBUFFER 0
 55 | #include "cave_sprite_render_zoom.h"
 56 | #undef ZBUFFER
 57 | #define ZBUFFER 1
 58 | #include "cave_sprite_render_zoom.h"
 59 | #undef ZBUFFER
 60 | #define ZBUFFER 2
 61 | #include "cave_sprite_render_zoom.h"
 62 | #undef ZBUFFER
 63 | #define ZBUFFER 3
 64 | #include "cave_sprite_render_zoom.h"
 65 | #undef ZBUFFER
 66 | #undef ZOOM
 67 | 
 68 | #undef XFLIP
 69 | #undef XSIZE
 70 | 
 71 | #define XSIZE 384
 72 | #define ZOOM 0
 73 | #define XFLIP 0
 74 | #define ZBUFFER 0
 75 | #include "cave_sprite_render.h"
 76 | #undef ZBUFFER
 77 | #define ZBUFFER 1
 78 | #include "cave_sprite_render.h"
 79 | #undef ZBUFFER
 80 | #define ZBUFFER 2
 81 | #include "cave_sprite_render.h"
 82 | #undef ZBUFFER
 83 | #define ZBUFFER 3
 84 | #include "cave_sprite_render.h"
 85 | #undef ZBUFFER
 86 | #undef XFLIP
 87 | #define XFLIP 1
 88 | #define ZBUFFER 0
 89 | #include "cave_sprite_render.h"
 90 | #undef ZBUFFER
 91 | #define ZBUFFER 1
 92 | #include "cave_sprite_render.h"
 93 | #undef ZBUFFER
 94 | #define ZBUFFER 2
 95 | #include "cave_sprite_render.h"
 96 | #undef ZBUFFER
 97 | #define ZBUFFER 3
 98 | #include "cave_sprite_render.h"
 99 | #undef ZBUFFER
100 | #undef XFLIP
101 | #undef ZOOM
102 | 
103 | #define XFLIP 0
104 | #define ZOOM 1
105 | #define ZBUFFER 0
106 | #include "cave_sprite_render_zoom.h"
107 | #undef ZBUFFER
108 | #define ZBUFFER 1
109 | #include "cave_sprite_render_zoom.h"
110 | #undef ZBUFFER
111 | #define ZBUFFER 2
112 | #include "cave_sprite_render_zoom.h"
113 | #undef ZBUFFER
114 | #define ZBUFFER 3
115 | #include "cave_sprite_render_zoom.h"
116 | #undef ZBUFFER
117 | #undef ZOOM
118 | 
119 | #define ZOOM 2
120 | #define ZBUFFER 0
121 | #include "cave_sprite_render_zoom.h"
122 | #undef ZBUFFER
123 | #define ZBUFFER 1
124 | #include "cave_sprite_render_zoom.h"
125 | #undef ZBUFFER
126 | #define ZBUFFER 2
127 | #include "cave_sprite_render_zoom.h"
128 | #undef ZBUFFER
129 | #define ZBUFFER 3
130 | #include "cave_sprite_render_zoom.h"
131 | #undef ZBUFFER
132 | #undef ZOOM
133 | 
134 | #undef XFLIP
135 | #undef XSIZE
136 | 
137 | #undef BPP
138 | 
139 | #undef ROT
140 | 
141 | #undef EIGHTBIT
142 | 
143 | #include "cave_sprite_func_table.h"
144 | 


--------------------------------------------------------------------------------
/burn/cave/cave_sprite_func_table.h:
--------------------------------------------------------------------------------
 1 | // Table with all function addresses.
 2 | static RenderSpriteFunction RenderSpriteFunctionTable[] = {
 3 | 	&RenderSprite16_320_ROT0_NOFLIP_NOZOOM_CLIPX_NOZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_NOZOOM_CLIPX_RZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_NOZOOM_CLIPX_WZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_NOZOOM_CLIPX_RWZBUFFER_256, 
 4 | 	&RenderSprite16_320_ROT0_FLIPX_NOZOOM_CLIPX_NOZBUFFER_256, &RenderSprite16_320_ROT0_FLIPX_NOZOOM_CLIPX_RZBUFFER_256, &RenderSprite16_320_ROT0_FLIPX_NOZOOM_CLIPX_WZBUFFER_256, &RenderSprite16_320_ROT0_FLIPX_NOZOOM_CLIPX_RWZBUFFER_256, 
 5 | 	&RenderSprite16_320_ROT0_NOFLIP_ZOOMOUT_NOCLIP_NOZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_ZOOMOUT_NOCLIP_RZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_ZOOMOUT_NOCLIP_WZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_ZOOMOUT_NOCLIP_RWZBUFFER_256, 
 6 | 	&RenderSprite16_320_ROT0_NOFLIP_ZOOMIN_NOCLIP_NOZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_ZOOMIN_NOCLIP_RZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_ZOOMIN_NOCLIP_WZBUFFER_256, &RenderSprite16_320_ROT0_NOFLIP_ZOOMIN_NOCLIP_RWZBUFFER_256, 
 7 | 	&RenderSprite16_384_ROT0_NOFLIP_NOZOOM_CLIPX_NOZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_NOZOOM_CLIPX_RZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_NOZOOM_CLIPX_WZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_NOZOOM_CLIPX_RWZBUFFER_256, 
 8 | 	&RenderSprite16_384_ROT0_FLIPX_NOZOOM_CLIPX_NOZBUFFER_256, &RenderSprite16_384_ROT0_FLIPX_NOZOOM_CLIPX_RZBUFFER_256, &RenderSprite16_384_ROT0_FLIPX_NOZOOM_CLIPX_WZBUFFER_256, &RenderSprite16_384_ROT0_FLIPX_NOZOOM_CLIPX_RWZBUFFER_256, 
 9 | 	&RenderSprite16_384_ROT0_NOFLIP_ZOOMOUT_NOCLIP_NOZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_ZOOMOUT_NOCLIP_RZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_ZOOMOUT_NOCLIP_WZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_ZOOMOUT_NOCLIP_RWZBUFFER_256, 
10 | 	&RenderSprite16_384_ROT0_NOFLIP_ZOOMIN_NOCLIP_NOZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_ZOOMIN_NOCLIP_RZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_ZOOMIN_NOCLIP_WZBUFFER_256, &RenderSprite16_384_ROT0_NOFLIP_ZOOMIN_NOCLIP_RWZBUFFER_256, 
11 | };
12 | 
13 | static RenderSpriteFunction* RenderSprite_ROT0[2] = {
14 | 	&RenderSpriteFunctionTable[0],
15 | 	&RenderSpriteFunctionTable[16]
16 | };
17 | 


--------------------------------------------------------------------------------
/burn/cave/cave_tile_func.h:
--------------------------------------------------------------------------------
 1 | #define XFLIP 0
 2 | #define YFLIP 0
 3 | #define ROT 0
 4 | 
 5 | #define BPP 16
 6 | #define XSIZE 320
 7 | #define EIGHTBIT 1
 8 | #define ROWSCROLL 0
 9 | #define ROWSELECT 0
10 | #define DOCLIP 0
11 | #include "cave_tile_render.h"
12 | #undef DOCLIP
13 | #define DOCLIP 1
14 | #include "cave_tile_render.h"
15 | #undef DOCLIP
16 | #undef ROWSELECT
17 | #undef ROWSCROLL
18 | #define ROWSCROLL 1
19 | #define ROWSELECT 0
20 | #define DOCLIP 0
21 | #include "cave_tile_render.h"
22 | #undef DOCLIP
23 | #define DOCLIP 1
24 | #include "cave_tile_render.h"
25 | #undef DOCLIP
26 | #undef ROWSELECT
27 | #undef ROWSCROLL
28 | #define ROWSCROLL 0
29 | #define ROWSELECT 1
30 | #define DOCLIP 0
31 | #include "cave_tile_render.h"
32 | #undef DOCLIP
33 | #define DOCLIP 1
34 | #include "cave_tile_render.h"
35 | #undef DOCLIP
36 | #undef ROWSELECT
37 | #undef ROWSCROLL
38 | #undef EIGHTBIT
39 | 
40 | #undef XSIZE
41 | 
42 | #define XSIZE 384
43 | #define EIGHTBIT 1
44 | #define ROWSCROLL 0
45 | #define ROWSELECT 0
46 | #define DOCLIP 0
47 | #include "cave_tile_render.h"
48 | #undef DOCLIP
49 | #define DOCLIP 1
50 | #include "cave_tile_render.h"
51 | #undef DOCLIP
52 | #undef ROWSELECT
53 | #undef ROWSCROLL
54 | #define ROWSCROLL 1
55 | #define ROWSELECT 0
56 | #define DOCLIP 0
57 | #include "cave_tile_render.h"
58 | #undef DOCLIP
59 | #define DOCLIP 1
60 | #include "cave_tile_render.h"
61 | #undef DOCLIP
62 | #undef ROWSELECT
63 | #undef ROWSCROLL
64 | #define ROWSCROLL 0
65 | #define ROWSELECT 1
66 | #define DOCLIP 0
67 | #include "cave_tile_render.h"
68 | #undef DOCLIP
69 | #define DOCLIP 1
70 | #include "cave_tile_render.h"
71 | #undef DOCLIP
72 | #undef ROWSELECT
73 | #undef ROWSCROLL
74 | #undef EIGHTBIT
75 | 
76 | #undef XSIZE
77 | 
78 | #undef BPP
79 | 
80 | #undef ROT
81 | 
82 | #undef YFLIP
83 | #undef XFLIP
84 | 
85 | #include "cave_tile_func_table.h"
86 | 


--------------------------------------------------------------------------------
/burn/cave/cave_tile_func_table.h:
--------------------------------------------------------------------------------
 1 | // Table with all function addresses.
 2 | static RenderTileFunction RenderTileFunctionTable[] = {
 3 | 	&RenderTile16_320_ROT0_NOFLIP_NOROWSCROLL_NOROWSELECT_NOCLIP_256, &RenderTile16_320_ROT0_NOFLIP_NOROWSCROLL_NOROWSELECT_CLIP_256, 
 4 | 	&RenderTile16_320_ROT0_NOFLIP_ROWSCROLL_NOROWSELECT_NOCLIP_256, &RenderTile16_320_ROT0_NOFLIP_ROWSCROLL_NOROWSELECT_CLIP_256, 
 5 | 	&RenderTile16_320_ROT0_NOFLIP_NOROWSCROLL_ROWSELECT_NOCLIP_256, &RenderTile16_320_ROT0_NOFLIP_NOROWSCROLL_ROWSELECT_CLIP_256, 
 6 | 	&RenderTile16_384_ROT0_NOFLIP_NOROWSCROLL_NOROWSELECT_NOCLIP_256, &RenderTile16_384_ROT0_NOFLIP_NOROWSCROLL_NOROWSELECT_CLIP_256, 
 7 | 	&RenderTile16_384_ROT0_NOFLIP_ROWSCROLL_NOROWSELECT_NOCLIP_256, &RenderTile16_384_ROT0_NOFLIP_ROWSCROLL_NOROWSELECT_CLIP_256, 
 8 | 	&RenderTile16_384_ROT0_NOFLIP_NOROWSCROLL_ROWSELECT_NOCLIP_256, &RenderTile16_384_ROT0_NOFLIP_NOROWSCROLL_ROWSELECT_CLIP_256, 
 9 | };
10 | 
11 | static RenderTileFunction* RenderTile_ROT0[2] = {
12 | 	&RenderTileFunctionTable[0],
13 | 	&RenderTileFunctionTable[6]
14 | };
15 | 


--------------------------------------------------------------------------------
/burn/cave/cave_tile_render.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/burn/cave/cave_tile_render.h


--------------------------------------------------------------------------------
/burn/cheat.h:
--------------------------------------------------------------------------------
 1 | #define CHEAT_MAX_ADDRESS ( 64)
 2 | #define CHEAT_MAX_OPTIONS (192)
 3 | #define CHEAT_MAX_NAME	  (128)
 4 | 
 5 | extern bool bCheatsAllowed;
 6 | 
 7 | struct CheatAddressInfo {
 8 | 	int nCPU;
 9 | 	int nAddress;
10 | 	unsigned int nValue;
11 | 	unsigned int nOriginalValue;
12 | };
13 | 
14 | struct CheatOption {
15 | 	TCHAR szOptionName[CHEAT_MAX_NAME];
16 | 	struct CheatAddressInfo AddressInfo[CHEAT_MAX_ADDRESS + 1];
17 | };
18 | 
19 | struct CheatInfo {
20 | 	struct CheatInfo* pNext;
21 | 	struct CheatInfo* pPrevious;
22 | 	int nType;									// Cheat type
23 | 	int nStatus;								// 0 = Inactive
24 | 	int nCurrent;								// Currently selected option
25 | 	int nDefault;								// Default option
26 | 	TCHAR szCheatName[CHEAT_MAX_NAME];
27 | 	struct CheatOption* pOption[CHEAT_MAX_OPTIONS];
28 | };
29 | 
30 | extern CheatInfo* pCheatInfo;
31 | 
32 | int CheatUpdate();
33 | int CheatEnable(int nCheat, int nOption);
34 | int CheatApply();
35 | int CheatInit();
36 | void CheatExit();
37 | 
38 | 


--------------------------------------------------------------------------------
/burn/cps3/cps3.h:
--------------------------------------------------------------------------------
 1 | #include "burnint.h"
 2 | 
 3 | #ifndef HARDWARE_CAPCOM_CPS3
 4 | 	#define HARDWARE_CAPCOM_CPS3		HARDWARE_MISC_MISC
 5 | #endif
 6 | 
 7 | #ifndef HARDWARE_CAPCOM_CPS3_NO_CD
 8 | 	#define HARDWARE_CAPCOM_CPS3_NO_CD	HARDWARE_CAPCOM_CPS3
 9 | #endif
10 | 
11 | extern unsigned char cps3_reset;
12 | extern unsigned char cps3_palette_change;
13 | 
14 | extern unsigned int cps3_key1, cps3_key2, cps3_isSpecial;
15 | extern unsigned int cps3_bios_test_hack, cps3_game_test_hack;
16 | extern unsigned int cps3_speedup_ram_address, cps3_speedup_code_address;
17 | extern unsigned char cps3_dip;
18 | extern unsigned int cps3_region_address, cps3_ncd_address;
19 | 
20 | extern unsigned char Cps3But1[16];
21 | extern unsigned char Cps3But2[16];
22 | extern unsigned char Cps3But3[16];
23 | 
24 | int cps3Init();
25 | int cps3Exit();
26 | int cps3Frame();
27 | int cps3Scan(int nAction,int *pnMin);
28 | 
29 | // sound 
30 | 
31 | unsigned char __fastcall cps3SndReadByte(unsigned int addr);
32 | unsigned short __fastcall cps3SndReadWord(unsigned int addr);
33 | unsigned int __fastcall cps3SndReadLong(unsigned int addr);
34 | 
35 | void __fastcall cps3SndWriteByte(unsigned int addr, unsigned char data);
36 | void __fastcall cps3SndWriteWord(unsigned int addr, unsigned short data);
37 | void __fastcall cps3SndWriteLong(unsigned int addr, unsigned int data);
38 | 
39 | int cps3SndInit(unsigned char *);
40 | void cps3SndReset();
41 | void cps3SndExit();
42 | void cps3SndUpdate();
43 | 
44 | int cps3SndScan(int);
45 | 
46 | 


--------------------------------------------------------------------------------
/burn/driver.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * For the MAME sound cores
 3 |  */
 4 | 
 5 | #ifndef DRIVER_H
 6 | #define DRIVER_H
 7 | 
 8 | #include <stdio.h>
 9 | #include <stdlib.h>
10 | #include <string.h>
11 | #include <math.h>
12 | 
13 | #if !defined (_WIN32)
14 |  #define __cdecl
15 | #endif
16 | 
17 | #ifndef INLINE
18 |  #define INLINE __inline static
19 | #endif
20 | 
21 | #define FBA
22 | 
23 | typedef signed char INT8;
24 | typedef unsigned char UINT8;
25 | typedef signed short INT16;
26 | typedef unsigned short UINT16;
27 | typedef signed int INT32;
28 | typedef unsigned int UINT32;
29 | typedef signed long long INT64;
30 | typedef unsigned long long UINT64;
31 | #define OSD_CPU_H
32 | 
33 | /* OPN */
34 | #define HAS_YM2203  1
35 | #define HAS_YM2608  1
36 | #define HAS_YM2610  1
37 | #define HAS_YM2610B 1
38 | #define HAS_YM2612  0
39 | #define HAS_YM3438  0
40 | /* OPL */
41 | #define HAS_YM3812  1
42 | #define HAS_YM3526  0
43 | #define HAS_Y8950   0
44 | 
45 | enum {
46 | 	CLEAR_LINE = 0,
47 | 	ASSERT_LINE,
48 | 	HOLD_LINE,
49 | 	PULSE_LINE
50 | };
51 | 
52 | #define timer_get_time() BurnTimerGetTime()
53 | 
54 | #define READ8_HANDLER(name) 	UINT8 name(void)
55 | #define WRITE8_HANDLER(name) 	void  name(UINT8 data)
56 | 
57 | #ifdef __cplusplus
58 |  extern "C" {
59 | #endif
60 |   double BurnTimerGetTime(void);
61 | 
62 |   typedef unsigned char (*read8_handler)(unsigned int offset);
63 |   typedef void (*write8_handler)(unsigned int offset,unsigned int data);
64 | 
65 |  #ifdef MAME_USE_LOGERROR
66 |   void __cdecl logerror(char* szFormat, ...);
67 |  #else
68 |   #define logerror
69 |  #endif
70 | #ifdef __cplusplus
71 |  }
72 | #endif
73 | 
74 | #endif /* DRIVER_H */
75 | 


--------------------------------------------------------------------------------
/burn/eeprom_93cxx.h:
--------------------------------------------------------------------------------
 1 | // 93Cxx EEPROM module
 2 | 
 3 | void EEPROMWrite(char SK, char CS, char DI);
 4 | int EEPROMRead();
 5 | void EEPROMFill(unsigned char* pData, int nOffset, int nSize);
 6 | void EEPROMReset();
 7 | void EEPROMScan(int nAction, int* pnMin);
 8 | void EEPROMExit();
 9 | int EEPROMInit(int nSize, int nWidth);
10 | 
11 | 
12 | 


--------------------------------------------------------------------------------
/burn/load.cpp:
--------------------------------------------------------------------------------
 1 | // Burn - Rom Loading module
 2 | #include "burnint.h"
 3 | 
 4 | // Load a rom and separate out the bytes by nGap
 5 | // Dest is the memory block to insert the rom into
 6 | static int LoadRom(unsigned char *Dest,int i,int nGap,int bXor)
 7 | {
 8 |   int nRet=0,nLen=0;
 9 |   if (BurnExtLoadRom==NULL) return 1; // Load function was not defined by the application
10 | 
11 |   // Find the length of the rom (as given by the current driver)
12 |   {
13 |     struct BurnRomInfo ri;
14 |     ri.nType=0;
15 |     ri.nLen=0;
16 |     BurnDrvGetRomInfo(&ri,i);
17 |     if (ri.nType==0) return 0; // Empty rom slot - don't load anything and return success
18 |     nLen=ri.nLen;
19 |   }
20 | 
21 |   if (nLen<=0) return 1;
22 | 
23 |   if (nGap>1 || bXor)
24 |   {
25 |     unsigned char *Load=NULL;
26 |     unsigned char *pd=NULL,*pl=NULL,*LoadEnd=NULL;
27 |     int nLoadLen=0;
28 | 
29 |     // Allocate space for the file
30 |     Load=(unsigned char *)malloc(nLen);
31 |     if (Load==NULL) return 1;
32 |     memset(Load,0,nLen);
33 | 
34 |     // Load in the file
35 |     nRet=BurnExtLoadRom(Load,&nLoadLen,i);
36 |     if (nRet!=0) { free(Load); return 1; }
37 | 
38 |     if (nLoadLen<0) nLoadLen=0;
39 |     if (nLoadLen>nLen) nLoadLen=nLen;
40 | 
41 |     // Loaded rom okay. Now insert into Dest
42 |     LoadEnd=Load+nLoadLen;
43 |     pd=Dest; pl=Load;
44 |     // Quickly copy in the bytes with a gap of 'nGap' between each byte
45 | 
46 |     if (bXor)
47 |     {
48 |       do { *pd ^= *pl++; pd+=nGap; } while (pl<LoadEnd);
49 |     }
50 |     else
51 |     {
52 |       do { *pd  = *pl++; pd+=nGap; } while (pl<LoadEnd);
53 |     }
54 |     free(Load);
55 |   }
56 |   else
57 |   {
58 |     // If no XOR, and gap of 1, just copy straight in
59 |     nRet=BurnExtLoadRom(Dest,NULL,i);
60 |     if (nRet!=0) return 1;
61 |   }
62 | 
63 |   return 0;
64 | }
65 | 
66 | int BurnLoadRom(unsigned char *Dest,int i,int nGap)
67 | {
68 |   return LoadRom(Dest,i,nGap,0);
69 | }
70 | 
71 | int BurnXorRom(unsigned char *Dest,int i,int nGap)
72 | {
73 |   return LoadRom(Dest,i,nGap,1);
74 | }
75 | 
76 | // Separate out a bitfield into Bit number 'nField' of each nibble in pDest
77 | // (end result: each dword in memory carries the 8 pixels of a tile line).
78 | int BurnLoadBitField(unsigned char *pDest,unsigned char *pSrc,int nField,int nSrcLen)
79 | {
80 |   int nPix=0;
81 |   for (nPix=0; nPix<(nSrcLen<<3); nPix++)
82 |   {
83 |     int nBit;
84 |     // Get the bitplane pixel value (on or off)
85 |     nBit=(*pSrc)>>(7-(nPix&7)); nBit&=1;
86 |     nBit<<=nField; // Move to correct bit for this field
87 | 
88 |     // use low nibble for each even pixel
89 |     if ((nPix&1)==1) nBit<<=4; // use high nibble for each odd pixel
90 | 
91 |     *pDest|=nBit; // OR into destination
92 |     if ((nPix&1)==1) pDest++;
93 |     if ((nPix&7)==7) pSrc++;
94 |   }
95 |   return 0;
96 | }
97 | 
98 | 


--------------------------------------------------------------------------------
/burn/misc/d_parent.cpp:
--------------------------------------------------------------------------------
  1 | // A module for keeping parents who have no driver in FBA
  2 | 
  3 | #include "burnint.h"
  4 | 
  5 | static unsigned char ParentReset         = 0;
  6 | 
  7 | static struct BurnInputInfo ParentInputList[] = {
  8 | 	{"Reset"             , BIT_DIGITAL  , &ParentReset        , "reset"     },
  9 | };
 10 | 
 11 | STDINPUTINFO(Parent);
 12 | 
 13 | static int ParentInit()
 14 | {
 15 | 	return 1;
 16 | }
 17 | 
 18 | static int ParentExit()
 19 | {
 20 | 	return 0;
 21 | }
 22 | 
 23 | static struct BurnRomInfo EightballactRomDesc[] = {
 24 | 	{ "8b-dk.5e",           0x01000, 0x166c1c9b, BRF_ESS | BRF_PRG },
 25 | 	{ "8b-dk.5c",           0x01000, 0x9ec87baa, BRF_ESS | BRF_PRG },
 26 | 	{ "8b-dk.5b",           0x01000, 0xf836a962, BRF_ESS | BRF_PRG },
 27 | 	{ "8b-dk.5a",           0x01000, 0xd45866d4, BRF_ESS | BRF_PRG },
 28 | 	
 29 | 	{ "8b-dk.3h",           0x00800, 0xa8752c60, BRF_ESS | BRF_PRG },
 30 | 
 31 | 	{ "8b-dk.3n",           0x00800, 0x44830867, BRF_GRA },
 32 | 	{ "8b-dk.3p",           0x00800, 0x6148c6f2, BRF_GRA },
 33 | 	
 34 | 	{ "8b-dk.7c",           0x00800, 0xe34409f5, BRF_GRA },
 35 | 	{ "8b-dk.7d",           0x00800, 0xb4dc37ca, BRF_GRA },
 36 | 	{ "8b-dk.7e",           0x00800, 0x655af8a8, BRF_GRA },
 37 | 	{ "8b-dk.7f",           0x00800, 0xa29b2763, BRF_GRA },
 38 | 	
 39 | 	{ "8b.2e",              0x00100, 0xc7379a12, BRF_GRA },
 40 | 	{ "8b.2f",              0x00100, 0x116612b4, BRF_GRA },
 41 | 	{ "8b.2n",              0x00100, 0x30586988, BRF_GRA },
 42 | 	
 43 | 	{ "82s147.prm",         0x00100, 0x46e5bc92, BRF_GRA },
 44 | 	
 45 | 	{ "pls153h.bin",        0x000eb, 0x00000000, BRF_NODUMP },
 46 | };
 47 | 
 48 | STD_ROM_PICK(Eightballact);
 49 | STD_ROM_FN(Eightballact);
 50 | 
 51 | struct BurnDriverD BurnDrvEightballact = {
 52 | 	"8ballact", NULL, NULL, "1984",
 53 | 	"Eight Ball Action (DK conversion)\0", NULL, "Seatongrove Ltd (Magic Eletronics USA licence)", "Miscellaneous",
 54 | 	NULL, NULL, NULL, NULL,
 55 | 	0, 2, HARDWARE_MISC_MISC,
 56 | 	NULL, EightballactRomInfo, EightballactRomName, ParentInputInfo, NULL,
 57 | 	ParentInit, ParentExit, NULL, NULL, NULL,
 58 | 	NULL, 256, 224, 4, 3
 59 | };
 60 | 
 61 | static struct BurnRomInfo ManiacsqRomDesc[] = {
 62 | 	{ "d8-d15.1m",          0x20000, 0x9121d1b6, BRF_ESS | BRF_PRG },
 63 | 	{ "d0-d7.1m",           0x20000, 0xa95cfd2a, BRF_ESS | BRF_PRG },
 64 | 	
 65 | 	{ "d0-d7.4m",           0x80000, 0xd8551b2f, BRF_GRA },
 66 | 	{ "d8-d15.4m",          0x80000, 0xb269c427, BRF_GRA },
 67 | 	{ "d16-d23.1m",         0x20000, 0xaf4ea5e7, BRF_GRA },
 68 | 	{ "d24-d31.1m",         0x20000, 0x578c3588, BRF_GRA },
 69 | };
 70 | 
 71 | STD_ROM_PICK(Maniacsq);
 72 | STD_ROM_FN(Maniacsq);
 73 | 
 74 | struct BurnDriverD BurnDrvManiacsq = {
 75 | 	"maniacsq", NULL, NULL, "1996",
 76 | 	"Maniac Square (unprotected)\0", NULL, "Gaelco", "Miscellaneous",
 77 | 	NULL, NULL, NULL, NULL,
 78 | 	0, 2, HARDWARE_MISC_MISC,
 79 | 	NULL, ManiacsqRomInfo, ManiacsqRomName, ParentInputInfo, NULL,
 80 | 	ParentInit, ParentExit, NULL, NULL, NULL,
 81 | 	NULL, 256, 224, 4, 3
 82 | };
 83 | 
 84 | static struct BurnRomInfo TumblepRomDesc[] = {
 85 | 	{ "hl00-1.f12",         0x40000, 0xfd697c1b, BRF_ESS | BRF_PRG },
 86 | 	{ "hl01-1.f13",         0x40000, 0xd5a62a3f, BRF_ESS | BRF_PRG },
 87 | 	
 88 | 	{ "hl02-.f16",          0x10000, 0xa5cab888, BRF_ESS | BRF_PRG },
 89 | 
 90 | 	{ "map-02.rom",         0x80000, 0xdfceaa26, BRF_GRA },
 91 | 	
 92 | 	{ "map-01.rom",         0x80000, 0xe81ffa09, BRF_GRA },
 93 | 	{ "map-00.rom",         0x80000, 0x8c879cfe, BRF_GRA },
 94 | 	
 95 | 	{ "hl03-.j15",          0x20000, 0x01b81da0, BRF_SND },
 96 | };
 97 | 
 98 | STD_ROM_PICK(Tumblep);
 99 | STD_ROM_FN(Tumblep);
100 | 
101 | struct BurnDriver BurnDrvTumblep = {
102 | 	"tumblep", NULL, NULL, "1991",
103 | 	"Tumble Pop (World)\0", NULL, "Data East Corporation", "Miscellaneous",
104 | 	NULL, NULL, NULL, NULL,
105 | 	0, 2, HARDWARE_MISC_MISC,
106 | 	NULL, TumblepRomInfo, TumblepRomName, ParentInputInfo, NULL,
107 | 	ParentInit, ParentExit, NULL, NULL, NULL,
108 | 	NULL, 256, 224, 4, 3
109 | };
110 | 


--------------------------------------------------------------------------------
/burn/misc/taito_68k/snd_tc0140.h:
--------------------------------------------------------------------------------
 1 | /*Taito sound controller
 2 | =========================
 3 | Part of FBAs Taito 68k hardware drivers
 4 | Credits: Mame team, Raine team
 5 | Coding by KEV, with help from Treble Winner and Jan_Klaassen
 6 | */
 7 | // taken from MAME
 8 | #ifndef __tc0140_H__
 9 | #define __tc0140_H__
10 | 
11 | void tc0140_port_w(unsigned char d);
12 | void tc0140_comm_w(unsigned char d);
13 | unsigned char tc0140_comm_r();
14 | 
15 | void tc0140_slave_port_w(unsigned char d);
16 | void tc0140_slave_comm_w(unsigned char d);
17 | unsigned char tc0140_slave_comm_r();
18 | 
19 | void tc0140_scan(int nAction);
20 | 
21 | #endif
22 | 
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/burn/misc/taito_68k/taito.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Part of FBAs Taito 68k hardware drivers
 3 | Credits: Mame team, Raine team
 4 | Coding by KEV, with help from Treble Winner and Jan_Klaassen
 5 | */
 6 | 
 7 | #ifndef __Taito_H__
 8 | #define __Taito_H__
 9 | #include "burnint.h"
10 | #include "burn_ym2151.h"
11 | #include "taito_gfx.h"
12 | #include "snd_tc0140.h"
13 | #include "rain_chip.h"
14 | extern int rCyclesDone[3];
15 | #endif
16 | 
17 | 
18 | 
19 | 
20 | 


--------------------------------------------------------------------------------
/burn/misc/taito_68k/taito_gfx.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Part of FBAs Taito 68k hardware drivers
 3 | Credits: Mame team, Raine team
 4 | Coding by KEV, with help from Treble Winner and Jan_Klaassen
 5 | */
 6 | #include "taito.h"
 7 | int nLastTileBpp=-1;
 8 | int nLastTileMaskBpp=-1;
 9 | int nLastSpriteMaskBpp=-1;
10 | int nLastSpriteBpp=-1;
11 | unsigned char taitoRecalcPal = 0;
12 | 
13 | unsigned char *tsprites=NULL;
14 | unsigned char *ttiles=NULL;
15 | 
16 | 
17 | void init_taito_gfx()
18 | {
19 | 	nLastTileBpp=-1;
20 | 	nLastTileMaskBpp=-1;
21 | 	nLastSpriteMaskBpp=-1;
22 | 	nLastSpriteBpp=-1;
23 | 
24 | }
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/burn/misc/taito_68k/taito_gfx.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | Part of FBAs Taito 68k hardware drivers
 3 | Credits: Mame team, Raine team
 4 | Coding by KEV, with help from Treble Winner and Jan_Klaassen
 5 | */
 6 | 
 7 | #ifndef __TAITOGFX_H__
 8 | #define __TAITOGFX_H__
 9 | 
10 | // Common Stuff
11 | extern unsigned int *taito_pal;
12 | extern int nLastTileBpp;
13 | extern int nLastTileMaskBpp;
14 | extern int nLastSpriteMaskBpp;
15 | extern int nLastSpriteBpp;
16 | extern unsigned char taitoRecalcPal;
17 | 
18 | extern unsigned char *tsprites; // Sprite buffer
19 | extern unsigned char *ttiles; // Tile Buffer
20 | void init_taito_gfx();
21 | 
22 | // PC090OJ - used for sprites in Rastan, Rainbow and OpWolf
23 | extern unsigned char *PC090OJ_word_0;
24 | extern unsigned char *PC090OJ_spritectrl;
25 | void PC090OJ_draw_sprites();
26 | 
27 | // PC080SN - used for backgrounds in Rastan, Rainbow and OpWolf
28 | // This will need to be redone as its not 100% accurate. :)
29 | extern unsigned char *PC080SN_word_0,*PC080SN_yscroll_word_0;
30 | extern unsigned char *PC080SN_xscroll_word_0,*PC080SN_ctrl_word_0;
31 | void PC080SN_bg();
32 | void PC080SN_fg();
33 | void draw_gun(int x, int y);
34 | void init_gun();
35 | extern int p1scrollx,p2scrollx;
36 | extern int p1scrolly,p2scrolly;
37 | 
38 | //tatio systemx
39 | void SysXSprites();
40 | void SysXBG();
41 | extern unsigned char *sysbvidattr,*sysbvidram;
42 | void SysXInit(int game);
43 | extern unsigned char *SysxTempGfx;
44 | 
45 | 
46 | #endif
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/burn/msm5205.h:
--------------------------------------------------------------------------------
 1 | #define MAX_MSM5205 (4)  // maximum number of adpcm channels
 2 | int MSM5205Init(int nChip, int nSamplerate, float fMaxVolume, bool bAddSignal);
 3 | void MSM5205Reset(int nChip);
 4 | void MSM5205Exit(int nChip);
 5 | int MSM5205Render(int nChip, short* pSoundBuf, int nSegmentLength);
 6 | int MSM5205Scan(int nChip, int nAction);
 7 | void MSM5205Play(unsigned int nStart, unsigned int nEnd, int channel);
 8 | 
 9 | inline static unsigned int adpcmReadStatus()
10 | {
11 | 	extern unsigned int nadpcmStatus;
12 | 	return nadpcmStatus;
13 | }
14 | 
15 | extern unsigned char* MSM5205ROM;
16 | 
17 | extern unsigned char* MSM5205SampleInfo[MAX_MSM5205];
18 | extern unsigned char* MSM5205SampleData[MAX_MSM5205];
19 | 
20 | 


--------------------------------------------------------------------------------
/burn/msm6295.h:
--------------------------------------------------------------------------------
 1 | // MSM6295 module header
 2 | 
 3 | #define MAX_MSM6295 (2)
 4 | 
 5 | int MSM6295Init(int nChip, int nSamplerate, float fMaxVolume, bool bAddSignal);
 6 | void MSM6295Reset(int nChip);
 7 | void MSM6295Exit(int nChip);
 8 | 
 9 | int MSM6295Render(int nChip, short* pSoundBuf, int nSegmenLength);
10 | void MSM6295Command(int nChip, unsigned char nCommand);
11 | int MSM6295Scan(int nChip, int nAction);
12 | 
13 | extern unsigned char* MSM6295ROM;
14 | extern unsigned char* MSM6295SampleInfo[MAX_MSM6295][4];
15 | extern unsigned char* MSM6295SampleData[MAX_MSM6295][4];
16 | 
17 | inline static unsigned int MSM6295ReadStatus(const int nChip)
18 | {
19 | 	extern unsigned int nMSM6295Status[MAX_MSM6295];
20 | 
21 | 	return nMSM6295Status[nChip];
22 | }
23 | 
24 | 


--------------------------------------------------------------------------------
/burn/neogeo/neo_palette.cpp:
--------------------------------------------------------------------------------
  1 | #include "neogeo.h"
  2 | // Neo Geo -- palette functions
  3 | 
  4 | unsigned char* NeoPalSrc[2];		// Pointer to input palettes
  5 | unsigned int* NeoPalette;
  6 | int nNeoPaletteBank;				// Selected palette bank
  7 | 
  8 | static unsigned int* NeoPaletteData[2] = {NULL, NULL};
  9 | static unsigned short* NeoPaletteCopy[2] = {NULL, NULL};
 10 | 
 11 | unsigned char NeoRecalcPalette;
 12 | 
 13 | int NeoInitPalette()
 14 | {
 15 | 	for (int i = 0; i < 2; i++) {
 16 | 		free(NeoPaletteData[i]);
 17 | 		free(NeoPaletteCopy[i]);
 18 | 		NeoPaletteData[i] = (unsigned int*)malloc(4096 * sizeof(int));
 19 | 		NeoPaletteCopy[i] = (unsigned short*)malloc(4096 * sizeof(short));
 20 | 	}
 21 | 
 22 | 	NeoRecalcPalette = 1;
 23 | 
 24 | 	return 0;
 25 | }
 26 | 
 27 | void NeoExitPalette()
 28 | {
 29 | 	for (int i = 0; i < 2; i++) {
 30 | 		free(NeoPaletteData[i]);
 31 | 		free(NeoPaletteCopy[i]);
 32 | 		NeoPaletteData[i] = NULL;
 33 | 		NeoPaletteCopy[i] = NULL;
 34 | 	}
 35 | }
 36 | 
 37 | inline static unsigned int CalcCol(unsigned short nColour)
 38 | {
 39 | 	int r = (nColour & 0x0F00) >> 4;	// Red
 40 | 	r |= (nColour >> 11) & 8;
 41 | 	int g = (nColour & 0x00F0);			// Green
 42 | 	g |= (nColour >> 10) & 8;
 43 | 	int b = (nColour & 0x000F) << 4;	// Blue
 44 | 	b |= (nColour >> 9) & 8;
 45 | 
 46 | 	r |= r >> 5;
 47 | 	g |= g >> 5;
 48 | 	b |= b >> 5;
 49 | 
 50 | 	return BurnHighCol(r, g, b, 0);
 51 | }
 52 | 
 53 | int NeoUpdatePalette()
 54 | {
 55 | 	if (NeoRecalcPalette) {
 56 | 		int i;
 57 | 		unsigned short* ps;
 58 | 		unsigned short* pc;
 59 | 		unsigned int* pd;
 60 | 
 61 | 		// Update both palette banks
 62 | 		for (int j = 0; j < 2; j++) {
 63 | 			for (i = 0, ps = (unsigned short*)NeoPalSrc[j], pc = NeoPaletteCopy[j], pd = NeoPaletteData[j]; i < 4096; i++, ps++, pc++, pd++) {
 64 | 				*pc = *ps;
 65 | 				*pd = CalcCol(*ps);
 66 | 			}
 67 | 		}
 68 | 
 69 | 		NeoRecalcPalette = 0;
 70 | 
 71 | 	}
 72 | 
 73 | 	return 0;
 74 | }
 75 | 
 76 | void NeoSetPalette()
 77 | {
 78 | 	NeoPalette = NeoPaletteData[nNeoPaletteBank];
 79 | }
 80 | 
 81 | // Update the PC copy of the palette on writes to the palette memory
 82 | void __fastcall NeoPalWriteByte(unsigned int nAddress, unsigned char byteValue)
 83 | {
 84 | 	nAddress &= 0x1FFF;
 85 | 	nAddress ^= 1;
 86 | 
 87 | 	NeoPalSrc[nNeoPaletteBank][nAddress] = byteValue;							// write byte
 88 | 
 89 | 	if (*((unsigned char*)(NeoPaletteCopy[nNeoPaletteBank] + nAddress)) != byteValue) {
 90 | 		*((unsigned char*)(NeoPaletteCopy[nNeoPaletteBank] + nAddress)) = byteValue;
 91 | 		NeoPaletteData[nNeoPaletteBank][nAddress >> 1] = CalcCol(*(unsigned short*)(NeoPalSrc[nNeoPaletteBank] + (nAddress & ~0x01)));
 92 | 	}
 93 | }
 94 | 
 95 | void __fastcall NeoPalWriteWord(unsigned int nAddress, unsigned short wordValue)
 96 | {
 97 | 	nAddress &= 0x1FFF;
 98 | 	nAddress >>= 1;
 99 | 
100 | 	((unsigned short*)NeoPalSrc[nNeoPaletteBank])[nAddress] = wordValue;		// write word
101 | 
102 | 	if (NeoPaletteCopy[nNeoPaletteBank][nAddress] != wordValue) {
103 | 		NeoPaletteCopy[nNeoPaletteBank][nAddress] = wordValue;
104 | 		NeoPaletteData[nNeoPaletteBank][nAddress] = CalcCol(wordValue);
105 | 	}
106 | }
107 | 
108 | 


--------------------------------------------------------------------------------
/burn/neogeo/neo_sprite.cpp:
--------------------------------------------------------------------------------
  1 | #include "neogeo.h"
  2 | 
  3 | unsigned char* NeoSpriteROM;
  4 | unsigned char* NeoZoomROM;
  5 | 
  6 | static unsigned char* NeoTileAttrib = NULL;
  7 | 
  8 | unsigned int nNeoTileMask;
  9 | int nNeoMaxTile;
 10 | 
 11 | int nSliceStart, nSliceEnd, nSliceSize;
 12 | 
 13 | static unsigned int* pTileData;
 14 | static unsigned int* pTilePalette;
 15 | 
 16 | static unsigned short* pBank;
 17 | 
 18 | static int nBankSize;
 19 | static int nBankXPos, nBankYPos;
 20 | static int nBankXZoom, nBankYZoom;
 21 | 
 22 | static int nNeoSpriteFrame04, nNeoSpriteFrame08;
 23 | 
 24 | static int nLastBPP = -1;
 25 | 
 26 | typedef void (*RenderBankFunction)();
 27 | static RenderBankFunction* RenderBank;
 28 | 
 29 | // Include the tile rendering functions
 30 | #include "neo_sprite_func.h"
 31 | 
 32 | #include "cache.h"
 33 | int NeoRenderSprites()
 34 | {
 35 | 	if (nLastBPP != nBurnBpp ) {
 36 | 		nLastBPP = nBurnBpp;
 37 | 
 38 | 		RenderBank = RenderBankNormal[nBurnBpp - 2];
 39 | 	}
 40 | 
 41 | 	if (!(nBurnLayer & 1)) {
 42 | 		return 0;
 43 | 	}
 44 | 
 45 | 	unsigned short BankAttrib01, BankAttrib02, BankAttrib03;
 46 | 
 47 | 	nNeoSpriteFrame04 = nNeoSpriteFrame & 3;
 48 | 	nNeoSpriteFrame08 = nNeoSpriteFrame & 7;
 49 | 
 50 | 	for (int nBank = 1; nBank < 0x17D; nBank++) {
 51 | 
 52 | 		BankAttrib01 = *((unsigned short*)(NeoGraphicsRAM + 0x010000 + (nBank << 1)));
 53 | 		BankAttrib02 = *((unsigned short*)(NeoGraphicsRAM + 0x010400 + (nBank << 1)));
 54 | 		BankAttrib03 = *((unsigned short*)(NeoGraphicsRAM + 0x010800 + (nBank << 1)));
 55 | 
 56 | 		pBank = (unsigned short*)(NeoGraphicsRAM + (nBank << 7));
 57 | 
 58 | 		if (BankAttrib02 & 0x40) {
 59 | 			nBankXPos += nBankXZoom + 1;
 60 | 		} else {
 61 | 			nBankYPos = (0x0200 - (BankAttrib02 >> 7)) & 0x01FF;
 62 | 			nBankXPos = (BankAttrib03 >> 7);
 63 | 			if (nNeoScreenWidth == 304) {
 64 | 				nBankXPos -= 8;
 65 | 			}
 66 | 
 67 | 			nBankYZoom = BankAttrib01 & 0xFF;
 68 | 
 69 | 			nBankSize = (BankAttrib02 & 0x3F);
 70 | 			if (nBankSize > 0x20) {
 71 | 				nBankSize = 0x20;
 72 | 			}
 73 | 
 74 | //			if (nBankSize /* > 0x10 */ && nSliceStart == 0x10) bprintf(PRINT_NORMAL, _T("bank: %04X, x: %04X, y: %04X, zoom: %02X, size: %02X.\n"), nBank, nBankXPos, nBankYPos, nBankYZoom, nBankSize);
 75 | 		}
 76 | 
 77 | 		if (nBankSize) {
 78 | 
 79 | 			nBankXZoom = (BankAttrib01 >> 8) & 0x0F;
 80 | 			if (nBankXPos >= 0x01E0) {
 81 | 				nBankXPos -= 0x200;
 82 | 			}
 83 | 
 84 | 			if (nBankXPos >= 0 && nBankXPos < (nNeoScreenWidth - nBankXZoom - 1)) {
 85 | 				RenderBank[nBankXZoom]();
 86 | 			} else {
 87 | 				if (nBankXPos >= -nBankXZoom && nBankXPos < nNeoScreenWidth) {
 88 | 					RenderBank[nBankXZoom + 16]();
 89 | 				}
 90 | 			}
 91 | 		}
 92 | 	}
 93 | 
 94 | //	bprintf(PRINT_NORMAL, _T("\n"));
 95 | 
 96 | 	return 0;
 97 | }
 98 | 
 99 | int NeoInitSprites()
100 | {
101 | 	// Create a table that indicates if a tile is transparent
102 | 	NeoTileAttrib = (unsigned char*)malloc(nNeoTileMask + 1);
103 | 	if ( bBurnUseRomCache ) {
104 | 		BurnCacheRead(NeoTileAttrib, 5);
105 | 	} else {
106 | 	for (int i = 0; i < nNeoMaxTile; i++) {
107 | 		bool bTransparent = true;
108 | 		for (int j = i << 7; j < (i + 1) << 7; j++) {
109 | 			if (NeoSpriteROM[j]) {
110 | 				bTransparent = false;
111 | 				break;
112 | 			}
113 | 		}
114 | 		if (bTransparent) {
115 | 			NeoTileAttrib[i] = 1;
116 | 		} else {
117 | 			NeoTileAttrib[i] = 0;
118 | 		}
119 | 	}
120 | 
121 | 	for (unsigned int i = nNeoMaxTile; i < nNeoTileMask + 1; i++) {
122 | 		NeoTileAttrib[i] = 1;
123 | 	}
124 | 
125 | 	}
126 | 	return 0;
127 | }
128 | 
129 | void NeoExitSprites()
130 | {
131 | 	free(NeoTileAttrib);
132 | }
133 | 
134 | 


--------------------------------------------------------------------------------
/burn/neogeo/neo_sprite_func_table.h:
--------------------------------------------------------------------------------
 1 | // Table with all function addresses.
 2 | static RenderBankFunction RenderBankFunctionTable[] = {
 3 | 	&RenderBank16_ZOOM0_NOCLIP_TRANS, &RenderBank16_ZOOM1_NOCLIP_TRANS, &RenderBank16_ZOOM2_NOCLIP_TRANS, &RenderBank16_ZOOM3_NOCLIP_TRANS, &RenderBank16_ZOOM4_NOCLIP_TRANS, &RenderBank16_ZOOM5_NOCLIP_TRANS, &RenderBank16_ZOOM6_NOCLIP_TRANS, &RenderBank16_ZOOM7_NOCLIP_TRANS, &RenderBank16_ZOOM8_NOCLIP_TRANS, &RenderBank16_ZOOM9_NOCLIP_TRANS, &RenderBank16_ZOOM10_NOCLIP_TRANS, &RenderBank16_ZOOM11_NOCLIP_TRANS, &RenderBank16_ZOOM12_NOCLIP_TRANS, &RenderBank16_ZOOM13_NOCLIP_TRANS, &RenderBank16_ZOOM14_NOCLIP_TRANS, &RenderBank16_ZOOM15_NOCLIP_TRANS, 
 4 | 	&RenderBank16_ZOOM0_CLIP_TRANS, &RenderBank16_ZOOM1_CLIP_TRANS, &RenderBank16_ZOOM2_CLIP_TRANS, &RenderBank16_ZOOM3_CLIP_TRANS, &RenderBank16_ZOOM4_CLIP_TRANS, &RenderBank16_ZOOM5_CLIP_TRANS, &RenderBank16_ZOOM6_CLIP_TRANS, &RenderBank16_ZOOM7_CLIP_TRANS, &RenderBank16_ZOOM8_CLIP_TRANS, &RenderBank16_ZOOM9_CLIP_TRANS, &RenderBank16_ZOOM10_CLIP_TRANS, &RenderBank16_ZOOM11_CLIP_TRANS, &RenderBank16_ZOOM12_CLIP_TRANS, &RenderBank16_ZOOM13_CLIP_TRANS, &RenderBank16_ZOOM14_CLIP_TRANS, &RenderBank16_ZOOM15_CLIP_TRANS, 
 5 | 	&RenderBank24_ZOOM0_NOCLIP_TRANS, &RenderBank24_ZOOM1_NOCLIP_TRANS, &RenderBank24_ZOOM2_NOCLIP_TRANS, &RenderBank24_ZOOM3_NOCLIP_TRANS, &RenderBank24_ZOOM4_NOCLIP_TRANS, &RenderBank24_ZOOM5_NOCLIP_TRANS, &RenderBank24_ZOOM6_NOCLIP_TRANS, &RenderBank24_ZOOM7_NOCLIP_TRANS, &RenderBank24_ZOOM8_NOCLIP_TRANS, &RenderBank24_ZOOM9_NOCLIP_TRANS, &RenderBank24_ZOOM10_NOCLIP_TRANS, &RenderBank24_ZOOM11_NOCLIP_TRANS, &RenderBank24_ZOOM12_NOCLIP_TRANS, &RenderBank24_ZOOM13_NOCLIP_TRANS, &RenderBank24_ZOOM14_NOCLIP_TRANS, &RenderBank24_ZOOM15_NOCLIP_TRANS, 
 6 | 	&RenderBank24_ZOOM0_CLIP_TRANS, &RenderBank24_ZOOM1_CLIP_TRANS, &RenderBank24_ZOOM2_CLIP_TRANS, &RenderBank24_ZOOM3_CLIP_TRANS, &RenderBank24_ZOOM4_CLIP_TRANS, &RenderBank24_ZOOM5_CLIP_TRANS, &RenderBank24_ZOOM6_CLIP_TRANS, &RenderBank24_ZOOM7_CLIP_TRANS, &RenderBank24_ZOOM8_CLIP_TRANS, &RenderBank24_ZOOM9_CLIP_TRANS, &RenderBank24_ZOOM10_CLIP_TRANS, &RenderBank24_ZOOM11_CLIP_TRANS, &RenderBank24_ZOOM12_CLIP_TRANS, &RenderBank24_ZOOM13_CLIP_TRANS, &RenderBank24_ZOOM14_CLIP_TRANS, &RenderBank24_ZOOM15_CLIP_TRANS, 
 7 | 	&RenderBank32_ZOOM0_NOCLIP_TRANS, &RenderBank32_ZOOM1_NOCLIP_TRANS, &RenderBank32_ZOOM2_NOCLIP_TRANS, &RenderBank32_ZOOM3_NOCLIP_TRANS, &RenderBank32_ZOOM4_NOCLIP_TRANS, &RenderBank32_ZOOM5_NOCLIP_TRANS, &RenderBank32_ZOOM6_NOCLIP_TRANS, &RenderBank32_ZOOM7_NOCLIP_TRANS, &RenderBank32_ZOOM8_NOCLIP_TRANS, &RenderBank32_ZOOM9_NOCLIP_TRANS, &RenderBank32_ZOOM10_NOCLIP_TRANS, &RenderBank32_ZOOM11_NOCLIP_TRANS, &RenderBank32_ZOOM12_NOCLIP_TRANS, &RenderBank32_ZOOM13_NOCLIP_TRANS, &RenderBank32_ZOOM14_NOCLIP_TRANS, &RenderBank32_ZOOM15_NOCLIP_TRANS, 
 8 | 	&RenderBank32_ZOOM0_CLIP_TRANS, &RenderBank32_ZOOM1_CLIP_TRANS, &RenderBank32_ZOOM2_CLIP_TRANS, &RenderBank32_ZOOM3_CLIP_TRANS, &RenderBank32_ZOOM4_CLIP_TRANS, &RenderBank32_ZOOM5_CLIP_TRANS, &RenderBank32_ZOOM6_CLIP_TRANS, &RenderBank32_ZOOM7_CLIP_TRANS, &RenderBank32_ZOOM8_CLIP_TRANS, &RenderBank32_ZOOM9_CLIP_TRANS, &RenderBank32_ZOOM10_CLIP_TRANS, &RenderBank32_ZOOM11_CLIP_TRANS, &RenderBank32_ZOOM12_CLIP_TRANS, &RenderBank32_ZOOM13_CLIP_TRANS, &RenderBank32_ZOOM14_CLIP_TRANS, &RenderBank32_ZOOM15_CLIP_TRANS, 
 9 | };
10 | 
11 | static RenderBankFunction* RenderBankNormal[3] = {
12 | 	&RenderBankFunctionTable[0],
13 | 	&RenderBankFunctionTable[32],
14 | 	&RenderBankFunctionTable[64]
15 | };
16 | 


--------------------------------------------------------------------------------
/burn/neogeo/neo_text_render.h:
--------------------------------------------------------------------------------
 1 | #define FN(a) RenderTile ## a
 2 | #define FUNCTIONNAME(a) FN(a)
 3 | 
 4 | #define ISOPAQUE 0
 5 | 
 6 | #define ADVANCECOLUMN pPixel += (BPP >> 3)
 7 | 
 8 | #define ADVANCEROW pTileRow += ((BPP >> 3) * nNeoScreenWidth)
 9 | 
10 | #if ISOPAQUE == 0
11 |  #define OPACITY _TRANS
12 |  #define TESTCOLOUR(x) x
13 | #elif ISOPAQUE == 1
14 |  #define OPACITY _OPAQUE
15 |  #define TESTCOLOUR(x) 1
16 | #else
17 |  #error illegal isopaque value
18 | #endif
19 | 
20 | #if BPP == 16
21 |  #define PLOTPIXEL(a,b) if (TESTCOLOUR(b)) {						\
22 |    	*((unsigned short*)pPixel) = (unsigned short)pTilePalette[b];	\
23 |  }
24 | #elif BPP == 24
25 |  #define PLOTPIXEL(a,b) if (TESTCOLOUR(b)) {						\
26 | 	unsigned int nRGB = pTilePalette[b];							\
27 | 	pPixel[0] = (unsigned char)nRGB;								\
28 | 	pPixel[1] = (unsigned char)(nRGB >> 8);							\
29 | 	pPixel[2] = (unsigned char)(nRGB >> 16);						\
30 |  }
31 | #elif BPP == 32
32 |  #define PLOTPIXEL(a,b) if (TESTCOLOUR(b)) {						\
33 | 	*((unsigned int*)pPixel) = (unsigned int)pTilePalette[b];		\
34 |  }
35 | #else
36 |  #error unsupported bitdepth specified.
37 | #endif
38 | 
39 | static void FUNCTIONNAME(BPP)()
40 | {
41 | 	unsigned char *pTileRow, *pPixel;
42 | 	int y, nColour;
43 | 
44 | 	for (y = 0, pTileRow = pTile; y < 8; y++, ADVANCEROW) {
45 | 		pPixel = pTileRow;
46 | 
47 | 		nColour = *pTileData++;
48 | 		PLOTPIXEL(0,nColour >> 4);
49 | 		ADVANCECOLUMN;
50 | 		PLOTPIXEL(1,nColour & 0x0F);
51 | 		ADVANCECOLUMN;
52 | 
53 | 		nColour = *pTileData++;
54 | 		PLOTPIXEL(2,nColour >> 4);
55 | 		ADVANCECOLUMN;
56 | 		PLOTPIXEL(3,nColour & 0x0F);
57 | 		ADVANCECOLUMN;
58 | 
59 | 		nColour = *pTileData++;
60 | 		PLOTPIXEL(4,nColour >> 4);
61 | 		ADVANCECOLUMN;
62 | 		PLOTPIXEL(5,nColour & 0x0F);
63 | 		ADVANCECOLUMN;
64 | 
65 | 		nColour = *pTileData++;
66 | 		PLOTPIXEL(6,nColour >> 4);
67 | 		ADVANCECOLUMN;
68 | 		PLOTPIXEL(7,nColour & 0x0F);
69 | 	}
70 | }
71 | 
72 | #undef PLOTPIXEL
73 | #undef TESTCLIP
74 | #undef TESTCOLOUR
75 | #undef ADVANCEROW
76 | #undef ADVANCECOLUMN
77 | #undef CLIP
78 | #undef FUNCTIONNAME
79 | #undef FN
80 | 


--------------------------------------------------------------------------------
/burn/pgm/pgm.h:
--------------------------------------------------------------------------------
 1 | #include "burnint.h"
 2 | 
 3 | // pgm_run.cpp
 4 | extern unsigned char PgmJoy1[];
 5 | extern unsigned char PgmJoy2[];
 6 | extern unsigned char PgmJoy3[];
 7 | extern unsigned char PgmJoy4[];
 8 | extern unsigned char PgmBtn1[];
 9 | extern unsigned char PgmBtn2[];
10 | extern unsigned char PgmInput[];
11 | extern unsigned char PgmReset;
12 | 
13 | extern int pgmInit();
14 | extern int pgmExit();
15 | extern int pgmFrame();
16 | extern int pgmDraw();
17 | extern int pgmScan(int /*nAction*/, int */*pnMin*/);
18 | 
19 | extern int nPGM68KROMLen;
20 | extern unsigned char *USER0, *USER1, *USER2;
21 | extern unsigned char *PGM68KROM, *PGMTileROM, *PGMTileROMExp, *PGMSPRColROM, *PGMSPRMaskROM, *PGMSNDROM;
22 | extern unsigned short *RamRs, *RamPal, *RamVReg, *RamSpr;
23 | extern unsigned int *RamBg, *RamTx, *RamCurPal;
24 | extern unsigned char nPgmPalRecalc;
25 | 
26 | extern void (*pPgmInitCallback)();
27 | extern int (*pPgmScanCallback)(int, int*);
28 | 
29 | // pgm_draw
30 | extern int pgmDraw();
31 | 
32 | // pgm_snd
33 | extern unsigned char ics2115read(unsigned char offset);
34 | extern void ics2115write(unsigned char offset, unsigned char data);
35 | 
36 | extern int ics2115_init();
37 | extern void ics2115_exit();
38 | extern void ics2115_reset();
39 | 
40 | extern unsigned short ics2115_soundlatch_r(int i);
41 | extern void ics2115_soundlatch_w(int i, unsigned short d);
42 | 
43 | extern void ics2115_frame();
44 | extern void ics2115_update(int length);
45 | extern void ics2115_scan(int nAction,int *pnMin);
46 | 
47 | // pgm_prot.cpp
48 | 
49 | extern void pgm_asic28_w(unsigned short offset, unsigned short data);
50 | extern unsigned short pgm_asic28_r(unsigned short offset);
51 | 
52 | extern void pgm_asic3_reg_w(unsigned short offset, unsigned short data);
53 | extern void pgm_asic3_w(unsigned short offset, unsigned short data);
54 | extern unsigned char pgm_asic3_r(unsigned short offset);
55 | extern unsigned short sango_protram_r(unsigned short offset);
56 | 
57 | extern unsigned short dw2_d80000_r(unsigned int sekAddress);
58 | 
59 | extern unsigned short *killbld_sharedprotram;
60 | extern void killbld_prot_w(unsigned int sekAddress, unsigned short data);
61 | extern unsigned short killbld_prot_r(unsigned int sekAddress);
62 | 
63 | extern unsigned short PSTARS_protram_r(unsigned int sekAddress);
64 | extern unsigned short PSTARS_r16(unsigned int sekAddress);
65 | extern void PSTARS_w16(unsigned int sekAddress, unsigned short data);
66 | 
67 | extern void olds_w16(unsigned int offset, unsigned short data);
68 | extern unsigned short olds_r16(unsigned short offset);
69 | 
70 | extern void prot_reset();
71 | 
72 | extern int asic28Scan(int nAction,int */*pnMin*/);
73 | extern int asic3Scan(int nAction,int */*pnMin*/);
74 | extern int killbldtScan(int nAction,int */*pnMin*/);
75 | extern int pstarsScan(int nAction,int */*pnMin*/);
76 | extern int oldsScan(int nAction,int */*pnMin*/);
77 | 
78 | // pgm_crypt.cpp
79 | 
80 | extern void pgm_kov_decrypt();
81 | extern void pgm_kovsh_decrypt();
82 | extern void pgm_dw2_decrypt();
83 | extern void pgm_djlzz_decrypt();
84 | extern void pgm_pstar_decrypt();
85 | extern void pgm_dw3_decrypt();
86 | extern void pgm_killbld_decrypt();
87 | extern void pgm_dfront_decrypt();
88 | extern void pgm_ddp2_decrypt();
89 | extern void pgm_mm_decrypt();
90 | extern void pgm_kov2_decrypt();
91 | extern void pgm_puzzli2_decrypt();
92 | 
93 | 


--------------------------------------------------------------------------------
/burn/psikyo/psikyo.h:
--------------------------------------------------------------------------------
 1 | #include "burnint.h"
 2 | 
 3 | // General
 4 | enum {
 5 | 	PSIKYO_HW_SAMURAIA,
 6 | 	PSIKYO_HW_GUNBIRD,
 7 | 	PSIKYO_HW_S1945,
 8 | 	PSIKYO_HW_TENGAI
 9 | };
10 | 
11 | extern int PsikyoHardwareVersion;
12 | 
13 | // palette
14 | int PsikyoPalInit();
15 | int PsikyoPalExit();
16 | int PsikyoPalUpdate();
17 | 
18 | void PsikyoPalWriteByte(unsigned int nAddress, unsigned char byteValue);
19 | void PsikyoPalWriteWord(unsigned int nAddress, unsigned short wordValue);
20 | 
21 | extern unsigned char* PsikyoPalSrc;
22 | extern unsigned char PsikyoRecalcPalette;
23 | extern unsigned int* PsikyoPalette;
24 | 
25 | // Tile rendering
26 | int PsikyoTileRender();
27 | void PsikyoSetTileBank(int nLayer, int nBank);
28 | int PsikyoTileInit(unsigned int nROMSize);
29 | void PsikyoTileExit();
30 | 
31 | extern unsigned char* PsikyoTileROM;
32 | extern unsigned char* PsikyoTileRAM[3];
33 | 
34 | extern bool bPsikyoClearBackground;
35 | 
36 | // Sprite rendering
37 | int PsikyoSpriteInit(int nROMSize);
38 | void PsikyoSpriteExit();
39 | int PsikyoSpriteBuffer();
40 | int PsikyoSpriteRender(int nLowPriority, int nHighPriority);
41 | 
42 | extern unsigned char* PsikyoSpriteROM;
43 | extern unsigned char* PsikyoSpriteRAM;
44 | extern unsigned char* PsikyoSpriteLUT;
45 | 


--------------------------------------------------------------------------------
/burn/psikyo/psikyo_palette.cpp:
--------------------------------------------------------------------------------
 1 | #include "psikyo.h"
 2 | 
 3 | unsigned char* PsikyoPalSrc;
 4 | unsigned char PsikyoRecalcPalette;	// Set to 1 to force recalculation of the entire palette
 5 | 
 6 | unsigned int* PsikyoPalette;
 7 | static unsigned short* PsikyoPalCopy;
 8 | 
 9 | int PsikyoPalInit()
10 | {
11 | 	PsikyoPalette = (unsigned int*)malloc(0x1000 * sizeof(int));
12 | 	memset(PsikyoPalette, 0, 0x1000 * sizeof(int));
13 | 
14 | 	PsikyoPalCopy = (unsigned short*)malloc(0x1000 * sizeof(short));
15 | 	memset(PsikyoPalCopy, 0, 0x1000 * sizeof(short));
16 | 
17 | 	return 0;
18 | }
19 | 
20 | int PsikyoPalExit()
21 | {
22 | 	free(PsikyoPalette);
23 | 	PsikyoPalette = NULL;
24 | 	free(PsikyoPalCopy);
25 | 	PsikyoPalCopy = NULL;
26 | 
27 | 	return 0;
28 | }
29 | 
30 | inline static unsigned int CalcCol(unsigned short nColour)
31 | {
32 | 	int r, g, b;
33 | 
34 | 	r = (nColour & 0x7C00) >> 7;  	// Red
35 | 	r |= r >> 5;
36 | 	g = (nColour & 0x03E0) >> 2;	// Green
37 | 	g |= g >> 5;
38 | 	b = (nColour & 0x001F) << 3;	// Blue
39 | 	b |= b >> 5;
40 | 
41 | 	return BurnHighCol(r, g, b, 0);
42 | }
43 | 
44 | int PsikyoPalUpdate()
45 | {
46 | 	if (PsikyoRecalcPalette) {
47 | 		unsigned short c;
48 | 
49 | 		for (int i = 0; i < 0x1000; i++) {
50 | 			c = ((unsigned short*)PsikyoPalSrc)[i];
51 | 			PsikyoPalCopy[i] = c;
52 | 			PsikyoPalette[i] = CalcCol(c);
53 | 		}
54 | 
55 | 		PsikyoRecalcPalette = 0;
56 | 	}
57 | 
58 | 	return 0;
59 | }
60 | 
61 | // Update the PC copy of the palette on writes to the palette memory
62 | void PsikyoPalWriteByte(unsigned int nAddress, unsigned char byteValue)
63 | {
64 | 	nAddress ^= 1;
65 | 	PsikyoPalSrc[nAddress] = byteValue;							// write byte
66 | 
67 | 	if (*((unsigned char*)(PsikyoPalCopy + nAddress)) != byteValue) {
68 | 		*((unsigned char*)(PsikyoPalCopy + nAddress)) = byteValue;
69 | 		PsikyoPalette[nAddress >> 1] = CalcCol(*(unsigned short*)(PsikyoPalSrc + (nAddress & ~0x01)));
70 | 	}
71 | }
72 | 
73 | void PsikyoPalWriteWord(unsigned int nAddress, unsigned short wordValue)
74 | {
75 | 	nAddress >>= 1;
76 | 
77 | 	((unsigned short*)PsikyoPalSrc)[nAddress] = wordValue;		// write word
78 | 
79 | 	if (PsikyoPalCopy[nAddress] != wordValue) {
80 | 		PsikyoPalCopy[nAddress] = wordValue;
81 | 		PsikyoPalette[nAddress] = CalcCol(wordValue);
82 | 	}
83 | }
84 | 
85 | 


--------------------------------------------------------------------------------
/burn/psikyo/psikyo_render.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/burn/psikyo/psikyo_render.h


--------------------------------------------------------------------------------
/burn/sega/fd1094.h:
--------------------------------------------------------------------------------
1 | #define FD1094_STATE_RESET	0x0100
2 | #define FD1094_STATE_IRQ	0x0200
3 | #define FD1094_STATE_RTE	0x0300
4 | 
5 | int fd1094_set_state(unsigned char *key,int state);
6 | int fd1094_decode(int address,int val,unsigned char *key,int vector_fetch);
7 | 


--------------------------------------------------------------------------------
/burn/sekdebug.h:
--------------------------------------------------------------------------------
 1 | typedef enum SekRegister {
 2 | 	SEK_REG_D0, SEK_REG_D1, SEK_REG_D2, SEK_REG_D3, SEK_REG_D4, SEK_REG_D5, SEK_REG_D6, SEK_REG_D7,
 3 | 	SEK_REG_A0, SEK_REG_A1, SEK_REG_A2, SEK_REG_A3, SEK_REG_A4, SEK_REG_A5, SEK_REG_A6, SEK_REG_A7,
 4 | 	SEK_REG_PC,
 5 | 	SEK_REG_SR,
 6 | 	SEK_REG_SP, SEK_REG_USP, SEK_REG_ISP, SEK_REG_MSP,
 7 | 	SEK_REG_VBR,
 8 | 	SEK_REG_SFC, SEK_REG_DFC,
 9 | 	SEK_REG_CACR, SEK_REG_CAAR
10 | };
11 | 
12 | extern void (*SekDbgBreakpointHandlerRead)(unsigned int, int);
13 | extern void (*SekDbgBreakpointHandlerFetch)(unsigned int, int);
14 | extern void (*SekDbgBreakpointHandlerWrite)(unsigned int, int);
15 | 
16 | void SekDbgDisableBreakpoints();
17 | void SekDbgEnableBreakpoints();
18 | void SekDbgEnableSingleStep();
19 | 
20 | int SekDbgSetBreakpointDataRead(unsigned int nAddress, int nIdentifier);
21 | int SekDbgSetBreakpointDataWrite(unsigned int nAddress, int nIdentifier);
22 | int SekDbgSetBreakpointFetch(unsigned int nAddress, int nIdentifier);
23 | 
24 | int SekDbgGetCPUType();
25 | int SekDbgGetPendingIRQ();
26 | unsigned int SekDbgGetRegister(SekRegister nRegister);
27 | bool SekDbgSetRegister(SekRegister nRegister, unsigned int nValue);
28 | 


--------------------------------------------------------------------------------
/burn/state.h:
--------------------------------------------------------------------------------
 1 | #if !defined(_STATE_H)
 2 | 
 3 | #ifdef __cplusplus
 4 |  extern "C" {
 5 | #endif
 6 | 
 7 | /* Scan driver data */
 8 | int BurnAreaScan(int nAction, int* pnMin);
 9 | 
10 | /* flags to use for nAction */
11 | #define ACB_READ		 ( 1)
12 | #define ACB_WRITE		 ( 2)
13 | 
14 | #define ACB_MEMORY_ROM	 ( 4)
15 | #define ACB_NVRAM		 ( 8)
16 | #define ACB_MEMCARD		 (16)
17 | #define ACB_MEMORY_RAM	 (32)
18 | #define ACB_DRIVER_DATA	 (64)
19 | 
20 | #define ACB_FULLSCAN	(ACB_NVRAM | ACB_MEMCARD | ACB_MEMORY_RAM | ACB_DRIVER_DATA)
21 | 
22 | #define ACB_ACCESSMASK	(ACB_READ | ACB_WRITE)
23 | #define ACB_TYPEMASK	(ACB_MEMORY_ROM | ACB_NVRAM | ACB_MEMCARD | ACB_MEMORY_RAM | ACB_DRIVER_DATA)
24 | 
25 | #define ACB_VOLATILE    (ACB_MEMORY_RAM | ACB_DRIVER_DATA)
26 | 
27 | /* Structure used for area scanning */
28 | struct BurnArea { void *Data; unsigned int nLen; int nAddress; char *szName; };
29 | 
30 | /* Application-defined callback for processing the area */
31 | extern int (__cdecl *BurnAcb) (struct BurnArea* pba);
32 | 
33 | /* Scan a small variable or structure */
34 | inline static void ScanVar(void* pv, int nSize, char* szName)
35 | {
36 | 	struct BurnArea ba;
37 | 	memset(&ba, 0, sizeof(ba));
38 | 	ba.Data   = pv;
39 | 	ba.nLen   = nSize;
40 | 	ba.szName = szName;
41 | 	BurnAcb(&ba);
42 | }
43 | 
44 | #define SCAN_VAR(x) ScanVar(&x, sizeof(x), #x)
45 | 
46 | #ifdef OSD_CPU_H
47 |  /* wrappers for the MAME savestate functions (used by the FM sound cores) */
48 |  void state_save_register_func_postload(void (*pFunction)());
49 | 
50 |  void state_save_register_INT8(const char* module, int instance, const char* name, INT8* val, unsigned size);
51 |  void state_save_register_UINT8(const char* module, int instance, const char* name, UINT8* val, unsigned size);
52 |  void state_save_register_INT16(const char* module, int instance, const char* name, INT16* val, unsigned size);
53 |  void state_save_register_UINT16(const char* module, int instance, const char* name, UINT16* val, unsigned size);
54 |  void state_save_register_INT32(const char* module, int instance, const char* name, INT32* val, unsigned size);
55 |  void state_save_register_UINT32(const char* module, int instance, const char* name, UINT32* val, unsigned size);
56 | 
57 |  void state_save_register_int(const char* module, int instance, const char* name, int* val);
58 |  void state_save_register_float(const char* module, int instance, const char* name, float* val, unsigned size);
59 |  void state_save_register_double(const char* module, int instance, const char* name, double* val, unsigned size);
60 | #endif
61 | 
62 | #ifdef __cplusplus
63 |  }
64 | #endif
65 | 
66 | #define _STATE_H
67 | 
68 | #endif /* _STATE_H */
69 | 


--------------------------------------------------------------------------------
/burn/tchar.h:
--------------------------------------------------------------------------------
 1 | #ifndef _TCHAR_H_
 2 | #define _TCHAR_H_
 3 | 
 4 | //#define	TCHAR char
 5 | typedef char TCHAR;
 6 | 
 7 | #include <wchar.h>
 8 | 
 9 | #endif //_TCHAR_H_
10 | 


--------------------------------------------------------------------------------
/burn/timer.h:
--------------------------------------------------------------------------------
 1 | // FM timers
 2 | 
 3 | #define TIMER_TICKS_PER_SECOND (2048000000)
 4 | #define MAKE_TIMER_TICKS(n, m) ((long long)(n) * TIMER_TICKS_PER_SECOND / (m))
 5 | #define MAKE_CPU_CYLES(n, m) ((long long)(n) * (m) / TIMER_TICKS_PER_SECOND)
 6 | 
 7 | extern "C" double BurnTimerGetTime();
 8 | 
 9 | // Callbacks for various sound chips
10 | void BurnOPNTimerCallback(int n, int c, int cnt, double stepTime);	// period = cnt * stepTime in s
11 | void BurnOPLTimerCallback(int c, double period);					// period in  s
12 | void BurnYMFTimerCallback(int n, int c, double period);				// period in us
13 | 
14 | // Start / stop a timer
15 | void BurnTimerSetRetrig(int c, double period);						// period in  s
16 | void BurnTimerSetOneshot(int c, double period);						// period in  s
17 | 
18 | extern double dTime;
19 | 
20 | void BurnTimerExit();
21 | void BurnTimerReset();
22 | int BurnTimerInit(int (*pOverCallback)(int, int), double (*pTimeCallback)());
23 | int BurnTimerAttachSek(int nClockspeed);
24 | int BurnTimerAttachZet(int nClockspeed);
25 | void BurnTimerScan(int nAction, int* pnMin);
26 | int BurnTimerUpdate(int nCycles);
27 | void BurnTimerUpdateEnd();
28 | void BurnTimerEndFrame(int nCycles);
29 | 


--------------------------------------------------------------------------------
/burn/toaplan/toa_extratext.h:
--------------------------------------------------------------------------------
  1 | #define FN(a,b,c,d) RenderTile ## a ## _ROT ## b ## c ## d
  2 | #define FUNCTIONNAME(a,b,c,d) FN(a,b,c,d)
  3 | 
  4 | #define ISOPAQUE 0
  5 | 
  6 | #if ROT == 0
  7 |  #define ADVANCECOLUMN pPixel += (BPP >> 3)
  8 |  #define ADVANCEROW pTileRow += ((BPP >> 3) * 320)
  9 | #elif ROT == 270
 10 |  #define ADVANCECOLUMN pPixel -= ((BPP >> 3) * 240)
 11 |  #define ADVANCEROW pTileRow += (BPP >> 3)
 12 | #else
 13 |  #error unsupported rotation angle specified.
 14 | #endif
 15 | 
 16 | #if DOCLIP == 0
 17 |  #define CLIP _NOCLIP
 18 |  #define TESTCLIP(x) 1
 19 | #elif DOCLIP == 1
 20 |  #define CLIP _CLIP
 21 |  #define TESTCLIP(x) (nTileXPos + x) >= 0 && (nTileXPos + x) < 320
 22 | #else
 23 |  #error illegal doclip value.
 24 | #endif
 25 | 
 26 | #if ISOPAQUE == 0
 27 |  #define OPACITY _TRANS
 28 |  #define TESTCOLOUR(x) x
 29 | #elif ISOPAQUE == 1
 30 |  #define OPACITY _OPAQUE
 31 |  #define TESTCOLOUR(x) 1
 32 | #else
 33 |  #error illegal isopaque value
 34 | #endif
 35 | 
 36 | #if BPP == 16
 37 |  #define PLOTPIXEL(a,b) if (TESTCOLOUR(b) && TESTCLIP(a)) {			\
 38 |    	*((unsigned short *)pPixel) = (unsigned short)pTilePalette[b];	\
 39 |  }
 40 | #elif BPP == 24
 41 |  #define PLOTPIXEL(a,b) if (TESTCOLOUR(b) && TESTCLIP(a)) {			\
 42 | 	unsigned int nRGB = pTilePalette[b];							\
 43 | 	pPixel[0] = (unsigned char)nRGB;								\
 44 | 	pPixel[1] = (unsigned char)(nRGB >> 8);							\
 45 | 	pPixel[2] = (unsigned char)(nRGB >> 16);						\
 46 |  }
 47 | #elif BPP == 32
 48 |  #define PLOTPIXEL(a,b) if (TESTCOLOUR(b) && TESTCLIP(a)) {			\
 49 | 	 *((unsigned int *)pPixel) = (unsigned int)pTilePalette[b];		\
 50 |  }
 51 | #else
 52 |  #error unsupported bitdepth specified.
 53 | #endif
 54 | 
 55 | #if ROWMODE == 0
 56 |  #define MODE _NORMAL
 57 | #elif ROWMODE == 1
 58 |  #define MODE _ROWSEL
 59 | #else
 60 |  #error unsupported rowmode specified.
 61 | #endif
 62 | 
 63 | static void FUNCTIONNAME(BPP,ROT,CLIP,MODE)()
 64 | {
 65 | #if ROWMODE == 0
 66 | 	unsigned char *pTileRow, *pPixel;
 67 | 	int y, nColour;
 68 | 
 69 | 	for (y = 0, pTileRow = pTile; y < 8; y++, ADVANCEROW) {
 70 | 		pPixel = pTileRow;
 71 | #else
 72 | 	unsigned char *pPixel = pTile;
 73 | 	int nColour;
 74 | #endif
 75 | 
 76 | 		nColour = *pTileData++;
 77 | 		PLOTPIXEL(0,nColour >> 4);
 78 | 		ADVANCECOLUMN;
 79 | 		PLOTPIXEL(1,nColour & 0x0F);
 80 | 		ADVANCECOLUMN;
 81 | 
 82 | 		nColour = *pTileData++;
 83 | 		PLOTPIXEL(2,nColour >> 4);
 84 | 		ADVANCECOLUMN;
 85 | 		PLOTPIXEL(3,nColour & 0x0F);
 86 | 		ADVANCECOLUMN;
 87 | 
 88 | 		nColour = *pTileData++;
 89 | 		PLOTPIXEL(4,nColour >> 4);
 90 | 		ADVANCECOLUMN;
 91 | 		PLOTPIXEL(5,nColour & 0x0F);
 92 | 		ADVANCECOLUMN;
 93 | 
 94 | #if ROWMODE == 0
 95 | 		nColour = *pTileData++;
 96 | #else
 97 | 		nColour = *pTileData;
 98 | #endif
 99 | 		PLOTPIXEL(6,nColour >> 4);
100 | 		ADVANCECOLUMN;
101 | 		PLOTPIXEL(7,nColour & 0x0F);
102 | #if ROWMODE == 0
103 | 	}
104 | #endif
105 | }
106 | 
107 | #undef MODE
108 | #undef PLOTPIXEL
109 | #undef TESTCLIP
110 | #undef TESTCOLOUR
111 | #undef ADVANCEROW
112 | #undef ADVANCECOLUMN
113 | #undef CLIP
114 | #undef FUNCTIONNAME
115 | #undef FN
116 | 


--------------------------------------------------------------------------------
/burn/toaplan/toa_gp9001_render.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/burn/toaplan/toa_gp9001_render.h


--------------------------------------------------------------------------------
/burn/toaplan/toa_palette.cpp:
--------------------------------------------------------------------------------
 1 | #include "toaplan.h"
 2 | // Toaplan -- palette functions
 3 | 
 4 | unsigned char* ToaPalSrc;			// Pointer to input palette
 5 | unsigned char* ToaPalSrc2;
 6 | unsigned int* ToaPalette;
 7 | unsigned int* ToaPalette2;
 8 | int nToaPalLen;
 9 | 
10 | unsigned char ToaRecalcPalette;		// Set to 1 to force recalculation of the entire palette (not needed now)
11 | 
12 | int ToaPalInit()
13 | {
14 | 	return 0;
15 | }
16 | 
17 | int ToaPalExit()
18 | {
19 | 	return 0;
20 | }
21 | 
22 | inline static unsigned int CalcCol(unsigned short nColour)
23 | {
24 | 	int r, g, b;
25 | 
26 | 	r = (nColour & 0x001F) << 3;	// Red
27 | 	r |= r >> 5;
28 | 	g = (nColour & 0x03E0) >> 2;  	// Green
29 | 	g |= g >> 5;
30 | 	b = (nColour & 0x7C00) >> 7;	// Blue
31 | 	b |= b >> 5;
32 | 
33 | 	return BurnHighCol(r, g, b, 0);
34 | }
35 | 
36 | int ToaPalUpdate()
37 | {
38 | 	unsigned short* ps = (unsigned short*)ToaPalSrc;
39 | 	unsigned int* pd = ToaPalette;
40 | 
41 | 	for (int i = 0; i < nToaPalLen; i++) {
42 | 		pd[i] = CalcCol(ps[i]);
43 | 	}
44 | 	return 0;
45 | }
46 | 
47 | int ToaPal2Update()
48 | {
49 | 	unsigned short* ps = (unsigned short*)ToaPalSrc2;
50 | 	unsigned int* pd = ToaPalette2;
51 | 
52 | 	for (int i = 0; i < nToaPalLen; i++) {
53 | 		pd[i] = CalcCol(ps[i]);
54 | 	}
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/burn/toaplan/toaplan1.cpp:
--------------------------------------------------------------------------------
  1 | #include "toaplan.h"
  2 | 
  3 | // This function decodes the tile data for the GP9001 chip in place.
  4 | int ToaLoadTiles(unsigned char* pDest, int nStart, int nROMSize)
  5 | {
  6 | 	unsigned char* pTile;
  7 | 	int nSwap = 3;
  8 | 
  9 | 	BurnLoadRom(pDest + 3, nStart + 0, 4);
 10 | 	BurnLoadRom(pDest + 1, nStart + 1, 4);
 11 | 	BurnLoadRom(pDest + 2, nStart + 2, 4);
 12 | 	BurnLoadRom(pDest + 0, nStart + 3, 4);
 13 | 
 14 | 	for (pTile = pDest; pTile < (pDest + nROMSize); pTile += 4) {
 15 | 		unsigned char data[4];
 16 | 		for (int n = 0; n < 4; n++) {
 17 | 			int m = 7 - (n << 1);
 18 | 			unsigned char nPixels = ((pTile[0 ^ nSwap] >> m) & 1) << 0;
 19 | 			nPixels |= ((pTile[2 ^ nSwap] >> m) & 1) << 1;
 20 | 			nPixels |= ((pTile[1 ^ nSwap] >> m) & 1) << 2;
 21 | 			nPixels |= ((pTile[3 ^ nSwap] >> m) & 1) << 3;
 22 | 			nPixels |= ((pTile[0 ^ nSwap] >> (m - 1)) & 1) << 4;
 23 | 			nPixels |= ((pTile[2 ^ nSwap] >> (m - 1)) & 1) << 5;
 24 | 			nPixels |= ((pTile[1 ^ nSwap] >> (m - 1)) & 1) << 6;
 25 | 			nPixels |= ((pTile[3 ^ nSwap] >> (m - 1)) & 1) << 7;
 26 | 
 27 | 			data[n] = nPixels;
 28 | 		}
 29 | 
 30 | 		for (int n = 0; n < 4; n++) {
 31 | 			pTile[n] = data[n];
 32 | 		}
 33 | 	}
 34 | 	return 0;
 35 | }
 36 | 
 37 | // ----------------------------------------------------------------------------
 38 | // CPU synchronisation
 39 | 
 40 | int nToa1Cycles68KSync;
 41 | 
 42 | // Callbacks for the FM chip
 43 | 
 44 | void toaplan1FMIRQHandler(int, int nStatus)
 45 | {
 46 | 	if (nStatus) {
 47 | 		ZetSetIRQLine(0xFF, ZET_IRQSTATUS_ACK);
 48 | 	} else {
 49 | 		ZetSetIRQLine(0,    ZET_IRQSTATUS_NONE);
 50 | 	}
 51 | }
 52 | 
 53 | int toaplan1SynchroniseStream(int nSoundRate)
 54 | {
 55 | 	return (long long)ZetTotalCycles() * nSoundRate / 3500000;
 56 | }
 57 | 
 58 | // ----------------------------------------------------------------------------
 59 | 
 60 | inline void toaplan1SynchroniseZ80(int nExtraCycles)
 61 | {
 62 | 	int nCycles = ((long long)SekTotalCycles() * nCyclesTotal[1] / nCyclesTotal[0]) + nExtraCycles;
 63 | 
 64 | 	if (nCycles <= ZetTotalCycles()) {
 65 | 		return;
 66 | 	}
 67 | 
 68 | 	nToa1Cycles68KSync = nCycles - nExtraCycles;
 69 | 
 70 | 	BurnTimerUpdate(nCycles);
 71 | }
 72 | 
 73 | unsigned char __fastcall toaplan1ReadByteZ80RAM(unsigned int sekAddress)
 74 | {
 75 | //	bprintf(PRINT_NORMAL, _T("    Z80 %04X read\n"), sekAddress & 0x0FFF);
 76 | 
 77 | 	toaplan1SynchroniseZ80(0);
 78 | 	return RamZ80[(sekAddress & 0x0FFF) >> 1];
 79 | }
 80 | 
 81 | unsigned short __fastcall toaplan1ReadWordZ80RAM(unsigned int sekAddress)
 82 | {
 83 | //	bprintf(PRINT_NORMAL, _T("    Z80 %04X read\n"), sekAddress & 0x0FFF);
 84 | 
 85 | 	toaplan1SynchroniseZ80(0);
 86 | 	return RamZ80[(sekAddress & 0x0FFF) >> 1];
 87 | }
 88 | 
 89 | void __fastcall toaplan1WriteByteZ80RAM(unsigned int sekAddress, unsigned char byteValue)
 90 | {
 91 | //	bprintf(PRINT_NORMAL, _T("    Z80 %04X -> %02X\n"), sekAddress & 0x0FFF, byteValue);
 92 | 
 93 | 	toaplan1SynchroniseZ80(0);
 94 | 	RamZ80[(sekAddress & 0x0FFF) >> 1] = byteValue;
 95 | }
 96 | 
 97 | void __fastcall toaplan1WriteWordZ80RAM(unsigned int sekAddress, unsigned short wordValue)
 98 | {
 99 | //	bprintf(PRINT_NORMAL, _T("    Z80 %04X -> %04X\n"), sekAddress & 0x0FFF, wordValue);
100 | 
101 | 	toaplan1SynchroniseZ80(0);
102 | 	RamZ80[(sekAddress & 0x0FFF) >> 1] = wordValue & 0xFF;
103 | }
104 | 
105 | // ----------------------------------------------------------------------------
106 | 


--------------------------------------------------------------------------------
/burn/version.h:
--------------------------------------------------------------------------------
 1 | // Version number, written as  vV.V.BB  or  vV.V.BBaa
 2 | // (0xVVBBaa, in BCD notation)
 3 | 
 4 | #define VER_MAJOR  0
 5 | #define VER_MINOR  2
 6 | #define VER_BETA  96
 7 | #define VER_ALPHA 71
 8 | 
 9 | #define BURN_VERSION (VER_MAJOR * 0x100000) + (VER_MINOR * 0x010000) + (((VER_BETA / 10) * 0x001000) + ((VER_BETA % 10) * 0x000100)) + (((VER_ALPHA / 10) * 0x000010) + (VER_ALPHA % 10))
10 | 
11 | 
12 | 
13 | 
14 | 


--------------------------------------------------------------------------------
/burn/vez.h:
--------------------------------------------------------------------------------
 1 | // Nec V20/V30/V33 interface
 2 | 
 3 | #include "necintrf.h"
 4 | 
 5 | struct VezContext {
 6 | 	nec_Regs reg;
 7 | 	
 8 | 	unsigned char * ppMemRead[512];
 9 | 	unsigned char * ppMemWrite[512];
10 | 
11 | 	// Handlers
12 |  #ifdef FASTCALL
13 | 	unsigned char (__fastcall *ReadHandler)(unsigned int a);
14 | 	void (__fastcall *WriteHandler)(unsigned int a, unsigned char d);
15 | 	unsigned char (__fastcall *ReadPort)(unsigned int a);
16 | 	void (__fastcall *WritePort)(unsigned int a, unsigned char d);
17 |  #else
18 | 	unsigned char (__cdecl *ReadHandler)(unsigned int a);
19 | 	void (__cdecl *WriteHandler)(unsigned int a, unsigned char d);
20 | 	unsigned char (__cdecl *ReadPort)(unsigned int a);
21 | 	void (__cdecl *WritePort)(unsigned int a, unsigned char d);
22 |  #endif
23 | };
24 | 
25 | int VezInit(int nCount, unsigned int * typelist);
26 | void VezExit();
27 | void VezNewFrame();
28 | int VezOpen(int nCPU);
29 | void VezClose();
30 | 
31 | int VezMemCallback(int nStart,int nEnd,int nMode);
32 | int VezMapArea(int nStart, int nEnd, int nMode, unsigned char *Mem);
33 | 
34 | void VezSetReadHandler(unsigned char (__fastcall *)(unsigned int));
35 | void VezSetWriteHandler(void (__fastcall *)(unsigned int, unsigned char));
36 | void VezSetReadPort(unsigned char (__fastcall *)(unsigned int));
37 | void VezSetWritePort(void (__fastcall *)(unsigned int, unsigned char));
38 | 
39 | int VezReset();
40 | int VezPc(int n);
41 | int VezScan(int nAction);
42 | 
43 | int VezRun(int nCycles);
44 | 
45 | #define VEZ_IRQSTATUS_NONE 0
46 | #define VEZ_IRQSTATUS_AUTO 1
47 | #define VEZ_IRQSTATUS_ACK  2
48 | 
49 | void VezSetIRQLine(const int line, const int status);
50 | 
51 | 


--------------------------------------------------------------------------------
/burn/ym2151.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | **
 3 | ** File: ym2151.h - header file for software implementation of YM2151
 4 | **                                            FM Operator Type-M(OPM)
 5 | **
 6 | ** (c) 1997-2002 Jarek Burczynski (s0246@poczta.onet.pl, bujar@mame.net)
 7 | ** Some of the optimizing ideas by Tatsuyuki Satoh
 8 | **
 9 | ** Version 2.150 final beta May, 11th 2002
10 | **
11 | **
12 | ** I would like to thank following people for making this project possible:
13 | **
14 | ** Beauty Planets - for making a lot of real YM2151 samples and providing
15 | ** additional informations about the chip. Also for the time spent making
16 | ** the samples and the speed of replying to my endless requests.
17 | **
18 | ** Shigeharu Isoda - for general help, for taking time to scan his YM2151
19 | ** Japanese Manual first of all, and answering MANY of my questions.
20 | **
21 | ** Nao - for giving me some info about YM2151 and pointing me to Shigeharu.
22 | ** Also for creating fmemu (which I still use to test the emulator).
23 | **
24 | ** Aaron Giles and Chris Hardy - they made some samples of one of my favourite
25 | ** arcade games so I could compare it to my emulator.
26 | **
27 | ** Bryan McPhail and Tim (powerjaw) - for making some samples.
28 | **
29 | ** Ishmair - for the datasheet and motivation.
30 | */
31 | 
32 | #ifndef _H_YM2151_
33 | #define _H_YM2151_
34 | 
35 | /* 16- and 8-bit samples (signed) are supported*/
36 | #define SAMPLE_BITS 16
37 | 
38 | #if (SAMPLE_BITS==16)
39 | 	typedef INT16 SAMP;
40 | #endif
41 | #if (SAMPLE_BITS==8)
42 | 	typedef signed char SAMP;
43 | #endif
44 | 
45 | /*
46 | ** Initialize YM2151 emulator(s).
47 | **
48 | ** 'num' is the number of virtual YM2151's to allocate
49 | ** 'clock' is the chip clock in Hz
50 | ** 'rate' is sampling rate
51 | */
52 | int YM2151Init(int num, int clock, int rate);
53 | 
54 | /* shutdown the YM2151 emulators*/
55 | void YM2151Shutdown(void);
56 | 
57 | /* reset all chip registers for YM2151 number 'num'*/
58 | void YM2151ResetChip(int num);
59 | 
60 | /*
61 | ** Generate samples for one of the YM2151's
62 | **
63 | ** 'num' is the number of virtual YM2151
64 | ** '**buffers' is table of pointers to the buffers: left and right
65 | ** 'length' is the number of samples that should be generated
66 | */
67 | void YM2151UpdateOne(int num, INT16 **buffers, int length);
68 | 
69 | /* write 'v' to register 'r' on YM2151 chip number 'n'*/
70 | void YM2151WriteReg(int n, int r, int v);
71 | 
72 | /* read status register on YM2151 chip number 'n'*/
73 | int YM2151ReadStatus(int n);
74 | 
75 | /* set interrupt handler on YM2151 chip number 'n'*/
76 | void YM2151SetIrqHandler(int n, void (*handler)(int irq));
77 | 
78 | /* set port write handler on YM2151 chip number 'n'*/
79 | void YM2151SetPortWriteHandler(int n, write8_handler handler);
80 | 
81 | #endif /*_H_YM2151_*/
82 | 


--------------------------------------------------------------------------------
/burn/ymdeltat.h:
--------------------------------------------------------------------------------
 1 | #ifndef __YMDELTAT_H_
 2 | #define __YMDELTAT_H_
 3 | 
 4 | #define YM_DELTAT_SHIFT    (16)
 5 | 
 6 | #define YM_DELTAT_EMULATION_MODE_NORMAL	0
 7 | #define YM_DELTAT_EMULATION_MODE_YM2610	1
 8 | 
 9 | 
10 | typedef void (*STATUS_CHANGE_HANDLER)(UINT8 which_chip, UINT8 status_bits);
11 | 
12 | 
13 | /* DELTA-T (adpcm type B) struct */
14 | typedef struct deltat_adpcm_state {     /* AT: rearranged and tigntened structure */
15 | 	UINT8	*memory;
16 | 	INT32	*output_pointer;/* pointer of output pointers	*/
17 | 	INT32	*pan;			/* pan : &output_pointer[pan]	*/
18 | 	double	freqbase;
19 | #if 0
20 | 	double	write_time;		/* Y8950: 10 cycles of main clock; YM2608: 20 cycles of main clock */
21 | 	double	read_time;		/* Y8950: 8 cycles of main clock;  YM2608: 18 cycles of main clock */
22 | #endif
23 | 	UINT32	memory_size;
24 | 	int	output_range;
25 | 	UINT32	now_addr;		/* current address		*/
26 | 	UINT32	now_step;		/* currect step			*/
27 | 	UINT32	step;			/* step					*/
28 | 	UINT32	start;			/* start address		*/
29 | 	UINT32	limit;			/* limit address		*/
30 | 	UINT32	end;			/* end address			*/
31 | 	UINT32	delta;			/* delta scale			*/
32 | 	INT32	volume;			/* current volume		*/
33 | 	INT32	acc;			/* shift Measurement value*/
34 | 	INT32	adpcmd;			/* next Forecast		*/
35 | 	INT32	adpcml;			/* current value		*/
36 | 	INT32	prev_acc;		/* leveling value		*/
37 | 	UINT8	now_data;		/* current rom data		*/
38 | 	UINT8	CPU_data;		/* current data	from reg 08	*/
39 | 	UINT8	portstate;		/* port status			*/
40 | 	UINT8	control2;		/* control reg: SAMPLE, DA/AD, RAM TYPE (x8bit / x1bit), ROM/RAM */
41 | 	UINT8	portshift;		/* address bits shift-left:
42 | 							** 8 for YM2610,
43 | 							** 5 for Y8950 and YM2608 */
44 | 
45 | 	UINT8	DRAMportshift;	/* address bits shift-right:
46 | 							** 0 for ROM and x8bit DRAMs,
47 | 							** 3 for x1 DRAMs */
48 | 
49 | 	UINT8	memread;		/* needed for reading/writing external memory */
50 | 
51 | 	/* handlers and parameters for the status flags support */
52 | 	STATUS_CHANGE_HANDLER	status_set_handler;
53 | 	STATUS_CHANGE_HANDLER	status_reset_handler;
54 | 
55 | 	/* note that different chips have these flags on different
56 | 	** bits of the status register
57 | 	*/
58 | 	UINT8	status_change_which_chip;	/* this chip id */
59 | 	UINT8	status_change_EOS_bit;		/* 1 on End Of Sample (record/playback/cycle time of AD/DA converting has passed)*/
60 | 	UINT8	status_change_BRDY_bit;		/* 1 after recording 2 datas (2x4bits) or after reading/writing 1 data */
61 | 	UINT8	status_change_ZERO_bit;		/* 1 if silence lasts for more than 290 miliseconds on ADPCM recording */
62 | 
63 | 	/* neither Y8950 nor YM2608 can generate IRQ when PCMBSY bit changes, so instead of above,
64 | 	** the statusflag gets ORed with PCM_BSY (below) (on each read of statusflag of Y8950 and YM2608)
65 | 	*/
66 | 	UINT8	PCM_BSY;		/* 1 when ADPCM is playing; Y8950/YM2608 only */
67 | 
68 | 	UINT8	reg[16];		/* adpcm registers		*/
69 | 	UINT8	emulation_mode;	/* which chip we're emulating */
70 | }YM_DELTAT;
71 | 
72 | /*void YM_DELTAT_BRDY_callback(YM_DELTAT *DELTAT);*/
73 | 
74 | UINT8 YM_DELTAT_ADPCM_Read(YM_DELTAT *DELTAT);
75 | void YM_DELTAT_ADPCM_Write(YM_DELTAT *DELTAT,int r,int v);
76 | void YM_DELTAT_ADPCM_Reset(YM_DELTAT *DELTAT,int pan,int emulation_mode);
77 | void YM_DELTAT_ADPCM_CALC(YM_DELTAT *DELTAT);
78 | 
79 | void YM_DELTAT_postload(YM_DELTAT *DELTAT,UINT8 *regs);
80 | void YM_DELTAT_savestate(const char *statename,int num,YM_DELTAT *DELTAT);
81 | 
82 | #endif
83 | 


--------------------------------------------------------------------------------
/burn/ymf278b.h:
--------------------------------------------------------------------------------
 1 | #ifndef __YMF278B_H__
 2 | #define __YMF278B_H__
 3 | 
 4 | #ifdef FBA															/* !!! FBA */
 5 | #define MAX_YMF278B	(1)
 6 | #else																/* !!! FBA */
 7 | #define MAX_YMF278B	(2)
 8 | #endif																/* !!! FBA */
 9 | 
10 | #define YMF278B_STD_CLOCK (33868800)						/* standard clock for OPL4 */
11 | 
12 | struct YMF278B_interface {
13 | 	int num;        										/* Number of chips */
14 | 	int clock[MAX_YMF278B];									/* clock input, normally 33.8688 MHz */
15 | 	int region[MAX_YMF278B];								/* memory region of sample ROMs */
16 | 	int mixing_level[MAX_YMF278B];							/* volume */
17 | 	void (*irq_callback[MAX_YMF278B])(int num, int state);	/* irq callback */
18 | };
19 | 
20 | #ifdef FBA															/* !!! FBA */
21 | void ymf278b_pcm_update(int num, INT16 **outputs, int length);
22 | int ymf278b_timer_over(int num, int timer);
23 | int ymf278b_start(INT8 num, UINT8 *rom, void (*irq_cb)(int, int), void (*timer_cb)(int, int, double), int clock, int rate);
24 | #else																/* !!! FBA */
25 | int  YMF278B_sh_start( const struct MachineSound *msound );
26 | #endif																/* !!! FBA */
27 | void YMF278B_sh_stop(void);
28 | 
29 | READ8_HANDLER( YMF278B_status_port_0_r );
30 | READ8_HANDLER( YMF278B_data_port_0_r );
31 | WRITE8_HANDLER( YMF278B_control_port_0_A_w );
32 | WRITE8_HANDLER( YMF278B_data_port_0_A_w );
33 | WRITE8_HANDLER( YMF278B_control_port_0_B_w );
34 | WRITE8_HANDLER( YMF278B_data_port_0_B_w );
35 | WRITE8_HANDLER( YMF278B_control_port_0_C_w );
36 | WRITE8_HANDLER( YMF278B_data_port_0_C_w );
37 | 
38 | #ifndef FBA															/* !!! FBA */
39 | READ8_HANDLER( YMF278B_status_port_1_r );
40 | READ8_HANDLER( YMF278B_data_port_1_r );
41 | WRITE8_HANDLER( YMF278B_control_port_1_A_w );
42 | WRITE8_HANDLER( YMF278B_data_port_1_A_w );
43 | WRITE8_HANDLER( YMF278B_control_port_1_B_w );
44 | WRITE8_HANDLER( YMF278B_data_port_1_B_w );
45 | WRITE8_HANDLER( YMF278B_control_port_1_C_w );
46 | WRITE8_HANDLER( YMF278B_data_port_1_C_w );
47 | #endif																/* !!! FBA */
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/burn/ymz280b.h:
--------------------------------------------------------------------------------
 1 | // Yamaha YMZ280B module
 2 | 
 3 | int YMZ280BInit(int nClock, void (*IRQCallback)(int), int nChannels);
 4 | void YMZ280BReset();
 5 | int YMZ280BScan();
 6 | void YMZ280BExit();
 7 | int YMZ280BRender(short* pSoundBuf, int nSegmenLength);
 8 | void YMZ280BWriteRegister(unsigned char nValue);
 9 | unsigned int YMZ280BReadStatus();
10 | 
11 | extern unsigned char* YMZ280BROM;
12 | 
13 | extern unsigned int nYMZ280BStatus;
14 | extern unsigned int nYMZ280BRegister;
15 | 
16 | inline static void YMZ280BSelectRegister(unsigned char nRegister)
17 | {
18 | 	nYMZ280BRegister = nRegister;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/burn/zet.h:
--------------------------------------------------------------------------------
  1 | // Z80 (Zed Eight-Ty) Interface
  2 | 
  3 | #ifndef _ZET_H_
  4 | #define _ZET_H_
  5 | 
  6 | #ifndef FASTCALL
  7 |  #undef __fastcall
  8 |  #define __fastcall
  9 | #endif
 10 | 
 11 | //#define EMU_DRZ80
 12 | #define EMU_MAME_Z80
 13 | #define EMU_CZ80
 14 | 
 15 | #ifdef EMU_DOZE
 16 |  #include "doze.h"
 17 | #endif
 18 | 
 19 | #ifdef EMU_MAME_Z80
 20 |  #include "z80.h"
 21 | #endif
 22 | 
 23 | #ifdef EMU_CZ80
 24 |  #include "cz80.h"
 25 | #endif
 26 | extern int nHasZet;
 27 | extern int nZetCpuCore; // 0 - CZ80, 1 - MAME_Z80
 28 | void ZetWriteByte(unsigned short address, unsigned char data);
 29 | unsigned char ZetReadByte(unsigned short address);
 30 | int ZetInit(int nCount);
 31 | void ZetExit();
 32 | void ZetNewFrame();
 33 | int ZetOpen(int nCPU);
 34 | void ZetClose();
 35 | int ZetGetActive();
 36 | int ZetMemCallback(int nStart,int nEnd,int nMode);
 37 | int ZetMemEnd();
 38 | int ZetMapArea(int nStart, int nEnd, int nMode, unsigned char *Mem);
 39 | int ZetMapArea(int nStart, int nEnd, int nMode, unsigned char *Mem01, unsigned char *Mem02);
 40 | int ZetReset();
 41 | int ZetPc(int n);
 42 | int ZetBc(int n);
 43 | int ZetDe(int n);
 44 | int ZetHL(int n);
 45 | int ZetScan(int nAction);
 46 | int ZetRun(int nCycles);
 47 | void ZetRunEnd();
 48 | void ZetSetIRQLine(const int line, const int status);
 49 | int ZetNmi();
 50 | int ZetIdle(int nCycles);
 51 | int ZetSegmentCycles();
 52 | int ZetTotalCycles();
 53 | 
 54 | void ZetRaiseIrq(int n);
 55 | void ZetLowerIrq();
 56 | 
 57 | static inline int getZET_IRQSTATUS_NONE()
 58 | {
 59 | #ifdef EMU_DOZE
 60 | 	if(nZetCpuCore == 2) return DOZE_IRQSTATUS_NONE;
 61 | #endif
 62 | #ifdef EMU_MAME_Z80
 63 | 	if(nZetCpuCore == 1) return 0;
 64 | #endif
 65 | #ifdef EMU_CZ80
 66 | 	if(nZetCpuCore == 0) return CZ80_IRQSTATUS_NONE;
 67 | #endif
 68 | }
 69 | 
 70 | static inline int getZET_IRQSTATUS_AUTO()
 71 | {
 72 | #ifdef EMU_DOZE
 73 | 	if(nZetCpuCore == 2) return DOZE_IRQSTATUS_AUTO;
 74 | #endif
 75 | #ifdef EMU_MAME_Z80
 76 | 	if(nZetCpuCore == 1) return 2;
 77 | #endif
 78 | #ifdef EMU_CZ80
 79 | 	if(nZetCpuCore == 0) return CZ80_IRQSTATUS_AUTO;
 80 | #endif
 81 | }
 82 | 
 83 | static inline int getZET_IRQSTATUS_ACK()
 84 | {
 85 | #ifdef EMU_DOZE
 86 | 	if(nZetCpuCore == 2) return DOZE_IRQSTATUS_ACK;
 87 | #endif
 88 | #ifdef EMU_MAME_Z80
 89 | 	if(nZetCpuCore == 1) return 1;
 90 | #endif
 91 | #ifdef EMU_CZ80
 92 | 	if(nZetCpuCore == 0) return CZ80_IRQSTATUS_ACK;
 93 | #endif
 94 | }
 95 | 
 96 | #define ZET_IRQSTATUS_NONE getZET_IRQSTATUS_NONE()
 97 | #define ZET_IRQSTATUS_AUTO getZET_IRQSTATUS_AUTO()
 98 | #define ZET_IRQSTATUS_ACK  getZET_IRQSTATUS_ACK()
 99 | 
100 | #ifdef EMU_MAME_Z80
101 | 
102 | typedef unsigned char (__fastcall *pZetInHandler)(unsigned short a);
103 | typedef void (__fastcall *pZetOutHandler)(unsigned short a, unsigned char d);
104 | typedef unsigned char (__fastcall *pZetReadHandler)(unsigned short a);
105 | typedef void (__fastcall *pZetWriteHandler)(unsigned short a, unsigned char d);
106 | 
107 | struct ZetExt {
108 | 
109 | 	Z80_Regs reg;
110 | 	
111 | 	unsigned char* pZetMemMap[0x100 * 4];
112 | 
113 | 	pZetInHandler ZetIn;
114 | 	pZetOutHandler ZetOut;
115 | 	pZetReadHandler ZetRead;
116 | 	pZetWriteHandler ZetWrite;
117 | 	
118 | 	int nCyclesTotal;
119 | 	int nCyclesSegment;
120 | 	int nCyclesLeft;
121 | 	
122 | 	int nEI;
123 | 	int nInterruptLatch;
124 | };
125 | 
126 | #endif
127 | 
128 | void ZetSetReadHandler(unsigned char (__fastcall *pHandler)(unsigned short));
129 | void ZetSetWriteHandler(void (__fastcall *pHandler)(unsigned short, unsigned char));
130 | void ZetSetInHandler(unsigned char (__fastcall *pHandler)(unsigned short));
131 | void ZetSetOutHandler(void (__fastcall *pHandler)(unsigned short, unsigned char));
132 | 
133 | #endif //_ZET_H_
134 | 


--------------------------------------------------------------------------------
/capex.cfg.template:
--------------------------------------------------------------------------------
 1 | # CAPEX config file v1.1
 2 | 
 3 | # FBA2X OPTIONS
 4 | 
 5 | fba2x_sound 1
 6 | fba2x_samplerate 44100
 7 | fba2x_showfps 0
 8 | fba2x_hiscore 1
 9 | 
10 | # CAPEX OPTIONS
11 | 
12 | capex_list 0
13 | capex_sely 239
14 | capex_selnum 0
15 | capex_seloffset_num 0
16 | 


--------------------------------------------------------------------------------
/cpu/cyclone/cyclone.h:
--------------------------------------------------------------------------------
 1 | #ifndef _CYCLONE_68000_H_
 2 | #define _CYCLONE_68000_H_
 3 | 
 4 | // Cyclone 68000 Emulator - Header File
 5 | 
 6 | // All code (c) Copyright 2005 Dave, All rights reserved.
 7 | // Cyclone 68000 is free for non-commercial use.
 8 | 
 9 | // For commercial use, separate licencing terms must be obtained.
10 | 
11 | #ifdef __cplusplus
12 | extern "C" {
13 | #endif
14 | 
15 | extern int CycloneVer; // Version number of library
16 | 
17 | struct Cyclone
18 | {
19 |   unsigned int d[8];   // [r7,#0x00]
20 |   unsigned int a[8];   // [r7,#0x20]
21 |   unsigned int pc;     // [r7,#0x40] Memory Base+PC
22 |   unsigned char srh;   // [r7,#0x44] Status Register high (T_S__III)
23 |   unsigned char xc;    // [r7,#0x45] Extend flag (____??X?)
24 |   unsigned char flags;   // [r7,#0x46] Condition Code Register (ARM order: ____NZCV)
25 |   unsigned char irq;   // [r7,#0x47] IRQ level
26 |   unsigned int osp;    // [r7,#0x48] Other Stack Pointer (USP/SSP)
27 |   unsigned int vector; // [r7,#0x50] IRQ vector (temporary)
28 |   unsigned int pad1[2];
29 |   int stopped;         // [r7,#0x58] 1 == processor is in stopped state
30 |   int cycles;          // [r7,#0x5c]
31 |   int membase;         // [r7,#0x60] Memory Base (ARM address minus 68000 address)
32 |   unsigned int   (*checkpc)(unsigned int pc); // [r7,#0x64] - Called to recalc Memory Base+pc
33 |   unsigned char  (*read8  )(unsigned int a);  // [r7,#0x68]
34 |   unsigned short (*read16 )(unsigned int a);  // [r7,#0x6c]
35 |   unsigned int   (*read32 )(unsigned int a);  // [r7,#0x70]
36 |   void (*write8 )(unsigned int a,unsigned char  d); // [r7,#0x74]
37 |   void (*write16)(unsigned int a,unsigned short d); // [r7,#0x78]
38 |   void (*write32)(unsigned int a,unsigned int   d); // [r7,#0x7c]
39 |   unsigned char  (*fetch8 )(unsigned int a);  // [r7,#0x80]
40 |   unsigned short (*fetch16)(unsigned int a);  // [r7,#0x84]
41 |   unsigned int   (*fetch32)(unsigned int a);  // [r7,#0x88]
42 |   void (*IrqCallback)(int int_level);         // [r7,#0x8c] - optional irq callback function, see config.h
43 |   void (*ResetCallback)();                    // [r7,#0x90] - if enabled in config.h, calls this whenever RESET opcode is encountered.
44 |   int  (*UnrecognizedCallback)();             // [r7,#0x94] - if enabled in config.h, calls this whenever unrecognized opcode is encountered.
45 | };
46 | 
47 | // used only if Cyclone was compiled with compressed jumptable, see config.h
48 | void CycloneInit();
49 | 
50 | // run cyclone. Cycles should be specified in context (pcy->cycles)
51 | void CycloneRun(struct Cyclone *pcy);
52 | 
53 | // utility functions to get and set SR
54 | void CycloneSetSr(struct Cyclone *pcy, unsigned int sr); // auto-swaps a7<->osp if detects supervisor change
55 | unsigned int CycloneGetSr(struct Cyclone *pcy);
56 | 
57 | #ifdef __cplusplus
58 | } // End of extern "C"
59 | #endif
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/cpu/cz80/cz80_op.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/cpu/cz80/cz80_op.c


--------------------------------------------------------------------------------
/cpu/cz80/cz80_opCB.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/cpu/cz80/cz80_opCB.c


--------------------------------------------------------------------------------
/cpu/cz80/cz80_opED.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/cpu/cz80/cz80_opED.c


--------------------------------------------------------------------------------
/cpu/cz80/cz80_opXY.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/cpu/cz80/cz80_opXY.c


--------------------------------------------------------------------------------
/cpu/cz80/cz80_opXYCB.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/cpu/cz80/cz80_opXYCB.c


--------------------------------------------------------------------------------
/cpu/cz80/cz80jmp.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/cpu/cz80/cz80jmp.c


--------------------------------------------------------------------------------
/cpu/cz80/readme.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/cpu/cz80/readme.txt


--------------------------------------------------------------------------------
/cpu/doze/dam.h:
--------------------------------------------------------------------------------
 1 | // Doze - Dave's optimized Z80 emulator
 2 | // Code maker -------------------------------------------------
 3 | #include <stdarg.h>
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <string.h>
 7 | 
 8 | #ifdef __ELF__
 9 |  #define PREFIX ""
10 | #else
11 |  #define PREFIX "_"
12 | #endif
13 | 
14 | // dam.cpp
15 | extern char DamPc[];
16 | extern char DamCycles[];
17 | int ot(char *Format,...);
18 | void DamAlign();
19 | void DamVarToReg();
20 | void DamRegToVar();
21 | int DamOpStart(unsigned int op);
22 | int DamOpDone(int nCycles,int bDontEnd);
23 | 
24 | // dama.cpp
25 | int DamaFlags(int bOverflow,char *Bits35);
26 | int DamaOp(unsigned int op);
27 | 
28 | // damc.cpp
29 | int DamcRotate(unsigned int op);
30 | int DamcOpCb(unsigned int op);
31 | 
32 | // dame.cpp
33 | int Dame_00xx_0001(unsigned int op);
34 | int Dame_00xx_x011(unsigned int op);
35 | int Dame_00xx_1001(unsigned int op);
36 | int Dame_11xx_0x01(unsigned int op);
37 | int DameExHL(unsigned int op);
38 | int DameDirectMem16(unsigned int op);
39 | int DameOpEd(unsigned int op);
40 | 
41 | // damf.cpp
42 | int Damf_ED_101x_x00x(unsigned int op);
43 | int Damf_ED_101x_x11x(unsigned int op);
44 | 
45 | // damj.cpp
46 | extern int DamJump[0x700];
47 | int DamJumpTab();
48 | 
49 | // damm.cpp
50 | char *DamLoc8(int r,int Ext);
51 | int DamLoc8IsReg(int r,int Ext);
52 | int DamGet8 (char *To  ,int r,int Ext);
53 | int DamPut8 (char *From,int r,int Ext);
54 | char *DamLoc16(int r,int Ext);
55 | int DamGet16(char *To  ,int r,int Ext);
56 | int DamPut16(char *From,int r,int Ext);
57 | void DamIxIyOffset(int nRel);
58 | void DamGetHL(int Ext);
59 | int DamMacros();
60 | int DamAddPc(int n);
61 | int DamFetch(int nRel,int nSize);
62 | 
63 | // damo.cpp
64 | int DamoOp(unsigned int op);
65 | 
66 | // damt.cpp
67 | int DamTables();
68 | 


--------------------------------------------------------------------------------
/cpu/doze/damc.cpp:
--------------------------------------------------------------------------------
  1 | // Doze - Dave's optimized Z80 emulator
  2 | // Code Maker - CB opcodes
  3 | #include "dam.h"
  4 | 
  5 | int DamcRotate(unsigned int op)
  6 | {
  7 |   int t=4,a=0,r=0;
  8 |   unsigned int Ext=0; // Extend code (00, dd or fd)
  9 |   static char Opco[8][4]={"rol","ror","rcl","rcr","sal","sar","sal","shr"};
 10 | 
 11 |   Ext=op>>8; if ((Ext&0xff)==0xcb) Ext=op>>16; // Get dd/fd extend code
 12 |   a=(op>>3)&7; r=op&7;
 13 | 
 14 |   DamOpStart(op);
 15 |   if (Ext)
 16 |   {
 17 |     // Get IX/IY offset (it's 2 bytes back because of the FD CB nn C6 opcode format)
 18 |     DamIxIyOffset(-2);
 19 |     t+=4;
 20 |   }
 21 |   if (Ext || r==6)
 22 |   {
 23 |     DamGetHL(Ext);
 24 |     t+=7;
 25 |   }
 26 |   DamGet8("dl",r,Ext);
 27 | 
 28 |   ot("\n");
 29 |   ot("  sahf\n");
 30 |   ot("  %s dl,1\n",Opco[a]);
 31 |   ot("  setc dh     ; ---- ---C\n");
 32 |   if (op>>8)
 33 |   {
 34 |     // One of the CB opcodes
 35 |     ot("  test dl,dl\n");
 36 |     ot("  lahf\n");
 37 |     ot("  and ah,0xc4 ; SZ-- -P--\n");
 38 |     ot("  or  ah,dh   ; SZ-- -P-C\n");
 39 |     ot("\n");
 40 |   }
 41 |   else
 42 |   {
 43 |     // One of the normal rotates
 44 |     ot("  and ah,0xc4 ; ..00 0.00\n");
 45 |     ot("  or  ah,dh   ; ..00 0.0C\n");
 46 |     ot("\n");
 47 |   }
 48 | 
 49 |   if (Ext || r==6) DamPut8("dl",6,Ext); // Put to memory
 50 |   if (r!=6) DamPut8("dl",r,0); // Put to register
 51 |   // (both of the above happen in the undocumented opcodes)
 52 |   DamOpDone(t,0);
 53 |   return op;
 54 | }
 55 | 
 56 | static int DamcBit(unsigned int op)
 57 | {
 58 |   int b=0,r=0,t=4;
 59 |   unsigned int Ext=0; // Extend code (00, dd or fd)
 60 | 
 61 |   Ext=op>>16; b=(op>>3)&7; r=op&7;
 62 | 
 63 |   DamOpStart(op);
 64 | 
 65 |   if (Ext)
 66 |   {
 67 |     // Get IX/IY offset (it's 2 bytes back because of the FD CB nn C6 opcode format)
 68 |     DamIxIyOffset(-2);
 69 |     t+=8;
 70 |   }
 71 |   if (Ext || r==6)
 72 |   {
 73 |     DamGetHL(Ext);
 74 |     t+=4;
 75 |   }
 76 | 
 77 |   DamGet8("dl",r,Ext);
 78 |   ot("  mov dh,ah\n");
 79 |   ot("  and dl,0x%.2x\n",1<<b);
 80 |   ot("  lahf\n");
 81 |   ot("  and dh,0x01 ; Preserve ---- ---C\n");
 82 |   ot("  and ah,0xc4 ;          SZ-- -P--\n");
 83 |   ot("  or  ah,dh   ;          SZ-- -P0C\n");
 84 |   ot("  or  ah,0x10 ;          SZ-1 -P0C\n");
 85 |   DamOpDone(t,0);
 86 |   return op;
 87 | }
 88 | 
 89 | static int DamcSet(unsigned int op)
 90 | {
 91 |   int b=0,r=0,t=4,s=0;
 92 |   unsigned int Ext=0; // Extend code (00, dd or fd)
 93 |   char *Targ="";
 94 | 
 95 |   Ext=op>>16; b=(op>>3)&7; r=op&7; s=(op>>6)&1;
 96 | 
 97 |   DamOpStart(op);
 98 | 
 99 |   if (Ext)
100 |   {
101 |     // Get IX/IY offset (it's 2 bytes back because of the FD CB nn C6 opcode format)
102 |     DamIxIyOffset(-2);
103 |     t+=4;
104 |   }
105 |   if (Ext || r==6)
106 |   {
107 |     DamGetHL(Ext);
108 |     t+=7;
109 |   }
110 | 
111 |   if (Ext || r==6)
112 |   {
113 |     // Get to dl, then change it
114 |     DamGet8("dl",6,Ext);
115 |     Targ="dl";
116 |   }
117 |   else
118 |   {
119 |     // Do it direct
120 |     Targ=DamLoc8(r,Ext);
121 |   }
122 | 
123 |   if (s) ot("  or  %s,0x%.2x\n",Targ,1<<b);
124 |   else   ot("  and %s,0x%.2x\n",Targ,0xff^(1<<b));
125 | 
126 |   if (Ext || r==6)
127 |   {
128 |     DamPut8("dl",6,Ext); // Put to memory
129 |     if (r!=6) DamPut8("dl",r,0); // (undocumented opcodes also put to register)
130 |   }
131 | 
132 |   DamOpDone(t,0);
133 |   return op;
134 | }
135 | 
136 | int DamcOpCb(unsigned int op)
137 | {
138 |   if ((op&0xc0)==0x00) return DamcRotate(op);
139 |   if ((op&0xc0)==0x40) return DamcBit(op);
140 |   if ((op&0x80)==0x80) return DamcSet(op);
141 |   return 0x00; // nop
142 | }
143 | 


--------------------------------------------------------------------------------
/cpu/doze/damj.cpp:
--------------------------------------------------------------------------------
 1 | // Doze - Dave's optimized Z80 emulator
 2 | // Code Maker - jump table
 3 | #include "dam.h"
 4 | 
 5 | int DamJump[0x700];
 6 | 
 7 | int DamJumpTab()
 8 | {
 9 |   unsigned int i=0;
10 |   ot("\n\n");
11 | 
12 |   // Output the Jump table
13 |   for (i=0;i< (sizeof(DamJump)/sizeof(DamJump[0]));i++)
14 |   {
15 |     int t=0,op=0;
16 |     int nTarget=0;
17 | 
18 |     nTarget=DamJump[i];
19 |     t=i>>8;
20 |     op=i&0xff;
21 |     if (op==0)
22 |     {
23 |       // Label the table
24 |       if (t==0) ot("JumpTab:     ; Normal   opcodes:\n");
25 |       if (t==1) ot("JumpTabCB:   ; CBxx     opcodes:\n");
26 |       if (t==2) ot("JumpTabED:   ; EDxx     opcodes:\n");
27 |       if (t==3) ot("JumpTabDD:   ; DDxx     opcodes:\n");
28 |       if (t==4) ot("JumpTabFD:   ; FDxx     opcodes:\n");
29 |       if (t==5) ot("JumpTabDDCB: ; DDCB__xx opcodes:\n");
30 |       if (t==6) ot("JumpTabFDCB: ; FDCB__xx opcodes:\n");
31 |     }
32 | 
33 |     if (((i+0)&0x0f)==0) ot("dd ");
34 | 
35 |     ot("Op%.2X",nTarget);
36 | 
37 |     if (((i+1)&0x0f)==0) ot("\n");
38 |     else                 ot(",");
39 | 
40 |     if (op==0xff) ot("\n");
41 |   }
42 |   ot("\n");
43 |   return 0;
44 | }
45 | 
46 | 


--------------------------------------------------------------------------------
/cpu/doze/damt.cpp:
--------------------------------------------------------------------------------
  1 | // Doze - Dave's optimized Z80 emulator
  2 | // Code Maker - tables
  3 | #include "dam.h"
  4 | 
  5 | int DamTables()
  6 | {
  7 |   int r=0;
  8 |   ot("IncFlag:\n");
  9 |   for (r=0;r<0x100;r++)
 10 |   {
 11 |     int i=0; int f=0;
 12 |     // If a value is increased to 'r', find out the flags
 13 |     i=(r-1)&0xff; // Find start value
 14 |     if (i==0x7f)    f|=0x04;   // ---- -V-- overflow
 15 |                     f|=r&0xa8; // S-5- 3V-- Sign, 5 and 3
 16 |     if (r==0)       f|=0x40;   // SZ5- 3V-- Zero
 17 |     if ((i&15)==15) f|=0x10;   // SZ5H 3V-- Half carry (low nibble overflows)
 18 | 
 19 |     if ((r&15)== 0) ot("db ");
 20 |     ot("0x%.2x",f);
 21 |     if ((r&15)< 15) ot(","); else ot("\n");
 22 |   }
 23 |   ot("\n");
 24 | 
 25 |   ot("DecFlag:\n");
 26 |   for (r=0;r<0x100;r++)
 27 |   {
 28 |     int i=0; int f=2; // negative
 29 |     // If a value is decreased to 'r', find out the flags
 30 |     i=(r+1)&0xff; // Find start value
 31 |     if (i==0x80)    f|=0x04;   // ---- -V-- overflow
 32 |                     f|=r&0xa8; // S-5- 3V-- Sign, 5 and 3
 33 |     if (r==0)       f|=0x40;   // SZ5- 3V-- Zero
 34 |     if ((i&15)== 0) f|=0x10;   // SZ5H 3V-- Half carry (low nibble overflows)
 35 | 
 36 |     if ((r&15)== 0) ot("db ");
 37 |     ot("0x%.2x",f);
 38 |     if ((r&15)< 15) ot(","); else ot("\n");
 39 |   }
 40 |   ot("\n");
 41 | 
 42 |   {
 43 |     int d=0;
 44 |     ot("DaaTable: ;(HNC nnnn nnnn)\n");
 45 |     for (d=0x0;d<0x800;d++)
 46 |     {
 47 |       int e=0,f=0;
 48 | 
 49 |       e=d&0x1ff; // include carry bit
 50 | 
 51 |       if (d&0x400) // Was a half-carry
 52 |       {
 53 |         if (d&0x200) // After subtraction
 54 |         {
 55 |           e-=6;
 56 |           f|=0x02; // N
 57 |           if (e>0x99-6) { e-=0x60; f|=0x01; } // Carry
 58 |           if ((e&15)>9) {          f|=0x10; } // Half-carry
 59 |         }
 60 |         else
 61 |         {
 62 |           e+=6;
 63 |           if (e>0x99+6) { e+=0x60; f|=0x01; } // Carry
 64 |           if ((e&15)<6) {          f|=0x10; } // Half-carry
 65 |         }
 66 |       }
 67 |       else
 68 |       {
 69 |         if (d&0x200) // After subtraction
 70 |         {
 71 |           f|=0x02; // N
 72 |           if (e>0x99)   { e-=0x60; f|=0x01; } // Carry
 73 |           if ((e&15)>9) { e-=0x06; f|=0x10; } // Half-carry
 74 |         }
 75 |         else // After addition
 76 |         {
 77 |           if (e>0x99)   { e+=0x60; f|=0x01; } // Carry
 78 |           if ((e&15)>9) { e+=0x06; f|=0x10; } // Half-carry
 79 |         }
 80 |       }
 81 | 
 82 |       e&=0xff;
 83 | 
 84 |       f|=e&0xa8; // S,5,3
 85 | 
 86 | 
 87 |       if (e==0) f|=0x40; // Z
 88 | 
 89 |       {
 90 |         int p;
 91 |         p=e^(e>>4); p&=15;
 92 |         p=p^(p>>2); p&=3;
 93 |         p=p^(p>>1); p&=1;
 94 |         if (p==0) f|=0x04; // parity
 95 |       }
 96 | 
 97 |       if ((d&15)== 0) ot("dw ");
 98 |       ot("0x%.4x",(f<<8)|e);
 99 |       if ((d&15)<15) ot(","); else ot(" ; %.3x\n",d-15);
100 |     }
101 |     ot("\n");
102 |   }
103 | 
104 |   return 0;
105 | }
106 | 
107 | 


--------------------------------------------------------------------------------
/cpu/doze/doze.cpp:
--------------------------------------------------------------------------------
  1 | #include <string.h>
  2 | #include "doze.h"
  3 | 
  4 | #include <stdio.h>
  5 | 
  6 | int nDozeVer = 0x1004;								// Version number of the library
  7 | 
  8 | static int Interrupt(int nVal)
  9 | {
 10 | 	if ((Doze.iff & 0xFF) == 0) {					// not enabled
 11 | 		return 0;
 12 | 	}
 13 | 
 14 | //	printf("    IRQ taken\n");
 15 | 
 16 | 	// Get out of any halt opcodes
 17 | 	if (DozeAsmRead(Doze.pc) == 0x76) {
 18 | 		Doze.pc++;
 19 | 	}
 20 | 
 21 | 	Doze.iff = 0;
 22 | 
 23 | 	if (Doze.im == 0) {
 24 | 		DozeAsmCall((unsigned short)(nVal & 0x38));	// rst nn
 25 | 		return 13;									// cycles done
 26 | 	} else {
 27 | 		if (Doze.im == 2) {
 28 | 			int nTabAddr = 0, nIntAddr = 0;
 29 | 			// Get interrupt address from table (I points to the table)
 30 | 			nTabAddr = (Doze.ir & 0xFF00) + nVal;
 31 | 
 32 | 			// Read 16-bit table value
 33 | 			nIntAddr  = DozeAsmRead((unsigned short)(nTabAddr + 1)) << 8;
 34 | 			nIntAddr |= DozeAsmRead((unsigned short)(nTabAddr));
 35 | 
 36 | 			DozeAsmCall((unsigned short)(nIntAddr));
 37 | 			return 19;								// cycles done
 38 | 		} else {
 39 | 			DozeAsmCall(0x38);						// rst 38h
 40 | 			return 13;								// cycles done
 41 | 		}
 42 | 	}
 43 | }
 44 | 
 45 | // Try to take the latched interrupt
 46 | static inline void TryInt()
 47 | {
 48 | 	int nDid;
 49 | 
 50 | 	if (Doze.nInterruptLatch & DOZE_IRQSTATUS_NONE) {
 51 | 		return;
 52 | 	}
 53 | 
 54 | 	nDid = Interrupt(Doze.nInterruptLatch & 0xFF);	// Success! we did some cycles, and took the interrupt
 55 | 	if (nDid > 0 && (Doze.nInterruptLatch & DOZE_IRQSTATUS_AUTO)) {
 56 | 		Doze.nInterruptLatch = DOZE_IRQSTATUS_NONE;
 57 | 	}
 58 | 
 59 | 	Doze.nCyclesLeft -= nDid;
 60 | }
 61 | 
 62 | void __cdecl DozeRun()
 63 | {
 64 | 	TryInt();										// Try the interrupt before we begin
 65 | 
 66 | 	if (Doze.nCyclesLeft < 0) {
 67 | 		return;
 68 | 	}
 69 | 
 70 | 	if (DozeAsmRead(Doze.pc) == 0x76) {
 71 | 		// cpu is halted (repeatedly doing halt inst.)
 72 | 		int nDid = (Doze.nCyclesLeft >> 2) + 1;
 73 | 		Doze.ir = (unsigned short)(((Doze.ir + nDid) & 0x7F) | (Doze.ir & 0xFF80)); // Increase R register
 74 | 		Doze.nCyclesLeft -= nDid;
 75 | 
 76 | 		return;
 77 | 	}
 78 | 
 79 | 	// Find out about mid-exec EIs
 80 | 	Doze.nEI = 1;
 81 | 	DozeAsmRun();
 82 | 
 83 | 	// Just enabled interrupts
 84 | 	while (Doze.nEI == 2) {
 85 | 
 86 | //		printf("    EI executed\n");
 87 | 
 88 | 		// (do one more instruction before interrupt)
 89 | 		int nTodo = Doze.nCyclesLeft;
 90 | 		Doze.nCyclesLeft = 0;
 91 | 		Doze.nEI = 0;
 92 | 		DozeAsmRun();
 93 | 		Doze.nCyclesLeft += nTodo;
 94 | 
 95 | 		TryInt();
 96 | 
 97 | 		// And continue the rest of the exec
 98 | 		DozeAsmRun();
 99 | 	}
100 | }
101 | 
102 | int __cdecl DozeReset()
103 | {
104 | 	// Reset z80
105 | 	memset(&Doze, 0, 32);
106 | 
107 | 	Doze.af = 0x0040;
108 | 	Doze.ix = 0xFFFF;
109 | 	Doze.iy = 0xFFFF;
110 | 
111 | 	return 0;
112 | }
113 | 
114 | int __cdecl DozeNmi()
115 | {
116 | 	Doze.iff &= 0xFF00;						// reset iff1
117 | 	DozeAsmCall((unsigned short)0x66);		// Do nmi
118 | 
119 | 	return 12;
120 | }
121 | 


--------------------------------------------------------------------------------
/cpu/doze/doze.h:
--------------------------------------------------------------------------------
 1 | //---------------------------------------------------------------------------
 2 | // Doze - Dave's optimized Z80 emulator
 3 | // Copyright (c) 2001 Dave (www.finalburn.com), all rights reserved.
 4 | 
 5 | // You can use, modify and redistribute this code freely as long as you
 6 | // don't do so commercially. This copyright notice must remain with the code.
 7 | // You must state if your program uses this code.
 8 | 
 9 | // Dave
10 | // Homepage: www.finalburn.com
11 | // E-mail:  dave@finalburn.com
12 | // -------------------------------------------------------------------------------------------
13 | 
14 | // Change log
15 | // 1.001 : Fixed mistake in timing of ini/r/d/outi/r/d  (4+16 cycles should have
16 | //         been 4+12 cycles)
17 | // 1.002 : Implemented seperate fetch mechanisms for opcodes and data (ayeye)
18 | //		   Modified the interface to allow for multiple emulated Z80's
19 | //		   Added support for using the __fastcall calling convention for handlers
20 | // 1.003 : Minor change to the .asm file to prevent problems with a recent (buggy)
21 | //         version of Gnu binutils
22 | // 1.004 : Improved IRQ support
23 | //
24 | 
25 | // (external) Header
26 | 
27 | #ifdef __cplusplus
28 |  extern "C" {
29 | #endif
30 | 
31 | #if !defined (_WIN32)
32 |  #define __cdecl
33 | #endif
34 | 
35 | #define DOZE_IRQSTATUS_NONE (0x8000)
36 | #define DOZE_IRQSTATUS_AUTO (0x2000)
37 | #define DOZE_IRQSTATUS_ACK  (0x1000)
38 | 
39 | struct DozeContext {
40 | 	// Registers
41 | 	unsigned short af,  bc,  de,  hl,  ix, iy, pc, sp;
42 | 	unsigned short af2, bc2, de2, hl2, ir;
43 | 	unsigned short iff;								  // iff.h = IFF2, iff.l = IFF1
44 | 	unsigned char im;
45 | 
46 | 	// Variables
47 | 	int nCyclesTotal;
48 | 	int nCyclesSegment;
49 | 	int nCyclesLeft;
50 | 	int nEI;
51 | 	int nInterruptLatch;
52 | 
53 | 	// Memory access
54 | 	unsigned char** ppMemFetch;
55 | 	unsigned char** ppMemFetchData;
56 | 	unsigned char** ppMemRead;
57 | 	unsigned char** ppMemWrite;
58 | 
59 | 	// Handlers
60 |  #ifdef FASTCALL
61 | 	unsigned char (__fastcall *ReadHandler)(unsigned short a);
62 | 	void (__fastcall *WriteHandler)(unsigned short a, unsigned char d);
63 | 	unsigned char (__fastcall *InHandler)(unsigned short a);
64 | 	void (__fastcall *OutHandler)(unsigned short a, unsigned char d);
65 |  #else
66 | 	unsigned char (__cdecl *ReadHandler)(unsigned short a);
67 | 	void (__cdecl *WriteHandler)(unsigned short a, unsigned char d);
68 | 	unsigned char (__cdecl *InHandler)(unsigned short a);
69 | 	void (__cdecl *OutHandler)(unsigned short a, unsigned char d);
70 |  #endif
71 | };
72 | 
73 | // Interface to the assembly code
74 | extern struct DozeContext Doze;
75 | 
76 | void __cdecl DozeAsmRun();
77 | void __cdecl DozeAsmCall(unsigned short nAddr);
78 | unsigned char __cdecl DozeAsmRead(unsigned short nAddr);
79 | 
80 | // doze.cpp
81 | extern int nDozeVer;					// Version number of the library
82 | void __cdecl DozeRun();
83 | int __cdecl DozeNmi();
84 | int __cdecl DozeReset();
85 | 
86 | #ifdef __cplusplus
87 |  } // End of extern "C"
88 | #endif
89 | 


--------------------------------------------------------------------------------
/cpu/drz80/DrZ80.h:
--------------------------------------------------------------------------------
 1 | 
 2 | /* DrZ80 - Header File */
 3 | 
 4 | /* All code (c) Copyright 2004 Reesy, All rights reserved. */
 5 | /* DrZ80 is free for non-commercial use. */
 6 | 
 7 | /* For commercial use, separate licencing terms must be obtained. */
 8 | 
 9 | #ifdef __cplusplus
10 | extern "C" {
11 | #endif
12 | 
13 | #ifndef DRZ80_H
14 | #define DRZ80_H
15 | 
16 | extern int DrZ80Ver; /* Version number of library */
17 | 
18 | struct DrZ80
19 | { 
20 |   unsigned int Z80A;            // 0x00 - A Register:   0xAA------
21 |   unsigned int Z80F;            // 0x04 - F Register:   0x------FF
22 |   unsigned int Z80BC;           // 0x08 - BC Registers: 0xBBCC----
23 |   unsigned int Z80DE;           // 0x0C - DE Registers: 0xDDEE----
24 |   unsigned int Z80HL;           // 0x10 - HL Registers: 0xHHLL----
25 |   unsigned int Z80PC;           // 0x14 - PC Program Counter (Memory Base + PC)
26 |   unsigned int Z80PC_BASE;      // 0x18 - PC Program Counter (Memory Base)
27 |   unsigned int Z80SP;           // 0x1C - SP Stack Pointer (Memory Base + PC)
28 |   unsigned int Z80SP_BASE;      // 0x20 - SP Stack Pointer (Memory Base)
29 |   unsigned int Z80IX;           // 0x24 - IX Index Register
30 |   unsigned int Z80IY;           // 0x28 - IY Index Register
31 |   unsigned int Z80I;            // 0x2C - I Interrupt Register
32 |   unsigned int Z80A2;           // 0x30 - A' Register:    0xAA------
33 |   unsigned int Z80F2;           // 0x34 - F' Register:    0x------FF
34 |   unsigned int Z80BC2;          // 0x38 - B'C' Registers: 0xBBCC----
35 |   unsigned int Z80DE2;          // 0x3C - D'E' Registers: 0xDDEE----
36 |   unsigned int Z80HL2;          // 0x40 - H'L' Registers: 0xHHLL----
37 |   unsigned char Z80_IRQ;        // 0x44 - Set IRQ Number
38 |   unsigned char Z80IF;          // 0x45 - Interrupt Flags:  bit1=_IFF1, bit2=_IFF2, bit3=_HALT
39 |   unsigned char Z80IM;          // 0x46 - Set IRQ Mode
40 |   unsigned char spare;          // 0x47 - N/A
41 |   unsigned int z80irqvector;    // 0x48 - Set IRQ Vector i.e. 0xFF=RST
42 | 
43 |   int nEI;
44 |   int nCyclesLeft;
45 |   int nCyclesTotal;
46 |   int nCyclesSegment;
47 |   int nInterruptLatch;
48 | 
49 |   void (*z80_irq_callback )(void);
50 |   
51 |   //void (*z80_write8 )(unsigned char d,unsigned short a); 
52 |   void (*z80_write8 )(unsigned short a, unsigned char d); 
53 |   void (*z80_write16 )(unsigned short d,unsigned short a); 
54 |   
55 |   unsigned char (*z80_in)(unsigned short p);
56 |   void (*z80_out )(unsigned short p,unsigned char d);
57 |   
58 |   unsigned char (*z80_read8)(unsigned short a);
59 |   unsigned short (*z80_read16)(unsigned short a);
60 |   
61 |   unsigned int (*z80_rebaseSP)(unsigned short new_sp);
62 |   unsigned int (*z80_rebasePC)(unsigned short new_pc);
63 | 
64 |   // Memory access
65 |   unsigned char ** ppMemFetch;
66 |   unsigned char ** ppMemFetchData;
67 |   unsigned char ** ppMemRead;
68 |   unsigned char ** ppMemWrite;
69 |   
70 |   void (*debugCallback)(unsigned short pc, unsigned int d);
71 |   
72 | };
73 | 
74 | // returns number of cycles left (usually negative)
75 | extern int DrZ80Run(struct DrZ80 *pcy, unsigned int cyc);
76 | 
77 | #endif
78 | 
79 | #ifdef __cplusplus
80 | } /* End of extern "C" */
81 | #endif
82 | 


--------------------------------------------------------------------------------
/cpu/nec/necintrf.h:
--------------------------------------------------------------------------------
 1 | /* ASG 971222 -- rewrote this interface */
 2 | #ifndef __NEC_H_
 3 | #define __NEC_H_
 4 | 
 5 | typedef union
 6 | {                   /* eight general registers */
 7 |     unsigned short w[8];    /* viewed as 16 bits registers */
 8 |     unsigned char  b[16];   /* or as 8 bit registers */
 9 | } necbasicregs;
10 | 
11 | typedef struct
12 | {
13 | 	necbasicregs regs;
14 |  	unsigned short	sregs[4];
15 | 
16 | 	unsigned short	ip;
17 | 
18 | 	signed int	SignVal;
19 |     unsigned int  AuxVal, OverVal, ZeroVal, CarryVal, ParityVal; /* 0 or non-0 valued flags */
20 | 	unsigned char	TF, IF, DF, MF; 	/* 0 or 1 valued flags */	/* OB[19.07.99] added Mode Flag V30 */
21 | 	unsigned int	int_vector;
22 | 	unsigned int	pending_irq;
23 | 	unsigned int	nmi_state;
24 | 	unsigned int	irq_state;
25 | 	int     (*irq_callback)(int irqline);
26 | 	
27 | 	unsigned int cpu_type;
28 | 	unsigned int prefix_base;
29 | 	signed char seg_prefix;
30 | 	int no_interrupt;
31 | 	int nec_ICount;
32 | 
33 | } nec_Regs;
34 | 
35 | enum {
36 | 	NEC_IP=1, NEC_AW, NEC_CW, NEC_DW, NEC_BW, NEC_SP, NEC_BP, NEC_IX, NEC_IY,
37 | 	NEC_FLAGS, NEC_ES, NEC_CS, NEC_SS, NEC_DS,
38 | 	NEC_VECTOR, NEC_PENDING, NEC_NMI_STATE, NEC_IRQ_STATE };
39 | 
40 | /* Public functions */
41 | 
42 | /*
43 | #define v20_ICount nec_ICount
44 | extern void v20_init(void);
45 | extern void v20_reset(void *param);
46 | extern void v20_exit(void);
47 | extern int v20_execute(int cycles);
48 | extern unsigned v20_get_context(void *dst);
49 | extern void v20_set_context(void *src);
50 | extern unsigned v20_get_reg(int regnum);
51 | extern void v20_set_reg(int regnum, unsigned val);
52 | extern void v20_set_irq_line(int irqline, int state);
53 | extern void v20_set_irq_callback(int (*callback)(int irqline));
54 | extern const char *v20_info(void *context, int regnum);
55 | extern unsigned v20_dasm(char *buffer, unsigned pc);
56 | 
57 | #define v30_ICount nec_ICount
58 | extern void v30_init(void);
59 | extern void v30_reset(void *param);
60 | extern void v30_exit(void);
61 | extern int v30_execute(int cycles);
62 | extern unsigned v30_get_context(void *dst);
63 | extern void v30_set_context(void *src);
64 | extern unsigned v30_get_reg(int regnum);
65 | extern void v30_set_reg(int regnum, unsigned val);
66 | extern void v30_set_irq_line(int irqline, int state);
67 | extern void v30_set_irq_callback(int (*callback)(int irqline));
68 | extern const char *v30_info(void *context, int regnum);
69 | extern unsigned v30_dasm(char *buffer, unsigned pc);
70 | 
71 | #define v33_ICount nec_ICount
72 | extern void v33_init(void);
73 | extern void v33_reset(void *param);
74 | extern void v33_exit(void);
75 | extern int v33_execute(int cycles);
76 | extern unsigned v33_get_context(void *dst);
77 | extern void v33_set_context(void *src);
78 | extern unsigned v33_get_reg(int regnum);
79 | extern void v33_set_reg(int regnum, unsigned val);
80 | extern void v33_set_irq_line(int irqline, int state);
81 | extern void v33_set_irq_callback(int (*callback)(int irqline));
82 | extern const char *v33_info(void *context, int regnum);
83 | extern unsigned v33_dasm(char *buffer, unsigned pc);
84 | */
85 | 
86 | void nec_set_reg(int,unsigned);
87 | int nec_execute(nec_Regs *pCPU,int cycles);	
88 | unsigned nec_get_reg(int regnum);
89 | void nec_reset (nec_Regs *pCPU);
90 | void nec_int(unsigned int wektor);
91 | 
92 | #endif
93 | 


--------------------------------------------------------------------------------
/cpu/nec/necmodrm.h:
--------------------------------------------------------------------------------
  1 | static struct {
  2 | 	struct {
  3 | 		WREGS w[256];
  4 | 		BREGS b[256];
  5 | 	} reg;
  6 | 	struct {
  7 | 		WREGS w[256];
  8 | 		BREGS b[256];
  9 | 	} RM;
 10 | } Mod_RM;
 11 | 
 12 | #define RegWord(ModRM) I->regs.w[Mod_RM.reg.w[ModRM]]
 13 | #define RegByte(ModRM) I->regs.b[Mod_RM.reg.b[ModRM]]
 14 | 
 15 | #define GetRMWord(ModRM) \
 16 | 	((ModRM) >= 0xc0 ? I->regs.w[Mod_RM.RM.w[ModRM]] : ( (*GetEA[ModRM])(), ReadWord( EA ) ))
 17 | 
 18 | #define PutbackRMWord(ModRM,val) 			     \
 19 | { 							     \
 20 | 	if (ModRM >= 0xc0) I->regs.w[Mod_RM.RM.w[ModRM]]=val; \
 21 |     else WriteWord(EA,val);  \
 22 | }
 23 | 
 24 | #define GetnextRMWord ReadWord((EA&0xf0000)|((EA+2)&0xffff))
 25 | 
 26 | #define PutRMWord(ModRM,val)				\
 27 | {							\
 28 | 	if (ModRM >= 0xc0)				\
 29 | 		I->regs.w[Mod_RM.RM.w[ModRM]]=val;	\
 30 | 	else {						\
 31 | 		(*GetEA[ModRM])();			\
 32 | 		WriteWord( EA ,val);			\
 33 | 	}						\
 34 | }
 35 | 
 36 | #define PutImmRMWord(ModRM) 				\
 37 | {							\
 38 | 	unsigned short val;					\
 39 | 	if (ModRM >= 0xc0)				\
 40 | 		FETCHWORD(I->regs.w[Mod_RM.RM.w[ModRM]]) \
 41 | 	else {						\
 42 | 		(*GetEA[ModRM])();			\
 43 | 		FETCHWORD(val)				\
 44 | 		WriteWord( EA , val);			\
 45 | 	}						\
 46 | }
 47 | 	
 48 | #define GetRMByte(ModRM) \
 49 | 	((ModRM) >= 0xc0 ? I->regs.b[Mod_RM.RM.b[ModRM]] : ReadByte( (*GetEA[ModRM])() ))
 50 | 	
 51 | #define PutRMByte(ModRM,val)				\
 52 | {							\
 53 | 	if (ModRM >= 0xc0)				\
 54 | 		I->regs.b[Mod_RM.RM.b[ModRM]]=val;	\
 55 | 	else						\
 56 | 		WriteByte( (*GetEA[ModRM])() ,val); 	\
 57 | }
 58 | 
 59 | #define PutImmRMByte(ModRM) 				\
 60 | {							\
 61 | 	if (ModRM >= 0xc0)				\
 62 | 		I->regs.b[Mod_RM.RM.b[ModRM]]=FETCH; 	\
 63 | 	else {						\
 64 | 		(*GetEA[ModRM])();			\
 65 | 		WriteByte( EA , FETCH );		\
 66 | 	}						\
 67 | }
 68 | 	
 69 | #define PutbackRMByte(ModRM,val)			\
 70 | {							\
 71 | 	if (ModRM >= 0xc0)				\
 72 | 		I->regs.b[Mod_RM.RM.b[ModRM]]=val;	\
 73 | 	else						\
 74 | 		WriteByte(EA,val);			\
 75 | }
 76 | 
 77 | #define DEF_br8							\
 78 | 	unsigned int ModRM = FETCH,src,dst;		\
 79 | 	src = RegByte(ModRM);				\
 80 |     dst = GetRMByte(ModRM)
 81 |     
 82 | #define DEF_wr16						\
 83 | 	unsigned int ModRM = FETCH,src,dst;		\
 84 | 	src = RegWord(ModRM);				\
 85 |     dst = GetRMWord(ModRM)
 86 | 
 87 | #define DEF_r8b							\
 88 | 	unsigned int ModRM = FETCH,src,dst;		\
 89 | 	dst = RegByte(ModRM);				\
 90 |     src = GetRMByte(ModRM)
 91 | 
 92 | #define DEF_r16w						\
 93 | 	unsigned int ModRM = FETCH,src,dst;		\
 94 | 	dst = RegWord(ModRM);				\
 95 |     src = GetRMWord(ModRM)
 96 | 
 97 | #define DEF_ald8						\
 98 | 	unsigned int src = FETCH;					\
 99 | 	unsigned int dst = I->regs.b[AL]
100 | 
101 | #define DEF_axd16						\
102 | 	unsigned int src = FETCH; 				\
103 | 	unsigned int dst = I->regs.w[AW];			\
104 |     src += (FETCH << 8)
105 | 


--------------------------------------------------------------------------------
/cpu/sh2/sh2.h:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #ifndef FASTCALL
 4 |  #undef __fastcall
 5 |  #define __fastcall
 6 | #endif
 7 | 
 8 | typedef unsigned char (__fastcall *pSh2ReadByteHandler)(unsigned int a);
 9 | typedef void (__fastcall *pSh2WriteByteHandler)(unsigned int a, unsigned char d);
10 | typedef unsigned short (__fastcall *pSh2ReadWordHandler)(unsigned int a);
11 | typedef void (__fastcall *pSh2WriteWordHandler)(unsigned int a, unsigned short d);
12 | typedef unsigned int (__fastcall *pSh2ReadLongHandler)(unsigned int a);
13 | typedef void (__fastcall *pSh2WriteLongHandler)(unsigned int a, unsigned int d);
14 | 
15 | extern int has_sh2;
16 | void __fastcall Sh2WriteByte(unsigned int a, unsigned char d);
17 | unsigned char __fastcall Sh2ReadByte(unsigned int a);
18 | 
19 | int Sh2Init(int nCount);
20 | int Sh2Exit();
21 | 
22 | void Sh2Open(const int i);
23 | void Sh2Close();
24 | 
25 | void Sh2Reset(unsigned int pc, unsigned r15);
26 | int Sh2Run(int cycles);
27 | 
28 | int Sh2MapMemory(unsigned char* pMemory, unsigned int nStart, unsigned int nEnd, int nType);
29 | int Sh2MapHandler(unsigned int nHandler, unsigned int nStart, unsigned int nEnd, int nType);
30 | 
31 | int Sh2SetReadByteHandler(int i, pSh2ReadByteHandler pHandler);
32 | int Sh2SetWriteByteHandler(int i, pSh2WriteByteHandler pHandler);
33 | int Sh2SetReadWordHandler(int i, pSh2ReadWordHandler pHandler);
34 | int Sh2SetWriteWordHandler(int i, pSh2WriteWordHandler pHandler);
35 | int Sh2SetReadLongHandler(int i, pSh2ReadLongHandler pHandler);
36 | int Sh2SetWriteLongHandler(int i, pSh2WriteLongHandler pHandler);
37 | 
38 | #define SH2_IRQSTATUS_NONE	(0x00)
39 | #define SH2_IRQSTATUS_AUTO	(0x01)
40 | //#define SH2_IRQSTATUS_ACK	(0x02)
41 | 
42 | void Sh2SetIRQLine(const int line, const int state);
43 | 
44 | unsigned int Sh2GetPC(int n);
45 | void Sh2StopRun();
46 | void Sh2SetVBR(unsigned int i);
47 | 
48 | void Sh2BurnUntilInt(int);
49 | 
50 | //unsigned int Sh2GetTotalCycles();
51 | int Sh2Scan(int);
52 | 
53 | 


--------------------------------------------------------------------------------
/cpu/z80/z80.h:
--------------------------------------------------------------------------------
 1 | #ifndef _Z80_H_
 2 | #define _Z80_H_
 3 | 
 4 | #define	CPUINFO_PTR_CPU_SPECIFIC	0x18000
 5 | #define Z80_CLEAR_LINE		0
 6 | #define Z80_ASSERT_LINE		1
 7 | #define Z80_INPUT_LINE_NMI	32
 8 | 
 9 | typedef union
10 | {
11 | 	struct { UINT8 l,h,h2,h3; } b;
12 | 	struct { UINT16 l,h; } w;
13 | 	UINT32 d;
14 | } PAIR;
15 | 
16 | typedef struct
17 | {
18 | 	PAIR	prvpc,pc,sp,af,bc,de,hl,ix,iy;
19 | 	PAIR	af2,bc2,de2,hl2;
20 | 	UINT8	r,r2,iff1,iff2,halt,im,i;
21 | 	UINT8	nmi_state;			/* nmi line state */
22 | 	UINT8	nmi_pending;		/* nmi pending */
23 | 	UINT8	irq_state;			/* irq line state */
24 | 	UINT8	after_ei;			/* are we in the EI shadow? */
25 | 	const struct z80_irq_daisy_chain *daisy;
26 | 	int		(*irq_callback)(int irqline);
27 | } Z80_Regs;
28 | 
29 | enum {
30 | 	Z80_PC=1, Z80_SP,
31 | 	Z80_A, Z80_B, Z80_C, Z80_D, Z80_E, Z80_H, Z80_L,
32 | 	Z80_AF, Z80_BC, Z80_DE, Z80_HL,
33 | 	Z80_IX, Z80_IY,	Z80_AF2, Z80_BC2, Z80_DE2, Z80_HL2,
34 | 	Z80_R, Z80_I, Z80_IM, Z80_IFF1, Z80_IFF2, Z80_HALT,
35 | 	Z80_DC0, Z80_DC1, Z80_DC2, Z80_DC3
36 | };
37 | 
38 | enum {
39 | 	Z80_TABLE_op,
40 | 	Z80_TABLE_cb,
41 | 	Z80_TABLE_ed,
42 | 	Z80_TABLE_xy,
43 | 	Z80_TABLE_xycb,
44 | 	Z80_TABLE_ex	/* cycles counts for taken jr/jp/call and interrupt latency (rst opcodes) */
45 | };
46 | 
47 | enum
48 | {
49 | 	CPUINFO_PTR_Z80_CYCLE_TABLE = CPUINFO_PTR_CPU_SPECIFIC,
50 | 	CPUINFO_PTR_Z80_CYCLE_TABLE_LAST = CPUINFO_PTR_Z80_CYCLE_TABLE + Z80_TABLE_ex
51 | };
52 | 
53 | extern void Z80Init();
54 | extern void Z80Reset();
55 | extern void Z80Exit();
56 | extern int  Z80Execute(int cycles);
57 | extern void Z80Burn(int cycles);
58 | extern void Z80SetIrqLine(int irqline, int state);
59 | extern void Z80GetContext (void *dst);
60 | extern void Z80SetContext (void *src);
61 | extern int Z80Scan(int nAction);
62 | 
63 | typedef unsigned char (__fastcall *Z80ReadIoHandler)(unsigned int a);
64 | typedef void (__fastcall *Z80WriteIoHandler)(unsigned int a, unsigned char v);
65 | typedef unsigned char (__fastcall *Z80ReadProgHandler)(unsigned int a);
66 | typedef void (__fastcall *Z80WriteProgHandler)(unsigned int a, unsigned char v);
67 | typedef unsigned char (__fastcall *Z80ReadOpHandler)(unsigned int a);
68 | typedef unsigned char (__fastcall *Z80ReadOpArgHandler)(unsigned int a);
69 | 
70 | extern void Z80SetIOReadHandler(Z80ReadIoHandler handler);
71 | extern void Z80SetIOWriteHandler(Z80WriteIoHandler handler);
72 | extern void Z80SetProgramReadHandler(Z80ReadProgHandler handler);
73 | extern void Z80SetProgramWriteHandler(Z80WriteProgHandler handler);
74 | extern void Z80SetCPUOpReadHandler(Z80ReadOpHandler handler);
75 | extern void Z80SetCPUOpArgReadHandler(Z80ReadOpArgHandler handler);
76 | 
77 | #endif
78 | 
79 | 


--------------------------------------------------------------------------------
/cpu/z80/z80daisy.cpp:
--------------------------------------------------------------------------------
 1 | /***************************************************************************
 2 | 
 3 |     z80daisy.c
 4 | 
 5 |     Z80/180 daisy chaining support functions.
 6 | 
 7 | ***************************************************************************/
 8 | 
 9 | #include "z80daisy.h"
10 | 
11 | #define CLEAR_LINE	0
12 | #define ASSERT_LINE	1
13 | 
14 | 
15 | void z80daisy_reset(const struct z80_irq_daisy_chain *daisy)
16 | {
17 | 	/* loop over all devices and call their reset function */
18 | 	for ( ; daisy->param != -1; daisy++)
19 | 		if (daisy->reset)
20 | 			(*daisy->reset)(daisy->param);
21 | }
22 | 
23 | 
24 | int z80daisy_update_irq_state(const struct z80_irq_daisy_chain *daisy)
25 | {
26 | 	/* loop over all devices; dev[0] is highest priority */
27 | 	for ( ; daisy->param != -1; daisy++)
28 | 	{
29 | 		int state = (*daisy->irq_state)(daisy->param);
30 | 
31 | 		/* if this device is asserting the INT line, that's the one we want */
32 | 		if (state & Z80_DAISY_INT)
33 | 			return ASSERT_LINE;
34 | 
35 | 		/* if this device is asserting the IEO line, it blocks everyone else */
36 | 		if (state & Z80_DAISY_IEO)
37 | 			return CLEAR_LINE;
38 | 	}
39 | 
40 | 	return CLEAR_LINE;
41 | }
42 | 
43 | 
44 | int z80daisy_call_ack_device(const struct z80_irq_daisy_chain *daisy)
45 | {
46 | 	/* loop over all devices; dev[0] is the highest priority */
47 | 	for ( ; daisy->param != -1; daisy++)
48 | 	{
49 | 		int state = (*daisy->irq_state)(daisy->param);
50 | 
51 | 		/* if this device is asserting the INT line, that's the one we want */
52 | 		if (state & Z80_DAISY_INT)
53 | 			return (*daisy->irq_ack)(daisy->param);
54 | 	}
55 | 
56 | //	logerror("z80daisy_call_ack_device: failed to find an device to ack!\n");
57 | 	return 0;
58 | }
59 | 
60 | 
61 | void z80daisy_call_reti_device(const struct z80_irq_daisy_chain *daisy)
62 | {
63 | 	/* loop over all devices; dev[0] is the highest priority */
64 | 	for ( ; daisy->param != -1; daisy++)
65 | 	{
66 | 		int state = (*daisy->irq_state)(daisy->param);
67 | 
68 | 		/* if this device is asserting the IEO line, that's the one we want */
69 | 		if (state & Z80_DAISY_IEO)
70 | 		{
71 | 			(*daisy->irq_reti)(daisy->param);
72 | 			return;
73 | 		}
74 | 	}
75 | 
76 | //	logerror("z80daisy_call_reti_device: failed to find an device to reti!\n");
77 | }
78 | 


--------------------------------------------------------------------------------
/cpu/z80/z80daisy.h:
--------------------------------------------------------------------------------
 1 | /***************************************************************************
 2 | 
 3 |     z80daisy.h
 4 | 
 5 |     Z80/180 daisy chaining support functions.
 6 | 
 7 | ***************************************************************************/
 8 | 
 9 | 
10 | #ifndef Z80DAISY_H
11 | #define Z80DAISY_H
12 | 
13 | 
14 | /* daisy-chain link */
15 | struct z80_irq_daisy_chain
16 | {
17 | 	void (*reset)(int); 			/* reset callback */
18 | 	int (*irq_state)(int);			/* get interrupt state */
19 | 	int (*irq_ack)(int);			/* interrupt acknowledge callback */
20 | 	void (*irq_reti)(int);			/* reti callback */
21 | 	int param;						/* callback parameter (-1 ends list) */
22 | };
23 | 
24 | 
25 | /* these constants are returned from the irq_state function */
26 | #define Z80_DAISY_INT 	0x01		/* interrupt request mask */
27 | #define Z80_DAISY_IEO 	0x02		/* interrupt disable mask (IEO) */
28 | 
29 | 
30 | /* prototypes */
31 | void z80daisy_reset(const struct z80_irq_daisy_chain *daisy);
32 | int z80daisy_update_irq_state(const struct z80_irq_daisy_chain *chain);
33 | int z80daisy_call_ack_device(const struct z80_irq_daisy_chain *chain);
34 | void z80daisy_call_reti_device(const struct z80_irq_daisy_chain *chain);
35 | 
36 | #endif
37 | 


--------------------------------------------------------------------------------
/fba2x.cfg.template:
--------------------------------------------------------------------------------
 1 | [Keyboard]
 2 | # Get codes from /usr/include/SDL/SDL_keysym.h
 3 | A_1=306
 4 | B_1=32
 5 | X_1=308
 6 | Y_1=304
 7 | L_1=122
 8 | R_1=120
 9 | START_1=13
10 | SELECT_1=9
11 | LEFT_1=276
12 | RIGHT_1=275
13 | UP_1=273
14 | DOWN_1=274
15 | QUIT=27
16 | #player 2 keyboard controls, disabled by default
17 | A_2=999
18 | B_2=999
19 | X_2=999
20 | Y_2=999
21 | L_2=999
22 | R_2=999
23 | START_2=999
24 | SELECT_2=999
25 | LEFT_2=999
26 | RIGHT_2=999
27 | UP_2=999
28 | DOWN_2=999
29 | 
30 | [Joystick]
31 | # Get codes from "jstest /dev/input/js0"
32 | # from package "joystick"
33 | # Defaults to XBOX 360 Controller
34 | A_1=1
35 | B_1=0
36 | X_1=2
37 | Y_1=3
38 | L_1=4
39 | R_1=5
40 | START_1=7
41 | SELECT_1=6
42 | #Joystick axis
43 | JA_LR=0
44 | JA_UD=1
45 | #player 2 button configuration
46 | A_2=1
47 | B_2=0
48 | X_2=2
49 | Y_2=3
50 | L_2=4
51 | R_2=5
52 | START_2=7
53 | SELECT_2=6
54 | #Joystick axis
55 | JA_LR_2=0
56 | JA_UD_2=1
57 | #player 3 button configuration
58 | A_3=1
59 | B_3=0
60 | X_3=2
61 | Y_3=3
62 | L_3=4
63 | R_3=5
64 | START_3=7
65 | SELECT_3=6
66 | #Joystick axis
67 | JA_LR_3=0
68 | JA_UD_3=1
69 | #player 4 button configuration
70 | A_4=1
71 | B_4=0
72 | X_4=2
73 | Y_4=3
74 | L_4=4
75 | R_4=5
76 | START_4=7
77 | SELECT_4=6
78 | #Joystick axis
79 | JA_LR_4=0
80 | JA_UD_4=1
81 | 
82 | [Graphics]
83 | DisplaySmoothStretch=1
84 | # Display Effect: 0 none, 1 scanlines
85 | DisplayEffect=0
86 | DisplayBorder=0
87 | MaintainAspectRatio=1
88 | DisplayAutoRotate=0
89 | 
90 | [Sound]
91 | 


--------------------------------------------------------------------------------
/fba_029671_clrmame_dat.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/fba_029671_clrmame_dat.zip


--------------------------------------------------------------------------------
/install.sh:
--------------------------------------------------------------------------------
1 | #/bin/sh
2 | #This is only used for the Pi Store
3 | 
4 | cd /usr/local/bin/indiecity/InstalledApps/pi-fba/Full
5 | chmod 777 ./fba2x ./fbacapex ./capex.cfg ./fba2x.cfg ./zipname.fba ./rominfo.fba ./FBACache_windows.zip ./fba_029671_clrmame_dat.zip ./roms ./skin ./preview ./preview/*
6 | 


--------------------------------------------------------------------------------
/rpi/boolean.h:
--------------------------------------------------------------------------------
 1 | /*  RetroArch - A frontend for libretro.
 2 |  *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
 3 |  * 
 4 |  *  RetroArch is free software: you can redistribute it and/or modify it under the terms
 5 |  *  of the GNU General Public License as published by the Free Software Found-
 6 |  *  ation, either version 3 of the License, or (at your option) any later version.
 7 |  *
 8 |  *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 9 |  *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 |  *  PURPOSE.  See the GNU General Public License for more details.
11 |  *
12 |  *  You should have received a copy of the GNU General Public License along with RetroArch.
13 |  *  If not, see <http://www.gnu.org/licenses/>.
14 |  */
15 | 
16 | #ifndef __RARCH_BOOLEAN_H
17 | #define __RARCH_BOOLEAN_H
18 | 
19 | #ifndef __cplusplus
20 | #include <stdbool.h>
21 | #endif
22 | 
23 | #endif
24 | 
25 | 


--------------------------------------------------------------------------------
/rpi/burner.h:
--------------------------------------------------------------------------------
 1 | // FB Alpha - Emulator for MC68000/Z80 based arcade games
 2 | //            Refer to the "license.txt" file for more info
 3 | 
 4 | #include <limits.h>
 5 | #include <stdio.h>
 6 | #include <stdlib.h>
 7 | #include <string.h>
 8 | #include <math.h>
 9 | 
10 | #include "tchar.h"
11 | 
12 | #define BZIP_MAX (8)								// Maximum zip files to search through
13 | #define DIRS_MAX (8)								// Maximum number of directories to search
14 | 
15 | #include "burn.h"
16 | 
17 | #ifndef MAX_PATH
18 | #define	MAX_PATH 256
19 | #endif
20 | 
21 | // state.cpp
22 | int BurnStateLoadEmbed(FILE* fp, int nOffset, int bAll, int (*pLoadGame)());
23 | int BurnStateLoad(const char * szName, int bAll, int (*pLoadGame)());
24 | int BurnStateSaveEmbed(FILE* fp, int nOffset, int bAll);
25 | int BurnStateSave(const char * szName, int bAll);
26 | 
27 | // statec.cpp
28 | int BurnStateCompress(unsigned char** pDef, int* pnDefLen, int bAll);
29 | int BurnStateDecompress(unsigned char* Def, int nDefLen, int bAll);
30 | 
31 | // zipfn.cpp
32 | struct ZipEntry { char* szName;	unsigned int nLen; unsigned int nCrc; };
33 | 
34 | int ZipOpen(char* szZip);
35 | int ZipClose();
36 | int ZipGetList(struct ZipEntry** pList, int* pnListCount);
37 | int ZipLoadFile(unsigned char* Dest, int nLen, int* pnWrote, int nEntry);
38 | 
39 | // bzip.cpp
40 | 
41 | #define BZIP_STATUS_OK		(0)
42 | #define BZIP_STATUS_BADDATA	(1)
43 | #define BZIP_STATUS_ERROR	(2)
44 | 
45 | int BzipOpen(bool);
46 | int BzipClose();
47 | int BzipInit();
48 | int BzipExit();
49 | int BzipStatus();
50 | 
51 | int DrvInitCallback(); // needed for StatedLoad/StatedSave
52 | 
53 | 


--------------------------------------------------------------------------------
/rpi/cache.cpp:
--------------------------------------------------------------------------------
  1 | #include "burnint.h"
  2 | 
  3 | #include <fcntl.h>
  4 | #include <unistd.h>
  5 | #include <sys/mman.h>
  6 | 
  7 | int bBurnUseRomCache = 0;
  8 | static int pBurnCacheFile = 0;
  9 | 
 10 | static struct BurnCacheHeader {
 11 | 	unsigned int ver;		// min fba version
 12 | 	char name[12];				// ROM Name
 13 | 	struct BurnCacheBlock {
 14 | 		unsigned int offset;	// block offset in cache file
 15 | 		char desc[12];			// describe of this block
 16 | 	} blocks[15];
 17 | } bcHeader;
 18 | 
 19 | //static void * blocks_map[14];
 20 | static void * BurnCacheBase = 0;
 21 | static int BurnCacheSize = 0;
 22 | 
 23 | extern char szAppRomPath[];		// bzip.cpp
 24 | void show_rom_loading_text(char * szText, int nSize, int nTotalSize);	// fba_player.cpp
 25 | 
 26 | void DisableReadAhead()
 27 | {
 28 | 	char * value = "0\r";
 29 | 	int fReadAhead = open("/proc/sys/vm/max-readahead",O_RDWR|O_TRUNC);
 30 | 	if (fReadAhead)
 31 | 	{
 32 | 		write(fReadAhead,value,2);
 33 | 		close(fReadAhead);
 34 | 	}
 35 | 	fReadAhead = open("/proc/sys/vm/min-readahead",O_RDWR|O_TRUNC);
 36 | 	if (fReadAhead)
 37 | 	{
 38 | 		write(fReadAhead,value,2);
 39 | 		close(fReadAhead);
 40 | 	}
 41 | }
 42 | 
 43 | int BurnCacheInit(const char * cfname, char *rom_name)
 44 | {
 45 | 	pBurnCacheFile = 0;
 46 | 	BurnCacheBase = 0;
 47 | 	
 48 | 	strcpy(szAppRomPath, cfname);
 49 | 	char * p = strrchr(szAppRomPath, '/');
 50 | 	if (p) {
 51 | 		p++;
 52 | 		strcpy(rom_name, p);
 53 | 		
 54 | 		*p = 0;
 55 | 		p = strrchr(rom_name, '.');
 56 | 		if (p) {
 57 | 			
 58 | 			if ( strcmp( p, ".zip" ) == 0 ) {
 59 | 				*p = 0;
 60 | 				return 0;
 61 | 			} else {
 62 | 				// cache file 
 63 | 				pBurnCacheFile = open(cfname, O_RDONLY);
 64 | 				if ( pBurnCacheFile ) {
 65 | 					
 66 | 					lseek( pBurnCacheFile, 0, SEEK_SET );
 67 | 					read( pBurnCacheFile, &bcHeader, sizeof(bcHeader) );
 68 | 					strcpy(rom_name, bcHeader.name);
 69 | 					
 70 | 					for (int i=0;i<15;i++)
 71 | 						if ( bcHeader.blocks[i].offset ) 
 72 | 							BurnCacheSize = bcHeader.blocks[i].offset;
 73 | 						else break;
 74 | 					
 75 | 					//show_rom_loading_text("Cache", 0x100, BurnCacheSize);
 76 | 					
 77 | 					BurnCacheBase = mmap(0, BurnCacheSize, PROT_READ, MAP_PRIVATE, pBurnCacheFile, 0);
 78 | 					if ((int)BurnCacheBase == -1) {
 79 | 						BurnCacheBase = 0;
 80 | 						return -3;
 81 | 					}
 82 | 					bBurnUseRomCache = 1;
 83 | 					DisableReadAhead();
 84 | 					return 0;
 85 | 					
 86 | 				} else return -2;
 87 | 			}
 88 | 		}
 89 | 	}
 90 | 	return -1;
 91 | }
 92 | 
 93 | unsigned int BurnCacheBlockSize(int blockid)
 94 | {
 95 | 	return  bcHeader.blocks[blockid+1].offset - bcHeader.blocks[blockid].offset;
 96 | }
 97 | 
 98 | int BurnCacheRead(unsigned char * dst, int blockid)
 99 | {
100 | 	if ( pBurnCacheFile ) {
101 | 		show_rom_loading_text(bcHeader.blocks[blockid].desc, bcHeader.blocks[blockid+1].offset-bcHeader.blocks[blockid].offset, BurnCacheSize);
102 | 		lseek( pBurnCacheFile, bcHeader.blocks[blockid].offset, SEEK_SET );
103 | 		read( pBurnCacheFile, dst, bcHeader.blocks[blockid+1].offset - bcHeader.blocks[blockid].offset );
104 | 		return 0;
105 | 	} 
106 | 	return 1;
107 | }
108 | 
109 | void * BurnCacheMap(int blockid)
110 | {
111 | 	if ( BurnCacheBase ) {
112 | 		if ( (bcHeader.blocks[blockid+1].offset - bcHeader.blocks[blockid].offset) > 0 ) {
113 | 			show_rom_loading_text(bcHeader.blocks[blockid].desc, bcHeader.blocks[blockid+1].offset-bcHeader.blocks[blockid].offset, BurnCacheSize);
114 | 			return (unsigned char *)BurnCacheBase + bcHeader.blocks[blockid].offset;
115 | 		} else return 0;
116 | 	} else
117 | 		return 0;
118 | }
119 | 
120 | void BurnCacheExit()
121 | {	
122 | 	if ( BurnCacheBase ) {
123 | 		munmap( BurnCacheBase, BurnCacheSize );
124 | 		BurnCacheBase = 0;
125 | 		BurnCacheSize = 0;
126 | 	}
127 | 
128 | 	if (pBurnCacheFile) {
129 | 		close(pBurnCacheFile);
130 | 		pBurnCacheFile = 0;
131 | 	}
132 | 
133 | 	bBurnUseRomCache = 0;
134 | }
135 | 
136 | 
137 | 


--------------------------------------------------------------------------------
/rpi/cache.h:
--------------------------------------------------------------------------------
 1 | #ifndef BURN_CACHE_H
 2 | #define BURN_CACHE_H
 3 | 
 4 | extern int bBurnUseRomCache;
 5 | 
 6 | int BurnCacheInit(const char * cfname, char *rom_name);
 7 | 
 8 | int BurnCacheBlockSize(int blockid);
 9 | int BurnCacheRead(unsigned char * dst, int blockid);
10 | void * BurnCacheMap(int blockid);
11 | 
12 | void BurnCacheExit();
13 | 
14 | #endif	// BURN_CACHE_H
15 | 


--------------------------------------------------------------------------------
/rpi/config.h:
--------------------------------------------------------------------------------
 1 | #ifndef _CONFIG_H_
 2 | #define _CONFIG_H_
 3 | 
 4 | typedef struct
 5 | {
 6 | 	int option_sound_enable;
 7 | 	int option_rescale;
 8 | 	int option_samplerate;
 9 | 	int option_showfps;
10 | 	int option_display_border;
11 | 	char option_frontend[MAX_PATH];
12 | 	int display_smooth_stretch;
13 | 	int display_effect;
14 | 	int maintain_aspect_ratio;
15 | 	int display_rotate;
16 | 	char config_file[MAX_PATH];
17 | } CFG_OPTIONS;
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/rpi/configfile.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * EZX Emulator for MOTO EZX Modile Phone
 3 |  * Copyright (C) 2006 OopsWare. CHINA.
 4 |  *
 5 |  * This program is free software; you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation; either version 2 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * This program is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with this program; if not, write to the Free Software
17 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 |  *
19 |  * $Id: configfile.h,v 0.10 2006/04 $
20 |  */
21 |  
22 | #ifndef _MP3PLATER_CONFIG_FILE_
23 | #define _MP3PLATER_CONFIG_FILE_
24 | 
25 | #include <stdio.h>
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/rpi/drv.cpp:
--------------------------------------------------------------------------------
  1 | // Driver Init module
  2 | #include "burner.h"
  3 | 
  4 | void logoutput(const char *text,...);
  5 | 
  6 | int bDrvOkay=0; // 1 if the Driver has been initted okay, and it's okay to use the BurnDrv functions
  7 | 
  8 | static bool bSaveRAM = false;
  9 | 
 10 | static int DoLibInit() // Do Init of Burn library driver
 11 | {
 12 |   	int nRet;
 13 |   
 14 | 	BzipOpen(false);
 15 | 
 16 | 	// If there is an error with the romset, report it
 17 | 	if (BzipStatus() != BZIP_STATUS_OK)  {
 18 | 		// 
 19 | 	}
 20 | 
 21 | 	nRet = BurnDrvInit();
 22 | 
 23 | 	BzipClose();
 24 | 
 25 | 	return (nRet) ? 3 : 0 ;
 26 | }
 27 | 
 28 | 
 29 | int DrvExit()
 30 | {
 31 | 	if (bDrvOkay) {
 32 | 
 33 | //		StopReplay();
 34 | 
 35 | //		VidExit();
 36 | 
 37 | //		InvalidateRect(hScrnWnd, NULL, 1);
 38 | //		UpdateWindow(hScrnWnd);			// Blank screen window
 39 | 
 40 | 		if (nBurnDrvSelect < nBurnDrvCount) {
 41 | 
 42 | //			MemCardEject();				// Eject memory card if present
 43 | 
 44 | //			if (bSaveRAM) {
 45 | //				StatedAuto(1);			// Save NV (or full) RAM
 46 | //				bSaveRAM = false;
 47 | //			}
 48 | 
 49 | //			ConfigGameSave(bSaveInputs);
 50 | 
 51 | //			GameInpExit();				// Exit game input
 52 | 			BurnDrvExit();				// Exit the driver
 53 | 		}
 54 | 	}
 55 | 
 56 | 	BurnExtLoadRom = NULL;
 57 | 
 58 | 	bDrvOkay = 0;					// Stop using the BurnDrv functions
 59 | 
 60 | //	bRunPause = 0;					// Don't pause when exitted
 61 | 
 62 | //	if (bAudOkay) {
 63 | 		// Write silence into the sound buffer on exit, and for drivers which don't use pBurnSoundOut
 64 | //		memset(nAudNextSound, 0, nAudSegLen << 2);
 65 | //	}
 66 | 
 67 | 	nBurnDrvSelect = ~0U;			// no driver selected
 68 | 	return 0;
 69 | }
 70 | 
 71 | static int __cdecl DrvLoadRom(unsigned char* Dest, int* pnWrote, int i)
 72 | {
 73 | 	int nRet;
 74 | 
 75 | //printf("real load rom\n");
 76 | logoutput("real load rom\n");
 77 | 
 78 | 	BzipOpen(false);
 79 | 
 80 | 	if ((nRet = BurnExtLoadRom(Dest, pnWrote, i)) != 0) {
 81 | 		char* pszFilename;
 82 | 
 83 | 		BurnDrvGetRomName(&pszFilename, i, 0);
 84 | 		//sq printf("Error load %s, requested by %s\n", pszFilename, BurnDrvGetText(DRV_NAME));
 85 | 		logoutput("Error load %s, requested by %s\n", pszFilename, BurnDrvGetText(DRV_NAME));
 86 | 	}
 87 | 
 88 | 	BzipClose();
 89 | 
 90 | 	BurnExtLoadRom = DrvLoadRom;
 91 | 
 92 | //	ScrnTitle();
 93 | 
 94 | 	return nRet;
 95 | }
 96 | 
 97 | int DrvInit(int nDrvNum, bool bRestore)
 98 | {
 99 | 	int nRet=0;
100 | 	DrvExit(); // Make sure exited
101 |   
102 | 	nBurnDrvSelect=nDrvNum; // set the driver number
103 | 	nRet=DoLibInit(); // Init the Burn library's driver
104 | 
105 | 	if (nRet!=0) {
106 | 		BurnDrvExit(); // Exit the driver
107 | 		//sq printf ("There was an error starting '%s'.\n", BurnDrvGetText(DRV_NAME));
108 | 		logoutput ("There was an error starting '%s'.\n", BurnDrvGetText(DRV_NAME));
109 | 		return 1;
110 | 	}
111 | 
112 | //  GameInpInit(); // Init game input
113 |   // Load config for the game
114 | //  nRet=ConfigGameLoad(); if (nRet!=0) ConfigGameSave(); // create initial game config file
115 | 
116 |   // Dip switch values in driver will have been set now:
117 | //  GameInpDefault(); // Auto-config any input which is still undefined to defaults
118 |   // (also sets/gets dip switch valeus from driver)
119 | 
120 | 	BurnExtLoadRom = DrvLoadRom;
121 | 
122 | 	bDrvOkay=1; // Okay to use the BurnDrv functions
123 | 
124 | 	nBurnLayer=0xff; // show all layers
125 | 
126 |   // Init the video plugin
127 | //  nRet=VidInit();
128 | //  if (nRet!=0) { AppError("VidInit Failed",0); return 1; }
129 | 
130 |   // Reset the speed throttling code, so we don't 'jump' after the load
131 | //	RunReset();
132 | 
133 | 	return 0;
134 | }
135 | 
136 | int DrvInitCallback()
137 | {
138 |     return DrvInit(nBurnDrvSelect, false);
139 | }
140 | 
141 | 


--------------------------------------------------------------------------------
/rpi/fba_player.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * FinalBurn Alpha for MOTO EZX Modile Phone
 3 |  * Copyright (C) 2006 OopsWare. CHINA.
 4 |  *
 5 |  * This program is free software; you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation; either version 2 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * This program is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with this program; if not, write to the Free Software
17 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 |  *
19 |  * $Id: fba_player.h,v 0.10 2006/12/03 $
20 |  */
21 | 
22 | #ifndef _FBA_PLAYER_
23 | #define _FBA_PLAYER_
24 | 
25 | #include "gamewidget.h"
26 | 
27 | void run_fba_emulator(const char *);
28 | 
29 | #endif	// _FBA_PLAYER_
30 | 


--------------------------------------------------------------------------------
/rpi/fifo_buffer.c:
--------------------------------------------------------------------------------
  1 | /*  RSound - A PCM audio client/server
  2 |  *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  3 |  * 
  4 |  *  RSound is free software: you can redistribute it and/or modify it under the terms
  5 |  *  of the GNU General Public License as published by the Free Software Found-
  6 |  *  ation, either version 3 of the License, or (at your option) any later version.
  7 |  *
  8 |  *  RSound is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  9 |  *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 10 |  *  PURPOSE.  See the GNU General Public License for more details.
 11 |  *
 12 |  *  You should have received a copy of the GNU General Public License along with RSound.
 13 |  *  If not, see <http://www.gnu.org/licenses/>.
 14 |  */
 15 | 
 16 | #include "fifo_buffer.h"
 17 | #include <stdint.h>
 18 | 
 19 | struct fifo_buffer
 20 | {
 21 |    uint8_t *buffer;
 22 |    size_t bufsize;
 23 |    size_t first;
 24 |    size_t end;
 25 | };
 26 | 
 27 | fifo_buffer_t *fifo_new(size_t size)
 28 | {
 29 |    fifo_buffer_t *buf = (fifo_buffer_t*)calloc(1, sizeof(*buf));
 30 |    if (buf == NULL)
 31 |       return NULL;
 32 | 
 33 |    buf->buffer = (uint8_t*)calloc(1, size + 1);
 34 |    if (buf->buffer == NULL)
 35 |    {
 36 |       free(buf);
 37 |       return NULL;
 38 |    }
 39 |    buf->bufsize = size + 1;
 40 | 
 41 |    return buf;
 42 | }
 43 | 
 44 | void fifo_free(fifo_buffer_t *buffer)
 45 | {
 46 |    free(buffer->buffer);
 47 |    free(buffer);
 48 | }
 49 | 
 50 | size_t fifo_read_avail(fifo_buffer_t *buffer)
 51 | {
 52 |    size_t first = buffer->first;
 53 |    size_t end = buffer->end;
 54 |    if (end < first)
 55 |       end += buffer->bufsize;
 56 |    return end - first;
 57 | }
 58 | 
 59 | size_t fifo_write_avail(fifo_buffer_t *buffer)
 60 | {
 61 |    size_t first = buffer->first;
 62 |    size_t end = buffer->end;
 63 |    if (end < first)
 64 |       end += buffer->bufsize;
 65 | 
 66 |    return (buffer->bufsize - 1) - (end - first);
 67 | }
 68 | 
 69 | void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size)
 70 | {
 71 |    size_t first_write = size;
 72 |    size_t rest_write = 0;
 73 |    if (buffer->end + size > buffer->bufsize)
 74 |    {
 75 |       first_write = buffer->bufsize - buffer->end;
 76 |       rest_write = size - first_write;
 77 |    }
 78 | 
 79 |    memcpy(buffer->buffer + buffer->end, in_buf, first_write);
 80 |    memcpy(buffer->buffer, (const uint8_t*)in_buf + first_write, rest_write);
 81 | 
 82 |    buffer->end = (buffer->end + size) % buffer->bufsize;
 83 | }
 84 | 
 85 | 
 86 | void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size)
 87 | {
 88 |    size_t first_read = size;
 89 |    size_t rest_read = 0;
 90 |    if (buffer->first + size > buffer->bufsize)
 91 |    {
 92 |       first_read = buffer->bufsize - buffer->first;
 93 |       rest_read = size - first_read;
 94 |    }
 95 | 
 96 |    memcpy(in_buf, (const uint8_t*)buffer->buffer + buffer->first, first_read);
 97 |    memcpy((uint8_t*)in_buf + first_read, buffer->buffer, rest_read);
 98 | 
 99 |    buffer->first = (buffer->first + size) % buffer->bufsize;
100 | }
101 | 
102 | 


--------------------------------------------------------------------------------
/rpi/fifo_buffer.h:
--------------------------------------------------------------------------------
 1 | /*  RSound - A PCM audio client/server
 2 |  *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
 3 |  * 
 4 |  *  RSound is free software: you can redistribute it and/or modify it under the terms
 5 |  *  of the GNU General Public License as published by the Free Software Found-
 6 |  *  ation, either version 3 of the License, or (at your option) any later version.
 7 |  *
 8 |  *  RSound is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 9 |  *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 |  *  PURPOSE.  See the GNU General Public License for more details.
11 |  *
12 |  *  You should have received a copy of the GNU General Public License along with RSound.
13 |  *  If not, see <http://www.gnu.org/licenses/>.
14 |  */
15 | 
16 | #ifndef __BUFFER_H
17 | #define __BUFFER_H
18 | 
19 | #include <stdlib.h>
20 | #include <stdio.h>
21 | #include <string.h>
22 | 
23 | #ifndef FIFO_BUF_TYPEDEF
24 | #define FIFO_BUF_TYPEDEF
25 | typedef struct fifo_buffer fifo_buffer_t;
26 | #endif
27 | 
28 | fifo_buffer_t *fifo_new(size_t size);
29 | void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size);
30 | void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size);
31 | void fifo_free(fifo_buffer_t *buffer);
32 | size_t fifo_read_avail(fifo_buffer_t *buffer);
33 | size_t fifo_write_avail(fifo_buffer_t *buffer);
34 | 
35 | #endif
36 | 


--------------------------------------------------------------------------------
/rpi/font.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
 3 |  *
 4 |  * (c) Copyright 1996 - 2001 Gary Henderson (gary.henderson@ntlworld.com) and
 5 |  *                           Jerremy Koot (jkoot@snes9x.com)
 6 |  *
 7 |  * Super FX C emulator code 
 8 |  * (c) Copyright 1997 - 1999 Ivar (ivar@snes9x.com) and
 9 |  *                           Gary Henderson.
10 |  * Super FX assembler emulator code (c) Copyright 1998 zsKnight and _Demo_.
11 |  *
12 |  * DSP1 emulator code (c) Copyright 1998 Ivar, _Demo_ and Gary Henderson.
13 |  * C4 asm and some C emulation code (c) Copyright 2000 zsKnight and _Demo_.
14 |  * C4 C code (c) Copyright 2001 Gary Henderson (gary.henderson@ntlworld.com).
15 |  *
16 |  * DOS port code contains the works of other authors. See headers in
17 |  * individual files.
18 |  *
19 |  * Snes9x homepage: http://www.snes9x.com
20 |  *
21 |  * Permission to use, copy, modify and distribute Snes9x in both binary and
22 |  * source form, for non-commercial purposes, is hereby granted without fee,
23 |  * providing that this license information and copyright notice appear with
24 |  * all copies and any derived work.
25 |  *
26 |  * This software is provided 'as-is', without any express or implied
27 |  * warranty. In no event shall the authors be held liable for any damages
28 |  * arising from the use of this software.
29 |  *
30 |  * Snes9x is freeware for PERSONAL USE only. Commercial users should
31 |  * seek permission of the copyright holders first. Commercial use includes
32 |  * charging money for Snes9x or software derived from Snes9x.
33 |  *
34 |  * The copyright holders request that bug fixes and improvements to the code
35 |  * should be forwarded to them so everyone can benefit from the modifications
36 |  * in future versions.
37 |  *
38 |  * Super NES and Super Nintendo Entertainment System are trademarks of
39 |  * Nintendo Co., Limited and its subsidiary companies.
40 |  */
41 | 
42 | #ifndef _EMU_FONT_H_
43 | #define _EMU_FONT_H_
44 | 
45 | typedef unsigned short 	uint16;
46 | typedef unsigned char 	uint8;
47 | 
48 | void DisplayChar (uint16 *Screen, uint8 c, uint16 resW);
49 | void DrawString (const char *string, uint16 *screen, uint8 x, uint8 y, uint16 resW);
50 | void DrawRect ( uint16 *screen, int x, int y, int w, int h, int c, uint16 resW );
51 | 
52 | #endif	// _EMU_FONT_H_
53 | 


--------------------------------------------------------------------------------
/rpi/gamewidget.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * EZX Emulator for MOTO EZX Modile Phone
 3 |  * Copyright (C) 2006 OopsWare. CHINA.
 4 |  *
 5 |  * This program is free software; you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation; either version 2 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * This program is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with this program; if not, write to the Free Software
17 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 |  *
19 |  * $Id: gamewidget.h,v 0.10 2006/06/07 $
20 |  */
21 | 
22 | #ifndef _GAME_WIDGET_
23 | #define _GAME_WIDGET_
24 |  
25 | extern unsigned short *VideoBuffer;
26 | 
27 | struct HARD_KEY_CODE {
28 | 	int key_code;
29 | 	bool down;
30 | };
31 | 
32 | #define EZX_KEY_REAL		0
33 | #define EZX_KEY_RADIO		1
34 | #define EZX_KEY_VOL_UP		2
35 | #define EZX_KEY_VOL_DOWN	3
36 | #define EZX_KEY_CALL		4
37 | #define EZX_KEY_HANG		5
38 | #define EZX_KEY_OK			6
39 | 
40 | #define EZX_KEY_SOFT1		7
41 | #define EZX_KEY_SOFT2		8
42 | #define EZX_KEY_SOFT3		9
43 | 
44 | #define EZX_KEY_CAP			10
45 | 
46 | #define EZX_KEY_UP			11
47 | #define EZX_KEY_DOWN		12
48 | #define EZX_KEY_LEFT		13
49 | #define EZX_KEY_RIGHT		14
50 | 
51 | #define EZX_KEY_COUNT		15
52 | 
53 | extern struct HARD_KEY_CODE HKCS[];
54 | 
55 | extern bool GameLooping;
56 | extern bool GamePauseing;
57 | 
58 | extern int  GameScreenMode;
59 | extern int  GameFrameSkip;
60 | extern int  GameKeymap[10];
61 | extern bool GameMute;
62 | //int  GameGain		= 0;
63 | 
64 | /* SDL Timer */
65 | 
66 | void EZX_StartTicks(void);
67 | unsigned int EZX_GetTicks (void);
68 | void EZX_Delay (unsigned int ms);
69 | int EZX_SoftStretch(void *src, int sx, int sy, int sw, int sh, int sp, void *dst, int dw, int dh);
70 | 
71 | struct keymap_item  {
72 | 	char name[10];
73 | 	int  keypad;
74 | 	bool turbo;
75 | };
76 | 
77 | 
78 | #endif	// _GAME_WIDGET_
79 | 


--------------------------------------------------------------------------------
/rpi/main.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * NES for MOTO EZX Modile Phone
 3 |  * Copyright (C) 2006 OopsWare. CHINA.
 4 |  *
 5 |  * This program is free software; you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation; either version 2 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * This program is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with this program; if not, write to the Free Software
17 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 |  *
19 |  * SPECIAL THANKS:
20 |  *   Sam Revitch  	http://lsb.blogdns.net/ezx-devkit 
21 |  *
22 |  * $Id: main.h,v 0.10 2006/06/07 $
23 |  */
24 |  
25 | #ifndef MAIN_WIDGET_H
26 | #define MAIN_WIDGET_H
27 | 
28 | #include <stddef.h>
29 | #include <stdio.h>
30 | #include "configfile.h"
31 | 
32 | #define	EZX_EMU_VER	"1.12"
33 | 
34 | #endif // MAIN_WIDGET_H
35 | 


--------------------------------------------------------------------------------
/rpi/moose.h:
--------------------------------------------------------------------------------
1 | #define ushort unsigned short
2 | 


--------------------------------------------------------------------------------
/rpi/snd.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #define AUDIO_FORMAT	AFMT_S16_LE
 3 | 
 4 | //#define AUDIO_BITRATE	8000
 5 | 
 6 | #define AUDIO_BLOCKS	8
 7 | 
 8 | //#define AUDIO_FREGMENT	(10 | 8 << 16)
 9 | #define AUDIO_FREGMENT	0x0002000F
10 | 
11 | extern int dspfd;
12 | 
13 | //#define	EzxAudioBufferSize	(1024 * 10)
14 | 
15 | 
16 | int SndInit();
17 | int SndOpen();
18 | void SndClose();
19 | void SndPlay();
20 | void SndExit();
21 | int SegAim();
22 | 
23 | 
24 | 


--------------------------------------------------------------------------------
/rpi/thread.h:
--------------------------------------------------------------------------------
 1 | /*  RetroArch - A frontend for libretro.
 2 |  *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
 3 |  * 
 4 |  *  RetroArch is free software: you can redistribute it and/or modify it under the terms
 5 |  *  of the GNU General Public License as published by the Free Software Found-
 6 |  *  ation, either version 3 of the License, or (at your option) any later version.
 7 |  *
 8 |  *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 9 |  *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 |  *  PURPOSE.  See the GNU General Public License for more details.
11 |  *
12 |  *  You should have received a copy of the GNU General Public License along with RetroArch.
13 |  *  If not, see <http://www.gnu.org/licenses/>.
14 |  */
15 | 
16 | #ifndef THREAD_H__
17 | #define THREAD_H__
18 | 
19 | #include "boolean.h"
20 | 
21 | // Implements the bare minimum needed for RetroArch. :)
22 | 
23 | typedef struct sthread sthread_t;
24 | 
25 | // Threading
26 | sthread_t *sthread_create(void (*thread_func)(void*), void *userdata);
27 | void sthread_join(sthread_t *thread);
28 | 
29 | // Mutexes
30 | typedef struct slock slock_t;
31 | 
32 | slock_t *slock_new(void);
33 | void slock_free(slock_t *lock);
34 | 
35 | void slock_lock(slock_t *lock);
36 | void slock_unlock(slock_t *lock);
37 | 
38 | // Condition variables.
39 | typedef struct scond scond_t;
40 | 
41 | scond_t *scond_new(void);
42 | void scond_free(scond_t *cond);
43 | 
44 | void scond_wait(scond_t *cond, slock_t *lock);
45 | #ifndef RARCH_CONSOLE
46 | bool scond_wait_timeout(scond_t *cond, slock_t *lock, unsigned timeout_ms);
47 | #endif
48 | void scond_signal(scond_t *cond);
49 | 
50 | 
51 | #endif
52 | 
53 | 


--------------------------------------------------------------------------------
/rpi/zipfn.cpp:
--------------------------------------------------------------------------------
  1 | // Zip module
  2 | #include "burner.h"
  3 | #include "unzip.h"
  4 | 
  5 | static unzFile Zip=NULL;
  6 | static int nCurrFile=0; // The current file we are pointing to
  7 | 
  8 | int ZipOpen(char *szZip)
  9 | {
 10 |   Zip=unzOpen(szZip);
 11 |   if (Zip==NULL) return 1;
 12 |   unzGoToFirstFile(Zip); nCurrFile=0;
 13 |   return 0;
 14 | }
 15 | 
 16 | int ZipClose()
 17 | {
 18 |   if (Zip!=NULL) unzClose(Zip);  Zip=NULL;
 19 |   return 0;
 20 | }
 21 | 
 22 | // Get the contents of a zip file into an array of ZipEntrys
 23 | int ZipGetList(struct ZipEntry **pList,int *pnListCount)
 24 | {
 25 |   int nRet=0;
 26 |   int nNextRet=0;
 27 |   unz_global_info ZipGlobalInfo;
 28 |   struct ZipEntry *List=NULL; int nListLen=0;
 29 |   if (Zip==NULL) return 1;
 30 |   if (pList==NULL) return 1;
 31 | 
 32 |   memset(&ZipGlobalInfo,0,sizeof(ZipGlobalInfo));
 33 | 
 34 |   unzGetGlobalInfo(Zip,&ZipGlobalInfo);
 35 |   nListLen=ZipGlobalInfo.number_entry;
 36 | 
 37 |   // Make an array of File Entries
 38 |   List=(struct ZipEntry *)malloc(nListLen*sizeof(struct ZipEntry));
 39 |   if (List==NULL)  { unzClose(Zip); return 1; }
 40 |   memset(List,0,nListLen*sizeof(struct ZipEntry));
 41 | 
 42 |   nRet=unzGoToFirstFile(Zip); if (nRet!=UNZ_OK) { unzClose(Zip); return 1; }
 43 | 
 44 |   // Step through all of the files, until we get to the end
 45 | 
 46 |   for ( nCurrFile=0,          nNextRet=UNZ_OK;
 47 |         nCurrFile<nListLen && nNextRet==UNZ_OK;
 48 |         nCurrFile++,          nNextRet=unzGoToNextFile(Zip) )
 49 |   {
 50 |     unz_file_info FileInfo;
 51 |     char *szName=NULL;
 52 |     memset(&FileInfo,0,sizeof(FileInfo));
 53 | 
 54 |     nRet=unzGetCurrentFileInfo(Zip,&FileInfo,NULL,0,NULL,0,NULL,0); if (nRet!=UNZ_OK) continue;
 55 | 
 56 |     // Allocate space for the filename
 57 |     szName=(char *)malloc(FileInfo.size_filename+1); if (szName==NULL) continue;
 58 |     nRet=unzGetCurrentFileInfo(Zip,&FileInfo,szName,FileInfo.size_filename+1,NULL,0,NULL,0);
 59 | 
 60 |     List[nCurrFile].szName=szName;
 61 |     List[nCurrFile].nLen=FileInfo.uncompressed_size;
 62 |     List[nCurrFile].nCrc=FileInfo.crc;
 63 |   }
 64 | 
 65 |   // return the file list
 66 |   *pList=List;
 67 |   if (pnListCount!=NULL) *pnListCount=nListLen;
 68 | 
 69 |   unzGoToFirstFile(Zip); nCurrFile=0;
 70 |   return 0;
 71 | }
 72 | 
 73 | int ZipLoadFile(unsigned char *Dest,int nLen,int *pnWrote,int nEntry)
 74 | {
 75 |   int nRet=0;
 76 |   if (Zip==NULL) return 1;
 77 |   if (nEntry<nCurrFile)
 78 |   {
 79 |     // We'll have to go through the zip file again to get to our entry
 80 |     nRet=unzGoToFirstFile(Zip); if (nRet!=UNZ_OK) return 1;
 81 |     nCurrFile=0;
 82 |   }
 83 | 
 84 |   // Now step through to the file we need
 85 |   while(nCurrFile<nEntry)
 86 |   {
 87 |     nRet=unzGoToNextFile(Zip); if (nRet!=UNZ_OK) return 1;
 88 |     nCurrFile++;
 89 |   }
 90 | 
 91 |   nRet=unzOpenCurrentFile(Zip); if (nRet!=UNZ_OK) return 1;
 92 | 
 93 |   nRet=unzReadCurrentFile(Zip,Dest,nLen);
 94 |   if (nRet>=0 && pnWrote!=NULL) *pnWrote=nRet; // Return how many bytes were copied
 95 | 
 96 |   nRet=unzCloseCurrentFile(Zip);
 97 |   if (nRet==UNZ_CRCERROR) return 2;
 98 |   if (nRet!=UNZ_OK) return 1;
 99 | 
100 |   return 0;
101 | }
102 | 


--------------------------------------------------------------------------------
/skin/capex_bg.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/skin/capex_bg.bmp


--------------------------------------------------------------------------------
/skin/capex_selector.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/skin/capex_selector.bmp


--------------------------------------------------------------------------------
/skin/capex_title.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/skin/capex_title.bmp


--------------------------------------------------------------------------------
/skin/gfx_FONT.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RetroPie/pifba/289e5f4410e7674bd5da8ec49c265244b8251a4c/skin/gfx_FONT.bmp


--------------------------------------------------------------------------------
/zipit:
--------------------------------------------------------------------------------
1 | rm piFBA.zip
2 | cp -p capex.cfg.template capex.cfg
3 | cp -p fba2x.cfg.template fba2x.cfg
4 | zip piFBA.zip fba2x fbacapex zipname.fba rominfo.fba fba2x.cfg capex.cfg readme.txt FBACache_windows.zip fba_029671_clrmame_dat.zip skin/capex_bg.bmp skin/capex_selector.bmp skin/capex_title.bmp skin/gfx_FONT.bmp roms/dir.txt preview/* install.sh
5 | 


--------------------------------------------------------------------------------