Merge pull request #2 from script-php/playlist

Playlist

Author: script-php

README.md

@@ -11,6 +11,7 @@ GoStream is a lightweight MP3 streaming server written in Go. It provides real-t
 - **Audio normalization** - Automatic FFmpeg-based audio normalization to standardized bitrate and sample rate for consistent streaming
 - **Stream metadata** - ID3 tag parsing for track title and artist information
 - **Icecast compatibility** - Stats endpoint compatible with Icecast format for player integration
+- **Icecast source input** - Accept live audio from DJ apps and other sources via Icecast protocol
 - **Configurable gap/silence** - Set custom silence duration between songs (default 500ms)
 - **CORS support** - Cross-Origin Resource Sharing enabled for browser-based streaming
 - **Debug mode** - Enhanced logging for troubleshooting
@@ -61,6 +62,7 @@ The server will start on port 8090 by default.
 - `-debug` - Enable debug mode for detailed logging
 - `-n string` - Server name (default: "GoStream")
 - `-gap int` - Gap/silence between songs in milliseconds (default: 500)
+- `-icecast-source-port int` - Port for Icecast source client connections (default: 0 = disabled)
 - `-c string` - Load configuration from JSON file or URL
 - `-h` - Show help information
 
@@ -116,9 +118,72 @@ Create a `config.json` file:
 - `standard_sample_rate` (string) - Sample rate for normalized audio (e.g., "44100", "48000") - default: "44100"
 - `cache_dir` (string) - Directory to store cached normalized files - default: ".cache"
 - `cache_ttl_minutes` (int) - Cache time-to-live in minutes (files older than this are deleted, 0 = no cleanup) - default: 10
+- `icecast_source_port` (int) - Port for Icecast source client connections (0 = disabled) - default: 0
 
 **Note:** Audio normalization is always enabled for consistent stream quality. All songs are automatically normalized to the standard bitrate and sample rate. Command-line arguments take precedence over config file values.
 
+### Icecast Source Input (Live Audio)
+
+GoStream supports accepting live audio from DJ applications and other sources via the **Icecast protocol**. This allows you to stream live audio without pre-recorded files.
+
+#### Enabling Icecast Source Input
+
+Add to your config file:
+
+```json
+{
+  "port": 8090,
+  "icecast_source_port": 8001
+}
+```
+
+Or use command-line flag:
+
+```bash
+./gostream -icecast-source-port 8001
+```
+
+#### Connecting a Source
+
+Use any Icecast-compatible source client to push audio to your server:
+
+```bash
+# Example with curl and ffmpeg
+ffmpeg -i input.mp3 -f mp3 -b:a 128k - | \
+  curl -X SOURCE \
+  -H "Content-Type: audio/mpeg" \
+  --data-binary @- \
+  http://localhost:8001/
+```
+
+#### Features
+
+- Accept audio from DJ apps, ffmpeg, OBS Studio, and standard Icecast source clients
+- Automatic failover to file playlist when source disconnects
+- Broadcast live audio to all connected listeners
+- Full HTTP compatibility
+
+For detailed setup instructions and examples, see [ICECAST_SOURCE_GUIDE.md](release/ICECAST_SOURCE_GUIDE.md).
+
+#### Testing Icecast Connection
+
+Use the provided test scripts to verify your setup:
+
+**Linux/macOS:**
+```bash
+./release/test-icecast-source.sh localhost 8001 your_audio.mp3
+```
+
+**Windows (PowerShell):**
+```powershell
+.\release\test-icecast-source.ps1 localhost 8001 your_audio.mp3
+```
+
+**Windows (Batch):**
+```cmd
+release\test-icecast-source.bat localhost 8001 your_audio.mp3
+```
+
 ### Cache Management
 
 GoStream includes automatic cache cleanup to prevent unlimited disk usage when audio normalization is enabled.

TODO.md

@@ -1,8 +1,9 @@
 
-playlist
-update the song list on upload
+playlist {cm:2026-02-27}
+update the song list on upload {cm:2026-02-28}
 icy headers {cm:2026-02-26}
 stable {cm:2026-02-25}
 shoutcat protocol {cm:2026-02-26}
 hash identification instead of index id {cm:2026-02-26}
-change next song with a custom one
+change next song with a custom one {cm:2026-02-27}
+broadcast

main.go

@@ -5,14 +5,104 @@ import (
 	"gostream/modules"
 	"gostream/routes"
 	"fmt"
+	"time"
 
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 )
 
