Next: Introduction [Contents][Index]
This manual is for SatouSynth (v0.1.1, 18 August 2025), a high-performance VGM playback and sound chip emulation library written entirely in Common Lisp.
Next: Using SatouSynth, Previous: SatouSynth, Up: SatouSynth [Contents][Index]
SatouSynth is a high-performance VGM playback and sound chip emulator library written entirely in Common Lisp without using any C bindings. It is based on VGMPlay, and has had been modified to be object-oriented. The goals of SatouSynth are to provide native VGM playback in Common Lisp without bindings to any C library; a cleaned-up and object-oriented version of VGMPlay, redesigned to be a library; and performance on par with its sister Crystal library, YunoSynth.
SatouSynth is designed exclusively for the SBCL implementation of Common Lisp. Additional Common Lisp implementations may be supported in the future, though performance may vary greatly.
Next: Emulated Chips, Up: Introduction [Contents][Index]
Some of the features of SatouSynth include:
Previous: Library Features, Up: Introduction [Contents][Index]
Next: API Reference, Previous: Introduction, Up: SatouSynth [Contents][Index]
Next: Playing a VGM File, Up: Using SatouSynth [Contents][Index]
A small set of dependencies are needed before SatouSynth is loaded. Most of these can be installed using QuickLisp (though this hasn’t been tested).
One dependency that cannot be loaded via QuickLisp at the time of writing is CL-SDM. This must be obtained manually and placed somewhere where ASDF can locate it.
Once the dependencies are located, you can load SatouSynth in a REPL by doing the following:
(asdf:load-system :satou)
Previous: Loading the Library, Up: Using SatouSynth [Contents][Index]
Loading and playing a VGM file consists of a few steps: creating a
vgm-file instance, creating a vgm-player instance, starting the
player, then rendering audio data.
(let* (;; We start by creating a VGM-FILE by calling LOAD-VGM-FILE
(vgm (satou:load-vgm-file "/path/to/file.vgm"))
;; Now we create a VGM-PLAYER that will be used to play
;; this file.
(player (satou:make-vgm-player vgm)))
;; Now we start the VGM-PLAYER instance.
(satou:vgm-player-play player)
;; Now we are ready to render audio data.
)
Once we have our vgm-file loaded, and vgm-player created and
playing, we can begin rendering audio data. SatouSynth only renders to
single-float, and can either render stereo interleaved data, or render
the left and right channels separately. In most cases you will want to render
stereo interleaved data. In either case, you will need one or two (vector
single-float) buffers to hold the rendered audio data.
Some VGM files have loop information embedded into them, while others are “one-shot” VGM files that only play through once. This is important if you need to determine when to stop playing a VGM file. For example, the music used in the first stage of the arcade game Sunset Riders is designed to loop continuously, and so that VGM has loop information contained within it. However, the music that plays during the stage introduction (the screen where the “Wanted!” poster is shown introducing the boss) is designed just to play once and then stop, and so that VGM does not have any loop information. SatouSynth will automatically loop VGMs that support looping.
Determining when to stop playing can be accomplished by using the
vgm-player-times-played function. This is incremented by one each time a
VGM file loops, or when a “one-shot” VGM player finishes playing.
Given this information, lets expand our code to create a very simple player that plays a VGM file once; if the VGM has loop information, then it’s played back only one time.
(let* (;; Load the VGM file as before
(vgm (satou:load-vgm-file filename))
;; Create a player that will play the VGM
(player (satou:make-vgm-player vgm))
;; Create a buffer of 256 single-floats that we will render audio
;; data into. This will hold our stereo interleaved data.
(buf (make-array 256 :element-type 'single-float
:initial-element 0.0)))
;; Start the player like before
(satou:vgm-player-play player)
;; Now we loop until we've played through the VGM exactly once.
(loop until (= (satou:vgm-player-times-played player) 1)
do ;; Render audio data into BUF
(satou:vgm-player-render player buf)
;; Normally we would now do something with the data in BUF.
))
Rendering data into a buffer is fine, but usually we want to hear something. So as a final example, we will expand the code to actually play our rendered audio through our speakers using the CL-RemiAudio library via libao. This is a separate library that we are just using for this example, not a dependency of SatouSynth. We will also wrap the player code inside of a function for easier use.
;; Let's make sure CL-RemiAudio's libao driver is loaded
(asdf:load-system :cl-remiaudio-drivers-ao)
;; Create a function that will play VGM files.
(defun play-vgm (filename)
;; Initialize CL-RemiAudio's libao driver. We'll send audio data
;; to OUT.
(cl-ra/drivers:with-driver (:ao)
(cl-ra/drivers:with-open-device (out :ao)
;; Create the VGM-FILE, VGM-PLAYER, and buffer like before
(let* ((vgm (satou:load-vgm-file filename))
(player (satou:make-vgm-player vgm))
(buf (make-array 256 :element-type 'single-float
:initial-element 0.0)))
;; Start the player
(satou:vgm-player-play player)
;; Now we loop until we've played through the VGM exactly once.
(loop until (= (satou:vgm-player-times-played player) 1)
do ;; Render audio data into BUF
(satou:vgm-player-render player buf)
;; Send the rendered audio data to our speakers
(cl-ra/drivers:write-buffer out buf))))))
;; Now we can use this function to easily play a VGM file.
(play-vgm #P"/path/to/your/song.vgm")
Next: Concept Index, Previous: Using SatouSynth, Up: SatouSynth [Contents][Index]
Next: Basic Types, Up: API Reference [Contents][Index]
A constant string containing the version of the library.
A special variable that defines the maximum size of a VGM file (before decompression) that will be loaded.
This variable exists to help prevent bad or malicious files from eating up end users’ RAM. The default size is 100 megabytes, which should be more than enough for any VGM file out there. One of the largest VGMs in the author’s collection, before decompression, is “After Burner (Extended)” from the 32X version of After Burner II, and it’s 11 megabytes.
This won’t totally prevent zip bombs, but it will at least help. API users can tune this to their needs.
Next: Miscellaneous Functions, Previous: Globals and Constants, Up: API Reference [Contents][Index]
A buffer that is used during rendering to contain audio data generated by an
emulation core. This is basically an alias for a simple-array that
contains two additional simple-arrays representing the left and right
channels.
The type is defined as an alias to: (simple-array (simple-array
(signed-byte 32) (*)) (2))).
A symbol that represents an emulated chip.
Returns a basic short name for a t/chip as a string.
Some chips have multiple names associated with their type. For the most
accurate name when using a VGM file, instantiating a chip instance and using the
chip-short-name (see chip-short-name) generic function will be much
more accurate. This is because these names can only be determined after parsing
the VGM.
Returns a basic long name for a t/chip as a string.
Some chips have multiple names associated with their type. For the most
accurate name when using a VGM file, instantiating a chip instance and using the
chip-name (see chip-name) generic function will be much more
accurate. This is because these names can only be determined after parsing the
VGM.
This is the base condition type for all errors that can occur within SatouSynth.
A condition that indicates one or more requested chip emulators are unsupported
by the library. This is a subclass of satou-error.
This is raised when attempting to play a VGM that uses chips that are not
currently supported by SatouSynth. You can use the
unsupported-chip-error-chips method to get the list of unsupported chips.
This list is also reported when the condition instance is printed.
A list of t/chip symbols that are not supported by SatouSynth.
A condition that indicates a problem within a VGM file. This is a subclass of
satou-error.
A condition that indicates a VGM file is too large to load
(see *max-allowed-file-size*. This is a subclass of vgm-error.
Next: VGM Files, Previous: Basic Types, Up: API Reference [Contents][Index]
Returns a list of t/chip symbols indicating the chips that are
supported by SatouSynth.
Returns a list of t/chip symbols indicating the chips that are not
yet supported by SatouSynth.
Converts a playback sample number into a VGM file sample number. All parameters
must be (signed-byte 64).
Converts a VGM file sample number into a playback sample number. All parameters
must be (signed-byte 64).
Calculates the resampling values needed so that vgm can be played back at sample-rate. Returns two 32-bit unsigned integer values: the sample rate multiplier, and the sample rate divider.
Calculates the resampling values needed so that vgm can be played back at sample-rate, using a speed multiplier of playback-rate. If playback-rate is zero (the default), then it acts as a playback rate of 1x.
The sample-rate, playback-rate, and vgm-sample-rate parameters must be 32-bit unsigned integers.
Returns two 32-bit unsigned integer values: the sample rate multiplier, and the sample rate divider.
Next: VGM Compression, Previous: Miscellaneous Functions, Up: API Reference [Contents][Index]
VGM is a music format that logs the sound output from various sound chips so that it can be reproduced in a sample-accurate manner. This is accomplished by capturing the commands and data sent from a running program to sound chips, then storing these so that they may be replayed either on real hardware, or through emulators of the original sound chips. SatouSynth only supports emulated sound chips.
Many VGM files store music captured from various arcade, console, and home computer games. There is also a very large number that have been created from scratch to hold original compositions.
The official specification for VGM files can be found at this address: https://vgmrips.net/wiki/VGM_Specification. Some of the documentation found in this section is taken from these specifications, and is under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported license.
Next: Basic VGM File Functions, Up: VGM Files [Contents][Index]
This class is a virtual representation of a VGM file. You can load a file from
disk using the load-vgm-file function (see load-vgm-file).
A VGM file consists of a main header, which mainly contains offsets and clock values; a GD3 tag for metadata; optional c sample data, which may be compressed in various formats, depending on the chips used; and the actual instructions for playback. Some VGM files also have an “extra header”, which is a second header that contains additional clock and volume information.
Class precedence list: closer-mop:standard-class
This metaclass is used by the vgm-file-header class to provide additional
keywords for slots. Unless you’re wanting to subclass vgm-file-header,
you should not need to use this.
Class precedence list: closer-mop:standard-direct-slot-definition
This metaclass is used by the vgm-file-header class to provide additional
keywords for slots. This one is specifically for direct slots. Unless you’re
wanting to subclass vgm-file-header, you should not need to use this.
Class precedence list: closer-mop:standard-effective-slot-definition
This metaclass is used by the vgm-file-header class to provide additional
keywords for slots. This one is specifically for effective slots. Unless
you’re wanting to subclass vgm-file-header, you should not need to use
this.
Class precedence list: t
The vgm-file-header class contains all of the header values for a VGM
file. This includes offsets, clock values, the number of samples, loop
information, VGM format version, and many other fields. All functions which
access slots of this class are prefixed with vgm-header-.
Class precedence list: t
This class stores additional clock information, as found within the “extra
headers” field of a VGM file. All functions related to this class are prefixed
with extra-header-clock-.
Class precedence list: t
This class stores additional volume information, as found within the “extra
headers” field of a VGM file. All functions related to this class are prefixed
with extra-header-volume-.
Class precedence list: t
This class stores the “extra headers” field of a VGM file. All functions
related to this class are prefixed with extra-header-.
Next: VGM File Headers, Previous: VGM File Classes, Up: VGM Files [Contents][Index]
Returns the vgm-file-header instance stored in vgm.
Returns the gd3-tag instance stored in vgm.
When a VGM file is loaded and does not contain GD3 data, this will still return
a gd3-tag, but all of its fields will be blank.
Returns the (simple-array (unsigned-byte 8) (*)) containing the raw
non-header data stored in vgm.
Returns the offset where the raw non-header data is located in the original VGM file that was loaded to produce vgm.
Returns the extra-header instance stored in vgm, or nil if
there is none.
Returns the VGM format version that vgm conforms to.
Returns t if chip (which must be a t/chip symbol) is used in
the VGM file, or nil otherwise.
Returns the clock value, in hertz, for chip as found in the header fields
of vgm. If the chip is not used, this will return zero. chip must
be a t/chip symbol.
Returns a hash table where the keys are t/chip symbols, and the values
are the number of instances of that chip that are used in vgm. Chips that
are not used do not appear in the returned table.
Checks to see if vgm uses any chips that are currently unsupported by
SatouSynth. This returns a list of t/chip symbols for the chips
that are unsupported.
Calculates the total play time for vgm, in milliseconds. loops is the total number of times the VGM will play through, and is only taken into account of vgm has loop information. It must be at least 1, which is the default (zero would mean “don’t play the VGM even once,” and is thus meaningless).
Next: VGM File Loading, Previous: Basic VGM File Functions, Up: VGM Files [Contents][Index]
VGM files start with a 256 byte header that contains information such as chip clock speeds, offsets, and flags. It also contains the version of the VGM format of the file. SatouSynth has an almost 1:1 abstraction of this header.
When it comes to the clock values, bit 30 has a special meaning. When this bit is set, it indicates that the VGM expects that chip to be a “dual chip”. Chips that support this flag are: SN76479, YM2413, YM2612, YM2151, YM2203, YM2608, YM2610, YM3812, YM3526, Y8950, YMZ280B, YMF262, YMF278B, YMF271, AY8910, Game Boy DMG, NES APU, MultiPCM, µPD7759, OKIM6258, OKIM6295, K051649, K054539, HuC6280, C140, K053260, Pokey, SCSP, Wonderswan, VSU, SAA1099, ES5503, ES5506, X1-010, C352, and GA20.
Returns the version of the VGM format reported in header.
The version number is coded as a binary coded decimal. For example, version 1.71 is encoded as 0x00000171. The version field is used for backwards compatibility with players, and also defines which fields are present in the header.
Returns the clock value, in hertz, for the SN76489 chip. If this is zero, then the SN76489 is not used by the VGM file.
When bit 31 of the returned value is set, and the “dual chip” bit is also set (bit 30), then it indicates that the VGM expects the T6W28 variant of the SN76489 to be present instead of a normal SN76489. This is used, for example, in VGM files logged from NeoGeo Pocket games.
Returns the clock value, in hertz, for the YM2413 chip. If this is zero, then the YM2413 is not used by the VGM file.
For VGM versions 1.01 and earlier, this may actually be the clock for the YM2151 or YM2612. If the value returned is over 5,000,000, then it must be the clock value for the YM2612.
Returns the offset of the GD3 tag relative to where this field is in the header. If this is zero, then the VGM does not contain a GD3 tag.
Returns the total number of samples in the VGM. This is equivalent to how many audio samples are generated per-channel when the VGM is played back and not allowed to loop.
Returns the the relative offset to the loop point, or zero if there is no loop in the VGM file.
For example, if the data for the one-off introduction segment in a song was in bytes 0x0040 through 0x3FFF of the file, and then the main looping section started at 0x4000, this would contain the value
0x4000 - 0x1C = 0x3FE4
(A value of 0x1C is subtracted here because this header field is located at that byte).
Returns the number of samples in the loop section of a VGM, or zero if there is no loop. This is equivalent to how many audio samples are generated per-channel when the looping section of a VGM is played back exactly once.
The rate of recording, in hertz, of the VGM file. This is mainly used for rate scaling on playback, and is typically either 50 for VGMs recorded from PAL systems, or 60 for NTSC systems. Some VGMs set this to zero if rate scaling is not needed. VGM files that follow format version 1.00 will always have a value of zero here.
Returns the amount of white noise feedback for the SN76489 chip.
Known values are:
0x0003SN76489, SN94624
0x0006Used incorrectly by some packs to refer to SN76489A, SN76494, SN76496, and Y204 in combination with the LFSR width value of 16. Should be feedback pattern 0xC and LFSR width of 17. The latter correctly reflects 1 additional bit of latency between shift register and output.
0x0009Sega Master System 2/Game Gear/Mega Drive (SN76489/SN76496 integrated into Sega VDP chip)
0x000CSN76489A, SN76494, SN76496, Y204
0x0022NCR8496, PSSJ3
Returns the noise feedback shift register width for the SN76480 chip.
Known values are:
15SN76489, SN94624
16Sega Master System 2/Game Gear/Mega Drive (SN76489/SN76496 integrated into Sega VDP chip), NCR8496, PSSJ3
17SN76489A, SN76494, SN76496, Y204
Returns the flags for the SN76480 chip.
Frequency 0 is 0x400 (this should set for all chips but the Sega PSG)
Output negation flag
GameGear stereo on/off (on when bit clear)
Clock Divider is divided by 8 when on, or not when off (on when bit clear)
XNOR noise mode (for NCR8496/PSSJ-3)
Reserved (must be zero)
Returns the clock value, in hertz, of the YM2612, or zero if no YM2612 is used in the VGM file.
Note that for VGM versions 1.01 and earlier, the YM2413 clock rate should be used instead if its value is over 5,000,000 (see vgm-header-ym2413-clock).
In VGM file versions 1.51 and later, when bit 31 of the value returned by this function is set, then it indicates that the chip should be the YM3438 variant of the YM2612.
Returns the clock value, in hertz, of the YM2151, or zero if no YM2151 is used in the VGM file.
For VGM versions 1.01 and earlier, if the YM2413 clock rate is greater than zero and less than 5,000,000, then that header value should be used for the clock rate of the YM2151 instead (see vgm-header-ym2413-clock).
For VGM versions 1.51 and later, if bit 31 in the value returned by this function is set, then it indicates the VGM expects the YM2164 variant of the YM2151.
Returns the relative offset to the VGM data stream, i.e. the data that contains the playback instructions.
If this value is 0x0C, then the data offset is actually at absolute offset 0x40.
For VGM versions prior to 1.50, this field should be zero, and the data is expected to start at absolute offset 0x40.
Returns the clock value, in hertz, for the Sega PCM chip. This is zero if no Sega PCM chip is used in the VGM.
Returns the interface register for the Sega PCM chip. This should be zero if no Sega PCM chip is used.
Returns the clock value, in hertz, for the RF5C69 chip. This is zero if no RF5C69 chip is used in the VGM.
Returns the clock value, in hertz, for the YM2203 chip. This is zero if no YM2203 chip is used in the VGM.
Returns the clock value, in hertz, for the YM2608 chip. This is zero if no YM2608 chip is used in the VGM.
Returns the clock value, in hertz, for the YM2610 chip. This is zero if no YM2610 chip is used in the VGM.
When bit 31 of the value returned by this function is set, then the VGM expects the YM2610B variant of the chip, otherwise it expects the normal YM2610 variant.
Returns the clock value, in hertz, for the YM3812 chip. This is zero if no YM3812 chip is used in the VGM.
Returns the clock value, in hertz, for the YM3526 chip. This is zero if no YM3526 chip is used in the VGM.
Returns the clock value, in hertz, for the Y8950 chip. This is zero if no Y8950 chip is used in the VGM.
Returns the clock value, in hertz, for the YMF262 chip. This is zero if no YMF262 chip is used in the VGM.
Returns the clock value, in hertz, for the YMF268B chip. This is zero if no YMF268B chip is used in the VGM.
Returns the clock value, in hertz, for the YMF271 chip. This is zero if no YMF271 chip is used in the VGM.
Returns the clock value, in hertz, for the YMZ278B chip. This is zero if no YMZ278B chip is used in the VGM.
Returns the clock value, in hertz, for the RF5C164 chip. This is zero if no RF5C164 chip is used in the VGM.
Returns the clock value, in hertz, for the Sega PWM chip. This is zero if no Sega PWM chip is used in the VGM.
Returns the clock value, in hertz, for the AY-1-8910 chip. This is zero if no AY-1-8910 chip is used in the VGM.
Returns the type/variant of the AY-1-8910 chip that the VGM expects.
The possible values are:
0x00AY-1-8910
0x01AY-1-8912
0x02AY-1-8913
0x03AY-1-8930
0x04AY-1-8914
0x10YM2149
0x11YM3439
0x12YMZ284
0x13YMZ294
Returns various flags for the AY-1-8910 chip, encoded in the bits of the returned value. For additional information, see ay8910.h in the MAME source code.
The default value is 0x01. Other values are:
Legacy output
Single output
Discrete output
RAW output
YTMxxxx pin 26 (clock divider) is low
Reserved (must be zero)
Returns various flags for the AY-1-8910 chip that is part of the YM2203, encoded in the bits of the returned value. This is separate from the flags for the normal AY-1-8910.
Returns various flags for the AY-1-8910 chip that is part of the YM2608, encoded in the bits of the returned value. This is separate from the flags for the normal AY-1-8910.
A global volume modifier for the entire VGM file. The value returned by this function is not a direct volume modifier, but an encoded value, where 0xC1 is equal to a modifier value of -63, 0x00 is zero, and 0xC0 is 192. However, a decoded value of -63 should be replaced with a value of -64 so that a factor of 0.25 is possible.
To calculate the output volume, use this formula:
Volume = 2^{(DecodedModifier / 0x20)}.
The default is zero, which is equal to a factor of 1, or 100%.
How many times a VGM file should loop before playback ends.
The resulting number of loops that are played is calculated as following:
NumLoops = NumLoopsModified - LoopBase
The Default is 0. Negative numbers are possible.
This field is not used by SatouSynth’s VGM player code.
Modifies the number of loops that are played before playback ends. The resulting number of loops that are played is calculated using:
NumLoops = ProgramNumLoops * LoopModifier / 0x10
The default is zero, which is equal to 0x10.
This field is not used by SatouSynth’s VGM player code.
Returns the clock value, in hertz, for the DMG chip. This is zero if no DMG chip is used in the VGM.
Returns the clock value, in hertz, for the NES APU chip. This is zero if no NES APU chip is used in the VGM.
When bit 31 of the value returned by this function is set, then the Famicom Disk System sound add-on is expected to be present and enabled as well.
Returns the clock value, in hertz, for the MultiPCM chip. This is zero if no MultiPCM chip is used in the VGM.
Returns the clock value, in hertz, for the µPD7759 chip. This is zero if no µPD7759 chip is used in the VGM.
Returns the clock value, in hertz, for the OKI MSM6258 chip. This is zero if no OKI MSM6258 chip is used in the VGM.
Additional flags for the OKI MSM6258 chip. The default is zero. Other values are:
A two-bit value indicating the clock divider to use. A value of zero means a clock divider of 1024, a value of one is a divider of 768, and a divider of 2 or 3 is a divider of 512.
3-bit ADPCM when clear, 4-bit ADPCM when set (default is 4-bit, doesn’t work currently)
10-bit output when clear, 12-bit output when set
Reserved (must be zero)
Extra flags for the K054539 chip. The default is 0x01. Other values are:
Reverse stereo
Disable reverb
Update at KeyOn
Reserved (must be zero)
See k054539.h in the MAME source code for more information.
Defines the variant of the C140 chip that the VGM expects to use. Possible values are:
0x00Namco C140, as found in the Namco System 2 arcade board.
0x00Namco C140, as found in the Namco System 21 arcade board.
0x00Namco 219 ASIC, as found in the Namco NA-1 and NA-2 arcade boards.
Returns the clock value, in hertz, for the OKI MSM6295 chip. This is zero if no OKI MSM6295 chip is used in the VGM.
Returns the clock value, in hertz, for the K051649 chip. This is zero if no K051649 chip is used in the VGM.
Returns the clock value, in hertz, for the K054539 chip. This is zero if no K054539 chip is used in the VGM.
When bit 31 of the value returned by this function is set, then the VGM expects the K052539 variant of the chip.
Returns the clock value, in hertz, for the HuC6280 chip. This is zero if no HuC6280 chip is used in the VGM.
Returns the clock value, in hertz, for the C140 chip. This is zero if no C140 chip is used in the VGM.
Returns the clock value, in hertz, for the K052360 chip. This is zero if no K052360 chip is used in the VGM.
Returns the clock value, in hertz, for the POKEY chip. This is zero if no POKEY chip is used in the VGM.
Returns the clock value, in hertz, for the QSound chip. This is zero if no QSound chip is used in the VGM.
Returns the clock value, in hertz, for the SCSP (Saturn Custom Sound Processor, aka YMF292) chip. This is zero if no SCSP chip is used in the VGM.
The relative offset to the “extra header” section. This is zero if there is no “extra header” present.
Returns the clock value, in hertz, for the Wonderswan chip. This is zero if no Wonderswan chip is used in the VGM.
gReturns the clock value, in hertz, for the VSU-VUE chip. This is zero if no VSU-VUE chip is used in the VGM.
Returns the clock value, in hertz, for the SAA1099 chip. This is zero if no SAA1099 chip is used in the VGM.
Returns the clock value, in hertz, for the ES5503 chip. This is zero if no ES5503 chip is used in the VGM.
Returns the clock value, in hertz, for the ES5506/ES5505 chip. This is zero if no ES5506/ES5505 chip is used in the VGM.
If bit 31 of the value returned by this function is set, then the VGM expects an ES5506 variant of this chip, otherwise it expects the ES5505 variant.
The number of output channels for the ES5503 chip. Possible values are 1 to 8, and a typical value is 2.
The number of output channels for the ES5506/ES5505 chip. Possible values are 1 to 4 for the ES5505, and 1 to 8 for the ES5506. A typical value is 1.
Returns the clock divider value for the C352 chip, divided by four.
The value stored in the VGM is divided by four in order to achieve a divider range of 0 to 1020.
Returns the clock value, in hertz, for the X1-010 chip. This is zero if no X1-010 chip is used in the VGM.
Returns the clock value, in hertz, for the C352 chip. This is zero if no C352 chip is used in the VGM.
Returns the clock value, in hertz, for the GA20 chip. This is zero if no GA20 chip is used in the VGM.
Returns the clock value, in hertz, for the MIKEY chip. This is zero if no MIKEY chip is used in the VGM.
Returns the t/chip of the chip that uses this clock value.
Returns the clock value, in hertz.
Returns the numeric chip ID of the chip that uses this volume value.
Extra flags for this extra chip volume header. Possible values:
When set, then the volume is for the second chip, otherwise it is for the first/primary chip.
Reserved
Returns the volume modification value.
Note that if bit 15 of this value is zero, then this is an absolute volume setting. If bit 15 is 1, then this is a relative volume value, and the chip volume gets multiplied:
NewChipVolume = OrigChipVolume * ((Value & 0x7FFF) / 0x0100)
A hash table containing the extra-header-clock instances. The keys of
this table are t/chip symbols, and the values are a (vector extra-header-clock).
A hash table containing the extra-header-volume instances. The keys of
this table are t/chip symbols, and the values are a (vector extra-header-volume).
Previous: VGM File Headers, Up: VGM Files [Contents][Index]
Creates a new vgm-file instance by reading from the given source.
source can be a pathname, a pathname containing a path, or
an open stream. The data in the source may be compressed.
hint can be a keyword which will be passed to the
satou/decompression:maybe-decompress method
(see satou/decompression::maybe-decompress).
The size of source (in bytes) must be less than or equal to
*max-allowed-file-size* before decompression
(see *max-allowed-file-size*. If it’s greater, then a
vgm-too-large-error will be raised. When this happens, a restart called
load-anyway will be active that will allow loading to continue
regardless. This restart is in the satou package.
Creates a new vgm-file instance by reading data from stream. This
data must not be compressed. stream must be an open stream, and must able
to seek using file-position.
Checks to see if source is a valid VGM file. source may be a
string containing a path, a pathname, or an open stream. If it’s
a stream, it must be able to seek using file-position.
The size of source must be less than or equal to
*max-allowed-file-size* before decompression
(see *max-allowed-file-size*). If it is not, nil is returned.
Next: GD3 Tags, Previous: VGM Files, Up: API Reference [Contents][Index]
SatouSynth is able to load compressed VGM files. These are files that have been compressed in their entirety using one of the methods supported by SatouSynth. These methods (and the suggested file extensions) are:
The VGM Specification only lists GZip as a compression scheme. BZip2 and ZStandard were added to SatouSynth because these compress files better, ZStandard decompresses very quickly, and to give users more control over their data.
Here is a table showing some compression results based on a collection of 4493 VGM files:
| Format | Size (MB) | Size (Bytes) |
|---|---|---|
| Uncompressed | 1126.2 | 1209206332 |
| GZip | 389 | 408244197 |
| GZip + Advdef | 374 | 392424223 |
| ZStandard | 343 | 360470153 |
| BZip2 | 336 | 352141578 |
Note: “GZip + Advdef” means “GZipped, then recompressed using AdvanceCOMP”.
In addition to the above formats, SatouSynth’s decompression system is also
extensible. This allows users of the library to extend the supported
compression methods without needing to modify SatouSynth directly. This is
accomplished using the register function
(see satou/decompression::register).
Next: Custom VGM Decompression Scheme Example, Up: VGM Compression [Contents][Index]
All functions and types listed below reside in the satou/decompression
package.
A list that only contains simple-strings.
Defines a decompression scheme, as well as a list of file extensions commonly
associated with the scheme. Normally users do not create instances of
func-set directly, but rather use the register function to
implicitly create one and register it with the decompression system
(see satou/decompression::register).
Returns t if thing is a func-set, or nil otherwise.
Returns the t/extension-list of common file extensions for the
compression scheme defined by func-set. These file extensions should not
have the initial dot (e.g., "vgb", not ".vgb").
Sets the t/extension-list of common file extensions for the compression
scheme defined by func-set. These file extensions should not have the
initial dot (e.g., "vgb", not ".vgb").
Returns the function that is called to see if a stream uses the compression scheme defined in func-set.
Sets the function that is called to see if a stream uses the compression scheme
defined in func-set. This function must take a single argument, an open
stream, and must return a truthy value if the stream can be decompressed by
func-set, or nil otherwise. This function must also be sure to
rewind the stream to the position it was at before returning.
Returns the function that is called to decompress data from a stream.
Sets the a function that is called to decompress data from a stream. This
function must take a single argument, an open stream, and must return a
(sdm:memory-stream) that will return decompressed data.
Returns all of the identifiers for the currently registered decompression
schemes as a list of keyword symbols.
Checks to see if identifier is a registered compression scheme. Returns
the func-set if it’s a known scheme, or nil otherwise.
Registers a new method for checking for compressed data, and decompressing
that data. identifier can be used to reference the func-set using get-func-set after
registering.
extensions must consist entirely of strings, and is a set of file
extensions that can be used by get-hint for this compression scheme
(see satou/decompression::get-hint). The extensions should not include the
leading period, and should be entirely lowercase, e.g. "vgz".
extensions cannot contain the string "vgm", regardless of case.
check-fn must be a function that accepts a single argument (an open stream), and returns a generalized boolean indicating whether the stream contains compressed data or not.
decomp-fn must be a function that accepts a single argument (an open
stream), and returns an sdm:memory-stream that is ready to be read
from, and that contains the decompressed data.
get-stream-fn must be a function that accepts a single argument (an open
stream), and returns a stream that can be used for on-the-fly
decompression.
Note that identifier cannot be :none.
This may raise a duplicate-func-set-error condition. When it does, a
restart called replace-fn-set will be active. When this restart is
invoked, then the old information representing the decompression scheme will be
replaced with the newly registered information. This restart resides in the
satou/decompression package.
Checks to see if stream needs to be decompressed. If it does, this
decompresses the stream into RAM. This then returns either an
sdm:memory-stream that can be used to read uncompressed data, or the
original stream if it was not compressed. stream must support the
file-position function.
If hint is provided and is keyword representing a known decompression
scheme (see satou/decompression::get-func-set), then that scheme will be
tried first to offer a speedup in load times. You can get a hint by using
get-hint.
Checks to see if some-stream needs to be decompressed. If it does, this
returns a new stream that will return decompressed data when something
reads from it. If some-stream does not need to be decompressed, then this
returns some-stream.
some-stream must support seeking using file-position.
Looks at the extension of filename using pathname-type and attempts
to guess the compression method used on the file (if any). This will return a
keyword with its best guess, or nil otherwise.
If a keyword is returned, it will reference one of the registered compression
methods (see satou/decompression::get-func-set,
see satou/decompression::register). This keyword can then be passed to the
maybe-decompress function as its hint parameter for faster
checking of the decompression scheme.
This returns nil if it thinks that filename is an uncompressed VGM
file.
Previous: VGM Compression Functions and Types, Up: VGM Compression [Contents][Index]
This example registers a new compression scheme, XZ, with SatouSynth. It
assumes that you have some package, xz, that allows you to decompress
XZ-compressed streams.
;; This will be our "checker function". It returns T if it's an
;; XZ-compressed file, or NIL otherwise.
(defun xz-compressed-p (stream)
(let ((buf (make-array 6 :element-type '(unsigned-byte 8)
:initial-element 0))
(pos (file-position stream)))
;; Read the first six bytes, then return the file position to where
;; it was before reading.
(unwind-protect
(read-sequence buf stream)
(file-position stream pos))
;; Check that we have the magic XZ value.
(and (= (aref buf 0) #xFD)
(= (aref buf 1) #x37)
(= (aref buf 2) #x7A)
(= (aref buf 3) #x58)
(= (aref buf 4) #x5A)
(= (aref buf 5) #x00))))
(defun decompress-xz-stream (stream)
;; Create an SDM:MEMORY-STREAM. We'll store the decompressed data in
;; DECOMPRESSED.
(let ((decompressed (make-instance 'sdm:memory-stream)))
;; Decompress from STREAM into DECOMPRESSED.
(xz:decompress-stream stream decompressed)
;; Rewind and return
(file-position decompressed 0)
decompressed))
(defun get-xz-stream (stream)
(xz:make-decompressing-stream stream))
;; Register the decompression scheme. We'll assume that files ending
;; in .vgx or .xz are XZ-compressed.
(register :xz #'xz-compressed-p #'decompress-xz-stream #'get-xz-stream
"vgx" "xz")
Next: Playing VGM Files, Previous: VGM Compression, Up: API Reference [Contents][Index]
GD3 tags store metadata about VGM files. These are analogous to Vorbis Comments, APE Tags, or ID3v2 tags in other audio formats.
Class precedence list: t
A virtual representation of a GD3 tag.
Class precedence list: satou-error, simple-error, simple-condition, error, serious-condition, condition, t
Represents an error with a GD3 tag.
Class precedence list: gd3-tag-error, satou-error, simple-error, simple-condition, error, serious-condition, condition, t
A special subtype of gd3-tag-error that indicates an invalid GD3 tag
was possibly read because the stream or GD3 data ended early before reaching the
reported length of the tag.
Class precedence list: gd3-tag-error-size-mismatch, gd3-tag-error, satou-error, simple-error, simple-condition, error, serious-condition, condition, t
A special subtype of gd3-tag-error-size-mismatch that indicates a
valid GD3 tag was read, but there was leftover junk data after the GD3 was fully
read.
Returns the version of the GD3 tag data for tag.
Returns the English name of the song’s title from tag.
Returns the Japanese name of the song’s title from tag.
Returns the English name of the song’s source game from tag.
Returns the Japanese name of the song’s source game from tag.
Returns the English name of the song’s source system from tag.
Returns the Japanese name of the song’s source system from tag.
Returns the English name of the song’s artist from tag.
Returns the Japanese name of the song’s artist from tag.
This is just an alias for gd3-tag-author-en.
This is just an alias for gd3-tag-author-jp.
Returns the release date of the song from tag.
Returns the creator of the VGM from tag.
Returns any additional notes for the song from tag.
Creates a new gd3-tag instance by reading data from stream, which
should already be at the position of the raw GD3 data.
This may raise a gd3-tag-error-size-mismatch or
gd3-tag-error-junk-at-end condition if the reported size of the GD3 tag
data does not match what was read. When this happens, two restarts will be
active:
ignore-differenceThis will ignore the difference in size and continue as if there was no error.
return-empty-tagThis will discard what was read and instead return a new gd3-tag instance
with empty fields.
These restarts reside in the satou package.
Next: Chips, Previous: GD3 Tags, Up: API Reference [Contents][Index]
VGM files are played back by first loading a VGM file (see VGM File Loading), then using the vgm-player structure to render audio to a
buffer. Audio in SatouSynth is always rendered as single-float values
(which are 32-bit floating point in SBCL), and can be stored as either
interleaved stereo, or as separate left and right channels.
When playing VGM files, you must always use one player instance per VGM file.
Thus, if you need to change songs, you must first create a new vgm-player
instance.
Used to render audio data from vgm-file instances. Use
make-vgm-player to construct a new instance.
Creates a new vgm-player instance that will play the given VGM file,
vgm. The settings parameter can be a vgm-player-settings
instance, which will be used to control a few settings related to how the new
vgm-player instance will play back the VGM.
Before returning, this function will check to see if the given VGM uses any
unsupported chips. If it does, this will raise an
unsupported-chip-error.
Prepares player to play the VGM file loaded into it by setting up various internal values and tables, then initializing all of the required emulation cores. This must be called before rendering any audio.
When low-quality-resampling? is truthy, then a lower-quality (but faster) resampling method will be used if any resampling is required.
Stops the VGM player. Technically all this does is set an internal flag to indicate the song is at the end (see vgm-player-at-end-p).
Returns t if vgm-player-play has been called with player, or
nil otherwise.
Renders stereo audio to left and right. This will always fill the buffers completely.
left and right must both be (vector single-float)
instances or a subtype.
Renders interleaved stereo audio to dest. This will always fill the buffer completely.
dest must be a (vector single-float) or a subtype.
Returns the number of times the VGM has looped. If the VGM has no loop data, then this reaches a value of 1 or greater once it reaches the end of the song.
This is the best function to use to determine when to end a song.
Returns t if player has reached the end of the VGM file, or
nil otherwise.
Note that this value is only set when a VGM has no loop data, or when
vgm-player-stop is called.
Resets player back to its initial state. It does not unload the VGM.
Gets a nicely formatted list of chip names and their counts for all of
the chips used in the loaded VGM. When use-short is truthy, then the
short name is returned for each chip, otherwise the long names are returned.
The format used is simply the chip name when there is only one instance of a
chip, or the format <number>x <chip name> when there is one or more
instance of a chip.
Seeks the VGM file loaded into player. If relative is truthy, then
it will go either forward or backward by offset samples, depending on if
offset is positive or negative. Otherwise, if relative is
nil (the default), then it will seek to an absolute sample.
These samples are “PCM samples”, meaning they are based on the output sample rate, not the native VGM recording rate.
Returns a list of all the fancy names for the chips that are used in this
VGM. This only returns a valid set after the vgm-player-play has been
called.
If short-names is truthy, then the short names are returned for each chip, otherwise their full names are returned.
The format is the same as vgm-player-get-chip-names.
Returns a list of conses where the car of each is a
t/chip, and the cdr is the number of chips of that type.
Returns the vgm-player-settings instance loaded into player.
Returns the vgm-file instance loaded into player.
The main output volume of player. All samples are multiplied by this value before being returned by the rendering functions.
This is also setf-able. The value can be any real value, and will
be coerced to a single-float internally. Setting this will automatically
update the vgm-player-volume-modifier.
Returns the calculated global volume modifier value from player. This is automatically calculated based on the loaded chips, and is not the main output volume.
Returns the output sample rate of player.
Returns the minimum buffer size for player that will be accepted during rendering. This is the total size of the buffer, not per-channel.
Returns the minimum buffer size for player that will be accepted during rendering. This is the size per-channel, not the total size of the buffer.
Returns the number of samples-per-channel rendered so far.
Returns the internal table that contains the actual chip emulators. You should not modify this unless you know exactly what you are doing.
Up: Playing VGM Files [Contents][Index]
The playback of VGM files can be customized using the vgm-player-settings
class. This controls various aspects such as the output sample rate, the
emulation core used for various chips, chip options, and more.
Class precedence list: t
A set of settings that controls how VGM files are played back by the
vgm-player structure.
Returns the target sample rate to use for playback.
This is also setf-able. It must be an unsigned 32-bit integer.
When t, then the wave channel on the DMG chip is boosted. When this is
nil, then it is not.
This is also setf-able. It must be a boolean.
The emulation core to use for the YM2151 chip.
This is also setf-able. It must be one of the supported YM2151 emulation
cores.
The emulation core to use for the HuC6280 chip.
This is also setf-able. It must be one of the supported HuC6280
emulation cores.
When t, and you are using the :mame core for the YM2612, this
instructs the chip emulator to update the left/right channels alternatively,
creating a nice pseudo-stereo effect
This is also setf-able. It must be a boolean.
Creates a deep copy of settings and returns the new instance.
Previous: Playing VGM Files, Up: API Reference [Contents][Index]
All chip emulators in SatouSynth derive from the abstract-chip structure,
and this in conjunction with the associated generic functions make up the Chip
API. In nearly all cases, if you are only interested in playing VGM files, you
do not need to use the Chip API.
The abstract-chip structure is the base class for all public-facing
emulators. All functions related to this type are prefixed with chip-.
This is the base class for all classes that represent “flags” for the various emulation cores.
Creates a new chip of the given t/chip type. You will still need to
initialize the chip using chip-init before using it (see chip-init).
Returns the selected emulation core for chip.
Returns the default emulation core for chip.
All types that derive from abstract-chip have at least one possible
emulation core.
Initializes chip and various internal values, preparing it for use.
Whether or not chip is paired with another chip.
An example of a commonly paired chip is the YM2203, which has an internal YM2149 associated with it. This YM2149 is the “paired chip” of the YM2203.
Sets the mute mask for chip’s channels. The value should be an unsigned integer where the least significant bit is channel one, and so on, where each bit set to 1 means “mute this corresponding channel”.
Returns an accurate long name describing the type of chip.
Note that you must call chip-init first for this to return an accurate
value, otherwise it will return a generic string. See chip-init
Returns an accurate short name describing the type of chip.
Accesses chip’s “paired chip”. If this chip is not paired, this returns
nil.
Starts the emulation core for chip, with the given clock rate.
Some chip emulators require “start flags”, which are passed using the
flags parameter. A set of start flags can be retrieved using the
chip-start-flags function (see chip-start-flags).
Gets start flags (a subclass of chip-flags) for chip based on the
header values in the given vgm.
Resets chip to an initial state.
Sets the stereo mask for chip, allowing you to mute the left and/or right channels. The exact meaning of value depends on the type of chip.
Renders audio data using chip. This will render to each channel in outputs, starting at the offset start and continuing for samples elements. Note that samples does not mean “stereo samples”, but rather indicies into each channel in outputs.
The outputs parameter must be a t/output-buffer (see t/output-buffer)
Renders audio data using chip’s “paired chip”. If there is no paired chip, this does nothing.
This will render to each channel in outputs, starting at the offset start and continuing for samples elements. Note that samples does not mean “stereo samples”, but rather indicies into each channel in outputs.
The outputs parameter must be a t/output-buffer (see t/output-buffer)
Read internal data from the emulation core within chip at offset. The exact meaning of offset depends on the chip.
Not all chip emulators implement this function.
Writes data to the internal emulation core within chip. The exact meaning of offset, data, and port depend on the type of chip.
Writes DAC data to chip. The exact meaning of port, command, and data depend on the type of chip.
Writes ram-data, starting at data-start and continuing for data-length elements, to chip.
Writes rom-data, starting at data-start and continuing for data-length elements, to chip. The meaning of rom-size depends on the type of chip.
Returns the output volume of chip.
All chip emulators (i.e., subclasses of abstract-chip) are contained
within the satou-chips package, and so all names in this section are
found in that package. Each chip emulator subclass has one or more emulation
cores associated with it, a numeric ID, and a predicate function.
A class that emulates an General Instruments AY-1-8910 sound chip and related chips. This was used in a very large number of arcade games, consoles, and home computers.
Supported subtypes are:
The numeric ID for the AY-1-8910 emulator.
The set of available emulation cores for the AY-1-8910 emulator.
A class that emulates a Namco C140 sound chip. This was used in various arcade games such as Valkyrie Densetsu.
The numeric ID for the C140 emulator.
The set of available emulation cores for the C140 emulator.
A class that emulates a Namco C352 sound chip. This was used in various arcade games such as Burning Force and SoulCalibur.
The numeric ID for the C352 emulator.
The set of available emulation cores for the C352 emulator.
A class that emulates a Nintendo Game Boy sound chip.
The numeric ID for the DMG emulator.
The set of available emulation cores for the DMG emulator.
A class that emulates an Ensoniq ES5503 sound chip. This was used in various devices, such as the Apple IIGS.
The numeric ID for the ES5503 emulator.
The set of available emulation cores for the ES5503 emulator.
A class that emulates an Irem GA20 sound chip. This was used in various arcade games such as R-Type Leo and Ninja Baseball Bat Man.
The numeric ID for the GA20 emulator.
The set of available emulation cores for the GA20 emulator.
A class that emulates the sound portion of a Hudson Soft HuC6280 CPU. This was used in the PC Engine/TurboGrafx-16 and SuperGrafx consoles.
The numeric ID for the HuC6280 emulator.
The set of available emulation cores for the HuC6280 emulator.
A class that emulates a Konami K051649 sound chip. This was used in various iterations of the MSX, as well as various arcade games.
The numeric ID for the K051649 emulator.
The set of available emulation cores for the K051649 emulator.
A class that emulates a Konami K053260 sound chip. This was used in various arcade games such as Sunset Riders and Thunder Cross II.
The numeric ID for the K053260 emulator.
The set of available emulation cores for the K053260 emulator.
A class that emulates a Konami K054539 sound chip. This was used in various arcade games such as X-Men and Lethal Enforcers.
The numeric ID for the K054539 emulator.
The set of available emulation cores for the K054539 emulator.
A class that emulates a Sega MultiPCM sound chip. This was used in various arcade games such as Virtua Racing and Virtual Cop.
The numeric ID for the MultiPCM emulator.
The set of available emulation cores for the MultiPCM emulator.
A class that emulates the sound chip found in Nintendo Famicom/Nintendo Entertainment System (APU+DMC), as well as the Nintendo Famicom Disk System (FDS).
The numeric ID for the NES APU+DMC/FDS emulator.
The set of available emulation cores for the NES APU+DMC/FDS emulator.
A class that emulates an OKI MSM6258 sound chip. This was most prominently used in the Sharp X68000 home computer.
The numeric ID for the OKI MSM6258 emulator.
The set of available emulation cores for the OKI MSM6258 emulator.
A class that emulates an OKI MSM6295 sound chip. This was used in a large number of arcade games, including Street Fighter II: Champion Edition and Bad Dudes vs. Dragonninja.
The numeric ID for the OKI MSM6295 emulator.
The set of available emulation cores for the OKI MSM6295 emulator.
A class that emulates Sega’s PWM sound chip found in their 32X add-on for the Sega Genesis/Mega Drive.
The numeric ID for the PWM emulator.
The set of available emulation cores for the PWM emulator.
A class that emulates Capcom’s/QSound’s DL-1425 sound chip. This was used in various arcade games such as Night Warriors: Darkstalker’s Revenge.
The numeric ID for the QSound emulator.
The set of available emulation cores for the QSound emulator.
A class that emulates the Ricoh RF5C614 sound chip. This was used in the Sega CD add-on for the Sega Genesis/Mega Drive.
The numeric ID for the RF5C614 emulator.
The set of available emulation cores for the RF5C614 emulator.
A class that emulates a Philips SAA1099 sound chip. This was used in various arcade games such as Xor World.
The numeric ID for the SAA1099 emulator.
The set of available emulation cores for the SAA1099 emulator.
A class that emulates a Sega PCM sound chip. This was used in various arcade games such as Space Harrier.
The numeric ID for the segapcm emulator.
The set of available emulation cores for the Sega PCM emulator.
A class that emulates a Texas Instruments SN76489 sound chip and related chips. This was used in a large number of arcade games, as well as the Sega Genesis/Mega Drive.
Supported subtypes are:
The numeric ID for the SN76489 emulator.
The set of available emulation cores for the SN76489 emulator.
A class that emulates an NEC µPD7759 sound chip. This was used in various arcade games such as Cotton: Fantastic Night Dreams, Riot City, and Aurail.
The numeric ID for the µPD7759 emulator.
The set of available emulation cores for the µPD7759 emulator.
A class that emulates Nintendo’s VSU-VUE sound chip. This was used in their Virtual Boy console.
The numeric ID for the VSU-VUE emulator.
The set of available emulation cores for the VSU-VUE emulator.
A class that emulates the sound chip found in the Bandai Wonderswan.
The numeric ID for the Wonderswan emulator.
The set of available emulation cores for the Wonderswan emulator.
A class that emulates a Seta X1-010 sound chip. This was used in various arcade games such as Daioh.
The numeric ID for the X1-010 emulator.
The set of available emulation cores for the X1-010 emulator.
A class that emulates a Yamaha Y8950 (OPL) sound chip, also known as MSX-AUDIO. This was used in some MSX variants, as well as various arcade games such as Psycho Soldier and Ikari Warriors.
The numeric ID for the Y8950 emulator.
The set of available emulation cores for the Y8950 emulator.
A class that emulates a Yamaha YM2151 (OPM) sound chip. This was used in many arcade games, such as Street Fighter II: Champion Edition, as well as other systems such as the Sharp X68000 home computer.
The numeric ID for the YM2151 emulator.
The set of available emulation cores for the YM2151 emulator.
A class that emulates a Yamaha YM2203 (OPN) sound chip. This was used in various arcade games, such as Space Harrier, as well as various home computers such as the NEC PC-88 and PC-98.
The numeric ID for the YM2203 emulator.
The set of available emulation cores for the YM2203 emulator.
A class that emulates a Yamaha YM2413 (OPLL) sound chip. This was used in some arcade games, such as Space Harrier, as well as various MSX variants.
The numeric ID for the YM2413 emulator.
The set of available emulation cores for the YM2413 emulator.
A class that emulates a Yamaha YM2608 (OPNA) sound chip. This was used in various arcade games, such as Space Harrier, as well as various home computers such as the NEC PC-88 and PC-98.
The numeric ID for the YM2608 emulator.
The set of available emulation cores for the YM2608 emulator.
A class that emulates a Yamaha YM2610 (OPNB) sound chip. This was used in the SNK NeoGeo platform, as well as various arcade games such as Darius II.
The numeric ID for the YM2610 emulator.
The set of available emulation cores for the YM2610 emulator.
A class that emulates a Yamaha YM2612 (OPN2) sound chip. This was used in the Sega Genesis/Mega Drive home console.
The numeric ID for the YM2612 emulator.
The set of available emulation cores for the YM2612 emulator.
A class that emulates a Yamaha YM3526 (OPL) sound chip. This was used in various arcade games such as Bubble Bobble and Psycho Soldier.
The numeric ID for the YM3526 emulator.
The set of available emulation cores for the YM3526 emulator.
A class that emulates a Yamaha YM3812 (OPL2) sound chip. This was used in the Adlib sound card for IBM PCs, as well as various arcade games such as Vimana and Raiden.
The numeric ID for the YM3812 emulator.
The set of available emulation cores for the YM3812 emulator.
A class that emulates a Yamaha YMF262 (OPL3) sound chip. This was used in various sound cards for the IBM PC, some add-ons for the NEC PC-98, as well as some arcade games such as Touki Denshou -Angel Eyes-.
The numeric ID for the YMF262 emulator.
The set of available emulation cores for the YMF262 emulator.
A class that emulates a Yamaha YMZ280B (PCMD8) sound chip. This was used in various arcade games, such as DoDonPachi, Cyvern: The Dragon Weapons, and Skull Fang.
The numeric ID for the YMZ280B emulator.
The set of available emulation cores for the YMZ280B emulator.
Next: Function Index, Previous: API Reference, Up: SatouSynth [Contents][Index]
| Jump to: | A C D E F G H K M N O P Q R S U V W X Y |
|---|
| Jump to: | A C D E F G H K M N O P Q R S U V W X Y |
|---|
Next: Variable Index, Previous: Concept Index, Up: SatouSynth [Contents][Index]
| Jump to: | (
A C E F G L M P R S T U V |
|---|
| Jump to: | (
A C E F G L M P R S T U V |
|---|
Next: Type Index, Previous: Function Index, Up: SatouSynth [Contents][Index]
| Jump to: | * + |
|---|
| Jump to: | * + |
|---|
Previous: Variable Index, Up: SatouSynth [Contents][Index]
| Jump to: | A C D E F G H K M N O P Q R S T U V W X Y |
|---|
| Jump to: | A C D E F G H K M N O P Q R S T U V W X Y |
|---|