How to clean up an iPod music library

My entire music library was ‘backed up’ on an old iPod Classic. God, I miss iPods so much. Here’s how I was able to extract all my music files from my iPod and the steps I took to clean up the library.

Extract the content from the iPod

I plugged the iPod into my mac (luckily I have a box of legacy chargers and connectors). The iPod library structure is hidden and hashed.

First, hit Command + Shift + . to show all hidden files on the iPod. The raw music files are hidden under iPod_Control > Music

I copied this data to a workable area on my mac.

Flatten the files first to make them easier to work with

Apple hashes the filenames (likely) to make them easier to work with. But it’s not very human friendly. Here’s the screenshot of what the file names look like.

Before I started the renaming process, I wanted to flatten all the files out of Apple’s format. This is easy to do with a quick terminal command.

find /path/to/source -type f -exec mv {} /path/to/destination/ \;

Deal with the hashing problem and renaming the files

My files fell roughly into 2 categories along with different strategies on how to deal with them.

Music that had great metadata → I’ll use a bash script to rename the files from the metadata.
Music that had no (or dubious) metadata → I’ll extract those and use a music analyzer batch discover the content.

I have not dealt with music analyzers before and had to deal with some frustration around 2 elements: first, the quality of audio fingerprinting tech and second, the quality of the database the analyzer references.

Renaming files based on high quality meta data files

For this step, this is a relatively easy bash script to write and uses exiftool to help with the problem.

First, install exiftool via brew

brew install exiftool

Then, I wrote the bash script using exiftool to rename all the files with the meta data. Files that had unreliable metadata (i.e. missing) were skipped.

Create a new .sh file via local IDE or using nano rename_music.sh in terminal.

Make the .sh file executable by running chmod +x rename_music.sh

Run the script: ./rename_music.sh /path/to/folder

#!/bin/bash

# Check if directory argument is provided
if [ $# -eq 0 ]; then
    echo "Usage: $0 /path/to/folder"
    exit 1
fi

MUSIC_DIR="$1"

# Find all music files and rename them
find "$MUSIC_DIR" -type f \( -iname "*.mp3" -o -iname "*.m4a" -o -iname "*.flac" -o -iname "*.wav" \) | while read -r file; do
    # Get the directory and extension
    dir=$(dirname "$file")
    ext="${file##*.}"
    
    # Extract artist and title using exiftool
    artist=$(exiftool -s -s -s -Artist "$file" 2>/dev/null)
    title=$(exiftool -s -s -s -Title "$file" 2>/dev/null)
    
    # Check if both artist and title exist
    if [ -n "$artist" ] && [ -n "$title" ]; then
        # Clean up the strings (remove special characters that cause issues in filenames)
        artist_clean=$(echo "$artist" | sed 's/[/:*?"<>|]/_/g')
        title_clean=$(echo "$title" | sed 's/[/:*?"<>|]/_/g')
        
        # Create new filename
        new_name="${artist_clean} - ${title_clean}.${ext}"
        new_path="${dir}/${new_name}"
        
        # Rename the file if the new name is different
        if [ "$file" != "$new_path" ]; then
            mv "$file" "$new_path"
            echo "Renamed: $(basename "$file") -> $new_name"
        else
            echo "Skipped (already named correctly): $(basename "$file")"
        fi
    else
        echo "Skipped (missing metadata): $(basename "$file")"
    fi
done

echo "Done!"

This script took about 20 minutes to run through my database of ~13k tracks.

Isolate skipped tracks from renaming

I wanted to deal with the skipped tracks in an isolated area, I had 533 skipped tracks. That’s roughly 4% of the library that had low quality data (which is great!)

Since the skipped files were still hashed, it made it easy to isolate via bash script and move the files into a separate folder. I used the bash script below to make it happen.

#!/bin/bash

SOURCE_DIR="/source/path/here"
DEST_DIR="/destination/path/here"

# Create destination directory if it doesn't exist
mkdir -p "$DEST_DIR"

# Find and move files with 4-character names (excluding extension)
find "$SOURCE_DIR" -maxdepth 1 -type f | while read -r file; do
    # Get the basename (filename with extension)
    basename=$(basename "$file")
    
    # Extract filename without extension
    filename="${basename%.*}"
    
    # Check if the filename (without extension) is exactly 4 characters
    if [ ${#filename} -eq 4 ]; then
        echo "Moving: $basename"
        mv "$file" "$DEST_DIR/"
    fi
done

echo "Done! Files moved to $DEST_DIR"

Using a music analyzer

I was skeptical about using something like songrec or beets. Through a bunch of experimentation, I just couldn’t get it to work reliably.

I ended up using MusicBrainz Picard because it’s relatively simple GUI and its general reliability to rename files on my behalf. Picard uses AcoustID to fingerprint the tracks and its own database for metadata.

I followed Picard’s documentation on how to recognize the tracks and rename them. I did learn that Picard has an opinionated stance on how files should be renamed. Since I had a preference the ARTIST - TITLE format, I had to update that in Picard’s settings.

Go to Settings > File Naming > Check off “Rename files when saving”
I edited one of the presets to use my preferred method

Combine the data sets

After Picard ran through and renamed all my unknown tracks, I simply moved everything into a single folder and I had a relatively clean structure of my entire old music library.

Problems

This isn’t perfect, but it got me about 95% of the way to where I needed to go. There’s a few issues I still have

Metadata that exists is great, but the quality of the data matters too. Misspellings, dubious usage of capitalization, etc. all shines through in the file names. If I would do this again, I’d write a script that would improve the quality of the metadata.
Different databases refer to artists differently, which makes it hard to cleanly extract the artist name. For example, my band could be known as “Leon’z Band” or “Leonz Band” or “Leon’s Band”. It means different naming conventions lead the files to be less clean.
I would remove duplicates in tracks saved. This makes it harder because of the issue above, but I’m sure I can use something like Picard to re-analyze and consistently rename the entire library.