+// icecastNormalizerFeeder reads chunks from Icecast source, normalizes them, and feeds to MusicReader
+// It automatically manages mode switching based on whether an Icecast source is connected
+func icecastNormalizerFeeder() {
+	modules.Logger.Info("Icecast normalizer feeder started")
+	var isIcecastProcessing bool
+	var processorWaitCh chan struct{}
+
+	for {
+		// Check if there's an active Icecast source connection
+		hasSource := modules.IcecastSource.HasActiveSource()
+
+		// Transition: Source connected, start Icecast mode
+		if hasSource && !isIcecastProcessing {
+			modules.Logger.Info("Icecast source connected - switching to Icecast mode")
+			
+			// Close current file and advance to next song before switching modes
+			// This ensures: 1) current file is released (no lock for cleanup), 2) next song is ready when Icecast disconnects
+			modules.MusicReader.SkipToNext()
+			modules.Logger.Info("Advancing to next song in preparation for Icecast mode")
+			
+			modules.MusicReader.EnableIcecastMode()
+			
+			// Create a channel to signal when processor is done
+			processorWaitCh = make(chan struct{})
+			go func() {
+				modules.MusicReader.ProcessIcecastStream()
+				close(processorWaitCh)
+			}()
+			
+			isIcecastProcessing = true
+			time.Sleep(200 * time.Millisecond) // Give processor time to start
+			continue
+		}
+
+		// Transition: Source disconnected, revert to file mode
+		if !hasSource && isIcecastProcessing {
+			modules.Logger.Info("Icecast source disconnected - reverting to file mode")
+			modules.MusicReader.DisableIcecastMode()
+			
+			// Wait for processor to exit (with timeout)
+			select {
+			case <-processorWaitCh:
+				modules.Logger.Info("Icecast processor exited cleanly")
+			case <-time.After(2 * time.Second):
+				modules.Logger.Info("Icecast processor did not exit within 2s, continuing")
+			}
+			
+			isIcecastProcessing = false
+			time.Sleep(200 * time.Millisecond) // Give StartLoop time to resume file feeding
+			continue
+		}
+
+		// No source and not processing - check periodically
+		if !hasSource && !isIcecastProcessing {
+			time.Sleep(500 * time.Millisecond)
+			continue
+		}
+
+		// Source is active and we're processing - get next chunk
+		chunk, ok := modules.IcecastSource.GetAudioChunk()
+		if !ok {
+			time.Sleep(10 * time.Millisecond)
+			continue
+		}
+
+		// For live streaming, pass chunks through directly (no re-encoding)
+		// Icecast already provides MP3 data from Mixxx
+		// Skip FFmpeg normalization to avoid latency/jerkiness
+		
+		// Feed to MusicReader buffer system
+		err := modules.MusicReader.FeedIcecastChunk(chunk)
+		if err != nil {
+			modules.Logger.Debug("Failed to feed chunk: " + err.Error())
+		}
+	}
+}
+
 func main() {
 
 	modules.InitReader()
+	
+	// Initialize Icecast source server on port 8001
+	modules.InitIcecastServer("8001")
+	go func() {
+		err := modules.IcecastSource.Start()
+		if err != nil {
+			modules.Logger.Error(fmt.Sprintf("Icecast server failed: %v", err))
+		}
+	}()
+
+	// Start Icecast normalizer feeder (runs continuously, checks mode)
+	go icecastNormalizerFeeder()
 
 	e := echo.New()
 
@@ -31,3 +121,4 @@ func main() {
 		modules.Logger.Error(err)
 	}
 }
+

middlewares/auth.go

@@ -0,0 +1,32 @@
+package middlewares
+
+import (
+	"gostream/modules"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+)
+
+// BasicAuth middleware checks HTTP Basic Authentication
+func BasicAuth(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(ctx echo.Context) error {
+		// Skip auth if credentials are not configured
+		if modules.Config.Username == "" || modules.Config.Password == "" {
+			return next(ctx)
+		}
+
+		username, password, ok := ctx.Request().BasicAuth()
+		
+		// Check if credentials match
+		if !ok || username != modules.Config.Username || password != modules.Config.Password {
+			ctx.Response().Header().Set("WWW-Authenticate", "Basic realm=\"GoStream\"")
+			return ctx.JSON(http.StatusUnauthorized, map[string]string{
+				"error": "Unauthorized",
+				"message": "Invalid username or password",
+			})
+		}
+
+		return next(ctx)
+	}
+}
+

modules/config.go

@@ -35,6 +35,9 @@ type IConfig struct {
 	Notice1            string // Shoutcast notice 1 (icy-notice1 header)
 	Notice2            string // Shoutcast notice 2 (icy-notice2 header)
 	MetaInterval       int    // Metadata interval in bytes (default 8192)
+	// Authentication
+	Username           string // Username for API authentication
+	Password           string // Password for API authentication
 }
 
 var Config *IConfig
@@ -58,6 +61,9 @@ type JSONConfig struct {
 	Notice1            string `json:"notice1"`
 	Notice2            string `json:"notice2"`
 	MetaInterval       int    `json:"meta_interval"`
+	// Authentication
+	Username           string `json:"username"`
+	Password           string `json:"password"`
 }
 
 // LoadConfigFromFile loads configuration from a local JSON file
@@ -135,6 +141,8 @@ func init() {
 	var notice1 string = ""
 	var notice2 string = ""
 	var metaInterval int = 8192
+	var username string = ""
+	var password string = ""
 
 	flag.StringVar(&name, "n", "GoStream", "server name")
 	flag.IntVar(&port, "p", 8090, "server port number")
@@ -206,6 +214,12 @@ func init() {
 		if jsonConfig.MetaInterval > 0 {
 			metaInterval = jsonConfig.MetaInterval
 		}
+		if jsonConfig.Username != "" {
+			username = jsonConfig.Username
+		}
+		if jsonConfig.Password != "" {
+			password = jsonConfig.Password
+		}
 
 		// Boolean flags - only override if they're true in config
 		if jsonConfig.Random {
@@ -241,6 +255,8 @@ func init() {
 		Notice1:            notice1,
 		Notice2:            notice2,
 		MetaInterval:       metaInterval,
+		Username:           username,
+		Password:           password,
 	}
 }