Map selected Emby audio tracks

tces1 · tces1 · commit 4d4f949ba965 · 2026-05-21T13:31:56.000+08:00
diff --git a/README.md b/README.md
@@ -11,6 +11,7 @@ It is intentionally narrow: normal API traffic is forwarded to the upstream serv
 - Client profile matching by `User-Agent` and `X-Emby-Authorization`.
 - PlaybackInfo rewriting for matched profiles.
 - Local FFmpeg HLS sessions under `/streambridge/transcode/`.
+- Audio track selection through Emby `AudioStreamIndex`, mapped to the matching FFmpeg audio stream.
 - Playback lifecycle tracking through Emby `/Sessions/Playing*` check-ins plus HLS access.
 - Conservative output target: H.264 video, AAC audio, HLS MPEG-TS segments.
 
diff --git a/internal/emby/playback.go b/internal/emby/playback.go
@@ -32,6 +32,7 @@ type SourceReport struct {
 	AudioCodec               string
 	AudioChannels            int
 	AudioTitle               string
+	AudioStreams             []AudioStreamReport
 	Bitrate                  int64
 	RunTimeTicks             int64
 	BeforeSupportsDirectPlay bool
@@ -41,6 +42,14 @@ type SourceReport struct {
 	AfterTranscodingURL      string
 }
 
+type AudioStreamReport struct {
+	Index    int
+	Ordinal  int
+	Codec    string
+	Channels int
+	Title    string
+}
+
 func RewritePlaybackInfoWithReport(body []byte, itemID string, publicURL string, rawQuery ...string) ([]byte, bool, RewriteReport, error) {
 	report := RewriteReport{ItemID: itemID}
 	var root map[string]any
@@ -92,6 +101,7 @@ func RewritePlaybackInfoWithReport(body []byte, itemID string, publicURL string,
 			AudioCodec:               sourceReport.AudioCodec,
 			AudioChannels:            sourceReport.AudioChannels,
 			AudioTitle:               sourceReport.AudioTitle,
+			AudioStreams:             sourceReport.AudioStreams,
 			Bitrate:                  sourceReport.Bitrate,
 			RunTimeTicks:             sourceReport.RunTimeTicks,
 			BeforeSupportsDirectPlay: sourceReport.BeforeSupportsDirectPlay,
@@ -132,6 +142,7 @@ func sourceReportFromMap(source map[string]any) SourceReport {
 	}
 
 	rawStreams, _ := source["MediaStreams"].([]any)
+	audioOrdinal := 0
 	for _, rawStream := range rawStreams {
 		stream, ok := rawStream.(map[string]any)
 		if !ok {
@@ -142,10 +153,21 @@ func sourceReportFromMap(source map[string]any) SourceReport {
 			report.VideoCodec = stringValue(stream, "Codec")
 			report.Width = intValue(stream, "Width")
 			report.Height = intValue(stream, "Height")
-		case strings.EqualFold(stringValue(stream, "Type"), "Audio") && report.AudioCodec == "":
-			report.AudioCodec = stringValue(stream, "Codec")
-			report.AudioChannels = intValue(stream, "Channels")
-			report.AudioTitle = stringValue(stream, "DisplayTitle")
+		case strings.EqualFold(stringValue(stream, "Type"), "Audio"):
+			audio := AudioStreamReport{
+				Index:    intValue(stream, "Index"),
+				Ordinal:  audioOrdinal,
+				Codec:    stringValue(stream, "Codec"),
+				Channels: intValue(stream, "Channels"),
+				Title:    stringValue(stream, "DisplayTitle"),
+			}
+			report.AudioStreams = append(report.AudioStreams, audio)
+			audioOrdinal++
+			if report.AudioCodec == "" {
+				report.AudioCodec = audio.Codec
+				report.AudioChannels = audio.Channels
+				report.AudioTitle = audio.Title
+			}
 		}
 	}
 
diff --git a/internal/emby/playback_test.go b/internal/emby/playback_test.go
@@ -63,7 +63,7 @@ func TestRewritePlaybackInfoPreservesQueryString(t *testing.T) {
 }
 
 func TestRewritePlaybackInfoWithReportDescribesSources(t *testing.T) {
-	input := []byte(`{"MediaSources":[{"Id":"source1","Name":"4K - 80 Mbps","Path":"/media/Movie.mkv","Container":"mkv","Bitrate":80000000,"RunTimeTicks":72000000000,"SupportsDirectPlay":true,"DirectStreamUrl":"/Videos/1/stream","MediaStreams":[{"Type":"Video","Codec":"hevc","Width":3840,"Height":2160},{"Type":"Audio","Codec":"dts","Channels":6,"DisplayTitle":"DTS 5.1"}]}]}`)
+	input := []byte(`{"MediaSources":[{"Id":"source1","Name":"4K - 80 Mbps","Path":"/media/Movie.mkv","Container":"mkv","Bitrate":80000000,"RunTimeTicks":72000000000,"SupportsDirectPlay":true,"DirectStreamUrl":"/Videos/1/stream","MediaStreams":[{"Type":"Video","Index":0,"Codec":"hevc","Width":3840,"Height":2160},{"Type":"Audio","Index":1,"Codec":"dts","Channels":6,"DisplayTitle":"DTS 5.1"},{"Type":"Audio","Index":2,"Codec":"aac","Channels":2,"DisplayTitle":"AAC 2.0"}]}]}`)
 
 	_, changed, report, err := emby.RewritePlaybackInfoWithReport(input, "item123", "http://proxy.local")
 	if err != nil {
@@ -106,6 +106,15 @@ func TestRewritePlaybackInfoWithReportDescribesSources(t *testing.T) {
 	if source.AudioCodec != "dts" || source.AudioChannels != 6 || source.AudioTitle != "DTS 5.1" {
 		t.Fatalf("audio = %s channels=%d title=%q", source.AudioCodec, source.AudioChannels, source.AudioTitle)
 	}
+	if len(source.AudioStreams) != 2 {
+		t.Fatalf("audio streams = %+v", source.AudioStreams)
+	}
+	if source.AudioStreams[0].Index != 1 || source.AudioStreams[0].Ordinal != 0 || source.AudioStreams[0].Codec != "dts" {
+		t.Fatalf("first audio stream = %+v", source.AudioStreams[0])
+	}
+	if source.AudioStreams[1].Index != 2 || source.AudioStreams[1].Ordinal != 1 || source.AudioStreams[1].Codec != "aac" {
+		t.Fatalf("second audio stream = %+v", source.AudioStreams[1])
+	}
 	if source.Bitrate != 80000000 || source.RunTimeTicks != 72000000000 {
 		t.Fatalf("bitrate/runtime = %d/%d", source.Bitrate, source.RunTimeTicks)
 	}
diff --git a/internal/proxy/server.go b/internal/proxy/server.go
@@ -201,6 +201,15 @@ func (s *Server) handlePlaybackInfo(w http.ResponseWriter, r *http.Request) {
 					Bitrate:       source.Bitrate,
 					RunTimeTicks:  source.RunTimeTicks,
 				}
+				for _, audio := range source.AudioStreams {
+					mediaInfo.AudioStreams = append(mediaInfo.AudioStreams, transcode.AudioStreamInfo{
+						Index:    audio.Index,
+						Ordinal:  audio.Ordinal,
+						Codec:    audio.Codec,
+						Channels: audio.Channels,
+						Title:    audio.Title,
+					})
+				}
 				s.transcodeManager.RememberMedia(source.SessionID, mediaInfo)
 				logging.Debugf(
 					"playbackinfo source item=%s session=%s index=%d source_id=%q before_direct=%t before_transcode=%t had_direct_stream_url=%t had_transcoding_url=%t after=%s media=%s",
@@ -233,7 +242,9 @@ func (s *Server) upstreamURL(in *url.URL) string {
 func transcodeInputURL(upstream *url.URL, id string, r *http.Request) string {
 	u := *upstream
 	u.Path = singleJoiningSlash(upstream.Path, path.Join("/emby/Videos", id, "stream"))
-	u.RawQuery = r.URL.RawQuery
+	query := r.URL.Query()
+	query.Del("AudioStreamIndex")
+	u.RawQuery = query.Encode()
 	return u.String()
 }
 
diff --git a/internal/proxy/transcode_input_test.go b/internal/proxy/transcode_input_test.go
@@ -26,3 +26,20 @@ func TestTranscodeInputURLPreservesStartTimeTicks(t *testing.T) {
 		t.Fatalf("input url = %s", got)
 	}
 }
+
+func TestTranscodeInputURLStripsAudioStreamIndexForLocalMapping(t *testing.T) {
+	upstream, err := url.Parse("http://upstream.local")
+	if err != nil {
+		t.Fatal(err)
+	}
+	req := httptest.NewRequest("GET", "/streambridge/transcode/item123/master.m3u8?AudioStreamIndex=2&MediaSourceId=source1&X-Emby-Token=abc", nil)
+
+	got := transcodeInputURL(upstream, "item123", req)
+
+	if strings.Contains(got, "AudioStreamIndex=") {
+		t.Fatalf("input url should not forward AudioStreamIndex to upstream when local ffmpeg maps audio: %s", got)
+	}
+	if !strings.Contains(got, "MediaSourceId=source1") || !strings.Contains(got, "X-Emby-Token=abc") {
+		t.Fatalf("input url should preserve non-audio query params: %s", got)
+	}
+}
diff --git a/internal/transcode/ffmpeg_args_test.go b/internal/transcode/ffmpeg_args_test.go
@@ -103,6 +103,43 @@ func TestBuildFFmpegArgsAppliesVAAPIHardwareDecodeBeforeInput(t *testing.T) {
 	}
 }
 
+func TestBuildFFmpegArgsMapsRequestedEmbyAudioStreamIndex(t *testing.T) {
+	session := &Session{
+		ID:  "item123",
+		Dir: t.TempDir(),
+		Media: MediaInfo{
+			AudioStreams: []AudioStreamInfo{
+				{Index: 1, Ordinal: 0, Codec: "dts"},
+				{Index: 2, Ordinal: 1, Codec: "aac"},
+			},
+		},
+	}
+	request := Request{
+		InputURL:         "http://upstream/stream?AudioStreamIndex=2",
+		AudioStreamIndex: 2,
+	}
+
+	args := buildFFmpegArgs(session, request)
+
+	mapIndexes := allIndexes(args, "-map")
+	if len(mapIndexes) < 2 {
+		t.Fatalf("missing map args: %v", args)
+	}
+	if got := args[mapIndexes[1]+1]; got != "0:a:1?" {
+		t.Fatalf("audio map = %q, args=%v", got, args)
+	}
+}
+
+func allIndexes(values []string, needle string) []int {
+	var indexes []int
+	for i, value := range values {
+		if value == needle {
+			indexes = append(indexes, i)
+		}
+	}
+	return indexes
+}
+
 func TestResolveHardwareDecodeKeepsVAAPIWhenProbePasses(t *testing.T) {
 	options := resolveHardwareDecodeOptions("/usr/bin/ffmpeg", FFmpegOptions{
 		HardwareDecode: "vaapi",
diff --git a/internal/transcode/handler.go b/internal/transcode/handler.go
@@ -160,6 +160,8 @@ func (h Handler) sessionForSegment(id string, segmentIndex int, name string, r *
 			traceSwitch("segment_decision id=%s file=%s segment=%d decision=restart reason=process_done old_segment_start=%d old_start_ticks=%d elapsed=%s", id, name, segmentIndex, session.SegmentStartIndex, session.StartTimeTicks, time.Since(requestStarted))
 		case !segmentInputCompatible(session.InputURL, inputURL):
 			traceSwitch("segment_decision id=%s file=%s segment=%d decision=restart reason=input_changed old_input=%s new_input=%s elapsed=%s", id, name, segmentIndex, redactURLString(session.InputURL), redactURLString(inputURL), time.Since(requestStarted))
+		case session.AudioStreamIndex != request.AudioStreamIndex:
+			traceSwitch("segment_decision id=%s file=%s segment=%d decision=restart reason=audio_changed old_audio=%d new_audio=%d elapsed=%s", id, name, segmentIndex, session.AudioStreamIndex, request.AudioStreamIndex, time.Since(requestStarted))
 		case segmentReusable(session, segmentIndex, name):
 			traceSwitch("segment_decision id=%s file=%s segment=%d decision=hit session_start=%d dir=%s elapsed=%s", id, name, segmentIndex, session.SegmentStartIndex, session.Dir, time.Since(requestStarted))
 			h.Manager.RecordSegmentRequest(id, segmentIndex)
@@ -284,6 +286,7 @@ func requestFromHTTP(id string, inputURL string, r *http.Request) Request {
 		ItemID:                  id,
 		MediaSourceID:           query.Get("MediaSourceId"),
 		PlaySessionID:           playSessionID,
+		AudioStreamIndex:        int(int64Query(query.Get("AudioStreamIndex"))),
 		StartTimeTicks:          int64Query(query.Get("StartTimeTicks")),
 		RequestedStartTimeTicks: int64Query(query.Get("StartTimeTicks")),
 	}
diff --git a/internal/transcode/manager.go b/internal/transcode/manager.go
@@ -46,6 +46,7 @@ type Request struct {
 	ItemID                  string
 	MediaSourceID           string
 	PlaySessionID           string
+	AudioStreamIndex        int
 	StartTimeTicks          int64
 	RequestedStartTimeTicks int64
 	SegmentStartIndex       int
@@ -65,6 +66,7 @@ type Session struct {
 	ItemID                  string
 	MediaSourceID           string
 	PlaySessionID           string
+	AudioStreamIndex        int
 	StartTimeTicks          int64
 	RequestedStartTimeTicks int64
 	SegmentStartIndex       int
@@ -153,10 +155,19 @@ type MediaInfo struct {
 	AudioCodec    string
 	AudioChannels int
 	AudioTitle    string
+	AudioStreams  []AudioStreamInfo
 	Bitrate       int64
 	RunTimeTicks  int64
 }
 
+type AudioStreamInfo struct {
+	Index    int
+	Ordinal  int
+	Codec    string
+	Channels int
+	Title    string
+}
+
 func (info MediaInfo) Summary() string {
 	var parts []string
 	if info.Name != "" {
@@ -191,6 +202,9 @@ func (info MediaInfo) Summary() string {
 		}
 		parts = append(parts, "audio="+audio)
 	}
+	if len(info.AudioStreams) > 0 {
+		parts = append(parts, fmt.Sprintf("audio_streams=%d", len(info.AudioStreams)))
+	}
 	if info.Bitrate > 0 {
 		parts = append(parts, fmt.Sprintf("bitrate=%d", info.Bitrate))
 	}
@@ -204,7 +218,20 @@ func (info MediaInfo) Summary() string {
 }
 
 func (info MediaInfo) IsZero() bool {
-	return info == MediaInfo{}
+	return info.ItemID == "" &&
+		info.SourceID == "" &&
+		info.Name == "" &&
+		info.Path == "" &&
+		info.Container == "" &&
+		info.VideoCodec == "" &&
+		info.Width == 0 &&
+		info.Height == 0 &&
+		info.AudioCodec == "" &&
+		info.AudioChannels == 0 &&
+		info.AudioTitle == "" &&
+		len(info.AudioStreams) == 0 &&
+		info.Bitrate == 0 &&
+		info.RunTimeTicks == 0
 }
 
 func (m *Manager) RememberMedia(id string, info MediaInfo) {
@@ -488,6 +515,9 @@ func shouldRestart(session *Session, request Request) bool {
 	if request.SegmentStartIndex != session.SegmentStartIndex {
 		return true
 	}
+	if request.AudioStreamIndex != session.AudioStreamIndex {
+		return true
+	}
 	return request.InputURL != "" && session.InputURL != "" && request.InputURL != session.InputURL
 }
 
@@ -508,6 +538,7 @@ func touchSession(session *Session, request Request, now time.Time, mediaAccess
 	if request.PlaySessionID != "" {
 		session.PlaySessionID = request.PlaySessionID
 	}
+	session.AudioStreamIndex = request.AudioStreamIndex
 	session.StartTimeTicks = request.StartTimeTicks
 	session.RequestedStartTimeTicks = request.RequestedStartTimeTicks
 	session.SegmentStartIndex = request.SegmentStartIndex
@@ -764,7 +795,7 @@ func (r FFmpegRunner) Start(ctx context.Context, session *Session, request Reque
 	args := buildFFmpegArgs(session, request, r.Options)
 	playlist := filepath.Join(session.Dir, "master.m3u8")
 	logPath := filepath.Join(session.Dir, "ffmpeg.log")
-	logging.Infof("transcode start id=%s segment=%d decode=%s audio=optional-aac log=%s", session.ID, session.SegmentStartIndex, ffmpegOptionsSummary(r.Options), logPath)
+	logging.Infof("transcode start id=%s segment=%d decode=%s audio_stream_index=%d audio_map=%s audio=optional-aac log=%s", session.ID, session.SegmentStartIndex, ffmpegOptionsSummary(r.Options), request.AudioStreamIndex, audioMapArg(session, request), logPath)
 	logging.Debugf("ffmpeg start id=%s item=%s media_source=%s start_ticks=%d segment_start=%d path=%s input=%s playlist=%s media=%s args=%s", session.ID, session.ItemID, session.MediaSourceID, session.StartTimeTicks, session.SegmentStartIndex, r.Path, redactURLString(request.InputURL), playlist, session.Media.Summary(), redactFFmpegArgs(args))
 	cmd := exec.CommandContext(ctx, r.Path, args...)
 	stdin, err := cmd.StdinPipe()
@@ -845,7 +876,7 @@ func buildFFmpegArgs(session *Session, request Request, options ...FFmpegOptions
 	args = append(args,
 		"-i", request.InputURL,
 		"-map", "0:v:0",
-		"-map", "0:a:0?",
+		"-map", audioMapArg(session, request),
 		"-c:v", "libx264",
 		"-preset", "veryfast",
 		"-profile:v", "high",
@@ -872,6 +903,27 @@ func buildFFmpegArgs(session *Session, request Request, options ...FFmpegOptions
 	return args
 }
 
+func audioMapArg(session *Session, request Request) string {
+	ordinal := audioOrdinalForRequest(session, request)
+	return fmt.Sprintf("0:a:%d?", ordinal)
+}
+
+func audioOrdinalForRequest(session *Session, request Request) int {
+	if request.AudioStreamIndex < 0 {
+		return 0
+	}
+	media := request.Media
+	if media.IsZero() && session != nil {
+		media = session.Media
+	}
+	for _, stream := range media.AudioStreams {
+		if stream.Index == request.AudioStreamIndex && stream.Ordinal >= 0 {
+			return stream.Ordinal
+		}
+	}
+	return 0
+}
+
 func appendHardwareDecodeArgs(args []string, options FFmpegOptions) []string {
 	switch strings.ToLower(strings.TrimSpace(options.HardwareDecode)) {
 	case "", "none", "off", "false":
diff --git a/internal/transcode/manager_test.go b/internal/transcode/manager_test.go
@@ -195,6 +195,40 @@ func TestManagerRestartsSessionWhenSegmentStartIndexChanges(t *testing.T) {
 	}
 }
 
+func TestManagerRestartsSessionWhenAudioStreamIndexChanges(t *testing.T) {
+	var stopped atomic.Int32
+	m := transcode.NewManager(transcode.Options{
+		MaxSessions: 1,
+		TempDir:     t.TempDir(),
+		Runner: runnerFunc(func(ctx context.Context, session *transcode.Session, request transcode.Request) (transcode.Process, error) {
+			return stopFunc(func() error {
+				stopped.Add(1)
+				return nil
+			}), nil
+		}),
+	})
+	t.Cleanup(m.Close)
+
+	first, err := m.Ensure("item123", transcode.Request{InputURL: "http://upstream/stream", AudioStreamIndex: 1})
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := m.Ensure("item123", transcode.Request{InputURL: "http://upstream/stream", AudioStreamIndex: 2})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if first == second {
+		t.Fatal("expected a new session when audio stream index changes")
+	}
+	if second.AudioStreamIndex != 2 {
+		t.Fatalf("audio stream index = %d", second.AudioStreamIndex)
+	}
+	if stopped.Load() != 1 {
+		t.Fatalf("stopped = %d", stopped.Load())
+	}
+}
+
 func TestManagerRestartsSessionWhenRequestedStartTimeTicksChangesWithinSameSegment(t *testing.T) {
 	var stopped atomic.Int32
 	m := transcode.NewManager(transcode.Options{
@@ -354,10 +388,10 @@ func TestManagerPausesAndResumesBufferedProcess(t *testing.T) {
 func TestManagerDoesNotPauseImmediatelyForSeekedSession(t *testing.T) {
 	process := &pausingProcess{}
 	m := transcode.NewManager(transcode.Options{
-		MaxSessions:            1,
-		TempDir:                t.TempDir(),
-		BufferPauseThreshold:   5 * time.Second,
-		BufferResumeThreshold:  2 * time.Second,
+		MaxSessions:           1,
+		TempDir:               t.TempDir(),
+		BufferPauseThreshold:  5 * time.Second,
+		BufferResumeThreshold: 2 * time.Second,
 		Runner: runnerFunc(func(ctx context.Context, session *transcode.Session, request transcode.Request) (transcode.Process, error) {
 			return process, nil
 		}),
diff --git a/internal/transcode/process_internal_test.go b/internal/transcode/process_internal_test.go
