Lineup 2.0.0

Lineup 2.0.0

Lineup 2.0 is a major release focused on resilient live TV playback, Jellyfin-compatible transcoding, direct SiliconDust guide ingestion, virtual HDHomeRun devices, operational visibility, and safer persistent storage.

Important

This release includes significant Docker storage changes. Existing Docker users should read the upgrade notes before replacing their current container.

Highlights

Jellyfin FFmpeg and ATSC 3.0 AC-4 support

• Uses a pinned Jellyfin FFmpeg 8 build for reliable ATSC 3.0 AC-4 decoding.
• Converts AC-4 audio to AC-3 or E-AC-3 for broader client compatibility.
• Adds a Preserve option for receivers that can decode AC-4 directly.
• Adds configurable audio handling, H.264 video transcoding, quality controls, and repeated codec headers.
• Includes Docker integration and a checksum-verified Windows installation helper.
• Verifies during Docker builds that Jellyfin FFmpeg is selected and provides an AC-4 decoder.

Multiple audio tracks and subtitles

• Preserves compatible alternate-language, commentary, and SAP audio tracks through the MPEG-TS proxy.
• Retains language, title, default, forced, hearing-impaired, and closed-caption metadata where supported.
• Adds Audio and Subtitles selectors to the Watch page.
• Defaults to the source’s default or first audio track, with subtitles disabled until selected.
• Restarts only the affected playback session when a track selection changes.
• Preserves DVB subtitles and DVB teletext in MPEG-TS output.
• Retains embedded CEA-608/708 captions when the selected video handling supports them.
• Converts supported text subtitles to temporary WebVTT sidecars for browser playback.
• Burns bitmap subtitles into video only when video transcoding is required.
• Reports incompatible subtitle formats in stream diagnostics rather than silently mapping them incorrectly.
• Cleans temporary subtitle files after disconnect, application restart, and Factory Reset.

More reliable live streaming

• Hardens MPEG-TS, fragmented MP4, and HLS startup and shutdown behavior.
• Preserves tuner continuity between stream probing and playback.
• Shares one physical tuner input between compatible client sessions.
• Maintains independent output sessions and track selections for each client.
• Adds bounded buffering and slow-client eviction so one stalled consumer cannot block other viewers.
• Adds startup retries, inactivity expiration, client-disconnect detection, and deterministic cleanup.
• Improves FFmpeg process, HLS segment, subtitle sidecar, socket, and tuner-lock cleanup.
• Improves player errors and active-stream diagnostics.
• Reports client, channel, format, source and output codecs, bitrates, dimensions, audio channels, and track selections.

Manual Tune

• Adds Manual Tune to the Watch page.
• Allows users to enter a virtual channel number and attempt playback even when no guide entry exists.
• Uses the same stream planning, transcoding, protected-content detection, audio selection, subtitle selection, and diagnostics as guide-based playback.

Protected-content handling

• Detects DRM-protected channels and records their protected state.
• Prevents repeated playback attempts against channels already known to be protected.
• Can display a configurable protected-content slate instead of leaving the player in an unclear failure state.
• Improves protected-channel diagnostics and cleanup.

Virtual HDHomeRun proxy

• Exposes Lineup as one or more virtual HDHomeRun devices.
• Supports HDHomeRun discovery, device information, lineup endpoints, HTTP stream proxying, and tuner status.
• Adds SiliconDust UDP discovery on port 65001.
• Adds SSDP/UPnP advertisement on port 1900.
• Supports configurable virtual device IDs, friendly names, tuner limits, physical-device mappings, and advertised URLs.
• Supports multiple virtual profiles backed by the same or different physical devices.
• Tracks tuner capacity across proxied streams and first-party Watch sessions.
• Adds passive virtual-device resolution status for diagnostics and the Status API.
• Adds a global Enable HDHomeRun Proxy switch, disabled by default for new installations.
• Keeps Lineup’s built-in Watch page independent from the proxy setting.
• Strengthens listener startup, configuration-change handling, cancellation, and shutdown behavior.

Direct SiliconDust XMLTV ingestion

