!/bin/bash

#####################################################################

Hand Is Radio - Optimized Player & Streamer

This script includes dynamic track announcements.

Dependencies:

- Local/Stream: festival, lame, ffmpeg (provides ffprobe)

- Local Playback: mpg123

Install dependencies on Raspbian/Debian:

sudo apt update

sudo apt install mpg123 festival lame ffmpeg

Recommends at least a Pi2B preferably a Pi3B. Bottleneck issues tested on a Pi1B.

#####################################################################

--- Configuration ---

MUSIC_DIR="./music" JINGLE_TEXT="This is Hand Is Radio, your source for unique music. This month is music by .... Listen on eighty-eight point zero F.M. and online at hand is radio dot com." PREGEN_JINGLE_FILE="jingle.mp3"

--- Icecast Defaults (override with command-line flags) ---

ICECAST_HOST="" ICECAST_PORT="" ICECAST_PASS="" ICECAST_MOUNT="stream" BITRATE="126k" # Default bitrate for Icecast STREAM_TO_ICECAST=false ICE_NAME="Hand Is Radio" ICE_DESC="Unique Music"

--- Stream/Pipe Configuration ---

AUDIO_PIPE="radio.pipe" AUDIO_FORMAT="s16le" # 16-bit signed little-endian PCM AUDIO_RATE="44100" # 44.1kHz Sample Rate AUDIO_CHANNELS="2" # Stereo

--- Function Definitions ---

Print usage instructions

usage() { echo "Usage: $0 [options]" echo echo "Options:" echo " -s Enable streaming to Icecast (requires -H and -P)." echo " -H Icecast host/IP (e.g., 192.168.1.10)." echo " -p Icecast port (default: 8000)." echo " -P Icecast source password." echo " -m Icecast mount point (default: stream.mp3)." echo " -b Streaming bitrate (default: 32k, e.g., 64k, 128k)." echo " -h Show this help message." }

Check for required command-line tools

check_deps() { local missing=0 local cmds=("find" "shuf" "mktemp" "festival" "text2wave" "lame" "ffprobe" "mpg123")

if [ "$STREAM_TO_ICECAST" = true ]; then
    cmds+=("ffmpeg")
else
    cmds+=("aplay")
fi

for cmd in "${cmds[@]}"; do
    if ! command -v $cmd &> /dev/null; then
        echo "ERROR: Required command '$cmd' not found." >&2
        missing=1
    fi
done

if [ $missing -eq 1 ]; then
    echo "Please install dependencies and try again." >&2
    exit 1
fi

}

Generate the jingle MP3 file (as stereo)

generate_jingle() { if [ ! -f "$PREGEN_JINGLE_FILE" ]; then echo "---" >&2 echo "One-time setup: Generating jingle file '$PREGEN_JINGLE_FILE'..." >&2

    local temp_wav
    temp_wav=$(mktemp --suffix=.wav)
    echo "$JINGLE_TEXT" | text2wave -o "$temp_wav"

    ffmpeg -i "$temp_wav" -ac 2 -q:a 9 -ar "$AUDIO_RATE" "$PREGEN_JINGLE_FILE" -loglevel error

    rm "$temp_wav"

    if [ ! -f "$PREGEN_JINGLE_FILE" ]; then
         echo "ERROR: Failed to create jingle file. Exiting." >&2
         exit 1
    fi
    echo "Jingle generation complete." >&2
    echo "---" >&2
fi

}

Generate a temporary MP3 file (as stereo)

generate_tts_mp3() { local text="$1" local output_file="$2"

local temp_wav
temp_wav=$(mktemp --suffix=.wav)
echo "$text" | text2wave -o "$temp_wav"

ffmpeg -i "$temp_wav" -ac 2 -q:a 9 -ar "$AUDIO_RATE" "$output_file" -loglevel error

rm "$temp_wav"

}

Start the single, persistent ffmpeg process (the READER)

This new version runs in a loop to auto-reconnect if it dies.

start_streamer() {

Run this whole function in the background

(
    while true; do
        echo "STREAMER: (Re)starting ffmpeg process..." >&2

        ffmpeg -f "$AUDIO_FORMAT" -ar "$AUDIO_RATE" -ac "$AUDIO_CHANNELS" -i "$AUDIO_PIPE" \
               -filter_complex "[0:a]asplit=2[local][ice]" \
               \
               -map "[local]" \
               -f alsa "plughw:0" \
               \
               -map "[ice]" \
               -acodec libmp3lame -ab "$BITRATE" -ar "$AUDIO_RATE" -ac "$AUDIO_CHANNELS" \
               -content_type "audio/mpeg" \
               -ice_name "$ICE_NAME" \
               -ice_description "$ICE_DESC" \
               -ice_public 1 \
               -f mp3 "icecast://source:${ICECAST_PASS}@${ICECAST_HOST}:${ICECAST_PORT}/${ICECAST_MOUNT}" \
               -loglevel warning

        echo "STREAMER: ffmpeg process died. Restarting in 5 seconds..." >&2
        sleep 5
    done
) &

FFMPEG_PID=$!
echo "Streamer reconnect loop started with PID $FFMPEG_PID." >&2

}

Start a simple local-only player (the READER)

start_local_player() { echo "Starting persistent local player (aplay)..." >&2 aplay -f "$AUDIO_FORMAT" -r "$AUDIO_RATE" -c "$AUDIO_CHANNELS" < "$AUDIO_PIPE" & PLAYER_PID=$! echo "aplay process started with PID $PLAYER_PID." >&2 }

