If you’ve ever tried to load samples from Splice or Reddit’s r/drumkits onto your Roland SP404 MK2, you’ve probably run into the frustrating “Unsupported File” problem. You get everything organized, load your SD card, boot up the sampler and… half your carefully curated collection won’t play.

Annoying. After spending hours organizing my sample library only to find that a bunch of files were incompatible with my SP404, I decided to create a simple tool to solve this problem once and for all.

The SP404 MK2’s Picky Audio Requirements

Here’s the thing - the SP404 MK2 is an incredible sampler, but it has some very specific requirements for WAV files:

• Bit Depth: Must be either 16-bit or 24-bit
• Sample Rates: Must be one of these:
  • 16 kHz
  • 22.05 kHz
  • 32 kHz
  • 44.1 kHz (recommended)
  • 48 kHz
  • 88.2 kHz
  • 96 kHz
  • 176.4 kHz
  • 192 kHz

The problem is that samples from popular sources often don’t meet these requirements. For example:

• Samples from Reddit’s r/drumkits often come in various formats, many incompatible
• Professionally made sample packs often use 32-bit files for higher quality

Unfortunately, the SP404 simply won’t recognize files that don’t match its specifications. It will show “Unsupported File” when you try to load them, but it won’t tell you what the problem is.

A Simple Solution

After dealing with this issue repeatedly, I built a small shell script that automatically:

1. Scans your sample folders
2. Identifies WAV files that won’t work on the SP404 MK2
3. Converts incompatible files to a SP404-friendly format (16-bit, 44.1kHz)
4. For already compatible files, it simply copies them to the destination
5. Preserves your entire folder structure in a “converted” directory
6. Leaves your original files completely untouched

The best part is that it remembers files it’s already processed in previous runs, so you can run it multiple times without duplicating work. The end result is a single “converted” folder containing all your samples in SP404-compatible formats.

How the Script Works

The script is pretty straightforward. Here’s a breakdown of what’s happening behind the scenes:

1
2
3
4
5
# First, it uses macOS's native folder picker to let you select your samples
FOLDER=$(osascript -e 'tell application "Finder"
    set folderPath to POSIX path of (choose folder with prompt "Select folder containing WAV files:")
    return folderPath
end tell')

This gives you a familiar folder selection dialog that integrates seamlessly with macOS.

Then it defines a function to check if files are compatible:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
is_compatible() {
    local file="$1"
    
    # Get audio info using ffprobe
    local info=$(ffprobe -v error -select_streams a:0 -show_entries stream=sample_fmt,sample_rate -of csv=p=0 "$file" 2>/dev/null)
    
    # Extract bit depth and sample rate
    local sample_fmt=$(echo "$info" | head -1)
    local sample_rate=$(echo "$info" | tail -1)
    
    # Check if sample format is compatible (16-bit or 24-bit)
    if [[ "$sample_fmt" != *"s16"* && "$sample_fmt" != *"s24"* ]]; then
        return 1  # Not compatible
    fi
    
    # Check if sample rate is compatible with SP404 MK2
    case "$sample_rate" in
        16000|22050|32000|44100|48000|88200|96000|176400|192000)
            return 0  # Compatible
            ;;
        *)
            return 1  # Not compatible
            ;;
    esac
}

The real magic happens when it processes each file:

1. It checks if the file has already been processed in a previous run
2. If not, it checks if the file is already compatible with the SP404 MK2
3. For incompatible files, it converts them to 16-bit, 44.1kHz PCM WAV format
4. For compatible files, it simply copies them to maintain the same organization
5. It creates matching directories in the “converted” folder to preserve your folder structure
6. It keeps track of how many files were converted, copied, or previously processed

The actual conversion happens with this crucial FFmpeg command:

1
ffmpeg -i "$file" -acodec pcm_s16le -ar 44100 "'"$CONVERTED_DIR"'/$rel_path" 2>/dev/null

Let’s break down what this does:

• -i "$file" specifies the input file to convert
• -acodec pcm_s16le sets the audio codec to 16-bit PCM (Linear PCM), which is perfectly compatible with the SP404 MK2
• -ar 44100 sets the audio sample rate to 44.1kHz, the standard for most audio applications and ideal for the SP404
• "'"$CONVERTED_DIR"'/$rel_path" is the output path that preserves the original folder structure in the “converted” folder
• 2>/dev/null redirects error messages to nowhere, keeping the output clean

The command is wrapped in a conditional statement that increments our conversion counter only if the conversion was successful. If the command fails for any reason (corrupted audio file, permission issues, etc.), the script will display “Failed to convert” and continue processing other files.

Why I Built This

I could have manually converted files one by one using Logic Pro or another audio editor. But that’s tedious, especially when you have hundreds or thousands of samples. And honestly, I wanted to spend my time making music, not converting file formats.

There are existing libraries like r8brain-free-src that offer high-quality sample rate conversion, but they involve complex C++ code that I frankly don’t understand well enough to modify for my specific needs. I wanted something straightforward that I could easily customize for my own workflow without diving into advanced DSP algorithms.

I’ve had some experience with FFmpeg over the years and have been consistently impressed by its capabilities. For those who aren’t familiar, FFmpeg is an incredibly powerful open-source multimedia framework that can handle pretty much any audio or video format you throw at it. It’s the behind-the-scenes engine powering countless media applications and websites.

What makes FFmpeg perfect for this tool is its:

• Versatility: It can read virtually any audio format and convert between them seamlessly
• Accuracy: Its sample rate conversion algorithms preserve audio quality exceptionally well
• Efficiency: It’s really fast, even when processing large batches of files
• Command-line interface: Makes it easy to script and automate processes
• Active development: The project is constantly updated with improvements and new features (r8brain-free-src hasn’t been updated in over a year…)
• Cross-platform libraries: FFmpeg provides bindings for Python, JavaScript, and other languages, making it adaptable for different development environments

For this script, I’m only using a tiny fraction of FFmpeg’s capabilities. It could just as easily handle video conversions, audio effects processing, or even streaming tasks. But that simplicity is exactly what I wanted - a lightweight tool leveraging FFmpeg’s power without unnecessary complexity.

Given FFmpeg’s extensive language support, I could eventually rewrite this shell script as an Electron desktop app or even a web service that handles the conversions directly in the browser… 🤔 Maybe a project for another day when I’m not busy sampling on my SP404.

Fun fact: Even YouTube used FFmpeg in their video processing pipeline in the past. According to research from multimedia.cx, they discovered YouTube was using FFmpeg by uploading obscure video formats with specific rendering issues that only appeared in certain FFmpeg versions. While YouTube likely uses custom solutions nowadays, it shows how reliable and ubiquitous FFmpeg has become for serious media processing.

Anyways back to the whole why I built this thing, I also like keeping my original samples intact (some DAWs prefer 32-bit float files), so having an automated way to create a “SP404-ready” version of my sample library while preserving the originals felt like the right approach.

One thing that makes this script particularly useful is that all converted files are placed in the “converted” folder, regardless of whether they were already compatible or needed conversion. This gives you one neat, organized place where you know every single file will work with the SP404 MK2. No more guessing which samples might cause problems - just copy everything from the “converted” folder to your SD card and you’re ready to go.

Using the Tool

If you’re a fellow SP404 MK2 user struggling with sample compatibility, you can grab the script from my GitHub repository. All you need is:

1. macOS (the script uses AppleScript for the folder picker)
2. FFmpeg installed (brew install ffmpeg if you have Homebrew)

Just download the script, make it executable (chmod +x convert-wavs.sh), and run it. Select your sample folder when prompted, and it’ll handle the rest.

The script will create a “converted” folder containing only the files that needed conversion, with the same folder structure as your originals. Copy these to your SD card, and you’re good to go.

Final Thoughts

The SP404 MK2 is a fantastic instrument that has become central to my production workflow. This little script has saved me countless hours of frustration and let me focus on what matters, namely making music.

If you’re using the SP404 MK2, I hope this tool helps you as much as it’s helped me. And if you have any suggestions for improvements, feel free to contribute to the repository. I’m always open to making it better.

Happy sampling!