• Replaces paged guide retrieval with SiliconDust’s complete compressed XMLTV feed.
• Preserves canonical XMLTV metadata without reconstructing the guide from a lossy intermediate format.
• Uses secure XML parsing and normalized channel and programme persistence.
• Supports shared-station fan-out and refreshed DeviceAuth credentials.
• Coordinates guide refresh and publication so readers do not observe partially updated state.
• Adds safe fetch boundaries, cache statistics, progress reporting, and failure diagnostics.
• Automatically refreshes guide data at a randomized interval between 20 and 28 hours, as required by the upstream API.
• Persists refresh schedules across restarts.
• Retries failed automatic refreshes after one hour.
• Recovers from interrupted guide generation and removes stale temporary files.

XMLTV output improvements

• Publishes the canonical XMLTV document atomically after a successful guide refresh.

• Defaults XMLTV publication to: /xmltv/epg.xml

• Treats Lineup:XmltvPath and Lineup__XmltvPath as optional overrides.

• Aligns the application default with Docker’s xmltv:/xmltv volume mapping.

• Persists XMLTV output correctly even when the override is omitted.

• Preserves a saved XMLTV output path after initialization; the saved setting remains authoritative.

• Adds an editable XMLTV destination under Settings.

• Adds configured-path mismatch guidance and a reset-to-configured-path action.

• Restores the Server Directory Browser for selecting an output directory and filename.

• Continues serving the saved guide through GET /api/xmltv.

• Keeps local development output project-relative through an explicit development override.

Centralized persistent application data

• Adds AppDataStore as the single owner of Lineup-managed persistent storage.
• Centralizes:
  • Application settings and backups
  • SQLite guide data
  • Canonical guide cache
  • Rolling logs
  • ASP.NET Core Data Protection keys
  • Restart-safe Factory Reset requests
• Adds contained path derivation, directory creation, atomic replacement, backup handling, safe enumeration, and guarded deletion.
• Prevents persistent operations from escaping or deleting the application-data root.
• Removes primitive path injection from production dependency registrations.
• Defaults the application-data root to:/appdata
• Treats Lineup:AppDataPath and Lineup__AppDataPath as optional overrides for custom deployments.
• Aligns the application default with Docker’s appdata:/appdata volume mapping.
• Removes the deprecated Lineup:ConfigPath and Lineup__ConfigPath settings.
• Keeps local development state project-relative through an explicit development override.

Atomic settings and recovery

• Writes settings atomically instead of updating the active JSON document in place.
• Preserves a recoverable backup of the previous complete settings document.
• Recovers from a corrupt primary settings file when a valid backup is available.
• Safely initializes missing values from current defaults.
• Preserves explicit persisted values when startup configuration differs.
• Strengthens settings validation and concurrent update behavior.

Factory Reset and graceful restart

• Adds a dedicated Reset tab in Settings.
• Allows users to stage default settings for review before saving.
• Adds a restart-safe Factory Reset workflow.
• Removes only allowlisted Lineup-owned settings, databases, caches, logs, Data Protection keys, and temporary stream files.
• Preserves unrelated external files.
• Removes externally configured XMLTV output only when it is recognized as Lineup-owned.
• Displays a blocking restart screen while the application shuts down.
• Returns the browser to first-run Device setup after the new application instance starts.
• Works with supervisors such as Docker’s restart: unless-stopped.

Structured logging and Logs UI

• Adds provider-neutral structured logging.
• Adds console and in-memory logging sinks.
• Adds runtime application and category-level filters.
• Redacts sensitive structured properties such as authorization headers, tokens, passwords, secrets, connection strings, and device authentication values.
• Adds optional rolling file logs with configurable:
  • Minimum level
  • Retention period
  • Per-file size limit
• Adds a dedicated Logs page for viewing recent events.
• Allows retained log files to be listed and downloaded.
• Adds safe log deletion that can restart the managed file sink without disrupting other logging targets.
• Keeps console, in-memory, file, and external telemetry sinks independent.

OpenTelemetry export