--- THIS IS THE NEW WRITER PROCESS ---

This entire function will be run in a subshell with its

stdout redirected to the pipe.

run_radio_loop() {

This loop runs forever, writing audio to stdout

while true; do
    # --- 1. Generate Playlist ---
    echo "WRITER: Scanning '$MUSIC_DIR' and shuffling playlist..." >&2

    if [ ! -d "$MUSIC_DIR" ]; then
        echo "WRITER ERROR: Directory $MUSIC_DIR does not exist." >&2
        sleep 10 # Wait before trying again
        continue
    fi

    mapfile -t PLAYLIST < <(find "$MUSIC_DIR" -type f -iname "*.mp3" | shuf)

    if [ ${#PLAYLIST[@]} -eq 0 ]; then
        echo "WRITER ERROR: No .mp3 files found in $MUSIC_DIR." >&2
        sleep 10 # Wait before trying again
        continue
    fi

    echo "WRITER: Playlist generated with ${#PLAYLIST[@]} tracks." >&2

    counter=0

    # --- 2. Loop Through Playlist ---
    for file in "${PLAYLIST[@]}"; do
        ((counter++))

        # --- Play Jingle ---
        if (( counter % 4 == 0 )); then
            echo "[JINGLE] Playing jingle..." >&2
            mpg123 -s -r "$AUDIO_RATE" -c "$AUDIO_CHANNELS" -e "s16" "$PREGEN_JINGLE_FILE" 2>/dev/null
        fi

        # --- Generate Announcement ---
        title=$(ffprobe -v quiet -show_entries format_tags=title -of default:noprint_wrappers=1:nokey=1 "$file" 2>/dev/null)
        artist=$(ffprobe -v quiet -show_entries format_tags=artist -of default:noprint_wrappers=1:nokey=1 "$file" 2>/dev/null)

        if [ -z "$title" ]; then
            title=$(basename "$file" .mp3 | sed 's/_/ /g')
        fi
        if [ -z "$artist" ]; then
            artist="an unknown artist"
        fi

        announce_text="Next up is $title by $artist."

        # --- Create & Play Announcement ---
        ANNOUNCE_MP3="/tmp/announce_$(date +%s).mp3"
        echo "[ANNOUNCE] Generating: $announce_text" >&2
        generate_tts_mp3 "$announce_text" "$ANNOUNCE_MP3"

        mpg123 -s -r "$AUDIO_RATE" -c "$AUDIO_CHANNELS" -e "s16" "$ANNOUNCE_MP3" 2>/dev/null

        rm -f "$ANNOUNCE_MP3"

        # --- Play Song ---
        echo "[PLAYING] $(basename "$file")" >&2
        mpg123 -s -r "$AUDIO_RATE" -c "$AUDIO_CHANNELS" -e "s16" "$file" 2>/dev/null

    done

    echo "WRITER: Playlist finished. Re-shuffling..." >&2
done

}

--- Cleanup Function (runs on Ctrl+C) ---

cleanup() { echo "\nCaught exit signal. Shutting down..."

# Kill all background processes associated with this script
# This is more robust than just killing PIDs
pkill -P $$

echo "Removing audio pipe '$AUDIO_PIPE'..."
rm -f "$AUDIO_PIPE"

echo "Cleaning up any temporary announcement files..."
rm -f /tmp/announce_*.mp3

echo "Shutdown complete."
exit 0

}

Trap Ctrl+C (SIGINT) and script exit (SIGTERM)

trap cleanup SIGINT SIGTERM

--- Main Script ---

Parse command-line arguments

while getopts "sH:p:P:m:b:h" opt; do case $opt in s) STREAM_TO_ICECAST=true ;; H) ICECAST_HOST="$OPTARG" ;; p) ICECAST_PORT="$OPTARG" ;; P) ICECAST_PASS="$OPTARG" ;; m) ICECAST_MOUNT="$OPTARG" ;; b) BITRATE="$OPTARG" ;; h) usage; exit 0 ;; *) usage; exit 1 ;; esac done

Validate streaming options

if [ "$STREAM_TO_ICECAST" = true ]; then if [ -z "$ICECAST_HOST" ] || [ -z "$ICECAST_PASS" ]; then echo "ERROR: When streaming (-s), you must provide a host (-H) and password (-P)." >&2 usage exit 1 fi echo "--- Icecast Streaming + Local Playback Enabled ---" >&2 else echo "--- Local Playback Only Mode ---" >&2 fi

Check dependencies

check_deps

Generate jingle (if needed)

generate_jingle

Create the named pipe

if [ -e "$AUDIO_PIPE" ]; then rm -f "$AUDIO_PIPE" fi mkfifo "$AUDIO_PIPE"

Start the READER process (ffmpeg or aplay)

if [ "$STREAM_TO_ICECAST" = true ]; then start_streamer else start_local_player fi

Start the WRITER process (the main radio loop)

The ( ... ) runs it in a subshell

The > "$AUDIO_PIPE" redirects its stdout to the pipe

The & runs it in the background

echo "Starting persistent radio writer loop..." >&2 ( run_radio_loop ) > "$AUDIO_PIPE" & RADIO_WRITER_PID=$! echo "Writer process started with PID $RADIO_WRITER_PID." >&2

echo "--- Radio is LIVE. Press Ctrl+C to stop. ---" >&2

Keep the main script alive to wait for the cleanup trap

wait