How To Make A FSB File: The Complete FMOD Sample Bank Guide

Compiling raw audio assets into an FMOD Sample Bank (FSB) container optimizes game engine runtime performance by consolidating memory footprint and reducing disk seek times. This technical guide outlines how to format source files, execute the compilation using the official FMOD SDK command-line utilities, and configure compression standards for target hardware. Developers and modders can implement these steps to achieve seamless audio playback and optimal memory footprint management.

Source Asset Specifications and Tooling Requirements

Before compiling a functional FMOD Sample Bank, the raw input assets must meet strict formatting criteria to prevent runtime decoding errors, phase alignment issues, or outright compiler rejection. FMOD Sample Banks are highly sensitive to inconsistent channel layouts and sample rates among files written to the same bank. Setting up a standardized digital audio workstation (DAW) batch export script is highly recommended for larger asset libraries.

Asset and Hardware Checklist

• Primary Tooling: FMOD Studio Programmers API (specifically containing the command-line FSB tool, fmod_fsbtool.exe) or a full installation of FMOD Studio.
• Audio Assets: Uncompressed Waveform Audio File Format (WAV) assets, exported at 16-bit PCM depth.
• Target Sample Rates: Standardized at 44100 Hz or 48000 Hz depending on the target console or PC runtime specifications.
• Operating System Environment: Windows Command Prompt, PowerShell, or macOS Terminal with system path variables set to access FMOD binary folders.
• Project Budget & Timeline: Zero financial cost utilizing free-to-use development licenses; compilation takes 5 to 15 minutes depending on total asset size.

Compiling FSB Containers via Command Line and Studio Workflows

Generating an FSB file can be achieved through two primary vectors: the command-line FMOD FSB Tool for custom build scripts and automated modding pipelines, or the FMOD Studio GUI for integrated game development workflows.

Step 1: Standardizing Source Audio Files

Ensure every input audio asset is formatted correctly. Open your digital audio workstation or batch converter (such as Reaper, Audacity, or Adobe Audition) and export your sound files as uncompressed WAVs.

Set the sample rate to 48000 Hz for modern platforms, or 44100 Hz for legacy hardware compatibility. Ensure the bit depth is precisely 16-bit PCM. If you are packing sound effects like footsteps or explosions, render them as mono files to allow dynamic 3D spatialization within the game engine. Save all target files into a single, clean directory, such as C:\FMOD_Project\Source_Audio.

Step 2: Locating and Preparing the FMOD FSB Tool

Navigate to the official FMOD download portal and retrieve the FMOD Studio Programmers API package appropriate for your operating system. Install the package and locate the tools directory. On Windows platforms, the path is typically located within the FMOD Programmers API installation folder under api/core/tools.

Within this folder, verify the presence of fmod_fsbtool.exe. To facilitate easier execution without typing long path directories, copy the file path of this directory and add it to your system environment variables, or copy the fmod_fsbtool.exe executable directly into your C:\FMOD_Project directory where your source audio is stored.

Step 3: Configuring the Compression and Bank Parameters