• Adds optional OTLP log export.
• Supports HTTP/Protobuf and gRPC protocols.
• Supports configurable OTLP headers for authentication.
• Includes an example OpenTelemetry Collector configuration and Compose integration.
• Reports external logging-target status in the application.
• Uses background delivery so an unavailable collector does not block streaming or guide refresh.

Versioned Lineup Status API

Adds an unauthenticated, LAN-oriented status endpoint:

GET /api/v1/status

The stable, versioned response includes:

• Application version, runtime identity, setup state, and uptime
• Guide status, channel and programme counts, coverage, and freshness
• Automatic-fetch progress and scheduling
• XMLTV availability and publication time
• Physical HDHomeRun discovery and refresh state
• Configured virtual devices and their last resolution results
• Cached tuner state
• Active streams
• Source and output media tracks
• Codec, bitrate, resolution, channel count, language, title, disposition, and selection details

Additional API behavior:

• Returns Cache-Control: no-store.
• Uses passive cached state and does not initiate discovery or tuner refreshes during a request.
• Reports unavailable sections independently without hiding healthy sections.
• Provides separate privacy controls for:
  • Active-stream client addresses
  • Device addresses
  • URLs
• Leaves redacted properties present as JSON null.
• Never exposes HDHomeRun authentication values, certificate secrets, or server filesystem paths.
• Includes a Home Assistant REST sensor example in the documentation.

Optional HTTPS

• Adds optional HTTPS using a configured PFX certificate.
• Validates that the certificate:
  • Exists and is readable
  • Has a valid password
  • Contains a private key
  • Is currently within its validity period
• Continues serving HTTP when HTTPS is not configured.
• Logs a warning and continues with HTTP if an optional certificate is unavailable or invalid.
• Uses explicit Lineup HTTP and HTTPS listener configuration.
• Does not rely on ASPNETCORE_HTTP_PORTS.
• Persists ASP.NET Core Data Protection keys beneath the application-data root.
• Keeps certificate files and passwords outside persisted application settings.
• Includes Docker certificate-mounting guidance.
• Does not force HTTPS redirects; deployments may use a reverse proxy when required.

Settings, Dashboard, and navigation

• Reorganizes Settings into focused workflows for:
  • Device configuration
  • Virtual devices and proxy behavior
  • Transcoding
  • XMLTV
  • Logging
  • Status API privacy
  • HTTPS operational guidance
  • Reset and Factory Reset
• Sends first-run users directly to Settings → Device.
• Collapses HDHomeRun proxy options while the proxy is disabled.
• Standardizes transcoding language around Preserve and Transcode.
• Adds explicit AC-4 output codec choices where the selected output format matters.
• Improves Dashboard card alignment, device controls, guide actions, Auto-Fetch links, refresh behavior, and active-stream details.
• Adds clearer validation, loading, warning, empty, failure, and restart states.
• Adds copyable manual device, lineup, stream, discovery, and XMLTV URLs where appropriate.

Docker and container publishing

• Includes pinned Jellyfin FFmpeg 8.1.2-4-noble.

• Verifies that Jellyfin FFmpeg is selected and AC-4 decoding is available.

• Defaults Lineup-owned persistent storage to /appdata.

• Defaults XMLTV publication to /xmltv/epg.xml but is customizable in the UI or by config values.

• The standard Compose configuration mounts:

  volumes:
    - appdata:/appdata
    - xmltv:/xmltv

• Lineup__AppDataPath and Lineup__XmltvPath remain available as optional overrides but are not required for the standard container paths.

• Default ports are:

  • TCP 8080 for HTTP
  • TCP 8443 for optional HTTPS
  • UDP 65001 for HDHomeRun discovery
  • UDP 1900 for SSDP

• Adds a manually triggered GitHub Actions release workflow.

• Maintainers can publish one semantic version to Docker Hub and GitHub Container Registry.

• Publishing 2.0.0 creates:

  • am385/lineup:2.0.0
  • am385/lineup:2.0
  • ghcr.io/am385/lineup:2.0.0
  • ghcr.io/am385/lineup:2.0

• The workflow can optionally update both registries’ latest tags.

• Docker build contexts exclude generated Data Protection key rings and other runtime state.

Upgrade notes

Docker application-data path changed

