├── VGMPlay ├── .gitignore ├── chips │ ├── emu2413_NESpatches.txt │ ├── pwm.c │ ├── pwm.h │ ├── ym2612.c │ ├── ym2612.h │ ├── scd_pcm.c │ ├── ws_audio.c │ ├── adlibemu_opl2.c │ ├── adlibemu_opl3.c │ ├── panning.h │ ├── c6280intf.h │ ├── vsu.h │ ├── ay_intf.h │ ├── nes_intf.h │ ├── qsound_intf.h │ ├── ws_audio.h │ ├── np_nes_apu.h │ ├── np_nes_fds.h │ ├── gb.h │ ├── qsound_ctr.h │ ├── c352.h │ ├── c6280.h │ ├── adlibemu.h │ ├── dac_control.h │ ├── saa1099.h │ ├── sn764intf.h │ ├── 2413intf.h │ ├── np_nes_dmc.h │ ├── multipcm.h │ ├── qsound_mame.h │ ├── iremga20.h │ ├── c140.h │ ├── vrc7tone.h │ ├── scspdsp.h │ ├── rf5c68.h │ ├── ChipIncl.h │ ├── k053260.h │ ├── ymf271.h │ ├── x1_010.h │ ├── emutypes.h │ ├── es5503.h │ ├── ymf278b.h │ ├── 2151intf.h │ ├── 3526intf.h │ ├── segapcm.h │ ├── 3812intf.h │ ├── ymz280b.h │ ├── 262intf.h │ ├── k051649.h │ ├── ym2413.h │ ├── scsp.h │ ├── sn76496.h │ ├── 8950intf.h │ ├── upd7759.h │ ├── scd_pcm.h │ ├── okim6295.h │ ├── mamedef.h │ ├── okim6258.h │ ├── ymf262.h │ ├── 2203intf.h │ ├── nes_apu.h │ ├── k054539.h │ ├── 2608intf.h │ ├── 2610intf.h │ ├── es5506.h │ ├── panning.c │ ├── 2612intf.h │ ├── ym2413hd.h │ ├── Ootake_PSG.h │ ├── emu2149.h │ ├── ym2151.h │ ├── pokey.h │ ├── ymdeltat.h │ ├── c6280intf.c │ ├── sn76489.h │ ├── scsplfo.c │ ├── ay_intf.c │ ├── ws_initialIo.h │ ├── fmopl.h │ ├── sn764intf.c │ ├── ay8910.h │ ├── qsound_intf.c │ ├── nes_defs.h │ └── opll.h ├── VGMPlay.dsp ├── VGMPlay.dsw ├── pt_ioctl.c ├── vgm2wav.dsp ├── zlib │ ├── zdll.lib │ ├── zlib.lib │ ├── zlibd.lib │ └── zlib.def ├── PortTalk_IOCTL.h ├── XMasFiles │ ├── WEWISH.CMF │ ├── clyde1_1.dro │ ├── rudolph.dro │ ├── lem_xmas_001_jb.dro │ ├── lemmings_012_tim7.vgm │ └── SWJ-SQRC01_1C_trimmed_optimized.vgz ├── xdg │ ├── icons │ │ ├── vgmplay-16.png │ │ ├── vgmplay-32.png │ │ ├── vgmplay-64.png │ │ └── vgmplay-128.png │ ├── vgmplay-mime.xml │ └── vgmplay.desktop.in ├── dbus_stub.c ├── mmkeys_stub.c ├── licenses │ ├── List.txt │ └── mame_license.txt ├── mmkeys.h ├── stdbool.h ├── ChipMapper.h ├── dbus.h ├── Stream.h ├── VGMPlay.sln ├── VGMPlay.h ├── VGMPlay_Intf.h ├── mmkeys_Win.c ├── VGMFile.h ├── vgm2pcm.c └── vgmplay.1 ├── in_vgm ├── icon.ico ├── in_vgm.dsp ├── in_vgm.dsw ├── images │ ├── logo.bmp │ └── tabicons.bmp ├── README.md ├── ini_func.h ├── in_vgm.h ├── Winamp │ ├── GEN.H │ ├── ipc_pe.h │ ├── OUT.H │ ├── DSP.H │ └── IN2.H ├── ini_func.c └── resource.h ├── .gitattributes ├── .gitignore ├── .travis.yml └── README.md /VGMPlay/.gitignore: -------------------------------------------------------------------------------- 1 | /obj 2 | /vgm2pcm 3 | /vgmplay 4 | /vgm2wav 5 | vgmplay.desktop 6 | -------------------------------------------------------------------------------- /in_vgm/icon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/in_vgm/icon.ico -------------------------------------------------------------------------------- /VGMPlay/chips/emu2413_NESpatches.txt: -------------------------------------------------------------------------------- 1 | http://forums.nesdev.com/viewtopic.php?f=6&t=9141 2 | -------------------------------------------------------------------------------- /in_vgm/in_vgm.dsp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/in_vgm/in_vgm.dsp -------------------------------------------------------------------------------- /in_vgm/in_vgm.dsw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/in_vgm/in_vgm.dsw -------------------------------------------------------------------------------- /VGMPlay/VGMPlay.dsp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/VGMPlay.dsp -------------------------------------------------------------------------------- /VGMPlay/VGMPlay.dsw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/VGMPlay.dsw -------------------------------------------------------------------------------- /VGMPlay/chips/pwm.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/chips/pwm.c -------------------------------------------------------------------------------- /VGMPlay/chips/pwm.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/chips/pwm.h -------------------------------------------------------------------------------- /VGMPlay/pt_ioctl.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/pt_ioctl.c -------------------------------------------------------------------------------- /VGMPlay/vgm2wav.dsp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/vgm2wav.dsp -------------------------------------------------------------------------------- /VGMPlay/chips/ym2612.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/chips/ym2612.c -------------------------------------------------------------------------------- /VGMPlay/chips/ym2612.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/chips/ym2612.h -------------------------------------------------------------------------------- /VGMPlay/zlib/zdll.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/zlib/zdll.lib -------------------------------------------------------------------------------- /VGMPlay/zlib/zlib.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/zlib/zlib.lib -------------------------------------------------------------------------------- /VGMPlay/zlib/zlibd.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/zlib/zlibd.lib -------------------------------------------------------------------------------- /in_vgm/images/logo.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/in_vgm/images/logo.bmp -------------------------------------------------------------------------------- /VGMPlay/PortTalk_IOCTL.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/PortTalk_IOCTL.h -------------------------------------------------------------------------------- /VGMPlay/chips/scd_pcm.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/chips/scd_pcm.c -------------------------------------------------------------------------------- /VGMPlay/chips/ws_audio.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/chips/ws_audio.c -------------------------------------------------------------------------------- /in_vgm/images/tabicons.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/in_vgm/images/tabicons.bmp -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | *.dsp text eol=crlf 2 | *.dsw text eol=crlf 3 | *.sln text eol=crlf 4 | *.vcxproj* text eol=crlf 5 | -------------------------------------------------------------------------------- /VGMPlay/XMasFiles/WEWISH.CMF: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/XMasFiles/WEWISH.CMF -------------------------------------------------------------------------------- /VGMPlay/XMasFiles/clyde1_1.dro: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/XMasFiles/clyde1_1.dro -------------------------------------------------------------------------------- /VGMPlay/XMasFiles/rudolph.dro: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/XMasFiles/rudolph.dro -------------------------------------------------------------------------------- /VGMPlay/xdg/icons/vgmplay-16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/xdg/icons/vgmplay-16.png -------------------------------------------------------------------------------- /VGMPlay/xdg/icons/vgmplay-32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/xdg/icons/vgmplay-32.png -------------------------------------------------------------------------------- /VGMPlay/xdg/icons/vgmplay-64.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/xdg/icons/vgmplay-64.png -------------------------------------------------------------------------------- /VGMPlay/xdg/icons/vgmplay-128.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/xdg/icons/vgmplay-128.png -------------------------------------------------------------------------------- /VGMPlay/XMasFiles/lem_xmas_001_jb.dro: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/XMasFiles/lem_xmas_001_jb.dro -------------------------------------------------------------------------------- /VGMPlay/XMasFiles/lemmings_012_tim7.vgm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/XMasFiles/lemmings_012_tim7.vgm -------------------------------------------------------------------------------- /VGMPlay/chips/adlibemu_opl2.c: -------------------------------------------------------------------------------- 1 | #include "mamedef.h" 2 | 3 | #define OPLTYPE_IS_OPL2 4 | #include "adlibemu.h" 5 | #include "opl.c" 6 | -------------------------------------------------------------------------------- /VGMPlay/chips/adlibemu_opl3.c: -------------------------------------------------------------------------------- 1 | #include "mamedef.h" 2 | 3 | #define OPLTYPE_IS_OPL3 4 | #include "adlibemu.h" 5 | #include "opl.c" 6 | -------------------------------------------------------------------------------- /VGMPlay/XMasFiles/SWJ-SQRC01_1C_trimmed_optimized.vgz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vgmrips/vgmplay-legacy/HEAD/VGMPlay/XMasFiles/SWJ-SQRC01_1C_trimmed_optimized.vgz -------------------------------------------------------------------------------- /VGMPlay/dbus_stub.c: -------------------------------------------------------------------------------- 1 | #include "chips/mamedef.h" 2 | 3 | void DBus_ReadWriteDispatch(void) 4 | { 5 | 6 | } 7 | 8 | void DBus_EmitSignal(UINT8 type) 9 | { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /VGMPlay/mmkeys_stub.c: -------------------------------------------------------------------------------- 1 | #include "chips/mamedef.h" 2 | #include "mmkeys.h" 3 | 4 | UINT8 MultimediaKeyHook_Init(void) 5 | { 6 | return 0; 7 | } 8 | 9 | void MultimediaKeyHook_Deinit(void) 10 | { 11 | 12 | } 13 | 14 | void MultimediaKeyHook_SetCallback(mmkey_cbfunc callbackFunc) 15 | { 16 | 17 | } 18 | -------------------------------------------------------------------------------- /VGMPlay/licenses/List.txt: -------------------------------------------------------------------------------- 1 | MAME - mame_license.txt 2 | DosBox - GPL.txt 3 | openMSX - GPL.txt 4 | Gens/GS - GPL.txt 5 | NSFPlay - [Google Code lists Apache License 2.0] 6 | Ootake - ? 7 | Gens - Cardware 8 | MEKA - ? 9 | zlib - see zlib.h 10 | in_wsr - ? 11 | vbjin/mednafen - GNU GPLv2 12 | EMU2149/EMU2413 - MIT License 13 | -------------------------------------------------------------------------------- /VGMPlay/mmkeys.h: -------------------------------------------------------------------------------- 1 | #ifndef __MMKEYS_H__ 2 | #define __MMKEYS_H__ 3 | 4 | typedef void (*mmkey_cbfunc)(UINT8 event); 5 | 6 | #define MMKEY_PLAY 0x01 7 | #define MMKEY_PREV 0x10 8 | #define MMKEY_NEXT 0x11 9 | 10 | UINT8 MultimediaKeyHook_Init(void); 11 | void MultimediaKeyHook_Deinit(void); 12 | void MultimediaKeyHook_SetCallback(mmkey_cbfunc callbackFunc); 13 | 14 | #endif // __MMKEYS_H__ 15 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ################## 2 | ## Visual Studio 6 3 | ################## 4 | 5 | # Build results 6 | [Dd]ebug/ 7 | [Rr]elease/ 8 | *.exe 9 | *.dll 10 | 11 | # Object files 12 | *.ilk 13 | *.obj 14 | *.pch 15 | *.pdb 16 | *.sbr 17 | *.tmp 18 | 19 | # Project cache files 20 | *.aps 21 | *.ncb 22 | *.opt 23 | *.sdf 24 | *.suo 25 | *.user 26 | 27 | Thumbs.db 28 | ehthumbs.db 29 | Desktop.ini 30 | -------------------------------------------------------------------------------- /VGMPlay/chips/panning.h: -------------------------------------------------------------------------------- 1 | /* 2 | panning.h by Maxim in 2006 3 | Implements "simple equal power" panning using sine distribution 4 | I am not an expert on this stuff, but this is the best sounding of the methods I've tried 5 | */ 6 | 7 | #ifndef PANNING_H 8 | #define PANNING_H 9 | 10 | void calc_panning(float channels[2], int position); 11 | void centre_panning(float channels[2]); 12 | 13 | #endif -------------------------------------------------------------------------------- /VGMPlay/xdg/vgmplay-mime.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | VGM Audio File 5 | 6 | 7 | 8 | Compressed VGM Audio File 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /VGMPlay/stdbool.h: -------------------------------------------------------------------------------- 1 | // custom stdbool.h to for 1-byte bool types 2 | 3 | #ifndef _CSTM_STDBOOL_H_ 4 | #define _CSTM_STDBOOL_H_ 5 | 6 | #ifndef __cplusplus // C++ already has the bool-type 7 | 8 | #define false 0x00 9 | #define true 0x01 10 | 11 | // the MS VC++ 6 compiler uses a one-byte-type (unsigned char, to be exact), so I'll reproduce this here 12 | typedef unsigned char bool; 13 | 14 | #endif // !__cplusplus 15 | 16 | #endif // !_CSTM_STDBOOL_H_ 17 | -------------------------------------------------------------------------------- /VGMPlay/xdg/vgmplay.desktop.in: -------------------------------------------------------------------------------- 1 | [Desktop Entry] 2 | Name=VGMPlay 3 | GenericName=VGMPlay 4 | Comment=VGM File Player 5 | Exec=@BIN_PATH@vgmplay %f 6 | Terminal=true 7 | Icon=vgmplay 8 | Type=Application 9 | StartupNotify=false 10 | Version=1.0 11 | Categories=AudioVideo; 12 | MimeType=audio/x-vgm;audio/x-vgz;application/mpegurl;application/x-mpegurl;audio/mpegurl;audio/x-mpegurl; 13 | Keywords=Audio;Music;VGM;Player;Video Game Music;Sound Chip; OKI; SN; YM; OPL; PCM; AY; 14 | -------------------------------------------------------------------------------- /VGMPlay/chips/c6280intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void c6280_w(UINT8 ChipID, offs_t offset, UINT8 data); 4 | UINT8 c6280_r(UINT8 ChipID, offs_t offset); 5 | 6 | void c6280_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 7 | int device_start_c6280(UINT8 ChipID, int clock); 8 | void device_stop_c6280(UINT8 ChipID); 9 | void device_reset_c6280(UINT8 ChipID); 10 | 11 | void c6280_set_emu_core(UINT8 Emulator); 12 | void c6280_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 13 | -------------------------------------------------------------------------------- /VGMPlay/chips/vsu.h: -------------------------------------------------------------------------------- 1 | #ifndef __VB_VSU_H 2 | #define __VB_VSU_H 3 | 4 | void VSU_Write(UINT8 ChipID, UINT32 A, UINT8 V); 5 | 6 | void vsu_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 7 | 8 | int device_start_vsu(UINT8 ChipID, int clock); 9 | void device_stop_vsu(UINT8 ChipID); 10 | void device_reset_vsu(UINT8 ChipID); 11 | 12 | //void vsu_set_options(UINT16 Options); 13 | void vsu_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 14 | 15 | #endif // __VB_VSU_H 16 | -------------------------------------------------------------------------------- /VGMPlay/chips/ay_intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void ayxx_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 4 | 5 | int device_start_ayxx(UINT8 ChipID, int clock, UINT8 chip_type, UINT8 Flags); 6 | void device_stop_ayxx(UINT8 ChipID); 7 | void device_reset_ayxx(UINT8 ChipID); 8 | 9 | void ayxx_w(UINT8 ChipID, offs_t offset, UINT8 data); 10 | 11 | void ayxx_set_emu_core(UINT8 Emulator); 12 | void ayxx_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 13 | void ayxx_set_stereo_mask(UINT8 ChipID, UINT32 StereoMask); 14 | -------------------------------------------------------------------------------- /VGMPlay/chips/nes_intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void nes_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 4 | 5 | int device_start_nes(UINT8 ChipID, int clock); 6 | void device_stop_nes(UINT8 ChipID); 7 | void device_reset_nes(UINT8 ChipID); 8 | 9 | void nes_w(UINT8 ChipID, offs_t offset, UINT8 data); 10 | 11 | void nes_write_ram(UINT8 ChipID, offs_t DataStart, offs_t DataLength, const UINT8* RAMData); 12 | 13 | void nes_set_emu_core(UINT8 Emulator); 14 | void nes_set_options(UINT16 Options); 15 | void nes_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 16 | -------------------------------------------------------------------------------- /in_vgm/README.md: -------------------------------------------------------------------------------- 1 | # in_vgm Build Instructions 2 | 3 | In order to build in_vgm you need to download the source of VGMPlay and extract it to `..\VGMPlay\`. 4 | Then you can open `in_vgm.dsw` with MS Visual C++ to compile it. 5 | 6 | in_vgm was made with MS VC++ 6. It should compile with later versions of MS Visual C++ too, but it will ask you to convert the project first. 7 | 8 | ## Debug Build Notes 9 | To make testing easier, the `in_vgm.dll` gets copied to the `Winamp\Plugins` folder after the Debug build finished. 10 | You may want to edit the post-build-command so that it fits with your Winamp PlugIn-directory. 11 | -------------------------------------------------------------------------------- /VGMPlay/ChipMapper.h: -------------------------------------------------------------------------------- 1 | void open_fm_option(UINT8 ChipType, UINT8 OptType, UINT32 OptVal); 2 | void opl_chip_reset(void); 3 | void open_real_fm(void); 4 | void reset_real_fm(void); 5 | void setup_real_fm(UINT8 ChipType, UINT8 ChipID); 6 | void close_real_fm(void); 7 | void chip_reg_write(UINT8 ChipType, UINT8 ChipID, UINT8 Port, UINT8 Offset, UINT8 Data); 8 | void OPL_Hardware_Detecton(void); 9 | void OPL_HW_WriteReg(UINT16 Reg, UINT8 Data); 10 | void OPL_RegMapper(UINT16 Reg, UINT8 Data); 11 | void RefreshVolume(void); 12 | void StartSkipping(void); 13 | void StopSkipping(void); 14 | void ym2413opl_set_emu_core(UINT8 Emulator); 15 | -------------------------------------------------------------------------------- /VGMPlay/chips/qsound_intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void qsound_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 4 | int device_start_qsound(UINT8 ChipID, int clock); 5 | void device_stop_qsound(UINT8 ChipID); 6 | void device_reset_qsound(UINT8 ChipID); 7 | 8 | void qsound_w(UINT8 ChipID, offs_t offset, UINT8 data); 9 | UINT8 qsound_r(UINT8 ChipID, offs_t offset); 10 | 11 | void qsound_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 12 | const UINT8* ROMData); 13 | void qsound_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 14 | 15 | void qsound_set_emu_core(UINT8 Emulator); 16 | 17 | -------------------------------------------------------------------------------- /VGMPlay/chips/ws_audio.h: -------------------------------------------------------------------------------- 1 | #ifndef __WS_AUDIO_H__ 2 | #define __WS_AUDIO_H__ 3 | 4 | int ws_audio_init(UINT8 ChipID, int clock); 5 | void ws_audio_reset(UINT8 ChipID); 6 | void ws_audio_done(UINT8 ChipID); 7 | void ws_audio_update(UINT8 ChipID, stream_sample_t** buffer, int length); 8 | void ws_audio_port_write(UINT8 ChipID, UINT8 port, UINT8 value); 9 | UINT8 ws_audio_port_read(UINT8 ChipID, UINT8 port); 10 | //void ws_audio_process(void); 11 | //void ws_audio_sounddma(void); 12 | void ws_write_ram(UINT8 ChipID, UINT16 offset, UINT8 value); 13 | void ws_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 14 | //extern int WaveAdrs; 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /VGMPlay/chips/np_nes_apu.h: -------------------------------------------------------------------------------- 1 | void NES_APU_np_FrameSequence(void* chip, int s); 2 | void* NES_APU_np_Create(int clock, int rate); 3 | void NES_APU_np_Destroy(void* chip); 4 | void NES_APU_np_Reset(void* chip); 5 | bool NES_APU_np_Read(void* chip, UINT32 adr, UINT32* val); 6 | bool NES_APU_np_Write(void* chip, UINT32 adr, UINT32 val); 7 | UINT32 NES_APU_np_Render(void* chip, INT32 b[2]); 8 | void NES_APU_np_SetRate(void* chip, double rate); 9 | void NES_APU_np_SetClock(void* chip, double clock); 10 | void NES_APU_np_SetOption(void* chip, int id, int b); 11 | void NES_APU_np_SetMask(void* chip, int m); 12 | void NES_APU_np_SetStereoMix(void* chip, int trk, INT16 mixl, INT16 mixr); 13 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: c 2 | 3 | cache: ccache 4 | 5 | before_install: 6 | - cd VGMPlay 7 | - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update ; fi 8 | - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install libao; fi 9 | - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install ccache; fi 10 | - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then sed -i .bak 's/MACOSX = 0/MACOSX = 1/g' Makefile; fi 11 | 12 | os: 13 | - linux 14 | - osx 15 | 16 | compiler: 17 | - gcc 18 | 19 | addons: 20 | apt: 21 | packages: 22 | - make 23 | - gcc 24 | - zlib1g-dev 25 | - libao-dev 26 | - libdbus-1-dev 27 | 28 | script: 29 | - make 30 | -------------------------------------------------------------------------------- /VGMPlay/chips/np_nes_fds.h: -------------------------------------------------------------------------------- 1 | #ifndef _NP_NES_FDS_H_ 2 | #define _NP_NES_FDS_H_ 3 | 4 | void* NES_FDS_Create(int clock, int rate); 5 | void NES_FDS_Destroy(void* chip); 6 | void NES_FDS_Reset(void* chip); 7 | UINT32 NES_FDS_Render(void* chip, INT32 b[2]); 8 | bool NES_FDS_Write(void* chip, UINT32 adr, UINT32 val); 9 | bool NES_FDS_Read(void* chip, UINT32 adr, UINT32* val); 10 | void NES_FDS_SetRate(void* chip, double r); 11 | void NES_FDS_SetClock(void* chip, double c); 12 | void NES_FDS_SetOption(void* chip, int id, int val); 13 | void NES_FDS_SetMask(void* chip, int m); 14 | void NES_FDS_SetStereoMix(void* chip, int trk, INT16 mixl, INT16 mixr); 15 | 16 | #endif // _NP_NES_FDS_H_ 17 | -------------------------------------------------------------------------------- /VGMPlay/dbus.h: -------------------------------------------------------------------------------- 1 | #ifndef __DBUS_H__ 2 | #define __DBUS_H__ 3 | 4 | // Defines for the DBUS Signal handler 5 | #define SIGNAL_METADATA 0x01 // Metadata changed 6 | #define SIGNAL_PLAYSTATUS 0x02 // Playback Status Changed 7 | #define SIGNAL_SEEKSTATUS 0x04 // Seek Status Changed 8 | #define SIGNAL_SEEK 0x08 // Seeked 9 | #define SIGNAL_CONTROLS 0x10 // Playback controls need to be updated (CanGoNext/Previous) 10 | #define SIGNAL_VOLUME 0x20 // Volume needs to be updated 11 | #define SIGNAL_ALL 0xFF // All Signals 12 | 13 | #include "chips/mamedef.h" 14 | 15 | void DBus_ReadWriteDispatch(void); 16 | void DBus_EmitSignal(UINT8 type); 17 | 18 | #endif // __DBUS_H__ 19 | -------------------------------------------------------------------------------- /VGMPlay/chips/gb.h: -------------------------------------------------------------------------------- 1 | 2 | /* Custom Sound Interface */ 3 | UINT8 gb_wave_r(UINT8 ChipID, offs_t offset); 4 | void gb_wave_w(UINT8 ChipID, offs_t offset, UINT8 data); 5 | UINT8 gb_sound_r(UINT8 ChipID, offs_t offset); 6 | void gb_sound_w(UINT8 ChipID, offs_t offset, UINT8 data); 7 | 8 | void gameboy_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 9 | int device_start_gameboy_sound(UINT8 ChipID, int clock); 10 | void device_stop_gameboy_sound(UINT8 ChipID); 11 | void device_reset_gameboy_sound(UINT8 ChipID); 12 | 13 | void gameboy_sound_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 14 | UINT32 gameboy_sound_get_mute_mask(UINT8 ChipID); 15 | void gameboy_sound_set_options(UINT8 Flags); 16 | -------------------------------------------------------------------------------- /VGMPlay/chips/qsound_ctr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void qsoundc_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 4 | int device_start_qsound_ctr(UINT8 ChipID, int clock); 5 | void device_stop_qsound_ctr(UINT8 ChipID); 6 | void device_reset_qsound_ctr(UINT8 ChipID); 7 | 8 | void qsoundc_w(UINT8 ChipID, offs_t offset, UINT8 data); 9 | UINT8 qsoundc_r(UINT8 ChipID, offs_t offset); 10 | void qsoundc_write_data(UINT8 ChipID, UINT8 address, UINT16 data); 11 | 12 | void qsoundc_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 13 | const UINT8* ROMData); 14 | void qsoundc_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 15 | 16 | void qsoundc_wait_busy(UINT8 ChipID); 17 | -------------------------------------------------------------------------------- /VGMPlay/chips/c352.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef __C352_H__ 4 | #define __C352_H__ 5 | 6 | void c352_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 7 | int device_start_c352(UINT8 ChipID, int clock, int clkdiv); 8 | void device_stop_c352(UINT8 ChipID); 9 | void device_reset_c352(UINT8 ChipID); 10 | 11 | UINT16 c352_r(UINT8 ChipID, offs_t offset); 12 | void c352_w(UINT8 ChipID, offs_t offset, UINT16 data); 13 | 14 | void c352_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 15 | const UINT8* ROMData); 16 | 17 | void c352_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 18 | UINT32 c352_get_mute_mask(UINT8 ChipID); 19 | void c352_set_options(UINT8 Flags); 20 | 21 | #endif /* __C352_H__ */ 22 | -------------------------------------------------------------------------------- /VGMPlay/chips/c6280.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "devlegcy.h" 4 | 5 | typedef struct _c6280_interface c6280_interface; 6 | struct _c6280_interface 7 | { 8 | const char * cpu; 9 | }; 10 | 11 | /* Function prototypes */ 12 | //WRITE8_DEVICE_HANDLER( c6280_w ); 13 | //READ8_DEVICE_HANDLER( c6280_r ); 14 | void c6280m_w(void* chip, offs_t offset, UINT8 data); 15 | UINT8 c6280m_r(void* chip, offs_t offset); 16 | 17 | void c6280m_update(void* param, stream_sample_t **outputs, int samples); 18 | void* device_start_c6280m(int clock, int rate); 19 | void device_stop_c6280m(void* chip); 20 | void device_reset_c6280m(void* chip); 21 | 22 | void c6280m_set_mute_mask(void* chip, UINT32 MuteMask); 23 | 24 | //DECLARE_LEGACY_SOUND_DEVICE(C6280, c6280); 25 | -------------------------------------------------------------------------------- /VGMPlay/chips/adlibemu.h: -------------------------------------------------------------------------------- 1 | #if defined(OPLTYPE_IS_OPL2) 2 | #define ADLIBEMU(name) adlib_OPL2_##name 3 | #elif defined(OPLTYPE_IS_OPL3) 4 | #define ADLIBEMU(name) adlib_OPL3_##name 5 | #endif 6 | 7 | typedef void (*ADL_UPDATEHANDLER)(void *param); 8 | 9 | void* ADLIBEMU(init)(UINT32 clock, UINT32 samplerate, 10 | ADL_UPDATEHANDLER UpdateHandler, void* param); 11 | void ADLIBEMU(stop)(void *chip); 12 | void ADLIBEMU(reset)(void *chip); 13 | 14 | void ADLIBEMU(writeIO)(void *chip, UINT32 addr, UINT8 val); 15 | void ADLIBEMU(getsample)(void *chip, INT32 ** sndptr, INT32 numsamples); 16 | 17 | UINT32 ADLIBEMU(reg_read)(void *chip, UINT32 port); 18 | void ADLIBEMU(write_index)(void *chip, UINT32 port, UINT8 val); 19 | 20 | void ADLIBEMU(set_mute_mask)(void *chip, UINT32 MuteMask); 21 | -------------------------------------------------------------------------------- /VGMPlay/chips/dac_control.h: -------------------------------------------------------------------------------- 1 | void daccontrol_update(UINT8 ChipID, UINT32 samples); 2 | UINT8 device_start_daccontrol(UINT8 ChipID); 3 | void device_stop_daccontrol(UINT8 ChipID); 4 | void device_reset_daccontrol(UINT8 ChipID); 5 | void daccontrol_setup_chip(UINT8 ChipID, UINT8 ChType, UINT8 ChNum, UINT16 Command); 6 | void daccontrol_set_data(UINT8 ChipID, UINT8* Data, UINT32 DataLen, UINT8 StepSize, UINT8 StepBase); 7 | void daccontrol_refresh_data(UINT8 ChipID, UINT8* Data, UINT32 DataLen); 8 | void daccontrol_set_frequency(UINT8 ChipID, UINT32 Frequency); 9 | void daccontrol_start(UINT8 ChipID, UINT32 DataPos, UINT8 LenMode, UINT32 Length); 10 | void daccontrol_stop(UINT8 ChipID); 11 | 12 | #define DCTRL_LMODE_IGNORE 0x00 13 | #define DCTRL_LMODE_CMDS 0x01 14 | #define DCTRL_LMODE_MSEC 0x02 15 | #define DCTRL_LMODE_TOEND 0x03 16 | #define DCTRL_LMODE_BYTES 0x0F 17 | -------------------------------------------------------------------------------- /VGMPlay/chips/saa1099.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef __SAA1099_H__ 4 | #define __SAA1099_H__ 5 | 6 | /********************************************** 7 | Philips SAA1099 Sound driver 8 | **********************************************/ 9 | 10 | //WRITE8_DEVICE_HANDLER( saa1099_control_w ); 11 | void saa1099_control_w(UINT8 ChipID, offs_t offset, UINT8 data); 12 | //WRITE8_DEVICE_HANDLER( saa1099_data_w ); 13 | void saa1099_data_w(UINT8 ChipID, offs_t offset, UINT8 data); 14 | 15 | //DECLARE_LEGACY_SOUND_DEVICE(SAA1099, saa1099); 16 | void saa1099_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 17 | int device_start_saa1099(UINT8 ChipID, int clock); 18 | void device_stop_saa1099(UINT8 ChipID); 19 | void device_reset_saa1099(UINT8 ChipID); 20 | 21 | void saa1099_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 22 | 23 | #endif /* __SAA1099_H__ */ 24 | -------------------------------------------------------------------------------- /VGMPlay/chips/sn764intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /*WRITE8_DEVICE_HANDLER( ym2413_w ); 4 | 5 | WRITE8_DEVICE_HANDLER( ym2413_register_port_w ); 6 | WRITE8_DEVICE_HANDLER( ym2413_data_port_w ); 7 | 8 | DEVICE_GET_INFO( ym2413 ); 9 | #define SOUND_YM2413 DEVICE_GET_INFO_NAME( ym2413 )*/ 10 | 11 | void sn764xx_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 12 | 13 | int device_start_sn764xx(UINT8 ChipID, int clock, int shiftregwidth, int noisetaps, 14 | int negate, int stereo, int clockdivider, int freq0); 15 | void device_stop_sn764xx(UINT8 ChipID); 16 | void device_reset_sn764xx(UINT8 ChipID); 17 | 18 | void sn764xx_w(UINT8 ChipID, offs_t offset, UINT8 data); 19 | 20 | void sn764xx_set_emu_core(UINT8 Emulator); 21 | void sn764xx_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 22 | void sn764xx_set_panning(UINT8 ChipID, INT16* PanVals); 23 | -------------------------------------------------------------------------------- /VGMPlay/chips/2413intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /*WRITE8_DEVICE_HANDLER( ym2413_w ); 4 | 5 | WRITE8_DEVICE_HANDLER( ym2413_register_port_w ); 6 | WRITE8_DEVICE_HANDLER( ym2413_data_port_w ); 7 | 8 | DEVICE_GET_INFO( ym2413 ); 9 | #define SOUND_YM2413 DEVICE_GET_INFO_NAME( ym2413 )*/ 10 | 11 | void ym2413_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 12 | 13 | int device_start_ym2413(UINT8 ChipID, int clock); 14 | void device_stop_ym2413(UINT8 ChipID); 15 | void device_reset_ym2413(UINT8 ChipID); 16 | 17 | void ym2413_w(UINT8 ChipID, offs_t offset, UINT8 data); 18 | void ym2413_register_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 19 | void ym2413_data_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 20 | 21 | void ym2413_set_emu_core(UINT8 Emulator); 22 | void ym2413_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 23 | void ym2413_set_panning(UINT8 ChipID, INT16* PanVals); 24 | -------------------------------------------------------------------------------- /VGMPlay/Stream.h: -------------------------------------------------------------------------------- 1 | // Stream.h: Header File for constants and structures related to Sound Output 2 | // 3 | 4 | #ifdef WIN32 5 | #include 6 | #else 7 | #define MAX_PATH PATH_MAX 8 | #endif 9 | 10 | #define SAMPLESIZE sizeof(WAVE_16BS) 11 | #define BUFSIZE_MAX 0x1000 // Maximum Buffer Size in Bytes 12 | #ifndef WIN32 13 | #define BUFSIZELD 11 // Buffer Size 14 | #endif 15 | #define AUDIOBUFFERS 200 // Maximum Buffer Count 16 | // Windows: BUFFERSIZE = SampleRate / 100 * SAMPLESIZE (44100 / 100 * 4 = 1764) 17 | // 1 Audio-Buffer = 10 msec, Min: 5 18 | // Win95- / WinVista-safe: 500 msec 19 | // Linux: BUFFERSIZE = 1 << BUFSIZELD (1 << 11 = 2048) 20 | // 1 Audio-Buffer = 11.6 msec 21 | 22 | UINT8 SaveFile(UINT32 FileLen, const void* TempData); 23 | UINT8 SoundLogging(UINT8 Mode); 24 | UINT8 StartStream(UINT8 DeviceID); 25 | UINT8 StopStream(void); 26 | void PauseStream(bool PauseOn); 27 | -------------------------------------------------------------------------------- /VGMPlay/chips/np_nes_dmc.h: -------------------------------------------------------------------------------- 1 | #ifndef _NP_NES_DMC_H_ 2 | #define _NP_NES_DMC_H_ 3 | 4 | void* NES_DMC_np_Create(int clock, int rate); 5 | void NES_DMC_np_Destroy(void *chip); 6 | void NES_DMC_np_Reset(void *chip); 7 | void NES_DMC_np_SetRate(void* chip, double rate); 8 | void NES_DMC_np_SetPal(void* chip, bool is_pal); 9 | void NES_DMC_np_SetAPU(void* chip, void* apu_); 10 | UINT32 NES_DMC_np_Render(void* chip, INT32 b[2]); 11 | void NES_DMC_np_SetMemory(void* chip, const UINT8* r); 12 | bool NES_DMC_np_Write(void* chip, UINT32 adr, UINT32 val); 13 | bool NES_DMC_np_Read(void* chip, UINT32 adr, UINT32* val); 14 | void NES_DMC_np_SetClock(void* chip, double rate); 15 | void NES_DMC_np_SetOption(void* chip, int id, int val); 16 | int NES_DMC_np_GetDamp(void* chip); 17 | void NES_DMC_np_SetMask(void* chip, int m); 18 | void NES_DMC_np_SetStereoMix(void* chip, int trk, INT16 mixl, INT16 mixr); 19 | 20 | #endif // _NP_NES_DMC_H_ 21 | -------------------------------------------------------------------------------- /in_vgm/ini_func.h: -------------------------------------------------------------------------------- 1 | void ReadIni_Integer(const char* Section, const char* Key, UINT32* Value); 2 | void ReadIni_SIntSht(const char* Section, const char* Key, INT16* Value); 3 | void ReadIni_IntByte(const char* Section, const char* Key, UINT8* Value); 4 | void ReadIni_Boolean(const char* Section, const char* Key, bool* Value); 5 | void ReadIni_String(const char* Section, const char* Key, char* String, UINT32 StrSize); 6 | void ReadIni_Float(const char* Section, const char* Key, float* Value); 7 | 8 | void WriteIni_Integer(const char* Section, const char* Key, UINT32 Value); 9 | void WriteIni_SInteger(const char* Section, const char* Key, INT32 Value); 10 | void WriteIni_XInteger(const char* Section, const char* Key, UINT32 Value); 11 | void WriteIni_Boolean(const char* Section, const char* Key, bool Value); 12 | void WriteIni_String(const char* Section, const char* Key, char* String); 13 | void WriteIni_Float(const char* Section, const char* Key, float Value); 14 | -------------------------------------------------------------------------------- /VGMPlay/chips/multipcm.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "devlegcy.h" 4 | 5 | void MultiPCM_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 6 | int device_start_multipcm(UINT8 ChipID, int clock); 7 | void device_stop_multipcm(UINT8 ChipID); 8 | void device_reset_multipcm(UINT8 ChipID); 9 | 10 | //WRITE8_DEVICE_HANDLER( multipcm_w ); 11 | //READ8_DEVICE_HANDLER( multipcm_r ); 12 | void multipcm_w(UINT8 ChipID, offs_t offset, UINT8 data); 13 | UINT8 multipcm_r(UINT8 ChipID, offs_t offset); 14 | 15 | void multipcm_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 16 | const UINT8* ROMData); 17 | //void multipcm_set_bank(running_device *device, UINT32 leftoffs, UINT32 rightoffs); 18 | void multipcm_set_bank(UINT8 ChipID, UINT32 leftoffs, UINT32 rightoffs); 19 | void multipcm_bank_write(UINT8 ChipID, UINT8 offset, UINT16 data); 20 | 21 | void multipcm_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 22 | //DECLARE_LEGACY_SOUND_DEVICE(MULTIPCM, multipcm); 23 | -------------------------------------------------------------------------------- /VGMPlay/chips/qsound_mame.h: -------------------------------------------------------------------------------- 1 | /********************************************************* 2 | 3 | Capcom Q-Sound system 4 | 5 | *********************************************************/ 6 | 7 | #pragma once 8 | 9 | //#include "devlegcy.h" 10 | 11 | #define QSOUND_CLOCK 4000000 /* default 4MHz clock */ 12 | 13 | void qsoundm_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 14 | int device_start_qsoundm(UINT8 ChipID, int clock); 15 | void device_stop_qsoundm(UINT8 ChipID); 16 | void device_reset_qsoundm(UINT8 ChipID); 17 | 18 | 19 | //WRITE8_DEVICE_HANDLER( qsound_w ); 20 | //READ8_DEVICE_HANDLER( qsound_r ); 21 | void qsoundm_w(UINT8 ChipID, offs_t offset, UINT8 data); 22 | UINT8 qsoundm_r(UINT8 ChipID, offs_t offset); 23 | 24 | 25 | void qsoundm_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 26 | const UINT8* ROMData); 27 | void qsoundm_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 28 | 29 | //DECLARE_LEGACY_SOUND_DEVICE(QSOUND, qsound); 30 | -------------------------------------------------------------------------------- /VGMPlay/chips/iremga20.h: -------------------------------------------------------------------------------- 1 | /********************************************************* 2 | 3 | Irem GA20 PCM Sound Chip 4 | 5 | *********************************************************/ 6 | #pragma once 7 | 8 | #ifndef __IREMGA20_H__ 9 | #define __IREMGA20_H__ 10 | 11 | //#include "devlegcy.h" 12 | 13 | void IremGA20_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 14 | int device_start_iremga20(UINT8 ChipID, int clock); 15 | void device_stop_iremga20(UINT8 ChipID); 16 | void device_reset_iremga20(UINT8 ChipID); 17 | 18 | //WRITE8_DEVICE_HANDLER( irem_ga20_w ); 19 | //READ8_DEVICE_HANDLER( irem_ga20_r ); 20 | UINT8 irem_ga20_r(UINT8 ChipID, offs_t offset); 21 | void irem_ga20_w(UINT8 ChipID, offs_t offset, UINT8 data); 22 | 23 | void iremga20_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 24 | const UINT8* ROMData); 25 | 26 | void iremga20_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 27 | 28 | //DECLARE_LEGACY_SOUND_DEVICE(IREMGA20, iremga20); 29 | 30 | #endif /* __IREMGA20_H__ */ 31 | -------------------------------------------------------------------------------- /VGMPlay/chips/c140.h: -------------------------------------------------------------------------------- 1 | /* C140.h */ 2 | 3 | #pragma once 4 | 5 | void c140_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 6 | int device_start_c140(UINT8 ChipID, int clock, int banking_type); 7 | void device_stop_c140(UINT8 ChipID); 8 | void device_reset_c140(UINT8 ChipID); 9 | 10 | //READ8_DEVICE_HANDLER( c140_r ); 11 | //WRITE8_DEVICE_HANDLER( c140_w ); 12 | UINT8 c140_r(UINT8 ChipID, offs_t offset); 13 | void c140_w(UINT8 ChipID, offs_t offset, UINT8 data); 14 | 15 | //void c140_set_base(device_t *device, void *base); 16 | void c140_set_base(UINT8 ChipID, void *base); 17 | 18 | enum 19 | { 20 | C140_TYPE_SYSTEM2, 21 | C140_TYPE_SYSTEM21, 22 | C140_TYPE_ASIC219 23 | }; 24 | 25 | /*typedef struct _c140_interface c140_interface; 26 | struct _c140_interface { 27 | int banking_type; 28 | };*/ 29 | 30 | 31 | void c140_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 32 | const UINT8* ROMData); 33 | 34 | void c140_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 35 | 36 | //DECLARE_LEGACY_SOUND_DEVICE(C140, c140); 37 | -------------------------------------------------------------------------------- /in_vgm/in_vgm.h: -------------------------------------------------------------------------------- 1 | //#include "../VGMPlay.h" 2 | 3 | #if defined(APLHA) 4 | 5 | #define VER_EXTRA " alpha" 6 | #define VER_DATE " ("__DATE__" "__TIME__")" 7 | 8 | #elif defined(BETA) 9 | 10 | #define VER_EXTRA " beta" 11 | #define VER_DATE " ("__DATE__" "__TIME__")" 12 | 13 | #else 14 | 15 | #define VER_EXTRA "" 16 | #define VER_DATE "" 17 | 18 | #endif 19 | 20 | #define INVGM_VERSION VGMPLAY_VER_STR VER_EXTRA 21 | #define INVGM_TITLE "VGM Input Plugin v" INVGM_VERSION 22 | #define INVGM_TITLE_FULL "VGM Input Plugin v" INVGM_VERSION VER_DATE 23 | 24 | typedef struct plugin_options 25 | { 26 | bool ImmediateUpdate; 27 | bool NoInfoCache; 28 | 29 | UINT32 SampleRate; 30 | UINT32 ChipRate; 31 | UINT32 PauseNL; 32 | UINT32 PauseLp; 33 | 34 | char TitleFormat[0x80]; 35 | bool JapTags; 36 | bool AppendFM2413; 37 | bool TrimWhitespc; 38 | bool StdSeparators; 39 | bool TagFallback; 40 | UINT32 MLFileType; 41 | 42 | bool Enable7z; 43 | 44 | bool ResetMuting; 45 | } PLGIN_OPTS; 46 | 47 | extern PLGIN_OPTS Options; 48 | 49 | #include "resource.h" 50 | -------------------------------------------------------------------------------- /VGMPlay/chips/vrc7tone.h: -------------------------------------------------------------------------------- 1 | /* VRC7 VOICE */ 2 | /* Dumped via VRC7 debug mode by Nuke.YKT */ 3 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4 | 0x03, 0x21, 0x05, 0x06, 0xE8, 0x81, 0x42, 0x27, 5 | 0x13, 0x41, 0x14, 0x0D, 0xD8, 0xF6, 0x23, 0x12, 6 | 0x11, 0x11, 0x08, 0x08, 0xFA, 0xB2, 0x20, 0x12, 7 | 0x31, 0x61, 0x0C, 0x07, 0xA8, 0x64, 0x61, 0x27, 8 | 0x32, 0x21, 0x1E, 0x06, 0xE1, 0x76, 0x01, 0x28, 9 | 0x02, 0x01, 0x06, 0x00, 0xA3, 0xE2, 0xF4, 0xF4, 10 | 0x21, 0x61, 0x1D, 0x07, 0x82, 0x81, 0x11, 0x07, 11 | 0x23, 0x21, 0x22, 0x17, 0xA2, 0x72, 0x01, 0x17, 12 | 0x35, 0x11, 0x25, 0x00, 0x40, 0x73, 0x72, 0x01, 13 | 0xB5, 0x01, 0x0F, 0x0F, 0xA8, 0xA5, 0x51, 0x02, 14 | 0x17, 0xC1, 0x24, 0x07, 0xF8, 0xF8, 0x22, 0x12, 15 | 0x71, 0x23, 0x11, 0x06, 0x65, 0x74, 0x18, 0x16, 16 | 0x01, 0x02, 0xD3, 0x05, 0xC9, 0x95, 0x03, 0x02, 17 | 0x61, 0x63, 0x0C, 0x00, 0x94, 0xC0, 0x33, 0xF6, 18 | 0x21, 0x72, 0x0D, 0x00, 0xC1, 0xD5, 0x56, 0x06, 19 | 0x01, 0x01, 0x18, 0x0F, 0xDF, 0xF8, 0x6A, 0x6D, 20 | 0x01, 0x01, 0x00, 0x00, 0xC8, 0xD8, 0xA7, 0x68, 21 | 0x05, 0x01, 0x00, 0x00, 0xF8, 0xAA, 0x59, 0x55, 22 | -------------------------------------------------------------------------------- /VGMPlay/chips/scspdsp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef __SCSPDSP_H__ 4 | #define __SCSPDSP_H__ 5 | 6 | //the DSP Context 7 | struct _SCSPDSP 8 | { 9 | //Config 10 | UINT16 *SCSPRAM; 11 | UINT32 SCSPRAM_LENGTH; 12 | UINT32 RBP; //Ring buf pointer 13 | UINT32 RBL; //Delay ram (Ring buffer) size in words 14 | 15 | //context 16 | 17 | INT16 COEF[64]; //16 bit signed 18 | UINT16 MADRS[32]; //offsets (in words), 16 bit 19 | UINT16 MPRO[128*4]; //128 steps 64 bit 20 | INT32 TEMP[128]; //TEMP regs,24 bit signed 21 | INT32 MEMS[32]; //MEMS regs,24 bit signed 22 | UINT32 DEC; 23 | 24 | //input 25 | INT32 MIXS[16]; //MIXS, 24 bit signed 26 | INT16 EXTS[2]; //External inputs (CDDA) 16 bit signed 27 | 28 | //output 29 | INT16 EFREG[16]; //EFREG, 16 bit signed 30 | 31 | int Stopped; 32 | int LastStep; 33 | }; 34 | 35 | void SCSPDSP_Init(struct _SCSPDSP *DSP); 36 | void SCSPDSP_SetSample(struct _SCSPDSP *DSP, INT32 sample, INT32 SEL, INT32 MXL); 37 | void SCSPDSP_Step(struct _SCSPDSP *DSP); 38 | void SCSPDSP_Start(struct _SCSPDSP *DSP); 39 | 40 | #endif /* __SCSPDSP_H__ */ 41 | -------------------------------------------------------------------------------- /VGMPlay/chips/rf5c68.h: -------------------------------------------------------------------------------- 1 | /*********************************************************/ 2 | /* ricoh RF5C68(or clone) PCM controller */ 3 | /*********************************************************/ 4 | 5 | #pragma once 6 | 7 | /******************************************/ 8 | /*WRITE8_DEVICE_HANDLER( rf5c68_w ); 9 | 10 | READ8_DEVICE_HANDLER( rf5c68_mem_r ); 11 | WRITE8_DEVICE_HANDLER( rf5c68_mem_w ); 12 | 13 | DEVICE_GET_INFO( rf5c68 ); 14 | #define SOUND_RF5C68 DEVICE_GET_INFO_NAME( rf5c68 )*/ 15 | 16 | void rf5c68_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 17 | 18 | int device_start_rf5c68(UINT8 ChipID, int clock); 19 | void device_stop_rf5c68(UINT8 ChipID); 20 | void device_reset_rf5c68(UINT8 ChipID); 21 | 22 | void rf5c68_w(UINT8 ChipID, offs_t offset, UINT8 data); 23 | 24 | UINT8 rf5c68_mem_r(UINT8 ChipID, offs_t offset); 25 | void rf5c68_mem_w(UINT8 ChipID, offs_t offset, UINT8 data); 26 | void rf5c68_write_ram(UINT8 ChipID, offs_t DataStart, offs_t DataLength, const UINT8* RAMData); 27 | 28 | void rf5c68_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 29 | -------------------------------------------------------------------------------- /VGMPlay/chips/ChipIncl.h: -------------------------------------------------------------------------------- 1 | // includes all chip-headers 2 | 3 | #include "sn764intf.h" 4 | #include "2413intf.h" 5 | #include "2612intf.h" 6 | #include "2151intf.h" 7 | #include "segapcm.h" 8 | #include "rf5c68.h" 9 | #include "2203intf.h" 10 | #include "2608intf.h" 11 | #include "2610intf.h" 12 | #include "3812intf.h" 13 | #include "3526intf.h" 14 | #include "8950intf.h" 15 | #include "262intf.h" 16 | #include "ymz280b.h" 17 | #include "ymf271.h" 18 | #include "ymf278b.h" 19 | #include "scd_pcm.h" 20 | #include "pwm.h" 21 | #include "ay_intf.h" 22 | #include "dac_control.h" 23 | #include "gb.h" 24 | #include "nes_intf.h" 25 | #include "multipcm.h" 26 | #include "upd7759.h" 27 | #include "okim6258.h" 28 | #include "okim6295.h" 29 | #include "k051649.h" 30 | #include "k054539.h" 31 | #include "c6280intf.h" 32 | #include "c140.h" 33 | #include "k053260.h" 34 | #include "pokey.h" 35 | #include "qsound_intf.h" 36 | #include "scsp.h" 37 | #include "ws_audio.h" 38 | #include "vsu.h" 39 | #include "saa1099.h" 40 | #include "es5503.h" 41 | #include "es5506.h" 42 | #include "x1_010.h" 43 | #include "c352.h" 44 | #include "iremga20.h" 45 | -------------------------------------------------------------------------------- /VGMPlay/chips/k053260.h: -------------------------------------------------------------------------------- 1 | /********************************************************* 2 | 3 | Konami 053260 PCM/ADPCM Sound Chip 4 | 5 | *********************************************************/ 6 | 7 | #pragma once 8 | 9 | //#include "devlegcy.h" 10 | 11 | /*typedef struct _k053260_interface k053260_interface; 12 | struct _k053260_interface { 13 | const char *rgnoverride; 14 | timer_expired_func irq; // called on SH1 complete cycle ( clock / 32 ) // 15 | };*/ 16 | 17 | 18 | void k053260_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 19 | int device_start_k053260(UINT8 ChipID, int clock); 20 | void device_stop_k053260(UINT8 ChipID); 21 | void device_reset_k053260(UINT8 ChipID); 22 | 23 | //WRITE8_DEVICE_HANDLER( k053260_w ); 24 | //READ8_DEVICE_HANDLER( k053260_r ); 25 | void k053260_w(UINT8 ChipID, offs_t offset, UINT8 data); 26 | UINT8 k053260_r(UINT8 ChipID, offs_t offset); 27 | 28 | void k053260_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 29 | const UINT8* ROMData); 30 | void k053260_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 31 | 32 | //DECLARE_LEGACY_SOUND_DEVICE(K053260, k053260); 33 | -------------------------------------------------------------------------------- /VGMPlay/chips/ymf271.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "devcb.h" 4 | 5 | //typedef struct _ymf271_interface ymf271_interface; 6 | //struct _ymf271_interface 7 | //{ 8 | // //devcb_read8 ext_read; /* external memory read */ 9 | // //devcb_write8 ext_write; /* external memory write */ 10 | // //void (*irq_callback)(const device_config *device, int state); /* irq callback */ 11 | // void (*irq_callback)(int state); /* irq callback */ 12 | //}; 13 | 14 | /*READ8_DEVICE_HANDLER( ymf271_r ); 15 | WRITE8_DEVICE_HANDLER( ymf271_w ); 16 | 17 | DEVICE_GET_INFO( ymf271 ); 18 | #define SOUND_YMF271 DEVICE_GET_INFO_NAME( ymf271 )*/ 19 | 20 | void ymf271_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 21 | int device_start_ymf271(UINT8 ChipID, int clock); 22 | void device_stop_ymf271(UINT8 ChipID); 23 | void device_reset_ymf271(UINT8 ChipID); 24 | 25 | UINT8 ymf271_r(UINT8 ChipID, offs_t offset); 26 | void ymf271_w(UINT8 ChipID, offs_t offset, UINT8 data); 27 | void ymf271_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 28 | const UINT8* ROMData); 29 | 30 | void ymf271_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 31 | -------------------------------------------------------------------------------- /VGMPlay/chips/x1_010.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef __X1_010_H__ 4 | #define __X1_010_H__ 5 | 6 | //#include "devlegcy.h" 7 | 8 | 9 | /*typedef struct _x1_010_interface x1_010_interface; 10 | struct _x1_010_interface 11 | { 12 | int adr; // address 13 | };*/ 14 | 15 | 16 | void seta_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 17 | int device_start_x1_010(UINT8 ChipID, int clock); 18 | void device_stop_x1_010(UINT8 ChipID); 19 | void device_reset_x1_010(UINT8 ChipID); 20 | 21 | //READ8_DEVICE_HANDLER ( seta_sound_r ); 22 | //WRITE8_DEVICE_HANDLER( seta_sound_w ); 23 | UINT8 seta_sound_r(UINT8 ChipID, offs_t offset); 24 | void seta_sound_w(UINT8 ChipID, offs_t offset, UINT8 data); 25 | 26 | //READ16_DEVICE_HANDLER ( seta_sound_word_r ); 27 | //WRITE16_DEVICE_HANDLER( seta_sound_word_w ); 28 | 29 | //void seta_sound_enable_w(device_t *device, int data); 30 | 31 | void x1_010_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 32 | const UINT8* ROMData); 33 | 34 | void x1_010_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 35 | 36 | //DECLARE_LEGACY_SOUND_DEVICE(X1_010, x1_010); 37 | 38 | #endif /* __X1_010_H__ */ 39 | -------------------------------------------------------------------------------- /in_vgm/Winamp/GEN.H: -------------------------------------------------------------------------------- 1 | #ifndef NULLSOFT_WINAMP_GEN_H 2 | #define NULLSOFT_WINAMP_GEN_H 3 | 4 | #include 5 | 6 | #define GEN_INIT_SUCCESS 0 7 | 8 | // return values from the winampUninstallPlugin(HINSTANCE hdll, HWND parent, int param) 9 | // which determine if we can uninstall the plugin immediately or on winamp restart 10 | // 11 | // uninstall support was added from 5.0+ and uninstall now support from 5.5+ 12 | // it is down to you to ensure that if uninstall now is returned that it will not cause a crash 13 | // (ie don't use if you've been subclassing the main window) 14 | #define GEN_PLUGIN_UNINSTALL_NOW 0x1 15 | #define GEN_PLUGIN_UNINSTALL_REBOOT 0x0 16 | 17 | typedef struct { 18 | int version; 19 | char *description; 20 | int (*init)(); 21 | void (*config)(); 22 | void (*quit)(); 23 | HWND hwndParent; 24 | HINSTANCE hDllInstance; 25 | } winampGeneralPurposePlugin; 26 | 27 | #define GPPHDR_VER 0x10 28 | #ifdef __cplusplus 29 | extern "C" { 30 | #endif 31 | //extern winampGeneralPurposePlugin *gen_plugins[256]; 32 | typedef winampGeneralPurposePlugin * (*winampGeneralPurposePluginGetter)(); 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | 37 | #endif -------------------------------------------------------------------------------- /VGMPlay/chips/emutypes.h: -------------------------------------------------------------------------------- 1 | #ifndef _EMUTYPES_H_ 2 | #define _EMUTYPES_H_ 3 | 4 | #ifndef INLINE 5 | 6 | #if defined(_MSC_VER) 7 | //#define INLINE __forceinline 8 | #define INLINE __inline 9 | #elif defined(__GNUC__) 10 | #define INLINE __inline__ 11 | #elif defined(_MWERKS_) 12 | #define INLINE inline 13 | #else 14 | #define INLINE 15 | #endif 16 | 17 | #endif 18 | 19 | typedef unsigned int e_uint; 20 | typedef signed int e_int; 21 | 22 | typedef unsigned char e_uint8 ; 23 | typedef signed char e_int8 ; 24 | 25 | typedef unsigned short e_uint16 ; 26 | typedef signed short e_int16 ; 27 | 28 | typedef unsigned int e_uint32 ; 29 | typedef signed int e_int32 ; 30 | 31 | 32 | #if !defined(__int8_t_defined) && !defined(_STDINT) 33 | #define __int8_t_defined // for GCC 34 | #define _STDINT // for MSVC 35 | 36 | typedef e_uint8 uint8_t; 37 | typedef e_int8 int8_t; 38 | typedef e_uint16 uint16_t; 39 | typedef e_int16 int16_t; 40 | typedef e_uint32 uint32_t; 41 | typedef e_int32 int32_t; 42 | #ifdef _MSC_VER 43 | typedef unsigned __int64 uint64_t; 44 | typedef signed __int64 int64_t; 45 | #else 46 | #include 47 | #endif 48 | 49 | #endif 50 | 51 | 52 | #endif 53 | -------------------------------------------------------------------------------- /VGMPlay/chips/es5503.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef __ES5503_H__ 4 | #define __ES5503_H__ 5 | 6 | ///#include "devlegcy.h" 7 | 8 | /*typedef struct _es5503_interface es5503_interface; 9 | struct _es5503_interface 10 | { 11 | void (*irq_callback)(running_device *device, int state); 12 | read8_device_func adc_read; 13 | UINT8 *wave_memory; 14 | };*/ 15 | 16 | //READ8_DEVICE_HANDLER( es5503_r ); 17 | //WRITE8_DEVICE_HANDLER( es5503_w ); 18 | void es5503_w(UINT8 ChipID, offs_t offset, UINT8 data); 19 | UINT8 es5503_r(UINT8 ChipID, offs_t offset); 20 | 21 | void es5503_pcm_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 22 | int device_start_es5503(UINT8 ChipID, int clock, int channels); 23 | void device_stop_es5503(UINT8 ChipID); 24 | void device_reset_es5503(UINT8 ChipID); 25 | //void es5503_set_base(running_device *device, UINT8 *wavemem); 26 | 27 | void es5503_write_ram(UINT8 ChipID, offs_t DataStart, offs_t DataLength, const UINT8* RAMData); 28 | 29 | void es5503_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 30 | void es5503_set_srchg_cb(UINT8 ChipID, SRATE_CALLBACK CallbackFunc, void* DataPtr); 31 | 32 | //DECLARE_LEGACY_SOUND_DEVICE(ES5503, es5503); 33 | 34 | #endif /* __ES5503_H__ */ 35 | -------------------------------------------------------------------------------- /VGMPlay/chips/ymf278b.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define YMF278B_STD_CLOCK (33868800) /* standard clock for OPL4 */ 4 | 5 | 6 | typedef struct _ymf278b_interface ymf278b_interface; 7 | struct _ymf278b_interface 8 | { 9 | //void (*irq_callback)(const device_config *device, int state); /* irq callback */ 10 | void (*irq_callback)(int state); /* irq callback */ 11 | }; 12 | 13 | /*READ8_DEVICE_HANDLER( ymf278b_r ); 14 | WRITE8_DEVICE_HANDLER( ymf278b_w ); 15 | 16 | DEVICE_GET_INFO( ymf278b ); 17 | #define SOUND_YMF278B DEVICE_GET_INFO_NAME( ymf278b )*/ 18 | 19 | void ymf278b_pcm_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 20 | int device_start_ymf278b(UINT8 ChipID, int clock); 21 | void device_stop_ymf278b(UINT8 ChipID); 22 | void device_reset_ymf278b(UINT8 ChipID); 23 | 24 | UINT8 ymf278b_r(UINT8 ChipID, offs_t offset); 25 | void ymf278b_w(UINT8 ChipID, offs_t offset, UINT8 data); 26 | void ymf278b_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 27 | const UINT8* ROMData); 28 | void ymf278b_write_ram(UINT8 ChipID, offs_t DataStart, offs_t DataLength, const UINT8* RAMData); 29 | 30 | void ymf278b_set_mute_mask(UINT8 ChipID, UINT32 MuteMaskFM, UINT32 MuteMaskWT); 31 | 32 | -------------------------------------------------------------------------------- /VGMPlay/chips/2151intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /*typedef struct _ym2151_interface ym2151_interface; 4 | struct _ym2151_interface 5 | { 6 | //void (*irqhandler)(const device_config *device, int irq); 7 | void (*irqhandler)(int irq); 8 | write8_device_func portwritehandler; 9 | };*/ 10 | 11 | /*READ8_DEVICE_HANDLER( ym2151_r ); 12 | WRITE8_DEVICE_HANDLER( ym2151_w ); 13 | 14 | READ8_DEVICE_HANDLER( ym2151_status_port_r ); 15 | WRITE8_DEVICE_HANDLER( ym2151_register_port_w ); 16 | WRITE8_DEVICE_HANDLER( ym2151_data_port_w ); 17 | 18 | DEVICE_GET_INFO( ym2151 ); 19 | #define SOUND_YM2151 DEVICE_GET_INFO_NAME( ym2151 )*/ 20 | void ym2151_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 21 | 22 | int device_start_ym2151(UINT8 ChipID, int clock); 23 | void device_stop_ym2151(UINT8 ChipID); 24 | void device_reset_ym2151(UINT8 ChipID); 25 | 26 | UINT8 ym2151_r(UINT8 ChipID, offs_t offset); 27 | void ym2151_w(UINT8 ChipID, offs_t offset, UINT8 data); 28 | 29 | UINT8 ym2151_status_port_r(UINT8 ChipID, offs_t offset); 30 | void ym2151_register_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 31 | void ym2151_data_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 32 | 33 | void ym2151_set_emu_core(UINT8 Emulator); 34 | void ym2151_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 35 | -------------------------------------------------------------------------------- /VGMPlay/chips/3526intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /*typedef struct _ym3526_interface ym3526_interface; 4 | struct _ym3526_interface 5 | { 6 | //void (*handler)(const device_config *device, int linestate); 7 | void (*handler)(int linestate); 8 | };*/ 9 | 10 | /*READ8_DEVICE_HANDLER( ym3526_r ); 11 | WRITE8_DEVICE_HANDLER( ym3526_w ); 12 | 13 | READ8_DEVICE_HANDLER( ym3526_status_port_r ); 14 | READ8_DEVICE_HANDLER( ym3526_read_port_r ); 15 | WRITE8_DEVICE_HANDLER( ym3526_control_port_w ); 16 | WRITE8_DEVICE_HANDLER( ym3526_write_port_w ); 17 | 18 | DEVICE_GET_INFO( ym3526 ); 19 | #define SOUND_YM3526 DEVICE_GET_INFO_NAME( ym3526 )*/ 20 | void ym3526_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 21 | int device_start_ym3526(UINT8 ChipID, int clock); 22 | void device_stop_ym3526(UINT8 ChipID); 23 | void device_reset_ym3526(UINT8 ChipID); 24 | 25 | UINT8 ym3526_r(UINT8 ChipID, offs_t offset); 26 | void ym3526_w(UINT8 ChipID, offs_t offset, UINT8 data); 27 | 28 | UINT8 ym3526_status_port_r(UINT8 ChipID, offs_t offset); 29 | UINT8 ym3526_read_port_r(UINT8 ChipID, offs_t offset); 30 | void ym3526_control_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 31 | void ym3526_write_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 32 | 33 | void ym3526_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 34 | -------------------------------------------------------------------------------- /VGMPlay/chips/segapcm.h: -------------------------------------------------------------------------------- 1 | /*********************************************************/ 2 | /* SEGA 8bit PCM */ 3 | /*********************************************************/ 4 | 5 | #pragma once 6 | 7 | #define BANK_256 (11) 8 | #define BANK_512 (12) 9 | #define BANK_12M (13) 10 | #define BANK_MASK7 (0x70<<16) 11 | #define BANK_MASKF (0xf0<<16) 12 | #define BANK_MASKF8 (0xf8<<16) 13 | 14 | typedef struct _sega_pcm_interface sega_pcm_interface; 15 | struct _sega_pcm_interface 16 | { 17 | int bank; 18 | }; 19 | 20 | /*WRITE8_DEVICE_HANDLER( sega_pcm_w ); 21 | READ8_DEVICE_HANDLER( sega_pcm_r ); 22 | 23 | DEVICE_GET_INFO( segapcm ); 24 | #define SOUND_SEGAPCM DEVICE_GET_INFO_NAME( segapcm )*/ 25 | 26 | void SEGAPCM_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 27 | 28 | int device_start_segapcm(UINT8 ChipID, int clock, int intf_bank); 29 | void device_stop_segapcm(UINT8 ChipID); 30 | void device_reset_segapcm(UINT8 ChipID); 31 | 32 | void sega_pcm_w(UINT8 ChipID, offs_t offset, UINT8 data); 33 | UINT8 sega_pcm_r(UINT8 ChipID, offs_t offset); 34 | void sega_pcm_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 35 | const UINT8* ROMData); 36 | 37 | void segapcm_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 38 | 39 | -------------------------------------------------------------------------------- /VGMPlay/VGMPlay.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 11.00 3 | # Visual Studio 2010 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VGMPlay", "VGMPlay.vcxproj", "{8519237F-1B46-4C8A-994C-58D218182F2C}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Debug|x64 = Debug|x64 10 | Release|Win32 = Release|Win32 11 | Release|x64 = Release|x64 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Debug|Win32.ActiveCfg = Debug|Win32 15 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Debug|Win32.Build.0 = Debug|Win32 16 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Debug|x64.ActiveCfg = Debug|x64 17 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Debug|x64.Build.0 = Debug|x64 18 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Release|Win32.ActiveCfg = Release|Win32 19 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Release|Win32.Build.0 = Release|Win32 20 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Release|x64.ActiveCfg = Release|x64 21 | {8519237F-1B46-4C8A-994C-58D218182F2C}.Release|x64.Build.0 = Release|x64 22 | EndGlobalSection 23 | GlobalSection(SolutionProperties) = preSolution 24 | HideSolutionNode = FALSE 25 | EndGlobalSection 26 | EndGlobal 27 | -------------------------------------------------------------------------------- /VGMPlay/chips/3812intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /*typedef struct _ym3812_interface ym3812_interface; 4 | struct _ym3812_interface 5 | { 6 | //void (*handler)(const device_config *device, int linestate); 7 | void (*handler)(int linestate); 8 | };*/ 9 | 10 | /*READ8_DEVICE_HANDLER( ym3812_r ); 11 | WRITE8_DEVICE_HANDLER( ym3812_w ); 12 | 13 | READ8_DEVICE_HANDLER( ym3812_status_port_r ); 14 | READ8_DEVICE_HANDLER( ym3812_read_port_r ); 15 | WRITE8_DEVICE_HANDLER( ym3812_control_port_w ); 16 | WRITE8_DEVICE_HANDLER( ym3812_write_port_w ); 17 | 18 | DEVICE_GET_INFO( ym3812 ); 19 | #define SOUND_YM3812 DEVICE_GET_INFO_NAME( ym3812 )*/ 20 | 21 | void ym3812_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 22 | int device_start_ym3812(UINT8 ChipID, int clock); 23 | void device_stop_ym3812(UINT8 ChipID); 24 | void device_reset_ym3812(UINT8 ChipID); 25 | 26 | UINT8 ym3812_r(UINT8 ChipID, offs_t offset); 27 | void ym3812_w(UINT8 ChipID, offs_t offset, UINT8 data); 28 | 29 | UINT8 ym3812_status_port_r(UINT8 ChipID, offs_t offset); 30 | UINT8 ym3812_read_port_r(UINT8 ChipID, offs_t offset); 31 | void ym3812_control_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 32 | void ym3812_write_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 33 | 34 | void ym3812_set_emu_core(UINT8 Emulator); 35 | void ym3812_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 36 | -------------------------------------------------------------------------------- /VGMPlay/chips/ymz280b.h: -------------------------------------------------------------------------------- 1 | /********************************************************************************************** 2 | * 3 | * Yamaha YMZ280B driver 4 | * by Aaron Giles 5 | * 6 | **********************************************************************************************/ 7 | 8 | #pragma once 9 | 10 | //#include "devcb.h" 11 | 12 | typedef struct _ymz280b_interface ymz280b_interface; 13 | struct _ymz280b_interface 14 | { 15 | //void (*irq_callback)(const device_config *device, int state); /* irq callback */ 16 | void (*irq_callback)(int state); /* irq callback */ 17 | //devcb_read8 ext_read; /* external RAM read */ 18 | //devcb_write8 ext_write; /* external RAM write */ 19 | }; 20 | 21 | /*READ8_DEVICE_HANDLER ( ymz280b_r ); 22 | WRITE8_DEVICE_HANDLER( ymz280b_w ); 23 | 24 | DEVICE_GET_INFO( ymz280b ); 25 | #define SOUND_YMZ280B DEVICE_GET_INFO_NAME( ymz280b )*/ 26 | 27 | void ymz280b_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 28 | int device_start_ymz280b(UINT8 ChipID, int clock); 29 | void device_stop_ymz280b(UINT8 ChipID); 30 | void device_reset_ymz280b(UINT8 ChipID); 31 | 32 | UINT8 ymz280b_r(UINT8 ChipID, offs_t offset); 33 | void ymz280b_w(UINT8 ChipID, offs_t offset, UINT8 data); 34 | void ymz280b_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 35 | const UINT8* ROMData); 36 | 37 | void ymz280b_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 38 | -------------------------------------------------------------------------------- /VGMPlay/chips/262intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | 4 | /*typedef struct _ymf262_interface ymf262_interface; 5 | struct _ymf262_interface 6 | { 7 | //void (*handler)(const device_config *device, int irq); 8 | void (*handler)(int irq); 9 | };*/ 10 | 11 | 12 | /*READ8_DEVICE_HANDLER( ymf262_r ); 13 | WRITE8_DEVICE_HANDLER( ymf262_w ); 14 | 15 | READ8_DEVICE_HANDLER ( ymf262_status_r ); 16 | WRITE8_DEVICE_HANDLER( ymf262_register_a_w ); 17 | WRITE8_DEVICE_HANDLER( ymf262_register_b_w ); 18 | WRITE8_DEVICE_HANDLER( ymf262_data_a_w ); 19 | WRITE8_DEVICE_HANDLER( ymf262_data_b_w ); 20 | 21 | 22 | DEVICE_GET_INFO( ymf262 ); 23 | #define SOUND_YMF262 DEVICE_GET_INFO_NAME( ymf262 )*/ 24 | 25 | void ymf262_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 26 | 27 | int device_start_ymf262(UINT8 ChipID, int clock); 28 | void device_stop_ymf262(UINT8 ChipID); 29 | void device_reset_ymf262(UINT8 ChipID); 30 | 31 | UINT8 ymf262_r(UINT8 ChipID, offs_t offset); 32 | void ymf262_w(UINT8 ChipID, offs_t offset, UINT8 data); 33 | 34 | UINT8 ymf262_status_r(UINT8 ChipID, offs_t offset); 35 | void ymf262_register_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 36 | void ymf262_register_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 37 | void ymf262_data_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 38 | void ymf262_data_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 39 | 40 | void ymf262_set_emu_core(UINT8 Emulator); 41 | void ymf262_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 42 | 43 | -------------------------------------------------------------------------------- /VGMPlay/chips/k051649.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#ifndef __K051649_H__ 4 | //#define __K051649_H__ 5 | 6 | //#include "devlegcy.h" 7 | 8 | /*WRITE8_DEVICE_HANDLER( k051649_waveform_w ); 9 | READ8_DEVICE_HANDLER( k051649_waveform_r ); 10 | WRITE8_DEVICE_HANDLER( k051649_volume_w ); 11 | WRITE8_DEVICE_HANDLER( k051649_frequency_w ); 12 | WRITE8_DEVICE_HANDLER( k051649_keyonoff_w ); 13 | 14 | WRITE8_DEVICE_HANDLER( k052539_waveform_w ); 15 | 16 | DECLARE_LEGACY_SOUND_DEVICE(K051649, k051649);*/ 17 | 18 | void k051649_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 19 | int device_start_k051649(UINT8 ChipID, int clock); 20 | void device_stop_k051649(UINT8 ChipID); 21 | void device_reset_k051649(UINT8 ChipID); 22 | 23 | void k051649_waveform_w(UINT8 ChipID, offs_t offset, UINT8 data); 24 | UINT8 k051649_waveform_r(UINT8 ChipID, offs_t offset); 25 | void k051649_volume_w(UINT8 ChipID, offs_t offset, UINT8 data); 26 | void k051649_frequency_w(UINT8 ChipID, offs_t offset, UINT8 data); 27 | void k051649_keyonoff_w(UINT8 ChipID, offs_t offset, UINT8 data); 28 | 29 | void k052539_waveform_w(UINT8 ChipID, offs_t offset, UINT8 data); 30 | UINT8 k052539_waveform_r(UINT8 ChipID, offs_t offset); 31 | 32 | void k051649_test_w(UINT8 ChipID, offs_t offset, UINT8 data); 33 | UINT8 k051649_test_r(UINT8 ChipID, offs_t offset); 34 | 35 | void k051649_w(UINT8 ChipID, offs_t offset, UINT8 data); 36 | 37 | void k051649_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 38 | 39 | //#endif /* __K051649_H__ */ 40 | -------------------------------------------------------------------------------- /VGMPlay/chips/ym2413.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /* select output bits size of output : 8 or 16 */ 4 | #define SAMPLE_BITS 16 5 | 6 | /* compiler dependence */ 7 | //#ifndef __OSDCOMM_H__ 8 | //#define __OSDCOMM_H__ 9 | /*typedef unsigned char UINT8; // unsigned 8bit 10 | typedef unsigned short UINT16; // unsigned 16bit 11 | typedef unsigned int UINT32; // unsigned 32bit 12 | typedef signed char INT8; // signed 8bit 13 | typedef signed short INT16; // signed 16bit 14 | typedef signed int INT32; // signed 32bit */ 15 | //#endif 16 | 17 | //typedef INT32 stream_sample_t; 18 | typedef stream_sample_t SAMP; 19 | /* 20 | #if (SAMPLE_BITS==16) 21 | typedef INT16 SAMP; 22 | #endif 23 | #if (SAMPLE_BITS==8) 24 | typedef INT8 SAMP; 25 | #endif 26 | */ 27 | 28 | 29 | 30 | //void *ym2413_init(const device_config *device, int clock, int rate); 31 | void *ym2413_init(int clock, int rate); 32 | void ym2413_shutdown(void *chip); 33 | void ym2413_reset_chip(void *chip); 34 | void ym2413_write(void *chip, int a, int v); 35 | unsigned char ym2413_read(void *chip, int a); 36 | void ym2413_update_one(void *chip, SAMP **buffers, int length); 37 | 38 | typedef void (*OPLL_UPDATEHANDLER)(void *param,int min_interval_us); 39 | 40 | void ym2413_set_update_handler(void *chip, OPLL_UPDATEHANDLER UpdateHandler, void *param); 41 | void ym2413_set_mutemask(void* chip, UINT32 MuteMask); 42 | void ym2413_set_chip_mode(void* chip, UINT8 Mode); 43 | void ym2413_override_patches(void* chip, const UINT8* PatchDump); 44 | -------------------------------------------------------------------------------- /VGMPlay/chips/scsp.h: -------------------------------------------------------------------------------- 1 | /* 2 | SCSP (YMF292-F) header 3 | */ 4 | 5 | #pragma once 6 | 7 | #ifndef __SCSP_H__ 8 | #define __SCSP_H__ 9 | 10 | //#include "devlegcy.h" 11 | 12 | /*typedef struct _scsp_interface scsp_interface; 13 | struct _scsp_interface 14 | { 15 | int roffset; // offset in the region 16 | void (*irq_callback)(device_t *device, int state); // irq callback 17 | devcb_write_line main_irq; 18 | }; 19 | 20 | void scsp_set_ram_base(device_t *device, void *base);*/ 21 | 22 | 23 | void SCSP_Update(UINT8 ChipID, stream_sample_t **outputs, int samples); 24 | int device_start_scsp(UINT8 ChipID, int clock); 25 | void device_stop_scsp(UINT8 ChipID); 26 | void device_reset_scsp(UINT8 ChipID); 27 | 28 | // SCSP register access 29 | /*READ16_DEVICE_HANDLER( scsp_r ); 30 | WRITE16_DEVICE_HANDLER( scsp_w );*/ 31 | void scsp_w(UINT8 ChipID, offs_t offset, UINT8 data); 32 | //UINT8 scsp_r(UINT8 ChipID, offs_t offset); 33 | 34 | // MIDI I/O access (used for comms on Model 2/3) 35 | /*WRITE16_DEVICE_HANDLER( scsp_midi_in ); 36 | READ16_DEVICE_HANDLER( scsp_midi_out_r );*/ 37 | 38 | //void scsp_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 39 | // const UINT8* ROMData); 40 | void scsp_write_ram(UINT8 ChipID, offs_t DataStart, offs_t DataLength, const UINT8* RAMData); 41 | void scsp_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 42 | void scsp_set_options(UINT8 Flags); 43 | 44 | /*extern UINT32* stv_scu; 45 | 46 | DECLARE_LEGACY_SOUND_DEVICE(SCSP, scsp);*/ 47 | 48 | #endif /* __SCSP_H__ */ 49 | -------------------------------------------------------------------------------- /VGMPlay/chips/sn76496.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /*READ8_DEVICE_HANDLER( sn76496_ready_r ); 4 | WRITE8_DEVICE_HANDLER( sn76496_w ); 5 | WRITE8_DEVICE_HANDLER( sn76496_stereo_w ); 6 | 7 | DEVICE_GET_INFO( sn76496 ); 8 | DEVICE_GET_INFO( sn76489 ); 9 | DEVICE_GET_INFO( sn76489a ); 10 | DEVICE_GET_INFO( sn76494 ); 11 | DEVICE_GET_INFO( sn94624 ); 12 | DEVICE_GET_INFO( ncr7496 ); 13 | DEVICE_GET_INFO( gamegear ); 14 | DEVICE_GET_INFO( smsiii ); 15 | 16 | #define SOUND_SN76496 DEVICE_GET_INFO_NAME( sn76496 ) 17 | #define SOUND_SN76489 DEVICE_GET_INFO_NAME( sn76489 ) 18 | #define SOUND_SN76489A DEVICE_GET_INFO_NAME( sn76489a ) 19 | #define SOUND_SN76494 DEVICE_GET_INFO_NAME( sn76494 ) 20 | #define SOUND_SN94624 DEVICE_GET_INFO_NAME( sn94624 ) 21 | #define SOUND_NCR7496 DEVICE_GET_INFO_NAME( ncr7496 ) 22 | #define SOUND_GAMEGEAR DEVICE_GET_INFO_NAME( gamegear ) 23 | #define SOUND_SMSIII DEVICE_GET_INFO_NAME( smsiii )*/ 24 | 25 | UINT8 sn76496_ready_r(void *chip, offs_t offset); 26 | void sn76496_write_reg(void *chip, offs_t offset, UINT8 data); 27 | void sn76496_stereo_w(void *chip, offs_t offset, UINT8 data); 28 | 29 | void SN76496Update(void *chip, stream_sample_t **outputs, int samples); 30 | unsigned long int sn76496_start(void **chip, int clock, int shiftregwidth, int noisetaps, 31 | int negate, int stereo, int clockdivider, int freq0); 32 | void sn76496_shutdown(void *chip); 33 | void sn76496_reset(void *chip); 34 | void sn76496_freq_limiter(int clock, int clockdiv, int sample_rate); 35 | void sn76496_set_mutemask(void *chip, UINT32 MuteMask); 36 | -------------------------------------------------------------------------------- /VGMPlay/chips/8950intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /*typedef struct _y8950_interface y8950_interface; 4 | struct _y8950_interface 5 | { 6 | //void (*handler)(const device_config *device, int linestate); 7 | void (*handler)(int linestate); 8 | 9 | read8_device_func keyboardread; 10 | write8_device_func keyboardwrite; 11 | read8_device_func portread; 12 | write8_device_func portwrite; 13 | };*/ 14 | 15 | /*READ8_DEVICE_HANDLER( y8950_r ); 16 | WRITE8_DEVICE_HANDLER( y8950_w ); 17 | 18 | READ8_DEVICE_HANDLER( y8950_status_port_r ); 19 | READ8_DEVICE_HANDLER( y8950_read_port_r ); 20 | WRITE8_DEVICE_HANDLER( y8950_control_port_w ); 21 | WRITE8_DEVICE_HANDLER( y8950_write_port_w ); 22 | 23 | DEVICE_GET_INFO( y8950 ); 24 | #define SOUND_Y8950 DEVICE_GET_INFO_NAME( y8950 )*/ 25 | void y8950_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 26 | int device_start_y8950(UINT8 ChipID, int clock); 27 | void device_stop_y8950(UINT8 ChipID); 28 | void device_reset_y8950(UINT8 ChipID); 29 | 30 | UINT8 y8950_r(UINT8 ChipID, offs_t offset); 31 | void y8950_w(UINT8 ChipID, offs_t offset, UINT8 data); 32 | 33 | UINT8 y8950_status_port_r(UINT8 ChipID, offs_t offset); 34 | UINT8 y8950_read_port_r(UINT8 ChipID, offs_t offset); 35 | void y8950_control_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 36 | void y8950_write_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 37 | 38 | void y8950_write_data_pcmrom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, 39 | offs_t DataLength, const UINT8* ROMData); 40 | void y8950_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 41 | -------------------------------------------------------------------------------- /VGMPlay/chips/upd7759.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "devlegcy.h" 4 | 5 | /* There are two modes for the uPD7759, selected through the !MD pin. 6 | This is the mode select input. High is stand alone, low is slave. 7 | We're making the assumption that nobody switches modes through 8 | software. */ 9 | 10 | #define UPD7759_STANDARD_CLOCK 640000 11 | 12 | typedef struct _upd7759_interface upd7759_interface; 13 | struct _upd7759_interface 14 | { 15 | //void (*drqcallback)(running_device *device, int param); /* drq callback (per chip, slave mode only) */ 16 | void (*drqcallback)(int param); /* drq callback (per chip, slave mode only) */ 17 | }; 18 | 19 | void upd7759_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 20 | void device_reset_upd7759(UINT8 ChipID); 21 | int device_start_upd7759(UINT8 ChipID, int clock); 22 | void device_stop_upd7759(UINT8 ChipID); 23 | 24 | //void upd7759_set_bank_base(running_device *device, offs_t base); 25 | 26 | //void upd7759_reset_w(running_device *device, UINT8 data); 27 | //void upd7759_start_w(running_device *device, UINT8 data); 28 | //int upd7759_busy_r(running_device *device); 29 | //WRITE8_DEVICE_HANDLER( upd7759_port_w ); 30 | 31 | void upd7759_set_bank_base(UINT8 ChipID, offs_t base); 32 | 33 | void upd7759_reset_w(UINT8 ChipID, UINT8 data); 34 | void upd7759_start_w(UINT8 ChipID, UINT8 data); 35 | int upd7759_busy_r(UINT8 ChipID); 36 | void upd7759_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 37 | 38 | void upd7759_write(UINT8 ChipID, UINT8 Port, UINT8 Data); 39 | void upd7759_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 40 | const UINT8* ROMData); 41 | 42 | //DECLARE_LEGACY_SOUND_DEVICE(UPD7759, upd7759); 43 | -------------------------------------------------------------------------------- /VGMPlay/chips/scd_pcm.h: -------------------------------------------------------------------------------- 1 | struct pcm_chip_ 2 | { 3 | float Rate; 4 | int Smpl0Patch; 5 | int Enable; 6 | int Cur_Chan; 7 | int Bank; 8 | 9 | struct pcm_chan_ 10 | { 11 | unsigned int ENV; /* envelope register */ 12 | unsigned int PAN; /* pan register */ 13 | unsigned int MUL_L; /* envelope & pan product letf */ 14 | unsigned int MUL_R; /* envelope & pan product right */ 15 | unsigned int St_Addr; /* start address register */ 16 | unsigned int Loop_Addr; /* loop address register */ 17 | unsigned int Addr; /* current address register */ 18 | unsigned int Step; /* frequency register */ 19 | unsigned int Step_B; /* frequency register binaire */ 20 | unsigned int Enable; /* channel on/off register */ 21 | int Data; /* wave data */ 22 | unsigned int Muted; 23 | } Channel[8]; 24 | 25 | unsigned long int RAMSize; 26 | unsigned char* RAM; 27 | }; 28 | 29 | //extern struct pcm_chip_ PCM_Chip; 30 | //extern unsigned char Ram_PCM[64 * 1024]; 31 | //extern int PCM_Enable; 32 | 33 | //int PCM_Init(int Rate); 34 | //void PCM_Set_Rate(int Rate); 35 | //void PCM_Reset(void); 36 | //void PCM_Write_Reg(unsigned int Reg, unsigned int Data); 37 | //int PCM_Update(int **buf, int Length); 38 | 39 | void rf5c164_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 40 | int device_start_rf5c164(UINT8 ChipID, int clock); 41 | void device_stop_rf5c164(UINT8 ChipID); 42 | void device_reset_rf5c164(UINT8 ChipID); 43 | void rf5c164_w(UINT8 ChipID, offs_t offset, UINT8 data); 44 | void rf5c164_mem_w(UINT8 ChipID, offs_t offset, UINT8 data); 45 | void rf5c164_write_ram(UINT8 ChipID, offs_t DataStart, offs_t DataLength, const UINT8* RAMData); 46 | 47 | void rf5c164_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 48 | -------------------------------------------------------------------------------- /VGMPlay/chips/okim6295.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /* an interface for the OKIM6295 and similar chips */ 4 | 5 | /* 6 | Note about the playback frequency: the external clock is internally divided, 7 | depending on pin 7, by 132 (high) or 165 (low). 8 | */ 9 | /*typedef struct _okim6295_interface okim6295_interface; 10 | struct _okim6295_interface 11 | { 12 | int pin7; 13 | }; 14 | 15 | extern const okim6295_interface okim6295_interface_pin7high; 16 | extern const okim6295_interface okim6295_interface_pin7low;*/ 17 | 18 | 19 | 20 | //void okim6295_set_bank_base(running_device *device, int base); 21 | //void okim6295_set_pin7(running_device *device, int pin7); 22 | 23 | void okim6295_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 24 | int device_start_okim6295(UINT8 ChipID, int clock); 25 | void device_stop_okim6295(UINT8 ChipID); 26 | void device_reset_okim6295(UINT8 ChipID); 27 | 28 | //READ8_DEVICE_HANDLER( okim6295_r ); 29 | //WRITE8_DEVICE_HANDLER( okim6295_w ); 30 | void okim6295_w(UINT8 ChipID, offs_t offset, UINT8 data); 31 | 32 | void okim6295_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 33 | const UINT8* ROMData); 34 | void okim6295_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 35 | void okim6295_set_srchg_cb(UINT8 ChipID, SRATE_CALLBACK CallbackFunc, void* DataPtr); 36 | 37 | 38 | /* 39 | To help the various custom ADPCM generators out there, 40 | the following routines may be used. 41 | */ 42 | struct adpcm_state 43 | { 44 | INT32 signal; 45 | INT32 step; 46 | }; 47 | void reset_adpcm(struct adpcm_state *state); 48 | INT16 clock_adpcm(struct adpcm_state *state, UINT8 nibble); 49 | 50 | //DEVICE_GET_INFO( okim6295 ); 51 | //#define SOUND_OKIM6295 DEVICE_GET_INFO_NAME( okim6295 ) 52 | -------------------------------------------------------------------------------- /VGMPlay/chips/mamedef.h: -------------------------------------------------------------------------------- 1 | #ifndef __MAMEDEF_H__ 2 | #define __MAMEDEF_H__ 3 | 4 | // typedefs to use MAME's (U)INTxx types (copied from MAME\src\ods\odscomm.h) 5 | /* 8-bit values */ 6 | typedef unsigned char UINT8; 7 | typedef signed char INT8; 8 | 9 | /* 16-bit values */ 10 | typedef unsigned short UINT16; 11 | typedef signed short INT16; 12 | 13 | /* 32-bit values */ 14 | #ifndef _WINDOWS_H 15 | typedef unsigned int UINT32; 16 | typedef signed int INT32; 17 | #endif 18 | 19 | /* 64-bit values */ 20 | #ifndef _WINDOWS_H 21 | #ifdef _MSC_VER 22 | typedef signed __int64 INT64; 23 | typedef unsigned __int64 UINT64; 24 | #else 25 | __extension__ typedef unsigned long long UINT64; 26 | __extension__ typedef signed long long INT64; 27 | #endif 28 | #endif 29 | 30 | /* offsets and addresses are 32-bit (for now...) */ 31 | typedef UINT32 offs_t; 32 | 33 | /* stream_sample_t is used to represent a single sample in a sound stream */ 34 | typedef INT32 stream_sample_t; 35 | 36 | #if defined(VGM_BIG_ENDIAN) 37 | #define BYTE_XOR_BE(x) (x) 38 | #elif defined(VGM_LITTLE_ENDIAN) 39 | #define BYTE_XOR_BE(x) ((x) ^ 0x01) 40 | #else 41 | // don't define BYTE_XOR_BE so that it throws an error when compiling 42 | #endif 43 | 44 | #if defined(_MSC_VER) 45 | //#define INLINE static __forceinline 46 | #define INLINE static __inline 47 | #elif defined(__GNUC__) 48 | #define INLINE static __inline__ 49 | #else 50 | #define INLINE static inline 51 | #endif 52 | #ifndef M_PI 53 | #define M_PI 3.14159265358979323846 54 | #endif 55 | 56 | #ifdef _DEBUG 57 | #define logerror printf 58 | #else 59 | #define logerror 60 | #endif 61 | 62 | extern stream_sample_t* DUMMYBUF[]; 63 | 64 | typedef void (*SRATE_CALLBACK)(void*, UINT32); 65 | 66 | #endif // __MAMEDEF_H__ 67 | -------------------------------------------------------------------------------- /VGMPlay/chips/okim6258.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "devlegcy.h" 4 | 5 | /* an interface for the OKIM6258 and similar chips */ 6 | 7 | /*typedef struct _okim6258_interface okim6258_interface; 8 | struct _okim6258_interface 9 | { 10 | int divider; 11 | int adpcm_type; 12 | int output_12bits; 13 | };*/ 14 | 15 | 16 | #define FOSC_DIV_BY_1024 0 17 | #define FOSC_DIV_BY_768 1 18 | #define FOSC_DIV_BY_512 2 19 | 20 | #define TYPE_3BITS 0 21 | #define TYPE_4BITS 1 22 | 23 | #define OUTPUT_10BITS 0 24 | #define OUTPUT_12BITS 1 25 | 26 | void okim6258_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 27 | int device_start_okim6258(UINT8 ChipID, int clock, int divider, int adpcm_type, int output_12bits); 28 | void device_stop_okim6258(UINT8 ChipID); 29 | void device_reset_okim6258(UINT8 ChipID); 30 | 31 | //void okim6258_set_divider(running_device *device, int val); 32 | //void okim6258_set_clock(running_device *device, int val); 33 | //int okim6258_get_vclk(running_device *device); 34 | 35 | void okim6258_set_divider(UINT8 ChipID, int val); 36 | void okim6258_set_clock(UINT8 ChipID, int val); 37 | int okim6258_get_vclk(UINT8 ChipID); 38 | 39 | //READ8_DEVICE_HANDLER( okim6258_status_r ); 40 | //WRITE8_DEVICE_HANDLER( okim6258_data_w ); 41 | //WRITE8_DEVICE_HANDLER( okim6258_ctrl_w ); 42 | 43 | /*UINT8 okim6258_status_r(UINT8 ChipID, offs_t offset); 44 | void okim6258_data_w(UINT8 ChipID, offs_t offset, UINT8 data); 45 | void okim6258_ctrl_w(UINT8 ChipID, offs_t offset, UINT8 data);*/ 46 | void okim6258_write(UINT8 ChipID, UINT8 Port, UINT8 Data); 47 | 48 | void okim6258_set_options(UINT16 Options); 49 | void okim6258_set_srchg_cb(UINT8 ChipID, SRATE_CALLBACK CallbackFunc, void* DataPtr); 50 | 51 | //DECLARE_LEGACY_SOUND_DEVICE(OKIM6258, okim6258); 52 | -------------------------------------------------------------------------------- /VGMPlay/chips/ymf262.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "attotime.h" 4 | 5 | /* select number of output bits: 8 or 16 */ 6 | #define OPL3_SAMPLE_BITS 16 7 | 8 | /* compiler dependence */ 9 | //#ifndef __OSDCOMM_H__ 10 | //#define __OSDCOMM_H__ 11 | /*typedef unsigned char UINT8; // unsigned 8bit 12 | typedef unsigned short UINT16; // unsigned 16bit 13 | typedef unsigned int UINT32; // unsigned 32bit 14 | typedef signed char INT8; // signed 8bit 15 | typedef signed short INT16; // signed 16bit 16 | typedef signed int INT32; // signed 32bit*/ 17 | //#endif 18 | 19 | typedef stream_sample_t OPL3SAMPLE; 20 | /* 21 | #if (OPL3_SAMPLE_BITS==16) 22 | typedef INT16 OPL3SAMPLE; 23 | #endif 24 | #if (OPL3_SAMPLE_BITS==8) 25 | typedef INT8 OPL3SAMPLE; 26 | #endif 27 | */ 28 | 29 | //typedef void (*OPL3_TIMERHANDLER)(void *param,int timer,attotime period); 30 | typedef void (*OPL3_TIMERHANDLER)(void *param,int timer,int period); 31 | typedef void (*OPL3_IRQHANDLER)(void *param,int irq); 32 | typedef void (*OPL3_UPDATEHANDLER)(void *param/*,int min_interval_us*/); 33 | 34 | 35 | void *ymf262_init(int clock, int rate); 36 | void ymf262_shutdown(void *chip); 37 | void ymf262_reset_chip(void *chip); 38 | int ymf262_write(void *chip, int a, int v); 39 | unsigned char ymf262_read(void *chip, int a); 40 | int ymf262_timer_over(void *chip, int c); 41 | void ymf262_update_one(void *chip, OPL3SAMPLE **buffers, int length); 42 | 43 | void ymf262_set_timer_handler(void *chip, OPL3_TIMERHANDLER TimerHandler, void *param); 44 | void ymf262_set_irq_handler(void *chip, OPL3_IRQHANDLER IRQHandler, void *param); 45 | void ymf262_set_update_handler(void *chip, OPL3_UPDATEHANDLER UpdateHandler, void *param); 46 | 47 | void ymf262_set_emu_core(UINT8 Emulator); 48 | void ymf262_set_mutemask(void *chip, UINT32 MuteMask); 49 | 50 | -------------------------------------------------------------------------------- /VGMPlay/chips/2203intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "ay8910.h" 4 | #include "emu2149.h" 5 | 6 | void ym2203_update_request(void *param); 7 | 8 | typedef struct _ym2203_interface ym2203_interface; 9 | struct _ym2203_interface 10 | { 11 | ay8910_interface ay8910_intf; 12 | //void (*handler)(const device_config *device, int irq); 13 | void (*handler)(int irq); 14 | }; 15 | 16 | /*READ8_DEVICE_HANDLER( ym2203_r ); 17 | WRITE8_DEVICE_HANDLER( ym2203_w ); 18 | 19 | READ8_DEVICE_HANDLER( ym2203_status_port_r ); 20 | READ8_DEVICE_HANDLER( ym2203_read_port_r ); 21 | WRITE8_DEVICE_HANDLER( ym2203_control_port_w ); 22 | WRITE8_DEVICE_HANDLER( ym2203_write_port_w ); 23 | 24 | DEVICE_GET_INFO( ym2203 ); 25 | #define SOUND_YM2203 DEVICE_GET_INFO_NAME( ym2203 )*/ 26 | 27 | void ym2203_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 28 | void ym2203_stream_update_ay(UINT8 ChipID, stream_sample_t **outputs, int samples); 29 | 30 | int device_start_ym2203(UINT8 ChipID, int clock, UINT8 AYDisable, UINT8 AYFlags, int* AYrate); 31 | void device_stop_ym2203(UINT8 ChipID); 32 | void device_reset_ym2203(UINT8 ChipID); 33 | 34 | UINT8 ym2203_r(UINT8 ChipID, offs_t offset); 35 | void ym2203_w(UINT8 ChipID, offs_t offset, UINT8 data); 36 | 37 | UINT8 ym2203_status_port_r(UINT8 ChipID, offs_t offset); 38 | UINT8 ym2203_read_port_r(UINT8 ChipID, offs_t offset); 39 | void ym2203_control_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 40 | void ym2203_write_port_w(UINT8 ChipID, offs_t offset, UINT8 data); 41 | 42 | void ym2203_set_ay_emu_core(UINT8 Emulator); 43 | void ym2203_set_mute_mask(UINT8 ChipID, UINT32 MuteMaskFM, UINT32 MuteMaskAY); 44 | void ym2203_set_stereo_mask_ay(UINT8 ChipID, UINT32 StereoMaskAY); 45 | void ym2203_set_srchg_cb(UINT8 ChipID, SRATE_CALLBACK CallbackFunc, void* DataPtr, void* AYDataPtr); 46 | -------------------------------------------------------------------------------- /VGMPlay/VGMPlay.h: -------------------------------------------------------------------------------- 1 | // Header File for structures and constants used within VGMPlay.c 2 | 3 | #include "VGMFile.h" 4 | 5 | #define VGMPLAY_VER_STR "0.40.9.1" 6 | //#define APLHA 7 | //#define BETA 8 | #define VGM_VER_STR "1.71b" 9 | #define VGM_VER_NUM 0x170 10 | 11 | #define CHIP_COUNT 0x29 12 | typedef struct chip_options 13 | { 14 | bool Disabled; 15 | UINT8 EmuCore; 16 | UINT8 ChnCnt; 17 | // Special Flags: 18 | // YM2612: Bit 0 - DAC Highpass Enable, Bit 1 - SSG-EG Enable 19 | // YM-OPN: Bit 0 - Disable AY8910-Part 20 | UINT16 SpecialFlags; 21 | 22 | // Channel Mute Mask - 1 Channel is represented by 1 bit 23 | UINT32 ChnMute1; 24 | // Mask 2 - used by YMF287B for OPL4 Wavetable Synth and by YM2608/YM2610 for PCM 25 | UINT32 ChnMute2; 26 | // Mask 3 - used for the AY-part of some OPN-chips 27 | UINT32 ChnMute3; 28 | 29 | INT16* Panning; 30 | } CHIP_OPTS; 31 | typedef struct chips_options 32 | { 33 | CHIP_OPTS SN76496; 34 | CHIP_OPTS YM2413; 35 | CHIP_OPTS YM2612; 36 | CHIP_OPTS YM2151; 37 | CHIP_OPTS SegaPCM; 38 | CHIP_OPTS RF5C68; 39 | CHIP_OPTS YM2203; 40 | CHIP_OPTS YM2608; 41 | CHIP_OPTS YM2610; 42 | CHIP_OPTS YM3812; 43 | CHIP_OPTS YM3526; 44 | CHIP_OPTS Y8950; 45 | CHIP_OPTS YMF262; 46 | CHIP_OPTS YMF278B; 47 | CHIP_OPTS YMF271; 48 | CHIP_OPTS YMZ280B; 49 | CHIP_OPTS RF5C164; 50 | CHIP_OPTS PWM; 51 | CHIP_OPTS AY8910; 52 | CHIP_OPTS GameBoy; 53 | CHIP_OPTS NES; 54 | CHIP_OPTS MultiPCM; 55 | CHIP_OPTS UPD7759; 56 | CHIP_OPTS OKIM6258; 57 | CHIP_OPTS OKIM6295; 58 | CHIP_OPTS K051649; 59 | CHIP_OPTS K054539; 60 | CHIP_OPTS HuC6280; 61 | CHIP_OPTS C140; 62 | CHIP_OPTS K053260; 63 | CHIP_OPTS Pokey; 64 | CHIP_OPTS QSound; 65 | CHIP_OPTS SCSP; 66 | CHIP_OPTS WSwan; 67 | CHIP_OPTS VSU; 68 | CHIP_OPTS SAA1099; 69 | CHIP_OPTS ES5503; 70 | CHIP_OPTS ES5506; 71 | CHIP_OPTS X1_010; 72 | CHIP_OPTS C352; 73 | CHIP_OPTS GA20; 74 | // CHIP_OPTS OKIM6376; 75 | } CHIPS_OPTION; 76 | -------------------------------------------------------------------------------- /VGMPlay/VGMPlay_Intf.h: -------------------------------------------------------------------------------- 1 | // VGMPlay_Intf.h: VGMPlay Interface Header File 2 | // 3 | 4 | //#define NO_WCHAR_FILENAMES 5 | #ifndef WIN32 6 | // Linux uses UTF-8 Unicode and has no special wide-character file routines. 7 | #define NO_WCHAR_FILENAMES 8 | #endif 9 | 10 | typedef struct waveform_16bit_stereo 11 | { 12 | INT16 Left; 13 | INT16 Right; 14 | } WAVE_16BS; 15 | 16 | typedef struct waveform_32bit_stereo 17 | { 18 | INT32 Left; 19 | INT32 Right; 20 | } WAVE_32BS; 21 | 22 | 23 | void VGMPlay_Init(void); 24 | void VGMPlay_Init2(void); 25 | void VGMPlay_Deinit(void); 26 | char* FindFile(const char* FileName); 27 | char* FindFile_List(const char** FileNameList); 28 | 29 | UINT32 GetGZFileLength(const char* FileName); 30 | bool OpenVGMFile(const char* FileName); 31 | void CloseVGMFile(void); 32 | 33 | void FreeGD3Tag(GD3_TAG* TagData); 34 | UINT32 GetVGMFileInfo(const char* FileName, VGM_HEADER* RetVGMHead, GD3_TAG* RetGD3Tag); 35 | UINT32 CalcSampleMSec(UINT64 Value, UINT8 Mode); 36 | UINT32 CalcSampleMSecExt(UINT64 Value, UINT8 Mode, VGM_HEADER* FileHead); 37 | const char* GetChipName(UINT8 ChipID); 38 | const char* GetAccurateChipName(UINT8 ChipID, UINT8 SubType); 39 | UINT32 GetChipClock(VGM_HEADER* FileHead, UINT8 ChipID, UINT8* RetSubType); 40 | 41 | #ifndef NO_WCHAR_FILENAMES 42 | UINT32 GetGZFileLengthW(const wchar_t* FileName); 43 | bool OpenVGMFileW(const wchar_t* FileName); 44 | UINT32 GetVGMFileInfoW(const wchar_t* FileName, VGM_HEADER* RetVGMHead, GD3_TAG* RetGD3Tag); 45 | #endif 46 | 47 | INT32 SampleVGM2Playback(INT32 SampleVal); 48 | INT32 SamplePlayback2VGM(INT32 SampleVal); 49 | 50 | void PlayVGM(void); 51 | void StopVGM(void); 52 | void RestartVGM(void); 53 | void PauseVGM(bool Pause); 54 | void SeekVGM(bool Relative, INT32 PlayBkSamples); 55 | void RefreshMuting(void); 56 | void RefreshPanning(void); 57 | void RefreshPlaybackOptions(void); 58 | 59 | UINT32 FillBuffer(WAVE_16BS* Buffer, UINT32 BufferSize); 60 | -------------------------------------------------------------------------------- /VGMPlay/zlib/zlib.def: -------------------------------------------------------------------------------- 1 | ; zlib data compression library 2 | EXPORTS 3 | ; basic functions 4 | zlibVersion 5 | deflate 6 | deflateEnd 7 | inflate 8 | inflateEnd 9 | ; advanced functions 10 | deflateSetDictionary 11 | deflateGetDictionary 12 | deflateCopy 13 | deflateReset 14 | deflateParams 15 | deflateTune 16 | deflateBound 17 | deflatePending 18 | deflatePrime 19 | deflateSetHeader 20 | inflateSetDictionary 21 | inflateGetDictionary 22 | inflateSync 23 | inflateCopy 24 | inflateReset 25 | inflateReset2 26 | inflatePrime 27 | inflateMark 28 | inflateGetHeader 29 | inflateBack 30 | inflateBackEnd 31 | zlibCompileFlags 32 | ; utility functions 33 | compress 34 | compress2 35 | compressBound 36 | uncompress 37 | uncompress2 38 | gzopen 39 | gzdopen 40 | gzbuffer 41 | gzsetparams 42 | gzread 43 | gzfread 44 | gzwrite 45 | gzfwrite 46 | gzprintf 47 | gzvprintf 48 | gzputs 49 | gzgets 50 | gzputc 51 | gzgetc 52 | gzungetc 53 | gzflush 54 | gzseek 55 | gzrewind 56 | gztell 57 | gzoffset 58 | gzeof 59 | gzdirect 60 | gzclose 61 | gzclose_r 62 | gzclose_w 63 | gzerror 64 | gzclearerr 65 | ; large file functions 66 | gzopen64 67 | gzseek64 68 | gztell64 69 | gzoffset64 70 | adler32_combine64 71 | crc32_combine64 72 | ; checksum functions 73 | adler32 74 | adler32_z 75 | crc32 76 | crc32_z 77 | adler32_combine 78 | crc32_combine 79 | ; various hacks, don't look :) 80 | deflateInit_ 81 | deflateInit2_ 82 | inflateInit_ 83 | inflateInit2_ 84 | inflateBackInit_ 85 | gzgetc_ 86 | zError 87 | inflateSyncPoint 88 | get_crc_table 89 | inflateUndermine 90 | inflateValidate 91 | inflateCodesUsed 92 | inflateResetKeep 93 | deflateResetKeep 94 | gzopen_w 95 | -------------------------------------------------------------------------------- /VGMPlay/licenses/mame_license.txt: -------------------------------------------------------------------------------- 1 | Unless otherwise explicitly stated, all code in MAME is released under the 2 | following license: 3 | 4 | Copyright Nicola Salmoria and the MAME team 5 | All rights reserved. 6 | 7 | Redistribution and use of this code or any derivative works are permitted 8 | provided that the following conditions are met: 9 | 10 | * Redistributions may not be sold, nor may they be used in a commercial 11 | product or activity. 12 | 13 | * Redistributions that are modified from the original source must include the 14 | complete source code, including the source code for all components used by a 15 | binary built from the modified sources. However, as a special exception, the 16 | source code distributed need not include anything that is normally distributed 17 | (in either source or binary form) with the major components (compiler, kernel, 18 | and so on) of the operating system on which the executable runs, unless that 19 | component itself accompanies the executable. 20 | 21 | * Redistributions must reproduce the above copyright notice, this list of 22 | conditions and the following disclaimer in the documentation and/or other 23 | materials provided with the distribution. 24 | 25 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 | POSSIBILITY OF SUCH DAMAGE. 36 | -------------------------------------------------------------------------------- /VGMPlay/mmkeys_Win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "chips/mamedef.h" 5 | #include "mmkeys.h" 6 | 7 | #ifndef VK_MEDIA_NEXT_TRACK 8 | // from WinUser.h 9 | #define VK_MEDIA_NEXT_TRACK 0xB0 10 | #define VK_MEDIA_PREV_TRACK 0xB1 11 | #define VK_MEDIA_STOP 0xB2 12 | #define VK_MEDIA_PLAY_PAUSE 0xB3 13 | #endif 14 | 15 | static DWORD idThread = 0; 16 | static HANDLE hThread = NULL; 17 | static HANDLE hEvent = NULL; 18 | static mmkey_cbfunc evtCallback = NULL; 19 | 20 | static DWORD WINAPI KeyMessageThread(void* args) 21 | { 22 | MSG msg; 23 | BOOL retValB; 24 | 25 | // enforce creation of message queue 26 | PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE); 27 | 28 | retValB = RegisterHotKey(NULL, MMKEY_PLAY, 0, VK_MEDIA_PLAY_PAUSE); 29 | retValB = RegisterHotKey(NULL, MMKEY_PREV, 0, VK_MEDIA_PREV_TRACK); 30 | retValB = RegisterHotKey(NULL, MMKEY_NEXT, 0, VK_MEDIA_NEXT_TRACK); 31 | 32 | SetEvent(hEvent); 33 | 34 | while(retValB = GetMessage(&msg, NULL, 0, 0)) 35 | { 36 | if (msg.message == WM_HOTKEY) 37 | { 38 | if (evtCallback != NULL) 39 | evtCallback((UINT8)msg.wParam); 40 | } 41 | } 42 | 43 | UnregisterHotKey(NULL, MMKEY_PLAY); 44 | UnregisterHotKey(NULL, MMKEY_PREV); 45 | UnregisterHotKey(NULL, MMKEY_NEXT); 46 | 47 | return 0; 48 | } 49 | 50 | UINT8 MultimediaKeyHook_Init(void) 51 | { 52 | if (hThread != NULL) 53 | return 0x01; 54 | 55 | hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 56 | hThread = CreateThread(NULL, 0x00, &KeyMessageThread, NULL, 0x00, &idThread); 57 | if (hThread == NULL) 58 | return 0xFF; // CreateThread failed 59 | 60 | WaitForSingleObject(hEvent, INFINITE); 61 | 62 | return 0x00; 63 | } 64 | 65 | void MultimediaKeyHook_Deinit(void) 66 | { 67 | if (hThread == NULL) 68 | return; 69 | 70 | PostThreadMessage(idThread, WM_QUIT, 0, 0); 71 | WaitForSingleObject(hThread, INFINITE); 72 | 73 | CloseHandle(hThread); 74 | hThread = NULL; 75 | 76 | return; 77 | } 78 | 79 | void MultimediaKeyHook_SetCallback(mmkey_cbfunc callbackFunc) 80 | { 81 | evtCallback = callbackFunc; 82 | 83 | return; 84 | } 85 | -------------------------------------------------------------------------------- /VGMPlay/chips/nes_apu.h: -------------------------------------------------------------------------------- 1 | /***************************************************************************** 2 | 3 | MAME/MESS NES APU CORE 4 | 5 | Based on the Nofrendo/Nosefart NES N2A03 sound emulation core written by 6 | Matthew Conte (matt@conte.com) and redesigned for use in MAME/MESS by 7 | Who Wants to Know? (wwtk@mail.com) 8 | 9 | This core is written with the advise and consent of Matthew Conte and is 10 | released under the GNU Public License. This core is freely avaiable for 11 | use in any freeware project, subject to the following terms: 12 | 13 | Any modifications to this code must be duly noted in the source and 14 | approved by Matthew Conte and myself prior to public submission. 15 | 16 | ***************************************************************************** 17 | 18 | NES_APU.H 19 | 20 | NES APU external interface. 21 | 22 | *****************************************************************************/ 23 | 24 | #pragma once 25 | 26 | #ifndef __NES_APU_H__ 27 | #define __NES_APU_H__ 28 | 29 | //#include "devlegcy.h" 30 | 31 | 32 | /* AN EXPLANATION 33 | * 34 | * The NES APU is actually integrated into the Nintendo processor. 35 | * You must supply the same number of APUs as you do processors. 36 | * Also make sure to correspond the memory regions to those used in the 37 | * processor, as each is shared. 38 | */ 39 | 40 | /*typedef struct _nes_interface nes_interface; 41 | struct _nes_interface 42 | { 43 | const char *cpu_tag; // CPU tag 44 | }; 45 | 46 | READ8_DEVICE_HANDLER( nes_psg_r ); 47 | WRITE8_DEVICE_HANDLER( nes_psg_w ); 48 | 49 | DECLARE_LEGACY_SOUND_DEVICE(NES, nesapu);*/ 50 | 51 | UINT8 nes_psg_r(void* chip, offs_t offset); 52 | void nes_psg_w(void* chip, offs_t offset, UINT8 data); 53 | 54 | void nes_psg_update_sound(void* chip, stream_sample_t **outputs, int samples); 55 | void* device_start_nesapu(int clock, int rate); 56 | void device_stop_nesapu(void* chip); 57 | void device_reset_nesapu(void* chip); 58 | 59 | void nesapu_set_rom(void* chip, const UINT8* ROMData); 60 | 61 | void nesapu_set_mute_mask(void* chip, UINT32 MuteMask); 62 | 63 | #endif /* __NES_APU_H__ */ 64 | -------------------------------------------------------------------------------- /VGMPlay/chips/k054539.h: -------------------------------------------------------------------------------- 1 | /********************************************************* 2 | 3 | Konami 054539 PCM Sound Chip 4 | 5 | *********************************************************/ 6 | 7 | #pragma once 8 | 9 | //#include "devlegcy.h" 10 | 11 | /*typedef struct _k054539_interface k054539_interface; 12 | struct _k054539_interface 13 | { 14 | const char *rgnoverride; 15 | void (*apan)(device_t *, double, double); // Callback for analog output mixing levels (0..1 for each channel) 16 | void (*irq)(device_t *); 17 | };*/ 18 | 19 | 20 | void k054539_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 21 | int device_start_k054539(UINT8 ChipID, int clock); 22 | void device_stop_k054539(UINT8 ChipID); 23 | void device_reset_k054539(UINT8 ChipID); 24 | 25 | 26 | //WRITE8_DEVICE_HANDLER( k054539_w ); 27 | //READ8_DEVICE_HANDLER( k054539_r ); 28 | void k054539_w(UINT8 ChipID, offs_t offset, UINT8 data); 29 | UINT8 k054539_r(UINT8 ChipID, offs_t offset); 30 | 31 | //* control flags, may be set at DRIVER_INIT(). 32 | #define K054539_RESET_FLAGS 0 33 | #define K054539_REVERSE_STEREO 1 34 | #define K054539_DISABLE_REVERB 2 35 | #define K054539_UPDATE_AT_KEYON 4 36 | 37 | //void k054539_init_flags(device_t *device, int flags); 38 | void k054539_init_flags(UINT8 ChipID, int flags); 39 | 40 | /* 41 | Note that the eight PCM channels of a K054539 do not have separate 42 | volume controls. Considering the global attenuation equation may not 43 | be entirely accurate, k054539_set_gain() provides means to control 44 | channel gain. It can be called anywhere but preferrably from 45 | DRIVER_INIT(). 46 | 47 | Parameters: 48 | chip : 0 / 1 49 | channel : 0 - 7 50 | gain : 0.0=silent, 1.0=no gain, 2.0=twice as loud, etc. 51 | */ 52 | //void k054539_set_gain(device_t *device, int channel, double gain); 53 | void k054539_set_gain(UINT8 ChipID, int channel, double gain); 54 | 55 | 56 | void k054539_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 57 | const UINT8* ROMData); 58 | void k054539_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 59 | 60 | 61 | //DECLARE_LEGACY_SOUND_DEVICE(K054539, k054539); 62 | -------------------------------------------------------------------------------- /VGMPlay/chips/2608intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "fm.h" 4 | #include "ay8910.h" 5 | #include "emu2149.h" 6 | 7 | void ym2608_update_request(void *param); 8 | 9 | typedef struct _ym2608_interface ym2608_interface; 10 | struct _ym2608_interface 11 | { 12 | ay8910_interface ay8910_intf; 13 | //void ( *handler )( const device_config *device, int irq ); /* IRQ handler for the YM2608 */ 14 | void ( *handler )( int irq ); /* IRQ handler for the YM2608 */ 15 | }; 16 | 17 | /*READ8_DEVICE_HANDLER( ym2608_r ); 18 | WRITE8_DEVICE_HANDLER( ym2608_w ); 19 | 20 | READ8_DEVICE_HANDLER( ym2608_read_port_r ); 21 | READ8_DEVICE_HANDLER( ym2608_status_port_a_r ); 22 | READ8_DEVICE_HANDLER( ym2608_status_port_b_r ); 23 | 24 | WRITE8_DEVICE_HANDLER( ym2608_control_port_a_w ); 25 | WRITE8_DEVICE_HANDLER( ym2608_control_port_b_w ); 26 | WRITE8_DEVICE_HANDLER( ym2608_data_port_a_w ); 27 | WRITE8_DEVICE_HANDLER( ym2608_data_port_b_w ); 28 | 29 | DEVICE_GET_INFO( ym2608 ); 30 | #define SOUND_YM2608 DEVICE_GET_INFO_NAME( ym2608 )*/ 31 | 32 | void ym2608_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 33 | void ym2608_stream_update_ay(UINT8 ChipID, stream_sample_t **outputs, int samples); 34 | 35 | int device_start_ym2608(UINT8 ChipID, int clock, UINT8 AYDisable, UINT8 AYFlags, int* AYrate); 36 | void device_stop_ym2608(UINT8 ChipID); 37 | void device_reset_ym2608(UINT8 ChipID); 38 | 39 | UINT8 ym2608_r(UINT8 ChipID, offs_t offset); 40 | void ym2608_w(UINT8 ChipID, offs_t offset, UINT8 data); 41 | 42 | UINT8 ym2608_read_port_r(UINT8 ChipID, offs_t offset); 43 | UINT8 ym2608_status_port_a_r(UINT8 ChipID, offs_t offset); 44 | UINT8 ym2608_status_port_b_r(UINT8 ChipID, offs_t offset); 45 | 46 | void ym2608_control_port_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 47 | void ym2608_control_port_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 48 | void ym2608_data_port_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 49 | void ym2608_data_port_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 50 | 51 | void ym2608_set_ay_emu_core(UINT8 Emulator); 52 | void ym2608_write_data_pcmrom(UINT8 ChipID, UINT8 rom_id, offs_t ROMSize, offs_t DataStart, 53 | offs_t DataLength, const UINT8* ROMData); 54 | void ym2608_set_mute_mask(UINT8 ChipID, UINT32 MuteMaskFM, UINT32 MuteMaskAY); 55 | void ym2608_set_srchg_cb(UINT8 ChipID, SRATE_CALLBACK CallbackFunc, void* DataPtr, void* AYDataPtr); 56 | -------------------------------------------------------------------------------- /VGMPlay/chips/2610intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "fm.h" 4 | #include "ay8910.h" 5 | #include "emu2149.h" 6 | 7 | 8 | void ym2610_update_request(void *param); 9 | 10 | /*typedef struct _ym2610_interface ym2610_interface; 11 | struct _ym2610_interface 12 | { 13 | //void ( *handler )( const device_config *device, int irq ); // IRQ handler for the YM2610 14 | void ( *handler )( int irq ); // IRQ handler for the YM2610 15 | };*/ 16 | 17 | /*READ8_DEVICE_HANDLER( ym2610_r ); 18 | WRITE8_DEVICE_HANDLER( ym2610_w ); 19 | 20 | READ8_DEVICE_HANDLER( ym2610_status_port_a_r ); 21 | READ8_DEVICE_HANDLER( ym2610_status_port_b_r ); 22 | READ8_DEVICE_HANDLER( ym2610_read_port_r ); 23 | 24 | WRITE8_DEVICE_HANDLER( ym2610_control_port_a_w ); 25 | WRITE8_DEVICE_HANDLER( ym2610_control_port_b_w ); 26 | WRITE8_DEVICE_HANDLER( ym2610_data_port_a_w ); 27 | WRITE8_DEVICE_HANDLER( ym2610_data_port_b_w ); 28 | 29 | 30 | DEVICE_GET_INFO( ym2610 ); 31 | DEVICE_GET_INFO( ym2610b ); 32 | 33 | #define SOUND_YM2610 DEVICE_GET_INFO_NAME( ym2610 ) 34 | #define SOUND_YM2610B DEVICE_GET_INFO_NAME( ym2610b )*/ 35 | 36 | void ym2610_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 37 | void ym2610b_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 38 | void ym2610_stream_update_ay(UINT8 ChipID, stream_sample_t **outputs, int samples); 39 | 40 | int device_start_ym2610(UINT8 ChipID, int clock, UINT8 AYDisable, int* AYrate); 41 | void device_stop_ym2610(UINT8 ChipID); 42 | void device_reset_ym2610(UINT8 ChipID); 43 | 44 | UINT8 ym2610_r(UINT8 ChipID, offs_t offset); 45 | void ym2610_w(UINT8 ChipID, offs_t offset, UINT8 data); 46 | 47 | UINT8 ym2610_status_port_a_r(UINT8 ChipID, offs_t offset); 48 | UINT8 ym2610_status_port_b_r(UINT8 ChipID, offs_t offset); 49 | UINT8 ym2610_read_port_r(UINT8 ChipID, offs_t offset); 50 | 51 | void ym2610_control_port_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 52 | void ym2610_control_port_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 53 | void ym2610_data_port_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 54 | void ym2610_data_port_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 55 | 56 | void ym2610_set_ay_emu_core(UINT8 Emulator); 57 | void ym2610_write_data_pcmrom(UINT8 ChipID, UINT8 rom_id, offs_t ROMSize, offs_t DataStart, 58 | offs_t DataLength, const UINT8* ROMData); 59 | void ym2610_set_mute_mask(UINT8 ChipID, UINT32 MuteMaskFM, UINT32 MuteMaskAY); 60 | 61 | -------------------------------------------------------------------------------- /in_vgm/Winamp/ipc_pe.h: -------------------------------------------------------------------------------- 1 | #ifndef __IPC_PE_H 2 | #define __IPC_PE_H 3 | 4 | #define IPC_PE_GETCURINDEX 100 // returns current idx 5 | #define IPC_PE_GETINDEXTOTAL 101 // returns number of items 6 | #define IPC_PE_GETINDEXINFO 102 // (copydata) lpData is of type callbackinfo, callback is called with copydata/fileinfo structure and msg IPC_PE_GETINDEXINFORESULT 7 | #define IPC_PE_GETINDEXINFORESULT 103 // callback message for IPC_PE_GETINDEXINFO 8 | #define IPC_PE_DELETEINDEX 104 // lParam = index 9 | #define IPC_PE_SWAPINDEX 105 // (lParam & 0xFFFF0000) >> 16 = from, (lParam & 0xFFFF) = to 10 | #define IPC_PE_INSERTFILENAME 106 // (copydata) lpData is of type fileinfo 11 | #define IPC_PE_GETDIRTY 107 // returns 1 if the playlist changed since the last IPC_PE_SETCLEAN 12 | #define IPC_PE_SETCLEAN 108 // resets the dirty flag until next modification 13 | #define IPC_PE_GETIDXFROMPOINT 109 // pass a point parm, return a playlist index 14 | #define IPC_PE_SAVEEND 110 // pass index to save from 15 | #define IPC_PE_RESTOREEND 111 // no parm 16 | #define IPC_PE_GETNEXTSELECTED 112 // same as IPC_PLAYLIST_GET_NEXT_SELECTED for the main window 17 | #define IPC_PE_GETSELECTEDCOUNT 113 18 | #define IPC_PE_INSERTFILENAMEW 114 // (copydata) lpData is of type fileinfoW 19 | #define IPC_PE_GETINDEXINFO_TITLE 115 // like IPC_PE_GETINDEXINFO, but writes the title to char file[MAX_PATH] instead of filename 20 | #define IPC_PE_GETINDEXINFORESULT_TITLE 116 // callback message for IPC_PE_GETINDEXINFO 21 | typedef struct { 22 | char file[MAX_PATH]; 23 | int index; 24 | } fileinfo; 25 | 26 | typedef struct { 27 | wchar_t file[MAX_PATH]; 28 | int index; 29 | } fileinfoW; 30 | 31 | typedef struct { 32 | HWND callback; 33 | int index; 34 | } callbackinfo; 35 | 36 | // the following messages are in_process ONLY 37 | 38 | #define IPC_PE_GETINDEXTITLE 200 // lParam = pointer to fileinfo2 struct 39 | #define IPC_PE_GETINDEXTITLEW 201 // lParam = pointer to fileinfo2W struct 40 | #define IPC_PE_GETINDEXINFO_INPROC 202 // lParam = pointer to fileinfo struct 41 | #define IPC_PE_GETINDEXINFOW_INPROC 203 // lParam = pointer to fileinfoW struct 42 | 43 | typedef struct { 44 | int fileindex; 45 | char filetitle[256]; 46 | char filelength[16]; 47 | } fileinfo2; 48 | 49 | typedef struct 50 | { 51 | int fileindex; 52 | wchar_t filetitle[256]; 53 | wchar_t filelength[16]; 54 | } fileinfo2W; 55 | 56 | #endif -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # VGMPlay [![Build Status](https://travis-ci.org/vgmrips/vgmplay.svg?branch=master)](https://travis-ci.org/vgmrips/vgmplay) 2 | 3 | The official and always up-to-date player for all [VGM](https://en.wikipedia.org/wiki/VGM_(file_format)) files. 4 | 5 | In the future, the existing VGMPlay will be replaced by [libvgm](https://github.com/ValleyBell/libvgm), which is currently in development. 6 | 7 | ## Contact 8 | 9 | * [VGMRips Forums](http://vgmrips.net/forum/index.php) 10 | * IRC: irc.digibase.ca #vgmrips 11 | 12 | ## Compile VGMPlay under Windows 13 | 14 | ### Using MS Visual Studio 6.0: 15 | 16 | 1. Open `VGMPlay.dsw`. 17 | 2. Build the project. 18 | 3. Done. 19 | 20 | ### Using later versions of MS Visual Studio: 21 | 22 | 1. Open `VGMPlay.vcxproj`. 23 | 2. Build the project. 24 | 3. Done. 25 | 26 | ### Using MinGW/MSYS: 27 | 28 | 1. open MSYS and run `make WINDOWS=1` in VGMPlay's folder. 29 | 2. Done. 30 | 31 | Note: You can compile it without MSYS, but you need to manually create 32 | the OBJDIRS paths (or make them use the backslash '\'), because mkdir fails 33 | at paths with a forward slash. 34 | 35 | ## Compile VGMPlay under Linux 36 | 37 | 1. [optional step] If you have libao installed, you can edit the 38 | Makefile to make VGMPlay use `libao` instead of `OSS`. 39 | 2. run `make` in VGMPlay's folder 40 | 3. Done. Optionally `sudo make install` and `sudo make play_install`. 41 | 42 | ### Building on Ubuntu (16.04) 43 | 44 | #### Requirements 45 | 46 | The following packages are needed in order to compile the binaries 47 | 48 | ```sh 49 | sudo apt-get install make gcc zlib1g-dev libao-dev libdbus-1-dev 50 | ``` 51 | 52 | #### Building 53 | 54 | ```sh 55 | make 56 | ``` 57 | 58 | ## Compile VGMPlay under macOS 59 | 60 | 1. install libao by executing the line `brew install libao` 61 | 2. run `make install MACOSX=1 DISABLE_HWOPL_SUPPORT=1` in VGMPlay's folder 62 | (Alternatively edit the Makefile to set those constants and just run `make`.) 63 | 3. Done. 64 | 65 | Thanks to grauw for macOS compilation instructions. 66 | 67 | ## Compile VGMPlay under Android 68 | 1. Install [Termux](https://github.com/termux/termux-app) on [F-Droid](https://f-droid.org/en/packages/com.termux/) or [GitHub](https://github.com/termux/termux-app/releases). Do not download Termux from Play Store for security and depreciation reasons 69 | 2. Open Termux and do `pkg update` 70 | 3. When you do pkg update, do `pkg install clang dbus git libao make pkg-config -y` 71 | 4. After the installation is done, do `git clone https://github.com/vgmrips/vgmplay` 72 | 5. After Done Cloning, do `cd vgmplay/VGMPlay` 73 | 6. And then do `make` 74 | -------------------------------------------------------------------------------- /VGMPlay/chips/es5506.h: -------------------------------------------------------------------------------- 1 | /********************************************************************************************** 2 | * 3 | * Ensoniq ES5505/6 driver 4 | * by Aaron Giles 5 | * 6 | **********************************************************************************************/ 7 | 8 | #pragma once 9 | 10 | #ifndef __ES5506_H__ 11 | #define __ES5506_H__ 12 | 13 | //#include "devlegcy.h" 14 | 15 | /*typedef struct _es5505_interface es5505_interface; 16 | struct _es5505_interface 17 | { 18 | const char * region0; // memory region where the sample ROM lives 19 | const char * region1; // memory region where the sample ROM lives 20 | void (*irq_callback)(device_t *device, int state); // irq callback 21 | UINT16 (*read_port)(device_t *device); // input port read 22 | };* 23 | 24 | READ16_DEVICE_HANDLER( es5505_r ); 25 | WRITE16_DEVICE_HANDLER( es5505_w ); 26 | void es5505_voice_bank_w(device_t *device, int voice, int bank); 27 | void es5505_set_channel_volume(device_t *device, int channel, int volume); 28 | 29 | //DECLARE_LEGACY_SOUND_DEVICE(ES5505, es5505); 30 | 31 | 32 | typedef struct _es5506_interface es5506_interface; 33 | struct _es5506_interface 34 | { 35 | const char * region0; // memory region where the sample ROM lives 36 | const char * region1; // memory region where the sample ROM lives 37 | const char * region2; // memory region where the sample ROM lives 38 | const char * region3; // memory region where the sample ROM lives 39 | void (*irq_callback)(device_t *device, int state); // irq callback 40 | UINT16 (*read_port)(device_t *device); // input port read 41 | };*/ 42 | 43 | //READ8_DEVICE_HANDLER( es5506_r ); 44 | //WRITE8_DEVICE_HANDLER( es5506_w ); 45 | UINT8 es550x_r(UINT8 ChipID, offs_t offset); 46 | void es550x_w(UINT8 ChipID, offs_t offset, UINT8 data); 47 | void es550x_w16(UINT8 ChipID, offs_t offset, UINT16 data); 48 | 49 | void es5506_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 50 | int device_start_es5506(UINT8 ChipID, int clock, int channels); 51 | void device_stop_es5506(UINT8 ChipID); 52 | void device_reset_es5506(UINT8 ChipID); 53 | //void es5506_set_base(running_device *device, UINT8 *wavemem); 54 | 55 | void es5506_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 56 | const UINT8* ROMData); 57 | 58 | void es5506_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 59 | void es5506_set_srchg_cb(UINT8 ChipID, SRATE_CALLBACK CallbackFunc, void* DataPtr); 60 | 61 | //void es5506_voice_bank_w(device_t *device, int voice, int bank); 62 | 63 | //DECLARE_LEGACY_SOUND_DEVICE(ES5506, es5506); 64 | 65 | #endif /* __ES5506_H__ */ 66 | -------------------------------------------------------------------------------- /VGMPlay/chips/panning.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "panning.h" 4 | 5 | #ifndef PI 6 | #define PI 3.14159265359 7 | #endif 8 | #ifndef SQRT2 9 | #define SQRT2 1.414213562 10 | #endif 11 | #define RANGE 512 12 | 13 | //----------------------------------------------------------------- 14 | // Set the panning values for the two stereo channels (L,R) 15 | // for a position -256..0..256 L..C..R 16 | //----------------------------------------------------------------- 17 | void calc_panning(float channels[2], int position) 18 | { 19 | if ( position > RANGE / 2 ) 20 | position = RANGE / 2; 21 | else if ( position < -RANGE / 2 ) 22 | position = -RANGE / 2; 23 | position += RANGE / 2; // make -256..0..256 -> 0..256..512 24 | 25 | // Equal power law: equation is 26 | // right = sin( position / range * pi / 2) * sqrt( 2 ) 27 | // left is equivalent to right with position = range - position 28 | // position is in the range 0 .. RANGE 29 | // RANGE / 2 = centre, result = 1.0f 30 | channels[1] = (float)( sin( (double)position / RANGE * PI / 2 ) * SQRT2 ); 31 | position = RANGE - position; 32 | channels[0] = (float)( sin( (double)position / RANGE * PI / 2 ) * SQRT2 ); 33 | } 34 | 35 | //----------------------------------------------------------------- 36 | // Reset the panning values to the centre position 37 | //----------------------------------------------------------------- 38 | void centre_panning(float channels[2]) 39 | { 40 | channels[0] = channels[1] = 1.0f; 41 | } 42 | 43 | /*//----------------------------------------------------------------- 44 | // Generate a stereo position in the range 0..RANGE 45 | // with Gaussian distribution, mean RANGE/2, S.D. RANGE/5 46 | //----------------------------------------------------------------- 47 | int random_stereo() 48 | { 49 | int n = (int)(RANGE/2 + gauss_rand() * (RANGE * 0.2) ); 50 | if ( n > RANGE ) n = RANGE; 51 | if ( n < 0 ) n = 0; 52 | return n; 53 | } 54 | 55 | //----------------------------------------------------------------- 56 | // Generate a Gaussian random number with mean 0, variance 1 57 | // Copied from an ancient C newsgroup FAQ 58 | //----------------------------------------------------------------- 59 | double gauss_rand() 60 | { 61 | static double V1, V2, S; 62 | static int phase = 0; 63 | double X; 64 | 65 | if(phase == 0) { 66 | do { 67 | double U1 = (double)rand() / RAND_MAX; 68 | double U2 = (double)rand() / RAND_MAX; 69 | 70 | V1 = 2 * U1 - 1; 71 | V2 = 2 * U2 - 1; 72 | S = V1 * V1 + V2 * V2; 73 | } while(S >= 1 || S == 0); 74 | 75 | X = V1 * sqrt(-2 * log(S) / S); 76 | } else 77 | X = V2 * sqrt(-2 * log(S) / S); 78 | 79 | phase = 1 - phase; 80 | 81 | return X; 82 | }*/ 83 | -------------------------------------------------------------------------------- /VGMPlay/chips/2612intf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void ym2612_update_request(void *param); 4 | 5 | /*typedef struct _ym2612_interface ym2612_interface; 6 | struct _ym2612_interface 7 | { 8 | //void (*handler)(const device_config *device, int irq); 9 | void (*handler)(int irq); 10 | };*/ 11 | 12 | /*READ8_DEVICE_HANDLER( ym2612_r ); 13 | WRITE8_DEVICE_HANDLER( ym2612_w ); 14 | 15 | READ8_DEVICE_HANDLER( ym2612_status_port_a_r ); 16 | READ8_DEVICE_HANDLER( ym2612_status_port_b_r ); 17 | READ8_DEVICE_HANDLER( ym2612_data_port_a_r ); 18 | READ8_DEVICE_HANDLER( ym2612_data_port_b_r ); 19 | 20 | WRITE8_DEVICE_HANDLER( ym2612_control_port_a_w ); 21 | WRITE8_DEVICE_HANDLER( ym2612_control_port_b_w ); 22 | WRITE8_DEVICE_HANDLER( ym2612_data_port_a_w ); 23 | WRITE8_DEVICE_HANDLER( ym2612_data_port_b_w ); 24 | 25 | 26 | DEVICE_GET_INFO( ym2612 ); 27 | #define SOUND_YM2612 DEVICE_GET_INFO_NAME( ym2612 )*/ 28 | void ym2612_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 29 | int device_start_ym2612(UINT8 ChipID, int clock); 30 | void device_stop_ym2612(UINT8 ChipID); 31 | void device_reset_ym2612(UINT8 ChipID); 32 | 33 | UINT8 ym2612_r(UINT8 ChipID, offs_t offset); 34 | void ym2612_w(UINT8 ChipID, offs_t offset, UINT8 data); 35 | 36 | UINT8 ym2612_status_port_a_r(UINT8 ChipID, offs_t offset); 37 | UINT8 ym2612_status_port_b_r(UINT8 ChipID, offs_t offset); 38 | UINT8 ym2612_data_port_a_r(UINT8 ChipID, offs_t offset); 39 | UINT8 ym2612_data_port_b_r(UINT8 ChipID, offs_t offset); 40 | 41 | void ym2612_control_port_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 42 | void ym2612_control_port_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 43 | void ym2612_data_port_a_w(UINT8 ChipID, offs_t offset, UINT8 data); 44 | void ym2612_data_port_b_w(UINT8 ChipID, offs_t offset, UINT8 data); 45 | 46 | void ym2612_set_emu_core(UINT8 Emulator); 47 | void ym2612_set_options(UINT8 Flags); 48 | void ym2612_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 49 | 50 | 51 | /*typedef struct _ym3438_interface ym3438_interface; 52 | struct _ym3438_interface 53 | { 54 | //void (*handler)(const device_config *device, int irq); 55 | void (*handler)(int irq); 56 | }; 57 | 58 | 59 | #define ym3438_r ym2612_r 60 | #define ym3438_w ym2612_w 61 | 62 | #define ym3438_status_port_a_r ym2612_status_port_a_r 63 | #define ym3438_status_port_b_r ym2612_status_port_b_r 64 | #define ym3438_data_port_a_r ym2612_data_port_a_r 65 | #define ym3438_data_port_b_r ym2612_data_port_b_r 66 | 67 | #define ym3438_control_port_a_w ym2612_control_port_a_w 68 | #define ym3438_control_port_b_w ym2612_control_port_b_w 69 | #define ym3438_data_port_a_w ym2612_data_port_a_w 70 | #define ym3438_data_port_b_w ym2612_data_port_b_w*/ 71 | 72 | 73 | //DEVICE_GET_INFO( ym3438 ); 74 | //#define SOUND_YM3438 DEVICE_GET_INFO_NAME( ym3438 ) 75 | -------------------------------------------------------------------------------- /in_vgm/Winamp/OUT.H: -------------------------------------------------------------------------------- 1 | #ifndef NULLSOFT_OUTH 2 | #define NULLSOFT_OUTH 3 | #include 4 | #include 5 | // ids: 6 | // waveout: 32 7 | // gapless: 64 8 | // xfade: 63 9 | // disk: 33 10 | // dsound: 38 11 | // NULL: 65 12 | // mm2: 69 13 | 14 | #if (_MSC_VER <= 1200) 15 | typedef int intptr_t; 16 | #endif 17 | 18 | #define OUT_VER 0x10 19 | 20 | typedef struct 21 | { 22 | int version; // module version (OUT_VER) 23 | char *description; // description of module, with version string 24 | intptr_t id; // module id. each input module gets its own. non-nullsoft modules should 25 | // be >= 65536. 26 | 27 | HWND hMainWindow; // winamp's main window (filled in by winamp) 28 | HINSTANCE hDllInstance; // DLL instance handle (filled in by winamp) 29 | 30 | void (*Config)(HWND hwndParent); // configuration dialog 31 | void (*About)(HWND hwndParent); // about dialog 32 | 33 | void (*Init)(); // called when loaded 34 | void (*Quit)(); // called when unloaded 35 | 36 | int (*Open)(int samplerate, int numchannels, int bitspersamp, int bufferlenms, int prebufferms); 37 | // returns >=0 on success, <0 on failure 38 | 39 | // NOTENOTENOTE: bufferlenms and prebufferms are ignored in most if not all output plug-ins. 40 | // ... so don't expect the max latency returned to be what you asked for. 41 | // returns max latency in ms (0 for diskwriters, etc) 42 | // bufferlenms and prebufferms must be in ms. 0 to use defaults. 43 | // prebufferms must be <= bufferlenms 44 | // pass bufferlenms==-666 to tell the output plugin that it's clock is going to be used to sync video 45 | // out_ds turns off silence-eating when -666 is passed 46 | 47 | void (*Close)(); // close the ol' output device. 48 | 49 | int (*Write)(char *buf, int len); 50 | // 0 on success. Len == bytes to write (<= 8192 always). buf is straight audio data. 51 | // 1 returns not able to write (yet). Non-blocking, always. 52 | 53 | int (*CanWrite)(); // returns number of bytes possible to write at a given time. 54 | // Never will decrease unless you call Write (or Close, heh) 55 | 56 | int (*IsPlaying)(); // non0 if output is still going or if data in buffers waiting to be 57 | // written (i.e. closing while IsPlaying() returns 1 would truncate the song 58 | 59 | int (*Pause)(int pause); // returns previous pause state 60 | 61 | void (*SetVolume)(int volume); // volume is 0-255 62 | void (*SetPan)(int pan); // pan is -128 to 128 63 | 64 | void (*Flush)(int t); // flushes buffers and restarts output at time t (in ms) 65 | // (used for seeking) 66 | 67 | int (*GetOutputTime)(); // returns played time in MS 68 | int (*GetWrittenTime)(); // returns time written in MS (used for synching up vis stuff) 69 | 70 | } Out_Module; 71 | 72 | 73 | #endif -------------------------------------------------------------------------------- /VGMPlay/chips/ym2413hd.h: -------------------------------------------------------------------------------- 1 | /*-----------------------------------*/ 2 | /* YM-2413 emulator using OPL */ 3 | /* (c) by Hiromitsu Shioya */ 4 | /* Modified by Omar Cornut */ 5 | /*-----------------------------------*/ 6 | 7 | //#ifndef __YM2413HD_H__ 8 | //#define __YM2413HD_H__ 9 | #define YM2413_REGISTERS (64) // 64 registers area 10 | #define YM2413_INSTRUMENTS (16) // 16 instruments (0 is user defined) 11 | #define YM2413_VOLUME_STEPS (16) // 16 different volume steps 12 | #define YM2413_VOLUME_MASK (0x0F) 13 | 14 | //----------------------------------------------------------------------------- 15 | // Instrument Data 16 | //----------------------------------------------------------------------------- 17 | // FIXME: Currently placed outside of the MEKA_OPL test, as it is being 18 | // used by the FM Editor. 19 | //----------------------------------------------------------------------------- 20 | 21 | typedef struct 22 | { 23 | unsigned char MKS, CKS; /* KSL */ 24 | unsigned char MML, CML; /* MULTIPLE */ 25 | unsigned char MA, CA; /* ATTACK RATE */ 26 | unsigned char MSL, CSL; /* SUSTAIN LEVEL */ 27 | unsigned char MS, CS; /* EG */ 28 | unsigned char MD, CD; /* DECAY RATE */ 29 | unsigned char MR, CR; /* RELEASE RATE */ 30 | unsigned char MTL, CTL; /* TOTAL LEVEL */ 31 | unsigned char MEV, CEV; /* KSR */ 32 | unsigned char MW, CW; /* WAVE FORM */ 33 | unsigned char FB, CON; /* FEEDBACK / Connection */ 34 | } FM_OPL_Patch; 35 | 36 | //----------------------------------------------------------------------------- 37 | 38 | //#ifdef MEKA_OPL 39 | 40 | //----------------------------------------------------------------------------- 41 | 42 | // Registers 43 | byte FM_OPL_Regs [YM2413_REGISTERS]; 44 | #define FM_OPL_Rhythm_Mode (FM_OPL_Regs [0x0E] & 0x20) 45 | 46 | // Functions 47 | int FM_OPL_Init (void *userdata); 48 | void FM_OPL_Close (void); 49 | //void FM_OPL_Active (void); 50 | void FM_OPL_Update (void); 51 | void FM_OPL_Set_Voice (int R, int V, int VL); 52 | void FM_OPL_Set_User_Voice (void); 53 | 54 | // Interface (see FMUNIT.C/.H) 55 | void FM_OPL_Reset (void); 56 | void FM_OPL_Write (int Register, int Value); 57 | //void FM_OPL_Mute (void); 58 | //void FM_OPL_Resume (void); 59 | //void FM_OPL_Regenerate (void); 60 | 61 | //----------------------------------------------------------------------------- 62 | 63 | /*#else 64 | 65 | // A fake set of registers is created as sound/fmunit.c reference it. 66 | // FIXME: This sucks. 67 | byte FM_OPL_Regs [YM2413_REGISTERS]; 68 | 69 | #endif*/ 70 | 71 | //#endif /* !__YM2413HD_H__ */ 72 | 73 | -------------------------------------------------------------------------------- /in_vgm/Winamp/DSP.H: -------------------------------------------------------------------------------- 1 | #ifndef NULLSOFT_WINAMP_DSP_H 2 | #define NULLSOFT_WINAMP_DSP_H 3 | // DSP plugin interface 4 | 5 | // notes: 6 | // any window that remains in foreground should optimally pass unused 7 | // keystrokes to the parent (winamp's) window, so that the user 8 | // can still control it. As for storing configuration, 9 | // Configuration data should be stored in \plugin.ini 10 | // (look at the vis plugin for configuration code) 11 | 12 | typedef struct winampDSPModule { 13 | char *description; // description 14 | HWND hwndParent; // parent window (filled in by calling app) 15 | HINSTANCE hDllInstance; // instance handle to this DLL (filled in by calling app) 16 | 17 | void (*Config)(struct winampDSPModule *this_mod); // configuration dialog (if needed) 18 | int (*Init)(struct winampDSPModule *this_mod); // 0 on success, creates window, etc (if needed) 19 | 20 | // modify waveform samples: returns number of samples to actually write 21 | // (typically numsamples, but no more than twice numsamples, and no less than half numsamples) 22 | // numsamples should always be at least 128. should, but I'm not sure 23 | int (*ModifySamples)(struct winampDSPModule *this_mod, short int *samples, int numsamples, int bps, int nch, int srate); 24 | 25 | void (*Quit)(struct winampDSPModule *this_mod); // called when unloading 26 | 27 | void *userData; // user data, optional 28 | } winampDSPModule; 29 | 30 | typedef struct { 31 | int version; // DSP_HDRVER 32 | char *description; // description of library 33 | winampDSPModule* (*getModule)(int); // module retrieval function 34 | int (*sf)(int key); // DSP_HDRVER == 0x21 35 | } winampDSPHeader; 36 | 37 | // exported symbols 38 | #ifdef USE_DSP_HDR_HWND 39 | typedef winampDSPHeader* (*winampDSPGetHeaderType)(HWND); 40 | #define DSP_HDRVER 0x22 41 | 42 | #else 43 | 44 | typedef winampDSPHeader* (*winampDSPGetHeaderType)(HWND); 45 | // header version: 0x20 == 0.20 == winamp 2.0 46 | #define DSP_HDRVER 0x20 47 | #endif 48 | 49 | // return values from the winampUninstallPlugin(HINSTANCE hdll, HWND parent, int param) 50 | // which determine if we can uninstall the plugin immediately or on winamp restart 51 | #define DSP_PLUGIN_UNINSTALL_NOW 0x0 52 | #define DSP_PLUGIN_UNINSTALL_REBOOT 0x1 53 | // 54 | // uninstall support was added from 5.0+ and uninstall now support from 5.5+ 55 | // it is down to you to ensure that if uninstall now is returned that it will not cause a crash 56 | // (ie don't use if you've been subclassing the main window) 57 | 58 | // Version note: 59 | // 60 | // Added passing of Winamp's main hwnd in the call to the exported winampDSPHeader() 61 | // which allows for primarily the use of localisation features with the bundled plugins. 62 | // If you want to use the new version then either you can edit you version of dsp.h or 63 | // you can add USE_DSP_HDR_HWND to your project's defined list or before use of dsp.h 64 | // 65 | #endif -------------------------------------------------------------------------------- /VGMPlay/chips/Ootake_PSG.h: -------------------------------------------------------------------------------- 1 | /*----------------------------------------------------------------------------- 2 | [PSG.h] 3 | ＰＳＧを記述するのに必要な定義および関数のプロトタイプ宣言を行ないます． 4 | 5 | Copyright (C) 2004 Ki 6 | 7 | This program is free software; you can redistribute it and/or modify 8 | it under the terms of the GNU General Public License as published by 9 | the Free Software Foundation; either version 2 of the License, or 10 | (at your option) any later version. 11 | 12 | This program is distributed in the hope that it will be useful, 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | GNU General Public License for more details. 16 | 17 | You should have received a copy of the GNU General Public License 18 | along with this program; if not, write to the Free Software 19 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 | **---------------------------------------------------------------------------*/ 21 | //#include 22 | //#include "TypeDefs.h" 23 | 24 | typedef UINT8 Uint8; 25 | typedef INT16 Sint16; 26 | typedef INT32 Sint32; 27 | typedef UINT32 Uint32; 28 | typedef UINT8 BOOL; 29 | #define TRUE 1 30 | #define FALSE 0 31 | 32 | //#define PSG_FRQ 3579545.0 33 | 34 | 35 | /*----------------------------------------------------------------------------- 36 | ** 関数のプロトタイプ宣言を行ないます． 37 | **---------------------------------------------------------------------------*/ 38 | //Sint32 39 | void* 40 | PSG_Init( 41 | Sint32 clock, 42 | Sint32 sampleRate); 43 | 44 | void 45 | PSG_Deinit(void* chip); 46 | 47 | void 48 | PSG_Mix( 49 | // Sint16* pDst, // 出力先バッファ 50 | void* chip, 51 | Sint32** pDst, 52 | Sint32 nSample); // 書き出すサンプル数 53 | 54 | /*void 55 | PSG_SetSampleRate( 56 | Uint32 sampleRate); 57 | 58 | void 59 | PSGDEBUG_ShowRegs();*/ 60 | 61 | Uint8 62 | PSG_Read(void* chip, Uint32 regNum); 63 | 64 | void 65 | PSG_Write( 66 | void* chip, 67 | Uint32 regNum, 68 | Uint8 data); 69 | 70 | /*Sint32 71 | PSG_AdvanceClock(Sint32 clock); 72 | 73 | BOOL 74 | PSG_SaveState( 75 | FILE* p); 76 | 77 | BOOL 78 | PSG_LoadState( 79 | FILE* p);*/ 80 | 81 | //Kitao追加。PSGのボリュームも個別に設定可能にした。 82 | /*void 83 | PSG_SetVolume( 84 | Uint32 volume); // 0 - 65535 85 | 86 | //Kitao追加。ボリュームミュート、ハーフなどをできるようにした。 87 | void 88 | PSG_SetVolumeEffect( 89 | Uint32 volumeEffect);*/ 90 | 91 | //Kitao追加 92 | void 93 | PSG_ResetVolumeReg(void* chip); 94 | 95 | //Kitao追加 96 | void 97 | PSG_SetMutePsgChannel( 98 | void* chip, 99 | Sint32 num, 100 | BOOL bMute); 101 | 102 | void PSG_SetMuteMask(void* chip, Uint32 MuteMask); 103 | 104 | //Kitao追加 105 | BOOL 106 | PSG_GetMutePsgChannel( 107 | void* chip, 108 | Sint32 num); 109 | 110 | //Kitao追加。v2.60 111 | void 112 | PSG_SetHoneyInTheSky( 113 | void* chip, 114 | BOOL bHoneyInTheSky); 115 | -------------------------------------------------------------------------------- /VGMPlay/chips/emu2149.h: -------------------------------------------------------------------------------- 1 | /* emu2149.h */ 2 | #ifndef _EMU2149_H_ 3 | #define _EMU2149_H_ 4 | #include "emutypes.h" 5 | 6 | /*#ifdef EMU2149_DLL_EXPORTS 7 | #define EMU2149_API __declspec(dllexport) 8 | #elif EMU2149_DLL_IMPORTS 9 | #define EMU2149_API __declspec(dllimport) 10 | #else*/ 11 | #define EMU2149_API 12 | //#endif 13 | 14 | #define EMU2149_VOL_DEFAULT 1 15 | #define EMU2149_VOL_YM2149 0 16 | #define EMU2149_VOL_AY_3_8910 1 17 | 18 | #define EMU2149_ZX_STEREO 0x80 19 | 20 | #define PSG_MASK_CH(x) (1<<(x)) 21 | 22 | /*#ifdef __cplusplus 23 | extern "C" 24 | { 25 | #endif*/ 26 | 27 | typedef struct __PSG 28 | { 29 | 30 | /* Volume Table */ 31 | e_uint32 *voltbl; 32 | 33 | e_uint8 reg[0x20]; 34 | e_int32 out; 35 | e_int32 cout[3]; 36 | 37 | e_uint32 clk, rate, base_incr, quality; 38 | 39 | e_uint32 count[3]; 40 | e_uint32 volume[3]; 41 | e_uint32 freq[3]; 42 | e_uint32 edge[3]; 43 | e_uint32 tmask[3]; 44 | e_uint32 nmask[3]; 45 | e_uint32 mask; 46 | e_uint32 stereo_mask[3]; 47 | 48 | e_uint32 base_count; 49 | 50 | e_uint32 env_volume; 51 | e_uint32 env_ptr; 52 | e_uint32 env_face; 53 | 54 | e_uint32 env_continue; 55 | e_uint32 env_attack; 56 | e_uint32 env_alternate; 57 | e_uint32 env_hold; 58 | e_uint32 env_pause; 59 | e_uint32 env_reset; 60 | 61 | e_uint32 env_freq; 62 | e_uint32 env_count; 63 | 64 | e_uint32 noise_seed; 65 | e_uint32 noise_count; 66 | e_uint32 noise_freq; 67 | 68 | /* rate converter */ 69 | e_uint32 realstep; 70 | e_uint32 psgtime; 71 | e_uint32 psgstep; 72 | e_int32 prev, next; 73 | e_int32 sprev[2], snext[2]; 74 | 75 | /* I/O Ctrl */ 76 | e_uint32 adr; 77 | 78 | } 79 | PSG; 80 | 81 | EMU2149_API void PSG_set_quality (PSG * psg, e_uint32 q); 82 | EMU2149_API void PSG_set_clock(PSG * psg, e_uint32 c); 83 | EMU2149_API void PSG_set_rate (PSG * psg, e_uint32 r); 84 | EMU2149_API PSG *PSG_new (e_uint32 clk, e_uint32 rate); 85 | EMU2149_API void PSG_reset (PSG *); 86 | EMU2149_API void PSG_delete (PSG *); 87 | EMU2149_API void PSG_writeReg (PSG *, e_uint32 reg, e_uint32 val); 88 | EMU2149_API void PSG_writeIO (PSG * psg, e_uint32 adr, e_uint32 val); 89 | EMU2149_API e_uint8 PSG_readReg (PSG * psg, e_uint32 reg); 90 | EMU2149_API e_uint8 PSG_readIO (PSG * psg); 91 | EMU2149_API e_int16 PSG_calc (PSG *); 92 | EMU2149_API void PSG_calc_stereo (PSG * psg, e_int32 **out, e_int32 samples); 93 | EMU2149_API void PSG_setFlags (PSG * psg, e_uint8 flags); 94 | EMU2149_API void PSG_setVolumeMode (PSG * psg, int type); 95 | EMU2149_API e_uint32 PSG_setMask (PSG *, e_uint32 mask); 96 | EMU2149_API e_uint32 PSG_toggleMask (PSG *, e_uint32 mask); 97 | EMU2149_API void PSG_setStereoMask (PSG *psg, e_uint32 mask); 98 | 99 | /*#ifdef __cplusplus 100 | } 101 | #endif*/ 102 | 103 | #endif 104 | -------------------------------------------------------------------------------- /VGMPlay/chips/ym2151.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** File: ym2151.h - header file for software implementation of YM2151 3 | ** FM Operator Type-M(OPM) 4 | ** 5 | ** (c) 1997-2002 Jarek Burczynski (s0246@poczta.onet.pl, bujar@mame.net) 6 | ** Some of the optimizing ideas by Tatsuyuki Satoh 7 | ** 8 | ** Version 2.150 final beta May, 11th 2002 9 | ** 10 | ** 11 | ** I would like to thank following people for making this project possible: 12 | ** 13 | ** Beauty Planets - for making a lot of real YM2151 samples and providing 14 | ** additional informations about the chip. Also for the time spent making 15 | ** the samples and the speed of replying to my endless requests. 16 | ** 17 | ** Shigeharu Isoda - for general help, for taking time to scan his YM2151 18 | ** Japanese Manual first of all, and answering MANY of my questions. 19 | ** 20 | ** Nao - for giving me some info about YM2151 and pointing me to Shigeharu. 21 | ** Also for creating fmemu (which I still use to test the emulator). 22 | ** 23 | ** Aaron Giles and Chris Hardy - they made some samples of one of my favourite 24 | ** arcade games so I could compare it to my emulator. 25 | ** 26 | ** Bryan McPhail and Tim (powerjaw) - for making some samples. 27 | ** 28 | ** Ishmair - for the datasheet and motivation. 29 | */ 30 | 31 | #pragma once 32 | 33 | 34 | /* 16- and 8-bit samples (signed) are supported*/ 35 | #define SAMPLE_BITS 16 36 | 37 | typedef stream_sample_t SAMP; 38 | /* 39 | #if (SAMPLE_BITS==16) 40 | typedef INT16 SAMP; 41 | #endif 42 | #if (SAMPLE_BITS==8) 43 | typedef signed char SAMP; 44 | #endif 45 | */ 46 | 47 | /* 48 | ** Initialize YM2151 emulator(s). 49 | ** 50 | ** 'num' is the number of virtual YM2151's to allocate 51 | ** 'clock' is the chip clock in Hz 52 | ** 'rate' is sampling rate 53 | */ 54 | void *ym2151_init(int clock, int rate); 55 | 56 | /* shutdown the YM2151 emulators*/ 57 | void ym2151_shutdown(void *chip); 58 | 59 | /* reset all chip registers for YM2151 number 'num'*/ 60 | void ym2151_reset_chip(void *chip); 61 | 62 | /* 63 | ** Generate samples for one of the YM2151's 64 | ** 65 | ** 'num' is the number of virtual YM2151 66 | ** '**buffers' is table of pointers to the buffers: left and right 67 | ** 'length' is the number of samples that should be generated 68 | */ 69 | void ym2151_update_one(void *chip, SAMP **buffers, int length); 70 | 71 | /* write 'v' to register 'r' on YM2151 chip number 'n'*/ 72 | void ym2151_write_reg(void *chip, int r, int v); 73 | 74 | /* read status register on YM2151 chip number 'n'*/ 75 | int ym2151_read_status(void *chip); 76 | 77 | /* set interrupt handler on YM2151 chip number 'n'*/ 78 | //void ym2151_set_irq_handler(void *chip, void (*handler)(int irq)); 79 | 80 | /* set port write handler on YM2151 chip number 'n'*/ 81 | //void ym2151_set_port_write_handler(void *chip, write8_device_func handler); 82 | 83 | /* refresh chip when load state */ 84 | //STATE_POSTLOAD( ym2151_postload ); 85 | void ym2151_postload(void *param); 86 | 87 | void ym2151_set_mutemask(void *chip, UINT32 MuteMask); 88 | -------------------------------------------------------------------------------- /in_vgm/ini_func.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "stdbool.h" 5 | #include "chips/mamedef.h" // for (U)INTxx types 6 | 7 | extern char IniFilePath[MAX_PATH]; 8 | 9 | void ReadIni_Integer(const char* Section, const char* Key, UINT32* Value) 10 | { 11 | *Value = (INT32)GetPrivateProfileInt(Section, Key, *Value, IniFilePath); 12 | 13 | return; 14 | } 15 | 16 | void ReadIni_SIntSht(const char* Section, const char* Key, INT16* Value) 17 | { 18 | *Value = (INT16)GetPrivateProfileInt(Section, Key, *Value, IniFilePath); 19 | 20 | return; 21 | } 22 | 23 | void ReadIni_IntByte(const char* Section, const char* Key, UINT8* Value) 24 | { 25 | *Value = (UINT8)GetPrivateProfileInt(Section, Key, *Value, IniFilePath); 26 | 27 | return; 28 | } 29 | 30 | void ReadIni_Boolean(const char* Section, const char* Key, bool* Value) 31 | { 32 | char TempStr[0x10]; 33 | 34 | GetPrivateProfileString(Section, Key, "", TempStr, 0x10, IniFilePath); 35 | if (! strcmp(TempStr, "")) 36 | return; 37 | 38 | if (! stricmp(TempStr, "True")) 39 | *Value = true; 40 | else if (! stricmp(TempStr, "False")) 41 | *Value = false; 42 | else 43 | *Value = strtol(TempStr, NULL, 0) ? true : false; 44 | 45 | return; 46 | } 47 | 48 | void ReadIni_String(const char* Section, const char* Key, char* String, UINT32 StrSize) 49 | { 50 | GetPrivateProfileString(Section, Key, String, String, StrSize, IniFilePath); 51 | 52 | return; 53 | } 54 | 55 | void ReadIni_Float(const char* Section, const char* Key, float* Value) 56 | { 57 | char TempStr[0x10]; 58 | 59 | GetPrivateProfileString(Section, Key, "", TempStr, 0x10, IniFilePath); 60 | if (! strcmp(TempStr, "")) 61 | return; 62 | 63 | *Value = (float)strtod(TempStr, NULL); 64 | 65 | return; 66 | } 67 | 68 | 69 | 70 | void WriteIni_Integer(const char* Section, const char* Key, UINT32 Value) 71 | { 72 | char TempStr[0x10]; 73 | 74 | sprintf(TempStr, "%u", Value); 75 | WritePrivateProfileString(Section, Key, TempStr, IniFilePath); 76 | 77 | return; 78 | } 79 | 80 | void WriteIni_SInteger(const char* Section, const char* Key, INT32 Value) 81 | { 82 | char TempStr[0x10]; 83 | 84 | sprintf(TempStr, "%d", Value); 85 | WritePrivateProfileString(Section, Key, TempStr, IniFilePath); 86 | 87 | return; 88 | } 89 | 90 | void WriteIni_XInteger(const char* Section, const char* Key, UINT32 Value) 91 | { 92 | char TempStr[0x10]; 93 | 94 | sprintf(TempStr, "0x%02X", Value); 95 | WritePrivateProfileString(Section, Key, TempStr, IniFilePath); 96 | 97 | return; 98 | } 99 | 100 | void WriteIni_Boolean(const char* Section, const char* Key, bool Value) 101 | { 102 | char TempStr[0x10]; 103 | 104 | if (Value) 105 | strcpy(TempStr, "True"); 106 | else 107 | strcpy(TempStr, "False"); 108 | WritePrivateProfileString(Section, Key, TempStr, IniFilePath); 109 | 110 | return; 111 | } 112 | 113 | void WriteIni_String(const char* Section, const char* Key, char* String) 114 | { 115 | WritePrivateProfileString(Section, Key, String, IniFilePath); 116 | 117 | return; 118 | } 119 | 120 | void WriteIni_Float(const char* Section, const char* Key, float Value) 121 | { 122 | char TempStr[0x10]; 123 | 124 | sprintf(TempStr, "%f", Value); 125 | WritePrivateProfileString(Section, Key, TempStr, IniFilePath); 126 | 127 | return; 128 | } 129 | -------------------------------------------------------------------------------- /VGMPlay/chips/pokey.h: -------------------------------------------------------------------------------- 1 | /***************************************************************************** 2 | * 3 | * POKEY chip emulator 4.3 4 | * Copyright Nicola Salmoria and the MAME Team 5 | * 6 | * Based on original info found in Ron Fries' Pokey emulator, 7 | * with additions by Brad Oliver, Eric Smith and Juergen Buchmueller. 8 | * paddle (a/d conversion) details from the Atari 400/800 Hardware Manual. 9 | * Polynome algorithms according to info supplied by Perry McFarlane. 10 | * 11 | * This code is subject to the MAME license, which besides other 12 | * things means it is distributed as is, no warranties whatsoever. 13 | * For more details read mame.txt that comes with MAME. 14 | * 15 | *****************************************************************************/ 16 | 17 | #pragma once 18 | 19 | //#include "devlegcy.h" 20 | 21 | /* CONSTANT DEFINITIONS */ 22 | 23 | /* POKEY WRITE LOGICALS */ 24 | #define AUDF1_C 0x00 25 | #define AUDC1_C 0x01 26 | #define AUDF2_C 0x02 27 | #define AUDC2_C 0x03 28 | #define AUDF3_C 0x04 29 | #define AUDC3_C 0x05 30 | #define AUDF4_C 0x06 31 | #define AUDC4_C 0x07 32 | #define AUDCTL_C 0x08 33 | #define STIMER_C 0x09 34 | #define SKREST_C 0x0A 35 | #define POTGO_C 0x0B 36 | #define SEROUT_C 0x0D 37 | #define IRQEN_C 0x0E 38 | #define SKCTL_C 0x0F 39 | 40 | /* POKEY READ LOGICALS */ 41 | #define POT0_C 0x00 42 | #define POT1_C 0x01 43 | #define POT2_C 0x02 44 | #define POT3_C 0x03 45 | #define POT4_C 0x04 46 | #define POT5_C 0x05 47 | #define POT6_C 0x06 48 | #define POT7_C 0x07 49 | #define ALLPOT_C 0x08 50 | #define KBCODE_C 0x09 51 | #define RANDOM_C 0x0A 52 | #define SERIN_C 0x0D 53 | #define IRQST_C 0x0E 54 | #define SKSTAT_C 0x0F 55 | 56 | /* exact 1.79 MHz clock freq (of the Atari 800 that is) */ 57 | #define FREQ_17_EXACT 1789790 58 | 59 | 60 | /***************************************************************************** 61 | * pot0_r to pot7_r: 62 | * Handlers for reading the pot values. Some Atari games use 63 | * ALLPOT to return dipswitch settings and other things. 64 | * serin_r, serout_w, interrupt_cb: 65 | * New function pointers for serial input/output and a interrupt callback. 66 | *****************************************************************************/ 67 | 68 | /*typedef struct _pokey_interface pokey_interface; 69 | struct _pokey_interface 70 | { 71 | devcb_read8 pot_r[8]; 72 | devcb_read8 allpot_r; 73 | devcb_read8 serin_r; 74 | devcb_write8 serout_w; 75 | void (*interrupt_cb)(device_t *device, int mask); 76 | };*/ 77 | 78 | 79 | void pokey_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 80 | int device_start_pokey(UINT8 ChipID, int clock); 81 | void device_stop_pokey(UINT8 ChipID); 82 | void device_reset_pokey(UINT8 ChipID); 83 | 84 | //READ8_DEVICE_HANDLER( pokey_r ); 85 | //WRITE8_DEVICE_HANDLER( pokey_w ); 86 | UINT8 pokey_r(UINT8 ChipID, offs_t offset); 87 | void pokey_w(UINT8 ChipID, offs_t offset, UINT8 data); 88 | 89 | /* fix me: eventually this should be a single device with pokey subdevices */ 90 | //READ8_HANDLER( quad_pokey_r ); 91 | //WRITE8_HANDLER( quad_pokey_w ); 92 | 93 | /*void pokey_serin_ready (device_t *device, int after); 94 | void pokey_break_w (device_t *device, int shift); 95 | void pokey_kbcode_w (device_t *device, int kbcode, int make);*/ 96 | 97 | void pokey_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 98 | 99 | //DECLARE_LEGACY_SOUND_DEVICE(POKEY, pokey); 100 | -------------------------------------------------------------------------------- /VGMPlay/chips/ymdeltat.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define YM_DELTAT_SHIFT (16) 4 | 5 | #define YM_DELTAT_EMULATION_MODE_NORMAL 0 6 | #define YM_DELTAT_EMULATION_MODE_YM2610 1 7 | 8 | 9 | typedef void (*STATUS_CHANGE_HANDLER)(void *chip, UINT8 status_bits); 10 | 11 | 12 | /* DELTA-T (adpcm type B) struct */ 13 | typedef struct deltat_adpcm_state { /* AT: rearranged and tigntened structure */ 14 | UINT8 *memory; 15 | INT32 *output_pointer;/* pointer of output pointers */ 16 | INT32 *pan; /* pan : &output_pointer[pan] */ 17 | double freqbase; 18 | #if 0 19 | double write_time; /* Y8950: 10 cycles of main clock; YM2608: 20 cycles of main clock */ 20 | double read_time; /* Y8950: 8 cycles of main clock; YM2608: 18 cycles of main clock */ 21 | #endif 22 | UINT32 memory_size; 23 | UINT32 memory_mask; 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 | void * 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 device_config *device,YM_DELTAT *DELTAT); 81 | void YM_DELTAT_savestate(YM_DELTAT *DELTAT);*/ 82 | 83 | void YM_DELTAT_calc_mem_mask(YM_DELTAT* DELTAT); -------------------------------------------------------------------------------- /VGMPlay/VGMFile.h: -------------------------------------------------------------------------------- 1 | // Header file for VGM file handling 2 | 3 | typedef struct _vgm_file_header 4 | { 5 | UINT32 fccVGM; 6 | UINT32 lngEOFOffset; 7 | UINT32 lngVersion; 8 | UINT32 lngHzPSG; 9 | UINT32 lngHzYM2413; 10 | UINT32 lngGD3Offset; 11 | UINT32 lngTotalSamples; 12 | UINT32 lngLoopOffset; 13 | UINT32 lngLoopSamples; 14 | UINT32 lngRate; 15 | UINT16 shtPSG_Feedback; 16 | UINT8 bytPSG_SRWidth; 17 | UINT8 bytPSG_Flags; 18 | UINT32 lngHzYM2612; 19 | UINT32 lngHzYM2151; 20 | UINT32 lngDataOffset; 21 | UINT32 lngHzSPCM; 22 | UINT32 lngSPCMIntf; 23 | UINT32 lngHzRF5C68; 24 | UINT32 lngHzYM2203; 25 | UINT32 lngHzYM2608; 26 | UINT32 lngHzYM2610; 27 | UINT32 lngHzYM3812; 28 | UINT32 lngHzYM3526; 29 | UINT32 lngHzY8950; 30 | UINT32 lngHzYMF262; 31 | UINT32 lngHzYMF278B; 32 | UINT32 lngHzYMF271; 33 | UINT32 lngHzYMZ280B; 34 | UINT32 lngHzRF5C164; 35 | UINT32 lngHzPWM; 36 | UINT32 lngHzAY8910; 37 | UINT8 bytAYType; 38 | UINT8 bytAYFlag; 39 | UINT8 bytAYFlagYM2203; 40 | UINT8 bytAYFlagYM2608; 41 | UINT8 bytVolumeModifier; 42 | UINT8 bytReserved2; 43 | INT8 bytLoopBase; 44 | UINT8 bytLoopModifier; 45 | UINT32 lngHzGBDMG; 46 | UINT32 lngHzNESAPU; 47 | UINT32 lngHzMultiPCM; 48 | UINT32 lngHzUPD7759; 49 | UINT32 lngHzOKIM6258; 50 | UINT8 bytOKI6258Flags; 51 | UINT8 bytK054539Flags; 52 | UINT8 bytC140Type; 53 | UINT8 bytReservedFlags; 54 | UINT32 lngHzOKIM6295; 55 | UINT32 lngHzK051649; 56 | UINT32 lngHzK054539; 57 | UINT32 lngHzHuC6280; 58 | UINT32 lngHzC140; 59 | UINT32 lngHzK053260; 60 | UINT32 lngHzPokey; 61 | UINT32 lngHzQSound; 62 | UINT32 lngHzSCSP; 63 | // UINT32 lngHzOKIM6376; 64 | //UINT8 bytReserved[0x04]; 65 | UINT32 lngExtraOffset; 66 | UINT32 lngHzWSwan; 67 | UINT32 lngHzVSU; 68 | UINT32 lngHzSAA1099; 69 | UINT32 lngHzES5503; 70 | UINT32 lngHzES5506; 71 | UINT8 bytES5503Chns; 72 | UINT8 bytES5506Chns; 73 | UINT8 bytC352ClkDiv; 74 | UINT8 bytESReserved; 75 | UINT32 lngHzX1_010; 76 | UINT32 lngHzC352; 77 | UINT32 lngHzGA20; 78 | } VGM_HEADER; 79 | typedef struct _vgm_header_extra 80 | { 81 | UINT32 DataSize; 82 | UINT32 Chp2ClkOffset; 83 | UINT32 ChpVolOffset; 84 | } VGM_HDR_EXTRA; 85 | typedef struct _vgm_extra_chip_data32 86 | { 87 | UINT8 Type; 88 | UINT32 Data; 89 | } VGMX_CHIP_DATA32; 90 | typedef struct _vgm_extra_chip_data16 91 | { 92 | UINT8 Type; 93 | UINT8 Flags; 94 | UINT16 Data; 95 | } VGMX_CHIP_DATA16; 96 | typedef struct _vgm_extra_chip_extra32 97 | { 98 | UINT8 ChipCnt; 99 | VGMX_CHIP_DATA32* CCData; 100 | } VGMX_CHP_EXTRA32; 101 | typedef struct _vgm_extra_chip_extra16 102 | { 103 | UINT8 ChipCnt; 104 | VGMX_CHIP_DATA16* CCData; 105 | } VGMX_CHP_EXTRA16; 106 | typedef struct _vgm_header_extra_data 107 | { 108 | VGMX_CHP_EXTRA32 Clocks; 109 | VGMX_CHP_EXTRA16 Volumes; 110 | } VGM_EXTRA; 111 | 112 | #define VOLUME_MODIF_WRAP 0xC0 113 | typedef struct _vgm_gd3_tag 114 | { 115 | UINT32 fccGD3; 116 | UINT32 lngVersion; 117 | UINT32 lngTagLength; 118 | wchar_t* strTrackNameE; 119 | wchar_t* strTrackNameJ; 120 | wchar_t* strGameNameE; 121 | wchar_t* strGameNameJ; 122 | wchar_t* strSystemNameE; 123 | wchar_t* strSystemNameJ; 124 | wchar_t* strAuthorNameE; 125 | wchar_t* strAuthorNameJ; 126 | wchar_t* strReleaseDate; 127 | wchar_t* strCreator; 128 | wchar_t* strNotes; 129 | } GD3_TAG; 130 | typedef struct _vgm_pcm_bank_data 131 | { 132 | UINT32 DataSize; 133 | UINT8* Data; 134 | UINT32 DataStart; 135 | } VGM_PCM_DATA; 136 | typedef struct _vgm_pcm_bank 137 | { 138 | UINT32 BankCount; 139 | VGM_PCM_DATA* Bank; 140 | UINT32 DataSize; 141 | UINT8* Data; 142 | UINT32 DataPos; 143 | UINT32 BnkPos; 144 | } VGM_PCM_BANK; 145 | 146 | #define FCC_VGM 0x206D6756 // 'Vgm ' 147 | #define FCC_GD3 0x20336447 // 'Gd3 ' 148 | -------------------------------------------------------------------------------- /VGMPlay/chips/c6280intf.c: -------------------------------------------------------------------------------- 1 | #include // for NULL 2 | #include "mamedef.h" 3 | #ifdef ENABLE_ALL_CORES 4 | #include "c6280.h" 5 | #endif 6 | #include "Ootake_PSG.h" 7 | 8 | #ifdef ENABLE_ALL_CORES 9 | #define EC_MAME 0x01 10 | #endif 11 | #define EC_OOTAKE 0x00 12 | 13 | typedef struct _c6280_state 14 | { 15 | void* chip; 16 | } c6280_state; 17 | 18 | extern UINT32 SampleRate; 19 | extern UINT8 CHIP_SAMPLING_MODE; 20 | extern INT32 CHIP_SAMPLE_RATE; 21 | static UINT8 EMU_CORE = 0x00; 22 | 23 | #define MAX_CHIPS 0x02 24 | static c6280_state C6280Data[MAX_CHIPS]; 25 | 26 | void c6280_update(UINT8 ChipID, stream_sample_t **outputs, int samples) 27 | { 28 | c6280_state* info = &C6280Data[ChipID]; 29 | switch(EMU_CORE) 30 | { 31 | #ifdef ENABLE_ALL_CORES 32 | case EC_MAME: 33 | c6280m_update(info->chip, outputs, samples); 34 | break; 35 | #endif 36 | case EC_OOTAKE: 37 | PSG_Mix(info->chip, outputs, samples); 38 | break; 39 | } 40 | } 41 | 42 | int device_start_c6280(UINT8 ChipID, int clock) 43 | { 44 | c6280_state* info; 45 | int rate = 0; 46 | 47 | if (ChipID >= MAX_CHIPS) 48 | return 0; 49 | 50 | info = &C6280Data[ChipID]; 51 | switch(EMU_CORE) 52 | { 53 | #ifdef ENABLE_ALL_CORES 54 | case EC_MAME: 55 | rate = (clock & 0x7FFFFFFF)/16; 56 | if (((CHIP_SAMPLING_MODE & 0x01) && rate < CHIP_SAMPLE_RATE) || 57 | CHIP_SAMPLING_MODE == 0x02) 58 | rate = CHIP_SAMPLE_RATE; 59 | 60 | info->chip = device_start_c6280m(clock, rate); 61 | if (info->chip == NULL) 62 | return 0; 63 | break; 64 | #endif 65 | case EC_OOTAKE: 66 | rate = SampleRate; 67 | info->chip = PSG_Init(clock, rate); 68 | if (info->chip == NULL) 69 | return 0; 70 | break; 71 | } 72 | 73 | return rate; 74 | } 75 | 76 | void device_stop_c6280(UINT8 ChipID) 77 | { 78 | c6280_state* info = &C6280Data[ChipID]; 79 | switch(EMU_CORE) 80 | { 81 | #ifdef ENABLE_ALL_CORES 82 | case EC_MAME: 83 | device_stop_c6280m(info->chip); 84 | break; 85 | #endif 86 | case EC_OOTAKE: 87 | PSG_Deinit(info->chip); 88 | break; 89 | } 90 | info->chip = NULL; 91 | 92 | return; 93 | } 94 | 95 | void device_reset_c6280(UINT8 ChipID) 96 | { 97 | c6280_state* info = &C6280Data[ChipID]; 98 | switch(EMU_CORE) 99 | { 100 | #ifdef ENABLE_ALL_CORES 101 | case EC_MAME: 102 | device_reset_c6280m(info->chip); 103 | break; 104 | #endif 105 | case EC_OOTAKE: 106 | PSG_ResetVolumeReg(info->chip); 107 | break; 108 | } 109 | return; 110 | } 111 | 112 | UINT8 c6280_r(UINT8 ChipID, offs_t offset) 113 | { 114 | c6280_state* info = &C6280Data[ChipID]; 115 | switch(EMU_CORE) 116 | { 117 | #ifdef ENABLE_ALL_CORES 118 | case EC_MAME: 119 | return c6280m_r(info->chip, offset); 120 | #endif 121 | case EC_OOTAKE: 122 | return PSG_Read(info->chip, offset); 123 | default: 124 | return 0x00; 125 | } 126 | } 127 | 128 | void c6280_w(UINT8 ChipID, offs_t offset, UINT8 data) 129 | { 130 | c6280_state* info = &C6280Data[ChipID]; 131 | switch(EMU_CORE) 132 | { 133 | #ifdef ENABLE_ALL_CORES 134 | case EC_MAME: 135 | c6280m_w(info->chip, offset, data); 136 | break; 137 | #endif 138 | case EC_OOTAKE: 139 | PSG_Write(info->chip, offset, data); 140 | break; 141 | } 142 | 143 | return; 144 | } 145 | 146 | 147 | void c6280_set_emu_core(UINT8 Emulator) 148 | { 149 | #ifdef ENABLE_ALL_CORES 150 | EMU_CORE = (Emulator < 0x02) ? Emulator : 0x00; 151 | #else 152 | EMU_CORE = EC_OOTAKE; 153 | #endif 154 | 155 | return; 156 | } 157 | 158 | void c6280_set_mute_mask(UINT8 ChipID, UINT32 MuteMask) 159 | { 160 | c6280_state* info = &C6280Data[ChipID]; 161 | switch(EMU_CORE) 162 | { 163 | #ifdef ENABLE_ALL_CORES 164 | case EC_MAME: 165 | c6280m_set_mute_mask(info->chip, MuteMask); 166 | break; 167 | #endif 168 | case EC_OOTAKE: 169 | PSG_SetMuteMask(info->chip, MuteMask); 170 | break; 171 | } 172 | 173 | return; 174 | } 175 | -------------------------------------------------------------------------------- /VGMPlay/chips/sn76489.h: -------------------------------------------------------------------------------- 1 | #ifndef _SN76489_H_ 2 | #define _SN76489_H_ 3 | 4 | // all these defines are defined in mamedef.h, but GCC's #ifdef doesn't seem to know typedefs 5 | /*#ifndef INT32 6 | #define INT32 signed long 7 | #endif 8 | #ifndef UINT16 9 | #define UINT16 unsigned short 10 | #endif 11 | #ifndef INT16 12 | #define INT16 signed short 13 | #endif 14 | #ifndef INT8 15 | #define INT8 signed char 16 | #endif*/ 17 | #ifndef uint8 18 | #define uint8 signed char 19 | #endif 20 | 21 | 22 | /*#define MAX_SN76489 4*/ 23 | 24 | /* 25 | More testing is needed to find and confirm feedback patterns for 26 | SN76489 variants and compatible chips. 27 | */ 28 | enum feedback_patterns { 29 | FB_BBCMICRO = 0x8005, /* Texas Instruments TMS SN76489N (original) from BBC Micro computer */ 30 | FB_SC3000 = 0x0006, /* Texas Instruments TMS SN76489AN (rev. A) from SC-3000H computer */ 31 | FB_SEGAVDP = 0x0009, /* SN76489 clone in Sega's VDP chips (315-5124, 315-5246, 315-5313, Game Gear) */ 32 | }; 33 | 34 | enum sr_widths { 35 | SRW_SC3000BBCMICRO = 15, 36 | SRW_SEGAVDP = 16 37 | }; 38 | 39 | enum volume_modes { 40 | VOL_TRUNC = 0, /* Volume levels 13-15 are identical */ 41 | VOL_FULL = 1, /* Volume levels 13-15 are unique */ 42 | }; 43 | 44 | enum mute_values { 45 | MUTE_ALLOFF = 0, /* All channels muted */ 46 | MUTE_TONE1 = 1, /* Tone 1 mute control */ 47 | MUTE_TONE2 = 2, /* Tone 2 mute control */ 48 | MUTE_TONE3 = 4, /* Tone 3 mute control */ 49 | MUTE_NOISE = 8, /* Noise mute control */ 50 | MUTE_ALLON = 15, /* All channels enabled */ 51 | }; 52 | 53 | typedef struct 54 | { 55 | int Mute; // per-channel muting 56 | int BoostNoise; // double noise volume when non-zero 57 | 58 | /* Variables */ 59 | float Clock; 60 | float dClock; 61 | int PSGStereo; 62 | int NumClocksForSample; 63 | int WhiteNoiseFeedback; 64 | int SRWidth; 65 | 66 | /* PSG registers: */ 67 | int Registers[8]; /* Tone, vol x4 */ 68 | int LatchedRegister; 69 | int NoiseShiftRegister; 70 | int NoiseFreq; /* Noise channel signal generator frequency */ 71 | 72 | /* Output calculation variables */ 73 | int ToneFreqVals[4]; /* Frequency register values (counters) */ 74 | int ToneFreqPos[4]; /* Frequency channel flip-flops */ 75 | int Channels[4]; /* Value of each channel, before stereo is applied */ 76 | float IntermediatePos[4]; /* intermediate values used at boundaries between + and - (does not need double accuracy)*/ 77 | 78 | float panning[4][2]; /* fake stereo */ 79 | 80 | int NgpFlags; /* bit 7 - NGP Mode on/off, bit 0 - is 2nd NGP chip */ 81 | void* NgpChip2; 82 | } SN76489_Context; 83 | 84 | /* Function prototypes */ 85 | SN76489_Context* SN76489_Init(int PSGClockValue, int SamplingRate); 86 | void SN76489_Reset(SN76489_Context* chip); 87 | void SN76489_Shutdown(SN76489_Context* chip); 88 | void SN76489_Config(SN76489_Context* chip, /*int mute,*/ int feedback, int sw_width, int boost_noise); 89 | /* 90 | void SN76489_SetContext(SN76489_Context* chip, uint8 *data); 91 | void SN76489_GetContext(SN76489_Context* chip, uint8 *data); 92 | uint8 *SN76489_GetContextPtr(int chip); 93 | int SN76489_GetContextSize(void);*/ 94 | void SN76489_Write(SN76489_Context* chip, int data); 95 | void SN76489_GGStereoWrite(SN76489_Context* chip, int data); 96 | //void SN76489_Update(SN76489_Context* chip, INT16 **buffer, int length); 97 | void SN76489_Update(SN76489_Context* chip, INT32 **buffer, int length); 98 | 99 | /* Non-standard getters and setters */ 100 | //int SN76489_GetMute(SN76489_Context* chip); 101 | void SN76489_SetMute(SN76489_Context* chip, int val); 102 | 103 | void SN76489_SetPanning(SN76489_Context* chip, int ch0, int ch1, int ch2, int ch3); 104 | 105 | /* and a non-standard data getter */ 106 | //void SN76489_UpdateOne(SN76489_Context* chip, int *l, int *r); 107 | 108 | #endif /* _SN76489_H_ */ 109 | -------------------------------------------------------------------------------- /VGMPlay/chips/scsplfo.c: -------------------------------------------------------------------------------- 1 | /* 2 | SCSP LFO handling 3 | 4 | Part of the SCSP (YMF292-F) emulator package. 5 | (not compiled directly, #included from scsp.c) 6 | 7 | By ElSemi 8 | MAME/M1 conversion and cleanup by R. Belmont 9 | */ 10 | 11 | #define LFO_SHIFT 8 12 | 13 | struct _LFO 14 | { 15 | unsigned short phase; 16 | UINT32 phase_step; 17 | int *table; 18 | int *scale; 19 | }; 20 | 21 | #define LFIX(v) ((unsigned int) ((float) (1<phase+=LFO->phase_step; 119 | #if LFO_SHIFT!=8 120 | LFO->phase&=(1<<(LFO_SHIFT+8))-1; 121 | #endif 122 | p=LFO->table[LFO->phase>>LFO_SHIFT]; 123 | p=LFO->scale[p+128]; 124 | return p<<(SHIFT-LFO_SHIFT); 125 | } 126 | 127 | INLINE signed int ALFO_Step(struct _LFO *LFO) 128 | { 129 | int p; 130 | LFO->phase+=LFO->phase_step; 131 | #if LFO_SHIFT!=8 132 | LFO->phase&=(1<<(LFO_SHIFT+8))-1; 133 | #endif 134 | p=LFO->table[LFO->phase>>LFO_SHIFT]; 135 | p=LFO->scale[p]; 136 | return p<<(SHIFT-LFO_SHIFT); 137 | } 138 | 139 | static void LFO_ComputeStep(struct _LFO *LFO,UINT32 LFOF,UINT32 LFOWS,UINT32 LFOS,int ALFO) 140 | { 141 | float step=(float) LFOFreq[LFOF]*256.0/(float)44100; 142 | LFO->phase_step=(unsigned int) ((float) (1<table=ALFO_SAW; break; 148 | case 1: LFO->table=ALFO_SQR; break; 149 | case 2: LFO->table=ALFO_TRI; break; 150 | case 3: LFO->table=ALFO_NOI; break; 151 | } 152 | LFO->scale=ASCALES[LFOS]; 153 | } 154 | else 155 | { 156 | switch(LFOWS) 157 | { 158 | case 0: LFO->table=PLFO_SAW; break; 159 | case 1: LFO->table=PLFO_SQR; break; 160 | case 2: LFO->table=PLFO_TRI; break; 161 | case 3: LFO->table=PLFO_NOI; break; 162 | } 163 | LFO->scale=PSCALES[LFOS]; 164 | } 165 | } 166 | -------------------------------------------------------------------------------- /VGMPlay/vgm2pcm.c: -------------------------------------------------------------------------------- 1 | #define _GNU_SOURCE 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #ifdef WIN32 8 | #include 9 | #else 10 | #include 11 | #define MAX_PATH PATH_MAX 12 | #include 13 | #include 14 | #endif 15 | 16 | #ifdef WIN32 17 | #define DIR_CHR '\\' 18 | #define DIR_STR "\\" 19 | #define QMARK_CHR '\"' 20 | #else 21 | #define DIR_CHR '/' 22 | #define DIR_STR "/" 23 | #define QMARK_CHR '\'' 24 | #endif 25 | 26 | #include "chips/mamedef.h" 27 | #include "stdbool.h" 28 | #include "VGMPlay.h" 29 | #include "VGMPlay_Intf.h" 30 | 31 | #define SAMPLESIZE sizeof(WAVE_16BS) 32 | 33 | UINT8 CmdList[0x100]; // used by VGMPlay.c and VGMPlay_AddFmts.c 34 | bool ErrorHappened; // used by VGMPlay.c and VGMPlay_AddFmts.c 35 | extern VGM_HEADER VGMHead; 36 | extern UINT32 SampleRate; 37 | extern UINT32 VGMMaxLoopM; 38 | extern UINT32 FadeTime; 39 | extern bool EndPlay; 40 | extern char *AppPaths[8]; 41 | static char AppPathBuffer[MAX_PATH * 2]; 42 | 43 | static char* GetAppFileName(void) 44 | { 45 | char* AppPath; 46 | int RetVal; 47 | 48 | AppPath = (char*)malloc(MAX_PATH * sizeof(char)); 49 | #ifdef WIN32 50 | RetVal = GetModuleFileName(NULL, AppPath, MAX_PATH); 51 | if (! RetVal) 52 | AppPath[0] = '\0'; 53 | #else 54 | RetVal = readlink("/proc/self/exe", AppPath, MAX_PATH); 55 | if (RetVal == -1) 56 | AppPath[0] = '\0'; 57 | #endif 58 | 59 | return AppPath; 60 | } 61 | 62 | INLINE int fputBE16(UINT16 Value, FILE* hFile) 63 | { 64 | int RetVal; 65 | int ResVal; 66 | 67 | RetVal = fputc((Value & 0xFF00) >> 8, hFile); 68 | RetVal = fputc((Value & 0x00FF) >> 0, hFile); 69 | ResVal = (RetVal != EOF) ? 0x02 : 0x00; 70 | return ResVal; 71 | } 72 | 73 | int main(int argc, char *argv[]) { 74 | UINT8 result; 75 | WAVE_16BS *sampleBuffer; 76 | UINT32 bufferedLength; 77 | FILE *outputFile; 78 | char *AppName; 79 | char* AppPathPtr; 80 | const char *StrPtr; 81 | UINT8 CurPath; 82 | UINT32 ChrPos; 83 | 84 | if (argc < 3) { 85 | fputs("usage: vgm2pcm vgm_file pcm_file\n", stderr); 86 | return 1; 87 | } 88 | 89 | VGMPlay_Init(); 90 | // Path 2: exe's directory 91 | AppPathPtr = AppPathBuffer; 92 | AppName = GetAppFileName(); // "C:\VGMPlay\VGMPlay.exe" 93 | // Note: GetAppFileName always returns native directory separators. 94 | StrPtr = strrchr(AppName, DIR_CHR); 95 | if (StrPtr != NULL) 96 | { 97 | ChrPos = StrPtr + 1 - AppName; 98 | strncpy(AppPathPtr, AppName, ChrPos); 99 | AppPathPtr[ChrPos] = 0x00; // "C:\VGMPlay\" 100 | AppPaths[CurPath] = AppPathPtr; 101 | CurPath ++; 102 | AppPathPtr += ChrPos + 1; 103 | } 104 | VGMPlay_Init2(); 105 | 106 | if (!OpenVGMFile(argv[1])) { 107 | fprintf(stderr, "vgm2pcm: error: failed to open vgm_file (%s)\n", argv[1]); 108 | return 1; 109 | } 110 | 111 | if(!strcmp(argv[2], "-")) { 112 | outputFile = stdout; 113 | } else { 114 | outputFile = fopen(argv[2], "wb"); 115 | if (outputFile == NULL) { 116 | fprintf(stderr, "vgm2pcm: error: failed to open pcm_file (%s)\n", argv[2]); 117 | return 1; 118 | } 119 | } 120 | 121 | PlayVGM(); 122 | 123 | sampleBuffer = (WAVE_16BS*)malloc(SAMPLESIZE * SampleRate); 124 | if (sampleBuffer == NULL) { 125 | fprintf(stderr, "vgm2pcm: error: failed to allocate %lu bytes of memory\n", SAMPLESIZE * SampleRate); 126 | return 1; 127 | } 128 | 129 | while (!EndPlay) { 130 | UINT32 bufferSize = SampleRate; 131 | bufferedLength = FillBuffer(sampleBuffer, bufferSize); 132 | if (bufferedLength) { 133 | UINT32 numberOfSamples; 134 | UINT32 currentSample; 135 | const UINT16* sampleData; 136 | 137 | sampleData = (UINT16*)sampleBuffer; 138 | numberOfSamples = SAMPLESIZE * bufferedLength / 0x02; 139 | for (currentSample = 0x00; currentSample < numberOfSamples; currentSample++) { 140 | fputBE16(sampleData[currentSample], outputFile); 141 | } 142 | } 143 | } 144 | 145 | StopVGM(); 146 | 147 | CloseVGMFile(); 148 | 149 | VGMPlay_Deinit(); 150 | 151 | return 0; 152 | } 153 | -------------------------------------------------------------------------------- /VGMPlay/vgmplay.1: -------------------------------------------------------------------------------- 1 | .TH vgmplay "1" "November 10" "Valley Bell" "User Commands" 2 | .nh 3 | .SH NAME 4 | vgmplay \- the official and always up-to-date player for all VGM files 5 | .SH SYNOPSIS 6 | \fBvgmplay\fP file 7 | .SH KEYS 8 | Cursor Left/Right - Seek 5 seconds backward/forward 9 | .PP 10 | Ctrl + Cursor Left/Right - Seek 1 minute backward/forward 11 | .PP 12 | Space - Pause 13 | .PP 14 | ESC/Q - Quit the program 15 | .PP 16 | F - Fade out 17 | .PP 18 | R - Restart current Track 19 | .PP 20 | PageUp/B - Previous Track 21 | .PP 22 | PageDown/N - Next Track 23 | .SH SUPPORTED FILETYPES 24 | Video Game Music Files (.vgm, .vgz) 25 | .PP 26 | Creative Music Files (.cmf) 27 | .PP 28 | DosBox RAW OPL Log Files (.dro) 29 | .PP 30 | Playlist files (.m3u) 31 | .SH SUPPORTED CHIPS 32 | .PP 33 | SN76496 (2) (Sega PSG) and T6W28 (2) (NeoGeo Pocket custom) 34 | .PP 35 | YM2413 (1) (OPLL) 36 | .PP 37 | YM2612 (OPN2) 38 | .PP 39 | YM2151 (OPM) 40 | .PP 41 | SegaPCM 42 | .PP 43 | RF5C68 44 | .PP 45 | YM2203 (OPN) 46 | .PP 47 | YM2608 (OPNA) 48 | .PP 49 | YM2610/B (OPNB) 50 | .PP 51 | YM3812 (1) (OPL2) 52 | .PP 53 | YM3526 (1) (OPL) 54 | .PP 55 | Y8950 (1) (MSX AUDIO) 56 | .PP 57 | YMF262 (1) (OP3) 58 | .PP 59 | YMF278B (3) (OPL4) 60 | .PP 61 | YMF271 (OPLX) 62 | .PP 63 | YMZ280B 64 | .PP 65 | RF5C164 (Sega MegaCD PCM) 66 | .PP 67 | PWM (from Sega 32x) 68 | .PP 69 | AY8910 (MSX PSG) 70 | .PP 71 | GameBoy DMG 72 | .PP 73 | NES APU (incl. FDS) 74 | .PP 75 | MultiPCM 76 | .PP 77 | UPD7759 78 | .PP 79 | OKI6258 (Sharp X68000 ADPCM) 80 | .PP 81 | OKI6295 82 | .PP 83 | K051649 84 | .PP 85 | K054539 86 | .PP 87 | HuC6280 (PC Engine) 88 | .PP 89 | C140 90 | .PP 91 | K053260 92 | .PP 93 | Pokey (Atari) 94 | .PP 95 | QSound 96 | .PP 97 | SCSP (Saturn Custom Sound Processor, YMF292-F) 98 | .PP 99 | (1) This chip can be emulated via OPL Hardware (like Soundblaster sound cards). 100 | .PP 101 | (2) OPL hardware emulation is available, but software emulation is prefered. Hardware emulation is used if another chip activates HW emulation or FMForce is True. 102 | (3) You need a sample ROM, called yrw801.rom, to make playback work. Place it in the directory where vgmplay lies or in /usr/local/share/vgmplay/. 103 | .PP 104 | OPL hardware emulation can be enabled by setting the "FMPort"-entry in the ini-file. 105 | Under Linux the program must be run as root to use hardware FM. 106 | .PP 107 | It's possible to write Wave files by editing the "LogSound"-line in the ini-file. 108 | Batch conversions are possible by opening a playlist. 109 | FM hardware cannot be logged to Wave files. 110 | .SH CONFIGURATION 111 | vgmplay is configured in the file VGMPlay.ini, which should be located in $XDG_CONFIG_HOME/vgmplay (thus, by default ~/.config/vgmplay/VGMPlay.ini). A sample configuration /usr/share/vgmplay/VGMPlay.ini is available for copying and general reference. 112 | .SH BUGS 113 | PauseEmulation is disabled under Linux if no FM Hardware is used. 114 | .PP 115 | You have to double-tap ESC to quit the program. 116 | .PP 117 | Sometimes MAME's sound cores tend to sound strange. 118 | .SH COMMENTS 119 | The T6W28 doesn't use MAME's T6W28 core. Instead the SN76496 core is modified to emulate the T6W28 with 2 SN76496 chips. 120 | The SN76496 OPL emulation is okay, but it's impossible to get the noise sound right. 121 | .PP 122 | EMU2413 Emulator was added, because sometimes the one of MAME sounds strange. 123 | The Gens YM2612 core was added for the same reason before MAME's YM2612 core was fixed. 124 | .PP 125 | .SH AUTHORS 126 | This program was written by Valley Bell. 127 | .PP 128 | Almost all software emulators are from MAME (http://mamedev.org) 129 | .PP 130 | EMU2413 and Gens YM2612 were ported from Maxim's in_vgm 131 | .PP 132 | The YMF278B core was ported from openMSX 133 | .PP 134 | zlib compression by Jean-loup Gailly and Mark Adler is used 135 | .PP 136 | All custom OPL Mappers were written using MAME software emulators and the OPL2/3 programming guides by Jeffrey S. Lee and Vladimir Arnost 137 | .PP 138 | one YM2413 OPL Mapper was ported from MEKA. 139 | .PP 140 | The RF5C164 and PWM cores were ported from Gens/GS 141 | .PP 142 | The MAME YM2612 core was fixed with the help of Blargg's MAME YM2612 fix and Genesis Plus GX' YM2612 core 143 | .PP 144 | AdLibEmu (OPL2 and OPL3 core) was ported from DOSBox 145 | .PP 146 | The default HuC6280 core is from Ootake. 147 | .PP 148 | EMU2149, the alternative NES APU core and the NES FDS core were ported from rainwarrior's NSFPlay. 149 | -------------------------------------------------------------------------------- /VGMPlay/chips/ay_intf.c: -------------------------------------------------------------------------------- 1 | /**************************************************************** 2 | 3 | MAME / MESS functions 4 | 5 | ****************************************************************/ 6 | 7 | #include // for free 8 | #include // for memset 9 | #include // for NULL 10 | #include "mamedef.h" 11 | //#include "sndintrf.h" 12 | //#include "streams.h" 13 | #include "ay8910.h" // must be always included (for YM2149_PIN26_LOW) 14 | #include "emu2149.h" 15 | #include "ay_intf.h" 16 | 17 | 18 | #ifdef ENABLE_ALL_CORES 19 | #define EC_MAME 0x01 // AY8910 core from MAME 20 | #endif 21 | #define EC_EMU2149 0x00 // EMU2149 from NSFPlay 22 | 23 | 24 | /* for stream system */ 25 | typedef struct _ayxx_state ayxx_state; 26 | struct _ayxx_state 27 | { 28 | void *chip; 29 | }; 30 | 31 | extern UINT8 CHIP_SAMPLING_MODE; 32 | extern INT32 CHIP_SAMPLE_RATE; 33 | static UINT8 EMU_CORE = 0x00; 34 | 35 | extern UINT32 SampleRate; 36 | #define MAX_CHIPS 0x02 37 | static ayxx_state AYxxData[MAX_CHIPS]; 38 | 39 | void ayxx_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples) 40 | { 41 | ayxx_state *info = &AYxxData[ChipID]; 42 | switch(EMU_CORE) 43 | { 44 | #ifdef ENABLE_ALL_CORES 45 | case EC_MAME: 46 | ay8910_update_one(info->chip, outputs, samples); 47 | break; 48 | #endif 49 | case EC_EMU2149: 50 | PSG_calc_stereo((PSG*)info->chip, outputs, samples); 51 | break; 52 | } 53 | } 54 | 55 | int device_start_ayxx(UINT8 ChipID, int clock, UINT8 chip_type, UINT8 Flags) 56 | { 57 | ayxx_state *info; 58 | int rate; 59 | 60 | if (ChipID >= MAX_CHIPS) 61 | return 0; 62 | 63 | info = &AYxxData[ChipID]; 64 | if (Flags & YM2149_PIN26_LOW) 65 | rate = clock / 16; 66 | else 67 | rate = clock / 8; 68 | if (((CHIP_SAMPLING_MODE & 0x01) && rate < CHIP_SAMPLE_RATE) || 69 | CHIP_SAMPLING_MODE == 0x02) 70 | rate = CHIP_SAMPLE_RATE; 71 | 72 | switch(EMU_CORE) 73 | { 74 | #ifdef ENABLE_ALL_CORES 75 | case EC_MAME: 76 | rate = ay8910_start(&info->chip, clock, chip_type, Flags); 77 | break; 78 | #endif 79 | case EC_EMU2149: 80 | if (Flags & YM2149_PIN26_LOW) 81 | clock /= 2; 82 | info->chip = PSG_new(clock, rate); 83 | if (info->chip == NULL) 84 | return 0; 85 | PSG_setVolumeMode((PSG*)info->chip, (chip_type & 0x10) ? 1 : 2); 86 | PSG_setFlags((PSG*)info->chip, Flags & ~YM2149_PIN26_LOW); 87 | break; 88 | } 89 | 90 | return rate; 91 | } 92 | 93 | void device_stop_ayxx(UINT8 ChipID) 94 | { 95 | ayxx_state *info = &AYxxData[ChipID]; 96 | switch(EMU_CORE) 97 | { 98 | #ifdef ENABLE_ALL_CORES 99 | case EC_MAME: 100 | ay8910_stop_ym(info->chip); 101 | break; 102 | #endif 103 | case EC_EMU2149: 104 | PSG_delete((PSG*)info->chip); 105 | break; 106 | } 107 | info->chip = NULL; 108 | } 109 | 110 | void device_reset_ayxx(UINT8 ChipID) 111 | { 112 | ayxx_state *info = &AYxxData[ChipID]; 113 | switch(EMU_CORE) 114 | { 115 | #ifdef ENABLE_ALL_CORES 116 | case EC_MAME: 117 | ay8910_reset_ym(info->chip); 118 | break; 119 | #endif 120 | case EC_EMU2149: 121 | PSG_reset((PSG*)info->chip); 122 | break; 123 | } 124 | } 125 | 126 | 127 | void ayxx_w(UINT8 ChipID, offs_t offset, UINT8 data) 128 | { 129 | ayxx_state *info = &AYxxData[ChipID]; 130 | switch(EMU_CORE) 131 | { 132 | #ifdef ENABLE_ALL_CORES 133 | case EC_MAME: 134 | ay8910_write_ym(info->chip, offset, data); 135 | break; 136 | #endif 137 | case EC_EMU2149: 138 | PSG_writeIO((PSG*)info->chip, offset, data); 139 | break; 140 | } 141 | } 142 | 143 | void ayxx_set_emu_core(UINT8 Emulator) 144 | { 145 | #ifdef ENABLE_ALL_CORES 146 | EMU_CORE = (Emulator < 0x02) ? Emulator : 0x00; 147 | #else 148 | EMU_CORE = EC_EMU2149; 149 | #endif 150 | 151 | return; 152 | } 153 | 154 | void ayxx_set_mute_mask(UINT8 ChipID, UINT32 MuteMask) 155 | { 156 | ayxx_state *info = &AYxxData[ChipID]; 157 | switch(EMU_CORE) 158 | { 159 | #ifdef ENABLE_ALL_CORES 160 | case EC_MAME: 161 | ay8910_set_mute_mask_ym(info->chip, MuteMask); 162 | break; 163 | #endif 164 | case EC_EMU2149: 165 | PSG_setMask((PSG*)info->chip, MuteMask); 166 | break; 167 | } 168 | 169 | return; 170 | } 171 | 172 | void ayxx_set_stereo_mask(UINT8 ChipID, UINT32 StereoMask) 173 | { 174 | ayxx_state *info = &AYxxData[ChipID]; 175 | switch(EMU_CORE) 176 | { 177 | #ifdef ENABLE_ALL_CORES 178 | case EC_MAME: 179 | ay8910_set_stereo_mask_ym(info->chip, StereoMask); 180 | break; 181 | #endif 182 | case EC_EMU2149: 183 | PSG_setStereoMask((PSG*)info->chip, StereoMask); 184 | break; 185 | } 186 | 187 | return; 188 | } 189 | -------------------------------------------------------------------------------- /VGMPlay/chips/ws_initialIo.h: -------------------------------------------------------------------------------- 1 | //////////////////////////////////////////////////////////////////////////////// 2 | // Initial I/O values 3 | //////////////////////////////////////////////////////////////////////////////// 4 | // 5 | // 6 | // 7 | // 8 | // 9 | // 10 | ////////////////////////////////////////////////////////////////////////////// 11 | 12 | uint8 initialIoValue[256]= 13 | { 14 | 0x00,//0 15 | 0x00,//1 16 | 0x9d,//2 17 | 0xbb,//3 18 | 0x00,//4 19 | 0x00,//5 20 | 0x00,//6 21 | 0x26,//7 22 | 0xfe,//8 23 | 0xde,//9 24 | 0xf9,//a 25 | 0xfb,//b 26 | 0xdb,//c 27 | 0xd7,//d 28 | 0x7f,//e 29 | 0xf5,//f 30 | 0x00,//10 31 | 0x00,//11 32 | 0x00,//12 33 | 0x00,//13 34 | 0x01,//14 35 | 0x00,//15 36 | 0x9e,//16 37 | 0x9b,//17 38 | 0x00,//18 39 | 0x00,//19 40 | 0x00,//1a 41 | 0x00,//1b 42 | 0x99,//1c 43 | 0xfd,//1d 44 | 0xb7,//1e 45 | 0xdf,//1f 46 | 0x30,//20 47 | 0x57,//21 48 | 0x75,//22 49 | 0x76,//23 50 | 0x15,//24 51 | 0x73,//25 52 | 0x77,//26 53 | 0x77,//27 54 | 0x20,//28 55 | 0x75,//29 56 | 0x50,//2a 57 | 0x36,//2b 58 | 0x70,//2c 59 | 0x67,//2d 60 | 0x50,//2e 61 | 0x77,//2f 62 | 0x57,//30 63 | 0x54,//31 64 | 0x75,//32 65 | 0x77,//33 66 | 0x75,//34 67 | 0x17,//35 68 | 0x37,//36 69 | 0x73,//37 70 | 0x50,//38 71 | 0x57,//39 72 | 0x60,//3a 73 | 0x77,//3b 74 | 0x70,//3c 75 | 0x77,//3d 76 | 0x10,//3e 77 | 0x73,//3f 78 | 0x00,//40 79 | 0x00,//41 80 | 0x00,//42 81 | 0x00,//43 82 | 0x00,//44 83 | 0x00,//45 84 | 0x00,//46 85 | 0x00,//47 86 | 0x00,//48 87 | 0x00,//49 88 | 0x00,//4a 89 | 0x00,//4b 90 | 0x00,//4c 91 | 0x00,//4d 92 | 0x00,//4e 93 | 0x00,//4f 94 | 0x00,//50 95 | 0x00,//51 96 | 0x00,//52 97 | 0x00,//53 98 | 0x00,//54 99 | 0x00,//55 100 | 0x00,//56 101 | 0x00,//57 102 | 0x00,//58 103 | 0x00,//59 104 | 0x00,//5a 105 | 0x00,//5b 106 | 0x00,//5c 107 | 0x00,//5d 108 | 0x00,//5e 109 | 0x00,//5f 110 | 0x0a,//60 111 | 0x00,//61 112 | 0x00,//62 113 | 0x00,//63 114 | 0x00,//64 115 | 0x00,//65 116 | 0x00,//66 117 | 0x00,//67 118 | 0x00,//68 119 | 0x00,//69 120 | 0x00,//6a 121 | 0x0f,//6b 122 | 0x00,//6c 123 | 0x00,//6d 124 | 0x00,//6e 125 | 0x00,//6f 126 | 0x00,//70 127 | 0x00,//71 128 | 0x00,//72 129 | 0x00,//73 130 | 0x00,//74 131 | 0x00,//75 132 | 0x00,//76 133 | 0x00,//77 134 | 0x00,//78 135 | 0x00,//79 136 | 0x00,//7a 137 | 0x00,//7b 138 | 0x00,//7c 139 | 0x00,//7d 140 | 0x00,//7e 141 | 0x00,//7f 142 | 0xFF,//80 143 | 0x07,//81 144 | 0xFF,//82 145 | 0x07,//83 146 | 0xFF,//84 147 | 0x07,//85 148 | 0xFF,//86 149 | 0x07,//87 150 | 0x00,//88 151 | 0x00,//89 152 | 0x00,//8a 153 | 0x00,//8b 154 | 0x00,//8c 155 | 0x1f,//8d 1d ? 156 | 0x00,//8e 157 | 0x00,//8f 158 | 0x00,//90 159 | 0x00,//91 160 | 0x00,//92 161 | 0x00,//93 162 | 0x00,//94 163 | 0x00,//95 164 | 0x00,//96 165 | 0x00,//97 166 | 0x00,//98 167 | 0x00,//99 168 | 0x00,//9a 169 | 0x00,//9b 170 | 0x00,//9c 171 | 0x00,//9d 172 | 0x03,//9e 173 | 0x00,//9f 174 | 0x87-2,//a0 175 | 0x00,//a1 176 | 0x00,//a2 177 | 0x00,//a3 178 | 0x0,//a4 2b 179 | 0x0,//a5 7f 180 | 0x4f,//a6 181 | 0xff,//a7 cf ? 182 | 0x00,//a8 183 | 0x00,//a9 184 | 0x00,//aa 185 | 0x00,//ab 186 | 0x00,//ac 187 | 0x00,//ad 188 | 0x00,//ae 189 | 0x00,//af 190 | 0x00,//b0 191 | 0xdb,//b1 192 | 0x00,//b2 193 | 0x00,//b3 194 | 0x00,//b4 195 | 0x40,//b5 196 | 0x00,//b6 197 | 0x00,//b7 198 | 0x00,//b8 199 | 0x00,//b9 200 | 0x01,//ba 201 | 0x00,//bb 202 | 0x42,//bc 203 | 0x00,//bd 204 | 0x83,//be 205 | 0x00,//bf 206 | 0x2f,//c0 207 | 0x3f,//c1 208 | 0xff,//c2 209 | 0xff,//c3 210 | 0x00,//c4 211 | 0x00,//c5 212 | 0x00,//c6 213 | 0x00,//c7 214 | 215 | 0xd1,//c8? 216 | 0xd1,//c9 217 | 0xd1,//ca 218 | 0xd1,//cb 219 | 0xd1,//cc 220 | 0xd1,//cd 221 | 0xd1,//ce 222 | 0xd1,//cf 223 | 0xd1,//d0 224 | 0xd1,//d1 225 | 0xd1,//d2 226 | 0xd1,//d3 227 | 0xd1,//d4 228 | 0xd1,//d5 229 | 0xd1,//d6 230 | 0xd1,//d7 231 | 0xd1,//d8 232 | 0xd1,//d9 233 | 0xd1,//da 234 | 0xd1,//db 235 | 0xd1,//dc 236 | 0xd1,//dd 237 | 0xd1,//de 238 | 0xd1,//df 239 | 0xd1,//e0 240 | 0xd1,//e1 241 | 0xd1,//e2 242 | 0xd1,//e3 243 | 0xd1,//e4 244 | 0xd1,//e5 245 | 0xd1,//e6 246 | 0xd1,//e7 247 | 0xd1,//e8 248 | 0xd1,//e9 249 | 0xd1,//ea 250 | 0xd1,//eb 251 | 0xd1,//ec 252 | 0xd1,//ed 253 | 0xd1,//ee 254 | 0xd1,//ef 255 | 0xd1,//f0 256 | 0xd1,//f1 257 | 0xd1,//f2 258 | 0xd1,//f3 259 | 0xd1,//f4 260 | 0xd1,//f5 261 | 0xd1,//f6 262 | 0xd1,//f7 263 | 0xd1,//f8 264 | 0xd1,//f9 265 | 0xd1,//fa 266 | 0xd1,//fb 267 | 0xd1,//fc 268 | 0xd1,//fd 269 | 0xd1,//fe 270 | 0xd1 //ff 271 | }; 272 | -------------------------------------------------------------------------------- /VGMPlay/chips/fmopl.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "attotime.h" 4 | 5 | /* --- select emulation chips --- */ 6 | //#define BUILD_YM3812 (HAS_YM3812) 7 | //#define BUILD_YM3526 (HAS_YM3526) 8 | //#define BUILD_Y8950 (HAS_Y8950) 9 | #define BUILD_YM3812 1 10 | #define BUILD_YM3526 1 11 | #ifndef NO_Y8950 12 | #define BUILD_Y8950 1 13 | #else 14 | #define BUILD_Y8950 0 15 | #endif 16 | 17 | /* select output bits size of output : 8 or 16 */ 18 | #define OPL_SAMPLE_BITS 16 19 | 20 | /* compiler dependence */ 21 | /*#ifndef __OSDCOMM_H__ 22 | #define __OSDCOMM_H__ 23 | typedef unsigned char UINT8; // unsigned 8bit 24 | typedef unsigned short UINT16; // unsigned 16bit 25 | typedef unsigned int UINT32; // unsigned 32bit 26 | typedef signed char INT8; // signed 8bit 27 | typedef signed short INT16; // signed 16bit 28 | typedef signed int INT32; // signed 32bit 29 | #endif*/ /* __OSDCOMM_H__ */ 30 | 31 | typedef stream_sample_t OPLSAMPLE; 32 | /* 33 | #if (OPL_SAMPLE_BITS==16) 34 | typedef INT16 OPLSAMPLE; 35 | #endif 36 | #if (OPL_SAMPLE_BITS==8) 37 | typedef INT8 OPLSAMPLE; 38 | #endif 39 | */ 40 | 41 | //typedef void (*OPL_TIMERHANDLER)(void *param,int timer,attotime period); 42 | typedef void (*OPL_TIMERHANDLER)(void *param,int timer,int period); 43 | typedef void (*OPL_IRQHANDLER)(void *param,int irq); 44 | typedef void (*OPL_UPDATEHANDLER)(void *param/*,int min_interval_us*/); 45 | typedef void (*OPL_PORTHANDLER_W)(void *param,unsigned char data); 46 | typedef unsigned char (*OPL_PORTHANDLER_R)(void *param); 47 | 48 | 49 | #if BUILD_YM3812 50 | 51 | void *ym3812_init(UINT32 clock, UINT32 rate); 52 | void ym3812_shutdown(void *chip); 53 | void ym3812_reset_chip(void *chip); 54 | int ym3812_write(void *chip, int a, int v); 55 | unsigned char ym3812_read(void *chip, int a); 56 | int ym3812_timer_over(void *chip, int c); 57 | void ym3812_update_one(void *chip, OPLSAMPLE **buffer, int length); 58 | 59 | void ym3812_set_timer_handler(void *chip, OPL_TIMERHANDLER TimerHandler, void *param); 60 | void ym3812_set_irq_handler(void *chip, OPL_IRQHANDLER IRQHandler, void *param); 61 | void ym3812_set_update_handler(void *chip, OPL_UPDATEHANDLER UpdateHandler, void *param); 62 | 63 | #endif /* BUILD_YM3812 */ 64 | 65 | 66 | #if BUILD_YM3526 67 | 68 | /* 69 | ** Initialize YM3526 emulator(s). 70 | ** 71 | ** 'num' is the number of virtual YM3526's to allocate 72 | ** 'clock' is the chip clock in Hz 73 | ** 'rate' is sampling rate 74 | */ 75 | void *ym3526_init(UINT32 clock, UINT32 rate); 76 | /* shutdown the YM3526 emulators*/ 77 | void ym3526_shutdown(void *chip); 78 | void ym3526_reset_chip(void *chip); 79 | int ym3526_write(void *chip, int a, int v); 80 | unsigned char ym3526_read(void *chip, int a); 81 | int ym3526_timer_over(void *chip, int c); 82 | /* 83 | ** Generate samples for one of the YM3526's 84 | ** 85 | ** 'which' is the virtual YM3526 number 86 | ** '*buffer' is the output buffer pointer 87 | ** 'length' is the number of samples that should be generated 88 | */ 89 | void ym3526_update_one(void *chip, OPLSAMPLE **buffer, int length); 90 | 91 | void ym3526_set_timer_handler(void *chip, OPL_TIMERHANDLER TimerHandler, void *param); 92 | void ym3526_set_irq_handler(void *chip, OPL_IRQHANDLER IRQHandler, void *param); 93 | void ym3526_set_update_handler(void *chip, OPL_UPDATEHANDLER UpdateHandler, void *param); 94 | 95 | #endif /* BUILD_YM3526 */ 96 | 97 | 98 | #if BUILD_Y8950 99 | 100 | /* Y8950 port handlers */ 101 | void y8950_set_port_handler(void *chip, OPL_PORTHANDLER_W PortHandler_w, OPL_PORTHANDLER_R PortHandler_r, void *param); 102 | void y8950_set_keyboard_handler(void *chip, OPL_PORTHANDLER_W KeyboardHandler_w, OPL_PORTHANDLER_R KeyboardHandler_r, void *param); 103 | void y8950_set_delta_t_memory(void *chip, void * deltat_mem_ptr, int deltat_mem_size ); 104 | void y8950_write_pcmrom(void *chip, offs_t ROMSize, offs_t DataStart, 105 | offs_t DataLength, const UINT8* ROMData); 106 | 107 | void * y8950_init(UINT32 clock, UINT32 rate); 108 | void y8950_shutdown(void *chip); 109 | void y8950_reset_chip(void *chip); 110 | int y8950_write(void *chip, int a, int v); 111 | unsigned char y8950_read (void *chip, int a); 112 | int y8950_timer_over(void *chip, int c); 113 | void y8950_update_one(void *chip, OPLSAMPLE **buffer, int length); 114 | 115 | void y8950_set_timer_handler(void *chip, OPL_TIMERHANDLER TimerHandler, void *param); 116 | void y8950_set_irq_handler(void *chip, OPL_IRQHANDLER IRQHandler, void *param); 117 | void y8950_set_update_handler(void *chip, OPL_UPDATEHANDLER UpdateHandler, void *param); 118 | 119 | #endif /* BUILD_Y8950 */ 120 | 121 | void opl_set_mute_mask(void *chip, UINT32 MuteMask); 122 | 123 | -------------------------------------------------------------------------------- /VGMPlay/chips/sn764intf.c: -------------------------------------------------------------------------------- 1 | /**************************************************************** 2 | 3 | MAME / MESS functions 4 | 5 | ****************************************************************/ 6 | 7 | #include // for NULL 8 | #include "mamedef.h" 9 | //#include "sndintrf.h" 10 | //#include "streams.h" 11 | #include "sn76496.h" 12 | #include "sn76489.h" 13 | #include "sn764intf.h" 14 | 15 | 16 | #define EC_MAME 0x00 // SN76496 core from MAME 17 | #ifdef ENABLE_ALL_CORES 18 | #define EC_MAXIM 0x01 // SN76489 core by Maxim (from in_vgm) 19 | #endif 20 | 21 | /* for stream system */ 22 | typedef struct _sn764xx_state sn764xx_state; 23 | struct _sn764xx_state 24 | { 25 | void *chip; 26 | }; 27 | 28 | static UINT8 EMU_CORE = 0x00; 29 | 30 | extern UINT32 SampleRate; 31 | #define MAX_CHIPS 0x02 32 | static sn764xx_state SN764xxData[MAX_CHIPS]; 33 | 34 | void sn764xx_stream_update(UINT8 ChipID, stream_sample_t **outputs, int samples) 35 | { 36 | sn764xx_state *info = &SN764xxData[ChipID]; 37 | switch(EMU_CORE) 38 | { 39 | case EC_MAME: 40 | SN76496Update(info->chip, outputs, samples); 41 | break; 42 | #ifdef ENABLE_ALL_CORES 43 | case EC_MAXIM: 44 | SN76489_Update((SN76489_Context*)info->chip, outputs, samples); 45 | break; 46 | #endif 47 | } 48 | } 49 | 50 | int device_start_sn764xx(UINT8 ChipID, int clock, int shiftregwidth, int noisetaps, 51 | int negate, int stereo, int clockdivider, int freq0) 52 | { 53 | sn764xx_state *info; 54 | int rate = 0; 55 | 56 | if (ChipID >= MAX_CHIPS) 57 | return 0; 58 | 59 | info = &SN764xxData[ChipID]; 60 | /* emulator create */ 61 | switch(EMU_CORE) 62 | { 63 | case EC_MAME: 64 | rate = sn76496_start(&info->chip, clock, shiftregwidth, noisetaps, 65 | negate, stereo, clockdivider, freq0); 66 | sn76496_freq_limiter(clock & 0x3FFFFFFF, clockdivider, SampleRate); 67 | break; 68 | #ifdef ENABLE_ALL_CORES 69 | case EC_MAXIM: 70 | rate = SampleRate; 71 | info->chip = SN76489_Init(clock, rate); 72 | if (info->chip == NULL) 73 | return 0; 74 | SN76489_Config((SN76489_Context*)info->chip, noisetaps, shiftregwidth, 0); 75 | break; 76 | #endif 77 | } 78 | 79 | return rate; 80 | } 81 | 82 | void device_stop_sn764xx(UINT8 ChipID) 83 | { 84 | sn764xx_state *info = &SN764xxData[ChipID]; 85 | switch(EMU_CORE) 86 | { 87 | case EC_MAME: 88 | sn76496_shutdown(info->chip); 89 | break; 90 | #ifdef ENABLE_ALL_CORES 91 | case EC_MAXIM: 92 | SN76489_Shutdown((SN76489_Context*)info->chip); 93 | break; 94 | #endif 95 | } 96 | } 97 | 98 | void device_reset_sn764xx(UINT8 ChipID) 99 | { 100 | sn764xx_state *info = &SN764xxData[ChipID]; 101 | switch(EMU_CORE) 102 | { 103 | case EC_MAME: 104 | sn76496_reset(info->chip); 105 | break; 106 | #ifdef ENABLE_ALL_CORES 107 | case EC_MAXIM: 108 | SN76489_Reset((SN76489_Context*)info->chip); 109 | break; 110 | #endif 111 | } 112 | } 113 | 114 | 115 | void sn764xx_w(UINT8 ChipID, offs_t offset, UINT8 data) 116 | { 117 | sn764xx_state *info = &SN764xxData[ChipID]; 118 | switch(EMU_CORE) 119 | { 120 | case EC_MAME: 121 | switch(offset) 122 | { 123 | case 0x00: 124 | sn76496_write_reg(info->chip, offset & 1, data); 125 | break; 126 | case 0x01: 127 | sn76496_stereo_w(info->chip, offset, data); 128 | break; 129 | } 130 | break; 131 | #ifdef ENABLE_ALL_CORES 132 | case EC_MAXIM: 133 | switch(offset) 134 | { 135 | case 0x00: 136 | SN76489_Write((SN76489_Context*)info->chip, data); 137 | break; 138 | case 0x01: 139 | SN76489_GGStereoWrite((SN76489_Context*)info->chip, data); 140 | break; 141 | } 142 | break; 143 | #endif 144 | } 145 | } 146 | 147 | void sn764xx_set_emu_core(UINT8 Emulator) 148 | { 149 | #ifdef ENABLE_ALL_CORES 150 | EMU_CORE = (Emulator < 0x02) ? Emulator : 0x00; 151 | #else 152 | EMU_CORE = EC_MAME; 153 | #endif 154 | 155 | return; 156 | } 157 | 158 | void sn764xx_set_mute_mask(UINT8 ChipID, UINT32 MuteMask) 159 | { 160 | sn764xx_state *info = &SN764xxData[ChipID]; 161 | switch(EMU_CORE) 162 | { 163 | case EC_MAME: 164 | sn76496_set_mutemask(info->chip, MuteMask); 165 | break; 166 | #ifdef ENABLE_ALL_CORES 167 | case EC_MAXIM: 168 | SN76489_SetMute(info->chip, ~MuteMask & 0x0F); 169 | break; 170 | #endif 171 | } 172 | 173 | return; 174 | } 175 | 176 | void sn764xx_set_panning(UINT8 ChipID, INT16* PanVals) 177 | { 178 | sn764xx_state *info = &SN764xxData[ChipID]; 179 | switch(EMU_CORE) 180 | { 181 | case EC_MAME: 182 | break; 183 | #ifdef ENABLE_ALL_CORES 184 | case EC_MAXIM: 185 | SN76489_SetPanning(info->chip, PanVals[0x00], PanVals[0x01], PanVals[0x02], PanVals[0x03]); 186 | break; 187 | #endif 188 | } 189 | 190 | return; 191 | } 192 | -------------------------------------------------------------------------------- /VGMPlay/chips/ay8910.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "devcb.h" 4 | #define DEVCB_TYPE_NULL (0) 5 | #define DEVCB_NULL { DEVCB_TYPE_NULL } 6 | 7 | /* 8 | AY-3-8910A: 2 I/O ports 9 | AY-3-8912A: 1 I/O port 10 | AY-3-8913A: 0 I/O port 11 | AY8930: upper compatible with 8910. 12 | In extended mode, it has higher resolution and duty ratio setting 13 | YM2149: higher resolution 14 | YM3439: same as 2149 15 | YMZ284: 0 I/O port, different clock divider 16 | YMZ294: 0 I/O port 17 | */ 18 | 19 | #define ALL_8910_CHANNELS -1 20 | 21 | /* Internal resistance at Volume level 7. */ 22 | 23 | #define AY8910_INTERNAL_RESISTANCE (356) 24 | #define YM2149_INTERNAL_RESISTANCE (353) 25 | 26 | /* 27 | * Default values for resistor loads. 28 | * The macro should be used in AY8910interface if 29 | * the real values are unknown. 30 | */ 31 | #define AY8910_DEFAULT_LOADS {1000, 1000, 1000} 32 | 33 | /* 34 | * The following is used by all drivers not reviewed yet. 35 | * This will like the old behaviour, output between 36 | * 0 and 7FFF 37 | */ 38 | #define AY8910_LEGACY_OUTPUT (1) 39 | 40 | /* 41 | * Specifing the next define will simulate the special 42 | * cross channel mixing if outputs are tied together. 43 | * The driver will only provide one stream in this case. 44 | */ 45 | #define AY8910_SINGLE_OUTPUT (2) 46 | 47 | /* 48 | * The follwoing define is the default behaviour. 49 | * Output level 0 is 0V and 7ffff corresponds to 5V. 50 | * Use this to specify that a discrete mixing stage 51 | * follows. 52 | */ 53 | #define AY8910_DISCRETE_OUTPUT (4) 54 | 55 | /* 56 | * The follwoing define causes the driver to output 57 | * raw volume levels, i.e. 0 .. 15 and 0..31. 58 | * This is intended to be used in a subsequent 59 | * mixing modul (i.e. mpatrol ties 6 channels from 60 | * AY-3-8910 together). Do not use it now. 61 | */ 62 | /* TODO: implement mixing module */ 63 | #define AY8910_RAW_OUTPUT (8) 64 | 65 | #define AY8910_ZX_STEREO 0x80 66 | /* 67 | * This define specifies the initial state of YM2149 68 | * pin 26 (SEL pin). By default it is set to high, 69 | * compatible with AY8910. 70 | */ 71 | /* TODO: make it controllable while it's running (used by any hw???) */ 72 | #define YM2149_PIN26_HIGH (0x00) /* or N/C */ 73 | #define YM2149_PIN26_LOW (0x10) 74 | 75 | typedef struct _ay8910_interface ay8910_interface; 76 | struct _ay8910_interface 77 | { 78 | int flags; /* Flags */ 79 | int res_load[3]; /* Load on channel in ohms */ 80 | //devcb_read8 portAread; 81 | //devcb_read8 portBread; 82 | //devcb_write8 portAwrite; 83 | //devcb_write8 portBwrite; 84 | }; 85 | 86 | 87 | //void ay8910_set_volume(UINT8 ChipID,int channel,int volume); 88 | 89 | /*READ8_DEVICE_HANDLER( ay8910_r ); 90 | WITE8_DEVICE_HANDLER( ay8910_address_w ); 91 | WRITE8_DEVICE_HANDLER( ay8910_data_w );*/ 92 | /*UINT8 ay8910_r(UINT8 ChipID, offs_t offset); 93 | void ay8910_address_w(UINT8 ChipID, offs_t offset, UINT8 data); 94 | void ay8910_data_w(UINT8 ChipID, offs_t offset, UINT8 data);*/ 95 | 96 | /* use this when BC1 == A0; here, BC1=0 selects 'data' and BC1=1 selects 'latch address' */ 97 | //WRITE8_DEVICE_HANDLER( ay8910_data_address_w ); 98 | //void ay8910_data_address_w(UINT8 ChipID, offs_t offset, UINT8 data); 99 | 100 | /* use this when BC1 == !A0; here, BC1=0 selects 'latch address' and BC1=1 selects 'data' */ 101 | //WRITE8_DEVICE_HANDLER( ay8910_address_data_w ); 102 | //void ay8910_address_data_w(UINT8 ChipID, offs_t offset, UINT8 data); 103 | 104 | 105 | /*********** An interface for SSG of YM2203 ***********/ 106 | 107 | //void *ay8910_start_ym(void *infoptr, sound_type chip_type, const device_config *device, int clock, const ay8910_interface *intf); 108 | void *ay8910_start_ym(void *infoptr, unsigned char chip_type, int clock, const ay8910_interface *intf); 109 | 110 | void ay8910_stop_ym(void *chip); 111 | void ay8910_reset_ym(void *chip); 112 | void ay8910_set_clock_ym(void *chip, int clock); 113 | void ay8910_write_ym(void *chip, int addr, int data); 114 | int ay8910_read_ym(void *chip); 115 | 116 | //void ay8910_update(UINT8 ChipID, stream_sample_t **outputs, int samples); 117 | void ay8910_update_one(void *param, stream_sample_t **outputs, int samples); 118 | int ay8910_start(void **chip, int clock, UINT8 chip_type, UINT8 Flags); 119 | /*int device_start_ay8910(UINT8 ChipID, int clock, unsigned char chip_type, unsigned char Flags); 120 | void device_stop_ay8910(UINT8 ChipID); 121 | void device_reset_ay8910(UINT8 ChipID);*/ 122 | 123 | void ay8910_set_mute_mask_ym(void *chip, UINT32 MuteMask); 124 | void ay8910_set_stereo_mask_ym(void *chip, UINT32 StereoMask); 125 | //void ay8910_set_mute_mask(UINT8 ChipID, UINT32 MuteMask); 126 | void ay8910_set_srchg_cb_ym(void *chip, SRATE_CALLBACK CallbackFunc, void* DataPtr); 127 | 128 | /*DEVICE_GET_INFO( ay8910 ); 129 | DEVICE_GET_INFO( ay8912 ); 130 | DEVICE_GET_INFO( ay8913 ); 131 | DEVICE_GET_INFO( ay8930 ); 132 | DEVICE_GET_INFO( ym2149 ); 133 | DEVICE_GET_INFO( ym3439 ); 134 | DEVICE_GET_INFO( ymz284 ); 135 | DEVICE_GET_INFO( ymz294 ); 136 | 137 | #define SOUND_AY8910 DEVICE_GET_INFO_NAME( ay8910 ) 138 | #define SOUND_AY8912 DEVICE_GET_INFO_NAME( ay8912 ) 139 | #define SOUND_AY8913 DEVICE_GET_INFO_NAME( ay8913 ) 140 | #define SOUND_AY8930 DEVICE_GET_INFO_NAME( ay8930 ) 141 | #define SOUND_YM2149 DEVICE_GET_INFO_NAME( ym2149 ) 142 | #define SOUND_YM3439 DEVICE_GET_INFO_NAME( ym3439 ) 143 | #define SOUND_YMZ284 DEVICE_GET_INFO_NAME( ymz284 ) 144 | #define SOUND_YMZ294 DEVICE_GET_INFO_NAME( ymz294 )*/ 145 | -------------------------------------------------------------------------------- /VGMPlay/chips/qsound_intf.c: -------------------------------------------------------------------------------- 1 | //#include "emu.h" 2 | #include "mamedef.h" 3 | #ifdef _DEBUG 4 | #include 5 | #endif 6 | #include 7 | #include // for memset 8 | #include // for NULL 9 | #include 10 | #include "qsound_intf.h" 11 | #include "qsound_mame.h" 12 | #include "qsound_ctr.h" 13 | 14 | #ifdef ENABLE_ALL_CORES 15 | #define EC_MAME 0x01 // QSound HLE core from MAME 16 | #endif 17 | #define EC_CTR 0x00 // superctr custom HLE 18 | 19 | static UINT8 EMU_CORE = 0x00; 20 | // fix broken optimization of old VGMs causing problems with the new core 21 | static UINT8 key_on_hack = 0x00; 22 | static UINT16 start_addr_cache[2][16]; 23 | static UINT16 pitch_cache[2][16]; 24 | static UINT16 data_latch[2]; 25 | 26 | int device_start_qsound(UINT8 ChipID, int clock) 27 | { 28 | memset(start_addr_cache[ChipID], 0, sizeof(UINT16)*16); 29 | memset(pitch_cache[ChipID], 0, sizeof(UINT16)*16); 30 | switch(EMU_CORE) 31 | { 32 | #ifdef ENABLE_ALL_CORES 33 | case EC_MAME: 34 | return device_start_qsoundm(ChipID, clock); 35 | #endif 36 | case EC_CTR: 37 | if(clock < 10000000) 38 | { 39 | clock *= 15; 40 | key_on_hack = 1; 41 | } 42 | return device_start_qsound_ctr(ChipID, clock); 43 | } 44 | return 0; 45 | } 46 | 47 | void device_stop_qsound(UINT8 ChipID) 48 | { 49 | switch(EMU_CORE) 50 | { 51 | #ifdef ENABLE_ALL_CORES 52 | case EC_MAME: 53 | device_stop_qsoundm(ChipID); return; 54 | #endif 55 | case EC_CTR: 56 | device_stop_qsound_ctr(ChipID); return; 57 | } 58 | } 59 | 60 | void device_reset_qsound(UINT8 ChipID) 61 | { 62 | switch(EMU_CORE) 63 | { 64 | #ifdef ENABLE_ALL_CORES 65 | case EC_MAME: 66 | device_reset_qsoundm(ChipID); return; 67 | #endif 68 | case EC_CTR: 69 | device_reset_qsound_ctr(ChipID); 70 | 71 | // need to wait until the chip is ready before we start writing to it ... 72 | // we do this by time travel. 73 | qsoundc_wait_busy(ChipID); 74 | return; 75 | } 76 | } 77 | 78 | void qsound_w(UINT8 ChipID, offs_t offset, UINT8 data) 79 | { 80 | switch(EMU_CORE) 81 | { 82 | #ifdef ENABLE_ALL_CORES 83 | case EC_MAME: 84 | qsoundm_w(ChipID, offset, data); return; 85 | #endif 86 | case EC_CTR: 87 | if(key_on_hack) 88 | { 89 | int ch; 90 | switch (offset) 91 | { 92 | // need to handle three cases, as vgm_cmp can remove writes to both phase and bank 93 | // registers, depending on version. 94 | // - start address was written before end/loop, but phase register is written 95 | // - as above, but phase is not written (we use bank as a backup then) 96 | // - voice parameters are written during a note (we can't rewrite the address then) 97 | case 0: 98 | data_latch[ChipID] = (data_latch[ChipID] & 0x00ff) | (data << 8); 99 | break; 100 | case 1: 101 | data_latch[ChipID] = (data_latch[ChipID] & 0xff00) | data; 102 | break; 103 | case 2: 104 | if(data > 0x7f) 105 | break; 106 | ch = data>>3; 107 | 108 | switch(data & 7) 109 | { 110 | case 1: // Start addr. write 111 | start_addr_cache[ChipID][ch] = data_latch[ChipID]; 112 | break; 113 | case 2: // Pitch write 114 | // (old HLE assumed writing a non-zero value after a zero value was Key On) 115 | if(pitch_cache[ChipID][ch] == 0 && data_latch[ChipID] != 0) 116 | qsoundc_write_data(ChipID, (ch << 3) + 1, start_addr_cache[ChipID][ch]); 117 | pitch_cache[ChipID][ch] = data_latch[ChipID]; 118 | break; 119 | case 3: // Phase (old HLE also assumed this was Key On) 120 | qsoundc_write_data(ChipID, (ch << 3) + 1, start_addr_cache[ChipID][ch]); 121 | default: 122 | break; 123 | } 124 | } 125 | } 126 | qsoundc_w(ChipID, offset, data); 127 | 128 | // need to wait until the chip is ready before we start writing to it ... 129 | // we do this by time travel. 130 | if(offset == 2 && data == 0xe3) 131 | qsoundc_wait_busy(ChipID); 132 | 133 | return; 134 | } 135 | } 136 | 137 | UINT8 qsound_r(UINT8 ChipID, offs_t offset) 138 | { 139 | switch(EMU_CORE) 140 | { 141 | #ifdef ENABLE_ALL_CORES 142 | case EC_MAME: 143 | return qsoundm_r(ChipID, offset); 144 | #endif 145 | case EC_CTR: 146 | return qsoundc_r(ChipID, offset); 147 | } 148 | return 0; 149 | } 150 | 151 | void qsound_update(UINT8 ChipID, stream_sample_t **outputs, int samples) 152 | { 153 | switch(EMU_CORE) 154 | { 155 | #ifdef ENABLE_ALL_CORES 156 | case EC_MAME: 157 | qsoundm_update(ChipID, outputs, samples); return; 158 | #endif 159 | case EC_CTR: 160 | qsoundc_update(ChipID, outputs, samples); return; 161 | } 162 | } 163 | 164 | void qsound_write_rom(UINT8 ChipID, offs_t ROMSize, offs_t DataStart, offs_t DataLength, 165 | const UINT8* ROMData) 166 | { 167 | switch(EMU_CORE) 168 | { 169 | #ifdef ENABLE_ALL_CORES 170 | case EC_MAME: 171 | qsoundm_write_rom(ChipID, ROMSize, DataStart, DataLength, ROMData); return; 172 | #endif 173 | case EC_CTR: 174 | qsoundc_write_rom(ChipID, ROMSize, DataStart, DataLength, ROMData); return; 175 | } 176 | } 177 | 178 | void qsound_set_mute_mask(UINT8 ChipID, UINT32 MuteMask) 179 | { 180 | switch(EMU_CORE) 181 | { 182 | #ifdef ENABLE_ALL_CORES 183 | case EC_MAME: 184 | qsoundm_set_mute_mask(ChipID, MuteMask); return; 185 | #endif 186 | case EC_CTR: 187 | qsoundc_set_mute_mask(ChipID, MuteMask); return; 188 | } 189 | } 190 | 191 | void qsound_set_emu_core(UINT8 Emulator) 192 | { 193 | #ifdef ENABLE_ALL_CORES 194 | EMU_CORE = (Emulator < 0x02) ? Emulator : 0x00; 195 | #else 196 | EMU_CORE = EC_CTR; 197 | #endif 198 | 199 | return; 200 | } 201 | -------------------------------------------------------------------------------- /VGMPlay/chips/nes_defs.h: -------------------------------------------------------------------------------- 1 | /***************************************************************************** 2 | 3 | MAME/MESS NES APU CORE 4 | 5 | Based on the Nofrendo/Nosefart NES N2A03 sound emulation core written by 6 | Matthew Conte (matt@conte.com) and redesigned for use in MAME/MESS by 7 | Who Wants to Know? (wwtk@mail.com) 8 | 9 | This core is written with the advise and consent of Matthew Conte and is 10 | released under the GNU Public License. This core is freely avaiable for 11 | use in any freeware project, subject to the following terms: 12 | 13 | Any modifications to this code must be duly noted in the source and 14 | approved by Matthew Conte and myself prior to public submission. 15 | 16 | ***************************************************************************** 17 | 18 | NES_DEFS.H 19 | 20 | NES APU internal type definitions and constants. 21 | 22 | *****************************************************************************/ 23 | 24 | #pragma once 25 | 26 | #ifndef __NES_DEFS_H__ 27 | #define __NES_DEFS_H__ 28 | 29 | /* BOOLEAN CONSTANTS */ 30 | #ifndef TRUE 31 | #define TRUE 1 32 | #define FALSE 0 33 | #endif 34 | 35 | /* REGULAR TYPE DEFINITIONS */ 36 | typedef INT8 int8; 37 | typedef INT16 int16; 38 | typedef INT32 int32; 39 | typedef UINT8 uint8; 40 | typedef UINT16 uint16; 41 | typedef UINT32 uint32; 42 | typedef UINT8 boolean; 43 | 44 | 45 | /* QUEUE TYPES */ 46 | #ifdef USE_QUEUE 47 | 48 | #define QUEUE_SIZE 0x2000 49 | #define QUEUE_MAX (QUEUE_SIZE-1) 50 | 51 | typedef struct queue_s 52 | { 53 | int pos; 54 | unsigned char reg,val; 55 | } queue_t; 56 | 57 | #endif 58 | 59 | /* REGISTER DEFINITIONS */ 60 | #define APU_WRA0 0x00 61 | #define APU_WRA1 0x01 62 | #define APU_WRA2 0x02 63 | #define APU_WRA3 0x03 64 | #define APU_WRB0 0x04 65 | #define APU_WRB1 0x05 66 | #define APU_WRB2 0x06 67 | #define APU_WRB3 0x07 68 | #define APU_WRC0 0x08 69 | #define APU_WRC1 0x09 70 | #define APU_WRC2 0x0A 71 | #define APU_WRC3 0x0B 72 | #define APU_WRD0 0x0C 73 | #define APU_WRD2 0x0E 74 | #define APU_WRD3 0x0F 75 | #define APU_WRE0 0x10 76 | #define APU_WRE1 0x11 77 | #define APU_WRE2 0x12 78 | #define APU_WRE3 0x13 79 | #define APU_SMASK 0x15 80 | #define APU_IRQCTRL 0x17 81 | 82 | #define NOISE_LONG 0x4000 83 | #define NOISE_SHORT 93 84 | 85 | /* CHANNEL TYPE DEFINITIONS */ 86 | 87 | /* Square Wave */ 88 | typedef struct square_s 89 | { 90 | uint8 regs[4]; 91 | int vbl_length; 92 | int freq; 93 | float phaseacc; 94 | float output_vol; 95 | float env_phase; 96 | float sweep_phase; 97 | uint8 adder; 98 | uint8 env_vol; 99 | boolean enabled; 100 | boolean Muted; 101 | } square_t; 102 | 103 | /* Triangle Wave */ 104 | typedef struct triangle_s 105 | { 106 | uint8 regs[4]; /* regs[1] unused */ 107 | int linear_length; 108 | int vbl_length; 109 | int write_latency; 110 | float phaseacc; 111 | float output_vol; 112 | uint8 adder; 113 | boolean counter_started; 114 | boolean enabled; 115 | boolean Muted; 116 | } triangle_t; 117 | 118 | /* Noise Wave */ 119 | typedef struct noise_s 120 | { 121 | uint8 regs[4]; /* regs[1] unused */ 122 | int cur_pos; 123 | int vbl_length; 124 | float phaseacc; 125 | float output_vol; 126 | float env_phase; 127 | uint8 env_vol; 128 | boolean enabled; 129 | boolean Muted; 130 | } noise_t; 131 | 132 | /* DPCM Wave */ 133 | typedef struct dpcm_s 134 | { 135 | uint8 regs[4]; 136 | uint32 address; 137 | uint32 length; 138 | int bits_left; 139 | float phaseacc; 140 | float output_vol; 141 | uint8 cur_byte; 142 | boolean enabled; 143 | boolean irq_occurred; 144 | //address_space *memory; 145 | const uint8 *memory; 146 | //signed char vol; 147 | signed short vol; 148 | boolean Muted; 149 | } dpcm_t; 150 | 151 | /* APU type */ 152 | typedef struct apu 153 | { 154 | /* Sound channels */ 155 | square_t squ[2]; 156 | triangle_t tri; 157 | noise_t noi; 158 | dpcm_t dpcm; 159 | 160 | /* APU registers */ 161 | unsigned char regs[0x20]; 162 | 163 | /* Sound pointers */ 164 | void *buffer; 165 | 166 | #ifdef USE_QUEUE 167 | 168 | /* Event queue */ 169 | queue_t queue[QUEUE_SIZE]; 170 | int head, tail; 171 | 172 | #else 173 | 174 | int buf_pos; 175 | 176 | #endif 177 | 178 | int step_mode; 179 | } apu_t; 180 | 181 | /* CONSTANTS */ 182 | 183 | /* vblank length table used for squares, triangle, noise */ 184 | static const uint8 vbl_length[32] = 185 | { 186 | 5, 127, 10, 1, 19, 2, 40, 3, 80, 4, 30, 5, 7, 6, 13, 7, 187 | 6, 8, 12, 9, 24, 10, 48, 11, 96, 12, 36, 13, 8, 14, 16, 15 188 | }; 189 | 190 | /* frequency limit of square channels */ 191 | static const int freq_limit[8] = 192 | { 193 | //0x3FF, 0x555, 0x666, 0x71C, 0x787, 0x7C1, 0x7E0, 0x7F0, 194 | // Fixed, thanks to Delek 195 | 0x3FF, 0x555, 0x666, 0x71C, 0x787, 0x7C1, 0x7E0, 0x7F2, 196 | }; 197 | 198 | /* table of noise frequencies */ 199 | static const int noise_freq[16] = 200 | { 201 | //4, 8, 16, 32, 64, 96, 128, 160, 202, 254, 380, 508, 762, 1016, 2034, 2046 202 | // Fixed, thanks to Delek 203 | 4, 8, 16, 32, 64, 96, 128, 160, 202, 254, 380, 508, 762, 1016, 2034, 4068 204 | }; 205 | 206 | /* dpcm transfer freqs */ 207 | static const int dpcm_clocks[16] = 208 | { 209 | 428, 380, 340, 320, 286, 254, 226, 214, 190, 160, 142, 128, 106, 85, 72, 54 210 | }; 211 | 212 | /* ratios of pos/neg pulse for square waves */ 213 | /* 2/16 = 12.5%, 4/16 = 25%, 8/16 = 50%, 12/16 = 75% */ 214 | static const int duty_lut[4] = 215 | { 216 | 2, 4, 8, 12 217 | }; 218 | 219 | #endif /* __NES_DEFS_H__ */ 220 | -------------------------------------------------------------------------------- /in_vgm/resource.h: -------------------------------------------------------------------------------- 1 | //{{NO_DEPENDENCIES}} 2 | // Microsoft Developer Studio generated include file. 3 | // Used by in_vgm.rc 4 | // 5 | #define MainIcon 101 6 | #define TabIcons 102 7 | #define LogoBitmap 103 8 | #define DlgConfigMain 201 9 | #define DlgFileInfo 202 10 | #define DlgCfgPlayback 203 11 | #define DlgCfgTags 204 12 | #define DlgCfgVgm7z 205 13 | #define DlgCfgMuting 206 14 | #define DlgCfgOptPan 207 15 | #define TabCollection 1001 16 | #define ImmediateUpdCheck 1002 17 | #define HelpButton 1003 18 | #define LoopText 1101 19 | #define FadeText 1102 20 | #define PauseNlText 1103 21 | #define PauseLpText 1104 22 | #define RateRecRadio 1105 23 | #define Rate60HzRadio 1106 24 | #define Rate50HzRadio 1107 25 | #define RateOtherRadio 1108 26 | #define RateText 1109 27 | #define RateLabel 1110 28 | #define VolumeSlider 1111 29 | #define VolumeText 1112 30 | #define SmplPbRateText 1113 31 | #define ResmpModeList 1114 32 | #define SmplChipRateText 1115 33 | #define ChipSmpModeList 1116 34 | #define SurroundCheck 1117 35 | #define SmplChipRateLabel 1118 36 | #define SmplChipRateHzLabel 1119 37 | #define LoopTimesLabel 1120 38 | #define TitleFormatText 1201 39 | #define PreferJapCheck 1202 40 | #define FM2413Check 1203 41 | #define TrimWhitespcCheck 1204 42 | #define StdSeparatorsCheck 1205 43 | #define MLTypeText 1206 44 | #define TagFallbackCheck 1207 45 | #define NoInfoCacheCheck 1208 46 | #define MutingChipList 1301 47 | #define MutingChipNumList 1302 48 | #define MuteChn1Check 1303 49 | #define MuteChn2Check 1304 50 | #define MuteChn3Check 1305 51 | #define MuteChn4Check 1306 52 | #define MuteChn5Check 1307 53 | #define MuteChn6Check 1308 54 | #define MuteChn7Check 1309 55 | #define MuteChn8Check 1310 56 | #define MuteChn9Check 1311 57 | #define MuteChn10Check 1312 58 | #define MuteChn11Check 1313 59 | #define MuteChn12Check 1314 60 | #define MuteChn13Check 1315 61 | #define MuteChn14Check 1316 62 | #define MuteChn15Check 1317 63 | #define MuteChn16Check 1318 64 | #define MuteChn17Check 1319 65 | #define MuteChn18Check 1320 66 | #define MuteChn19Check 1321 67 | #define MuteChn20Check 1322 68 | #define MuteChn21Check 1323 69 | #define MuteChn22Check 1324 70 | #define MuteChn23Check 1325 71 | #define MuteChn24Check 1326 72 | #define ResetMuteCheck 1327 73 | #define MuteChipCheck 1328 74 | #define TrkTitleText 2001 75 | #define TrkAuthorText 2002 76 | #define GameNameText 2003 77 | #define GameSysText 2004 78 | #define GameDateText 2005 79 | #define VGMFileText 2006 80 | #define VGMCrtText 2007 81 | #define VGMVerText 2008 82 | #define VGMGainText 2009 83 | #define VGMSizeText 2010 84 | #define VGMLenText 2011 85 | #define VGMNotesText 2012 86 | #define ChipUseText 2013 87 | #define LangEngCheck 2014 88 | #define LangJapCheck 2015 89 | #define ConfigPluginButton 2016 90 | #define BrwsrInfoButton 2017 91 | #define EmuOptChipList 3001 92 | #define EmuOptChipNumList 3002 93 | #define EmuCoreRadio1 3003 94 | #define EmuCoreRadio2 3004 95 | #define PanChn1Label 3005 96 | #define PanChn2Label 3006 97 | #define PanChn3Label 3007 98 | #define PanChn4Label 3008 99 | #define PanChn5Label 3009 100 | #define PanChn6Label 3010 101 | #define PanChn7Label 3011 102 | #define PanChn8Label 3012 103 | #define PanChn9Label 3013 104 | #define PanChn10Label 3014 105 | #define PanChn11Label 3015 106 | #define PanChn12Label 3016 107 | #define PanChn13Label 3017 108 | #define PanChn14Label 3018 109 | #define PanChn15Label 3019 110 | #define PanChn1Slider 3020 111 | #define PanChn2Slider 3021 112 | #define PanChn3Slider 3022 113 | #define PanChn4Slider 3023 114 | #define PanChn5Slider 3024 115 | #define PanChn6Slider 3025 116 | #define PanChn7Slider 3026 117 | #define PanChn8Slider 3027 118 | #define PanChn9Slider 3028 119 | #define PanChn10Slider 3029 120 | #define PanChn11Slider 3030 121 | #define PanChn12Slider 3031 122 | #define PanChn13Slider 3032 123 | #define PanChn14Slider 3033 124 | #define PanChn15Slider 3034 125 | 126 | // Next default values for new objects 127 | // 128 | #ifdef APSTUDIO_INVOKED 129 | #ifndef APSTUDIO_READONLY_SYMBOLS 130 | #define _APS_NEXT_RESOURCE_VALUE 212 131 | #define _APS_NEXT_COMMAND_VALUE 40001 132 | #define _APS_NEXT_CONTROL_VALUE 3038 133 | #define _APS_NEXT_SYMED_VALUE 101 134 | #endif 135 | #endif 136 | -------------------------------------------------------------------------------- /VGMPlay/chips/opll.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019 Nuke.YKT 3 | * 4 | * This program is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU General Public License 6 | * as published by the Free Software Foundation; either version 2 7 | * of the License, or (at your option) any later version. 8 | * 9 | * This program is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | * GNU General Public License for more details. 13 | * 14 | * 15 | * Yamaha YM2413 emulator 16 | * Thanks: 17 | * siliconpr0n.org(digshadow, John McMaster): 18 | * VRC VII decap and die shot. 19 | * 20 | * version: 1.0 21 | */ 22 | 23 | #ifndef OPLL_H 24 | #define OPLL_H 25 | 26 | #include "emutypes.h" 27 | 28 | #define RSM_FRAC 10 29 | #define OPLL_WRITEBUF_SIZE 2048 30 | #define OPLL_WRITEBUF_DELAY 20 31 | 32 | enum { 33 | opll_type_ym2413 = 0x00, /* Yamaha YM2413 */ 34 | opll_type_ds1001, /* Konami VRC VII */ 35 | opll_type_ym2413b, /* Yamaha YM2413B */ 36 | opll_type_ymf281, /* Yamaha YMF281 */ 37 | opll_type_ymf281b, /* Yamaha YMF281B */ 38 | opll_type_ym2420, /* Yamaha YM2420 */ 39 | opll_type_ym2423, /* Yamaha YM2423 */ 40 | }; 41 | 42 | enum { 43 | opll_patch_1 = 0x00, 44 | opll_patch_2, 45 | opll_patch_3, 46 | opll_patch_4, 47 | opll_patch_5, 48 | opll_patch_6, 49 | opll_patch_7, 50 | opll_patch_8, 51 | opll_patch_9, 52 | opll_patch_10, 53 | opll_patch_11, 54 | opll_patch_12, 55 | opll_patch_13, 56 | opll_patch_14, 57 | opll_patch_15, 58 | opll_patch_drum_0, 59 | opll_patch_drum_1, 60 | opll_patch_drum_2, 61 | opll_patch_drum_3, 62 | opll_patch_drum_4, 63 | opll_patch_drum_5, 64 | opll_patch_max 65 | }; 66 | 67 | typedef struct _opll_writebuf { 68 | uint64_t time; 69 | uint8_t port; 70 | uint8_t data; 71 | } opll_writebuf; 72 | 73 | typedef struct { 74 | uint8_t tl; 75 | uint8_t dc; 76 | uint8_t dm; 77 | uint8_t fb; 78 | uint8_t am[2]; 79 | uint8_t vib[2]; 80 | uint8_t et[2]; 81 | uint8_t ksr[2]; 82 | uint8_t multi[2]; 83 | uint8_t ksl[2]; 84 | uint8_t ar[2]; 85 | uint8_t dr[2]; 86 | uint8_t sl[2]; 87 | uint8_t rr[2]; 88 | } opll_patch_t; 89 | 90 | typedef struct { 91 | uint32_t chip_type; 92 | uint32_t cycles; 93 | uint32_t slot; 94 | const opll_patch_t *patchrom; 95 | /* IO */ 96 | uint8_t write_data; 97 | uint8_t write_a; 98 | uint8_t write_d; 99 | uint8_t write_a_en; 100 | uint8_t write_d_en; 101 | uint8_t write_fm_address; 102 | uint8_t write_fm_data; 103 | uint8_t write_mode_address; 104 | uint8_t address; 105 | uint8_t data; 106 | /* Envelope generator */ 107 | uint8_t eg_counter_state; 108 | uint8_t eg_counter_state_prev; 109 | uint32_t eg_timer; 110 | uint8_t eg_timer_low_lock; 111 | uint8_t eg_timer_carry; 112 | uint8_t eg_timer_shift; 113 | uint8_t eg_timer_shift_lock; 114 | uint8_t eg_timer_shift_stop; 115 | uint8_t eg_state[18]; 116 | uint8_t eg_level[18]; 117 | uint8_t eg_kon; 118 | uint32_t eg_dokon; 119 | uint8_t eg_off; 120 | uint8_t eg_rate; 121 | uint8_t eg_maxrate; 122 | uint8_t eg_zerorate; 123 | uint8_t eg_inc_lo; 124 | uint8_t eg_inc_hi; 125 | uint8_t eg_rate_hi; 126 | uint16_t eg_sl; 127 | uint16_t eg_ksltl; 128 | uint8_t eg_out; 129 | uint8_t eg_silent; 130 | /* Phase generator */ 131 | uint16_t pg_fnum; 132 | uint8_t pg_block; 133 | uint16_t pg_out; 134 | uint32_t pg_inc; 135 | uint32_t pg_phase[18]; 136 | uint32_t pg_phase_next; 137 | /* Operator */ 138 | int16_t op_fb1[9]; 139 | int16_t op_fb2[9]; 140 | int16_t op_fbsum; 141 | int16_t op_mod; 142 | uint8_t op_neg; 143 | uint16_t op_logsin; 144 | uint16_t op_exp_m; 145 | uint16_t op_exp_s; 146 | /* Channel */ 147 | int16_t ch_out; 148 | int16_t ch_out_hh; 149 | int16_t ch_out_tm; 150 | int16_t ch_out_bd; 151 | int16_t ch_out_sd; 152 | int16_t ch_out_tc; 153 | /* LFO */ 154 | uint16_t lfo_counter; 155 | uint8_t lfo_vib_counter; 156 | uint16_t lfo_am_counter; 157 | uint8_t lfo_am_step; 158 | uint8_t lfo_am_dir; 159 | uint8_t lfo_am_car; 160 | uint8_t lfo_am_out; 161 | /* Register set */ 162 | uint16_t fnum[9]; 163 | uint8_t block[9]; 164 | uint8_t kon[9]; 165 | uint8_t son[9]; 166 | uint8_t vol[9]; 167 | uint8_t inst[9]; 168 | uint8_t rhythm; 169 | uint8_t testmode; 170 | opll_patch_t patch; 171 | uint8_t c_instr; 172 | uint8_t c_op; 173 | uint8_t c_tl; 174 | uint8_t c_dc; 175 | uint8_t c_dm; 176 | uint8_t c_fb; 177 | uint8_t c_am; 178 | uint8_t c_vib; 179 | uint8_t c_et; 180 | uint8_t c_ksr; 181 | uint8_t c_ksr_freq; 182 | uint8_t c_ksl_freq; 183 | uint8_t c_ksl_block; 184 | uint8_t c_multi; 185 | uint8_t c_ksl; 186 | uint8_t c_adrr[3]; 187 | uint8_t c_sl; 188 | uint16_t c_fnum; 189 | uint16_t c_block; 190 | /* Rhythm mode */ 191 | int8_t rm_enable; 192 | uint32_t rm_noise; 193 | uint32_t rm_select; 194 | uint8_t rm_hh_bit2; 195 | uint8_t rm_hh_bit3; 196 | uint8_t rm_hh_bit7; 197 | uint8_t rm_hh_bit8; 198 | uint8_t rm_tc_bit3; 199 | uint8_t rm_tc_bit5; 200 | 201 | int16_t output_m; 202 | int16_t output_r; 203 | 204 | uint32_t mute[14]; 205 | int32_t rateratio; 206 | int32_t samplecnt; 207 | int32_t oldsamples[2]; 208 | int32_t samples[2]; 209 | 210 | uint64_t writebuf_samplecnt; 211 | uint32_t writebuf_cur; 212 | uint32_t writebuf_last; 213 | uint64_t writebuf_lasttime; 214 | opll_writebuf writebuf[OPLL_WRITEBUF_SIZE]; 215 | 216 | } opll_t; 217 | 218 | void OPLL_Reset(opll_t *chip, uint32_t chip_type, uint32_t rate, uint32_t clock); 219 | void OPLL_Clock(opll_t *chip, int32_t *buffer); 220 | void OPLL_Write(opll_t *chip, uint32_t port, uint8_t data); 221 | 222 | void OPLL_WriteBuffered(opll_t*chip, uint32_t port, uint8_t data); 223 | void OPLL_GenerateStream(opll_t*chip, int32_t **sndptr, uint32_t numsamples); 224 | void OPLL_SetMute(opll_t*chip, uint32_t mute); 225 | #endif -------------------------------------------------------------------------------- /in_vgm/Winamp/IN2.H: -------------------------------------------------------------------------------- 1 | 2 | #ifndef NULLSOFT_WINAMP_IN2H 3 | #define NULLSOFT_WINAMP_IN2H 4 | #include "out.h" 5 | 6 | // note: exported symbol is now winampGetInModule2. 7 | 8 | #define IN_UNICODE 0x0F000000 9 | 10 | #ifdef UNICODE_INPUT_PLUGIN 11 | #define in_char wchar_t 12 | #define IN_VER (IN_UNICODE | 0x100) 13 | #else 14 | #define in_char char 15 | #define IN_VER 0x100 16 | #endif 17 | 18 | #define IN_MODULE_FLAG_USES_OUTPUT_PLUGIN 1 19 | // By default, Winamp assumes that your input plugin wants to use Winamp's EQ, and doesn't do replay gain 20 | // if you handle any of these yourself (EQ, Replay Gain adjustments), then set these flags accordingly 21 | #define IN_MODULE_FLAG_EQ 2 // set this if you do your own EQ 22 | #define IN_MODULE_FLAG_REPLAYGAIN 8 // set this if you adjusted volume for replay gain 23 | // for tracks with no replay gain metadata, you should clear this flag 24 | // UNLESS you handle "non_replaygain" gain adjustment yourself 25 | #define IN_MODULE_FLAG_REPLAYGAIN_PREAMP 16 // use this if you queried for the replay gain preamp parameter and used it 26 | // this parameter is new to 5.54 27 | typedef struct 28 | { 29 | int version; // module type (IN_VER) 30 | char *description; // description of module, with version string 31 | 32 | HWND hMainWindow; // winamp's main window (filled in by winamp) 33 | HINSTANCE hDllInstance; // DLL instance handle (Also filled in by winamp) 34 | 35 | char *FileExtensions; // "mp3\0Layer 3 MPEG\0mp2\0Layer 2 MPEG\0mpg\0Layer 1 MPEG\0" 36 | // May be altered from Config, so the user can select what they want 37 | 38 | int is_seekable; // is this stream seekable? 39 | int UsesOutputPlug; // does this plug-in use the output plug-ins? (musn't ever change, ever :) 40 | // note that this has turned into a "flags" field 41 | // see IN_MODULE_FLAG_* 42 | 43 | void (*Config)(HWND hwndParent); // configuration dialog 44 | void (*About)(HWND hwndParent); // about dialog 45 | 46 | void (*Init)(); // called at program init 47 | void (*Quit)(); // called at program quit 48 | 49 | #define GETFILEINFO_TITLE_LENGTH 2048 50 | void (*GetFileInfo)(const in_char *file, in_char *title, int *length_in_ms); // if file == NULL, current playing is used 51 | 52 | #define INFOBOX_EDITED 0 53 | #define INFOBOX_UNCHANGED 1 54 | int (*InfoBox)(const in_char *file, HWND hwndParent); 55 | 56 | int (*IsOurFile)(const in_char *fn); // called before extension checks, to allow detection of mms://, etc 57 | // playback stuff 58 | int (*Play)(const in_char *fn); // return zero on success, -1 on file-not-found, some other value on other (stopping winamp) error 59 | void (*Pause)(); // pause stream 60 | void (*UnPause)(); // unpause stream 61 | int (*IsPaused)(); // ispaused? return 1 if paused, 0 if not 62 | void (*Stop)(); // stop (unload) stream 63 | 64 | // time stuff 65 | int (*GetLength)(); // get length in ms 66 | int (*GetOutputTime)(); // returns current output time in ms. (usually returns outMod->GetOutputTime() 67 | void (*SetOutputTime)(int time_in_ms); // seeks to point in stream (in ms). Usually you signal your thread to seek, which seeks and calls outMod->Flush().. 68 | 69 | // volume stuff 70 | void (*SetVolume)(int volume); // from 0 to 255.. usually just call outMod->SetVolume 71 | void (*SetPan)(int pan); // from -127 to 127.. usually just call outMod->SetPan 72 | 73 | // in-window builtin vis stuff 74 | 75 | void (*SAVSAInit)(int maxlatency_in_ms, int srate); // call once in Play(). maxlatency_in_ms should be the value returned from outMod->Open() 76 | // call after opening audio device with max latency in ms and samplerate 77 | void (*SAVSADeInit)(); // call in Stop() 78 | 79 | 80 | // simple vis supplying mode 81 | void (*SAAddPCMData)(void *PCMData, int nch, int bps, int timestamp); 82 | // sets the spec data directly from PCM data 83 | // quick and easy way to get vis working :) 84 | // needs at least 576 samples :) 85 | 86 | // advanced vis supplying mode, only use if you're cool. Use SAAddPCMData for most stuff. 87 | int (*SAGetMode)(); // gets csa (the current type (4=ws,2=osc,1=spec)) 88 | // use when calling SAAdd() 89 | int (*SAAdd)(void *data, int timestamp, int csa); // sets the spec data, filled in by winamp 90 | 91 | 92 | // vis stuff (plug-in) 93 | // simple vis supplying mode 94 | void (*VSAAddPCMData)(void *PCMData, int nch, int bps, int timestamp); // sets the vis data directly from PCM data 95 | // quick and easy way to get vis working :) 96 | // needs at least 576 samples :) 97 | 98 | // advanced vis supplying mode, only use if you're cool. Use VSAAddPCMData for most stuff. 99 | int (*VSAGetMode)(int *specNch, int *waveNch); // use to figure out what to give to VSAAdd 100 | int (*VSAAdd)(void *data, int timestamp); // filled in by winamp, called by plug-in 101 | 102 | 103 | // call this in Play() to tell the vis plug-ins the current output params. 104 | void (*VSASetInfo)(int srate, int nch); // <-- Correct (benski, dec 2005).. old declaration had the params backwards 105 | 106 | 107 | // dsp plug-in processing: 108 | // (filled in by winamp, calld by input plug) 109 | 110 | // returns 1 if active (which means that the number of samples returned by dsp_dosamples 111 | // could be greater than went in.. Use it to estimate if you'll have enough room in the 112 | // output buffer 113 | int (*dsp_isactive)(); 114 | 115 | // returns number of samples to output. This can be as much as twice numsamples. 116 | // be sure to allocate enough buffer for samples, then. 117 | int (*dsp_dosamples)(short int *samples, int numsamples, int bps, int nch, int srate); 118 | 119 | 120 | // eq stuff 121 | void (*EQSet)(int on, char data[10], int preamp); // 0-64 each, 31 is +0, 0 is +12, 63 is -12. Do nothing to ignore. 122 | 123 | // info setting (filled in by winamp) 124 | void (*SetInfo)(int bitrate, int srate, int stereo, int synched); // if -1, changes ignored? :) 125 | 126 | Out_Module *outMod; // filled in by winamp, optionally used :) 127 | } In_Module; 128 | 129 | // return values from the winampUninstallPlugin(HINSTANCE hdll, HWND parent, int param) 130 | // which determine if we can uninstall the plugin immediately or on winamp restart 131 | // 132 | // uninstall support was added from 5.0+ and uninstall now support from 5.5+ 133 | // it is down to you to ensure that if uninstall now is returned that it will not cause a crash 134 | // (ie don't use if you've been subclassing the main window) 135 | #define IN_PLUGIN_UNINSTALL_NOW 0x1 136 | #define IN_PLUGIN_UNINSTALL_REBOOT 0x0 137 | 138 | #endif --------------------------------------------------------------------------------