The FSB format supports various compression codecs, and selecting the correct format is vital. For general compatibility and lower CPU utilization on desktop architectures, use FADPCM (FMOD's proprietary Adaptive Differential Pulse Code Modulation). For highly compressed music files where memory space is critical, choose Vorbis compression.

Prepare a plain-text configuration file if you plan to batch-compile dozens of assets. Create a file named file_list.txt in your working directory. Open this file and write the relative path to each WAV file on a separate line. This list allows the compiler to pack multiple files into a single FSB container sequentially.

Step 4: Compiling the FSB via Command Line

Open your command-line interface (Command Prompt or PowerShell) and navigate to your project directory by entering:

cd C:\FMOD_Project

To execute the compilation, write the command parameters explicitly. For example, to compile your files using FADPCM compression for Windows, type the following command and press Enter:

fmod_fsbtool.exe -o output_bank.fsb -f fadpcm -p pc file_list.txt

If you are not using a list file and instead want to compile a single WAV file directly, replace the list file name with the target audio file:

fmod_fsbtool.exe -o engine_loops.fsb -f vorbis -q 50 vehicle_idle.wav

The compiler will analyze the inputs, perform the compression downsampling, write the optimized header indexes, and output your final engine_loops.fsb or output_bank.fsb file in the specified directory.

Step 5: Verifying and Testing the Output FSB File

To guarantee the file compiled correctly without header corruption, use the FMOD Sandbox utility or import the FSB file directly into your game engine's audio directory.

For quick command-line verification, execute the FSB tool with the information query flag to output the file's internal directory list, channel format, and compression parameters:

fmod_fsbtool.exe -i output_bank.fsb

Confirm that the output list displays all sound tracks with their correct corresponding sample counts and that no decoding errors are flagged by the utility.

FMOD Compression Formats & Audio Codec Comparison

Choosing the correct codec parameters for your FSB file determines how much memory the audio pool will occupy in RAM and how much overhead is placed on the system CPU during real-time decoding. Use the following specifications to configure your compilation settings:

Debugging FSB Build Failures and Playback Glitches

When building FSB containers, strict engine integration and game console requirements can lead to errors. Below are the most common compilation and runtime failures along with instructions to resolve them.

Error 1: FSB Tool Rejects Source WAV File

• Root Cause: The input WAV file contains metadata chunks, non-standard headers (such as BWF / Broadcast Wave Format metadata), or utilizes an unsupported bit depth (e.g., 24-bit or 32-bit float PCM).
• Actionable Fix: Open the file in an audio editor, strip all metadata headers upon export, and force the export settings to strictly output 16-bit Signed PCM WAV files before running the compiler.

Error 2: Game Crashes or Fails to Play Audio at Runtime

• Root Cause: Codec incompatibility on the host platform. For example, attempting to load an FSB compiled with AT9 compression on a PC target, or XMA compression on a PlayStation platform.
• Actionable Fix: Re-run the command-line tool with the platform flag adjusted to match your target system architecture (e.g., use the -p pc flag alongside the -f vorbis or -f fadpcm compression settings).

Error 3: Loop Points Distort, Pop, or Fail to Seamlessly Repeat

• Root Cause: The loop points embedded in the WAV file are not aligned to sample-accurate boundaries, or the codec compression introduces padding samples at the start/end of the audio file.
• Actionable Fix: Align your DAW loop selections to zero-crossings to avoid audible pops. When compiling with lossy compression like Vorbis, utilize the FMOD loop alignment command-line parameters to trim encoder delay padding samples during final container generation.

Frequently Asked Questions

Can I extract original WAV files from an existing FSB container?

Yes, you can extract the audio assets, provided the bank was not compiled with encryption keys. To extract the raw files, utilize the command-line FSB tool with the extract command parameter, or use third-party community utilities like FSB Extractor. Be aware that lossy formats like Vorbis or FADPCM will not return to lossless WAV quality upon extraction due to the irreversible compression applied during the initial build process.

What is the structural difference between the FSB4 and FSB5 container formats?

FSB4 is a legacy container format used primarily in FMOD Designer and older game engines, which embeds audio metadata directly alongside each sample stream. FSB5 is the modern iteration used by FMOD Studio, separating all file headers, channel properties, and metadata indexes into a highly optimized block at the very beginning of the file. This architecture allows the game engine to read all track information in a single disk seek, reducing load times.

Can Audacity export audio files directly into the FSB format?

Audacity cannot native-export directly to the FSB format because FSB is a proprietary container structure owned by Firelight Technologies. To create these files, you must export your audio projects from Audacity as uncompressed 16-bit WAV files, then process those files using the official command-line FMOD compiler tools or the FMOD Studio user interface.

Is it possible to encrypt an FSB file to protect intellectual property?

Yes, FMOD supports full bank encryption to prevent unauthorized extraction of music and voice files. During compilation with the FMOD command-line tool, you can pass a specific hexadecimal encryption key parameter. The engine must then supply this matching key programmatically at runtime through the FMOD Studio API to unlock and stream the audio samples.

Optimize Your Interactive Game Audio Pipeline

Integrating an optimized asset build process ensures your gaming project maintains peak frame rates and minimal load screens. Standardize your build scripts using FMOD's command-line tool suite to ensure your sound design shines across all target platforms.