Lineup 2.0 changes its persistent application-data container path:

Old: /config
New: /appdata

The Compose volume is also renamed from config to appdata.

An ordinary docker compose up may create a new empty volume, causing Lineup to appear as a new installation even though the old data remains in the previous volume.

Before upgrading, use one of these approaches:

• Copy the contents of the old config volume into the new appdata volume.
• Configure the new appdata volume’s Compose name property to reference the existing Docker volume.
• If using a bind mount, mount the same existing host directory at /appdata.

Warning

Do not delete the old volume until Lineup 2.0 has started successfully with the expected settings and guide data.

Application-data configuration

The default application-data root is now: /appdata

No Lineup__AppDataPath setting is required when this is the desired location.

Custom deployments can override it:

Lineup__AppDataPath=/custom/path

The former Lineup:ConfigPath and Lineup__ConfigPath settings are no longer supported.

XMLTV migration

The default XMLTV output is now: /xmltv/epg.xml

No Lineup__XmltvPath setting is required when this is the desired location.

Custom deployments can override it:

Lineup__XmltvPath=/custom/xmltv

Existing valid XMLTV output paths remain authoritative after upgrade. If migrated settings still contain the former relative path:

xmltv/epg.xml

Open Settings → XMLTV and change it to /xmltv/epg.xml, or use the reset-to-configured-path action.

The Docker volume should remain mounted as:

volumes:
  - xmltv:/xmltv

Warning

Do not change the target to /app/xmltv.

HDHomeRun proxy

• The global HDHomeRun proxy is disabled by default for new installations.
• Enable it under Settings → Device before connecting Jellyfin, Plex, or another third-party application.
• Existing proxy configurations are migrated from the former primary-profile setting.
• Network discovery requires UDP ports 65001 and 1900.
• Some Docker networks cannot receive LAN broadcast or multicast traffic. Use host networking or manually configure advertised URLs when required.

Database, settings, and Data Protection

• Existing guide databases are upgraded automatically for additional channel, programme, and protected-content metadata.
• Settings are migrated and rewritten atomically when saved.
• Keep a backup of the existing application-data volume before upgrading.
• Data Protection keys now live beneath the application-data root.
• Preserving the key directory avoids invalidating protected browser state after container recreation.

Runtime and tests

• The project now targets .NET 10.
• Test infrastructure now uses xUnit v3.
• Custom source builds require the .NET 10 SDK.

Deployment and security

Lineup’s web interface and Status API are intended for a trusted local network and do not provide built-in authentication.

Important considerations:

• Do not expose Lineup directly to untrusted networks or users.
• XMLTV output settings can reference arbitrary relative or absolute server filesystem paths.
• Use a reverse proxy for authentication, access control, and externally enforced HTTPS.
• Store certificate passwords and OTLP credentials in deployment-platform secrets.
• Do not commit certificates, passwords, Data Protection keys, settings files, or databases.
• Use the Status API privacy settings before exposing status information beyond the local network.
• HDHomeRun authentication values and server filesystem paths are permanently excluded from the Status API.

Documentation and quality

• Updated Docker, Compose, local development, HTTPS, logging, Status API, Home Assistant, virtual-device, transcoding, XMLTV, and operational documentation.
• Updated the Unraid template for Lineup 2.0 container paths, ports, environment settings, and migration guidance.
• Expanded regression coverage across:
  • Guide ingestion and publication
  • Settings persistence and recovery
  • Application-data containment
  • Factory Reset
  • Device control and discovery
  • SSDP lifecycle behavior
  • Proxy profiles and tuner capacity
  • Streaming and input multiplexing
  • Transcoding plans
  • Multiple audio tracks and subtitles
  • Logging and sensitive-data redaction
  • HTTPS configuration
  • Status API contracts and privacy
  • Watch and Settings UI behavior
• Stabilized discovery-service startup and SSDP cancellation behavior under .NET 10.
• Enforces explicit // Arrange, // Act, and // Assert sections in tests.
• Enforces XML documentation for non-private entities.
• Enforces repository formatting and a 225-character C# line-length standard.
• Excludes generated secrets and runtime state from Git and Docker build contexts.