Merge pull request #169 from alexballas/devel

v2.6.1

Author: alexballas

assets/linux/app.go2tv.go2tv.appdata.xml

@@ -51,6 +51,14 @@
   </branding>
 
   <releases>
+      <release version="2.6.1" date="2026-09-16" type="stable">
+        <description>
+          <ul>
+            <li>Fixed a `getprotocolinfo` call error in version 2.6.0 that caused many MKV files to fail to play.</li>
+          </ul>
+        </description>
+        <url type="details">https://github.com/alexballas/go2tv/releases/tag/v2.6.1</url>
+      </release>
       <release version="2.6.0" date="2026-09-14" type="stable">
         <description>
           <ul>

internal/gui/main.go

@@ -6,12 +6,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"image/color"
 	"net/url"
 	"sort"
 	"time"
 
 	ttwidget "github.com/alexballas/fyne-tooltip/widget"
 	"github.com/alexballas/refyne/v2"
+	"github.com/alexballas/refyne/v2/canvas"
 	"github.com/alexballas/refyne/v2/container"
 	"github.com/alexballas/refyne/v2/data/binding"
 	"github.com/alexballas/refyne/v2/lang"
@@ -183,6 +185,17 @@ func mainWindow(s *FyneScreen) fyne.CanvasObject {
 	})
 	playpause.Importance = widget.HighImportance
 	// playpause.Alignment = widget.ButtonAlignCenter
+	// Reserve the widest playback label so transport controls stay in place.
+	playText := playpause.Text
+	playSize := playpause.MinSize()
+	for _, label := range []string{lang.L("Cast"), lang.L("Play"), lang.L("Pause")} {
+		playpause.SetText(label + "  ")
+		playSize = playSize.Max(playpause.MinSize())
+	}
+	playpause.SetText(playText)
+	playSpace := canvas.NewRectangle(color.Transparent)
+	playSpace.SetMinSize(playSize)
+	playControl := container.NewStack(playSpace, playpause)
 
 	stop := widget.NewButtonWithIcon(lang.L("Stop"), theme.MediaStopIcon(), func() {
 		stopAction(s)
@@ -362,7 +375,7 @@ func mainWindow(s *FyneScreen) fyne.CanvasObject {
 	muteSize = muteSize.Max(muteunmute.MinSize())
 	muteControl := container.NewGridWrap(muteSize, muteunmute)
 	volumeRow := container.NewHBox(widget.NewLabel(lang.L("Volume")), volumedown, volumeup, muteControl)
-	transportRow := container.NewHBox(playpause, stop, skipPrevious, skipNext)
+	transportRow := container.NewHBox(playControl, stop, skipPrevious, skipNext)
 	actionButtons := container.New(layout.NewCustomPaddedLayout(0, 0, theme.InnerPadding(), 0), container.NewBorder(nil, nil, transportRow, volumeRow))
 	s.playbackStatus = newPlaybackStatusLabel(lang.L("Select a device"))
 	s.playbackStatus.Importance = widget.MediumImportance

internal/gui/queue.go

@@ -680,6 +680,7 @@ type queueRow struct {
 	thumbPath          string
 	pendingThumbPath   string
 	thumbnailRequestID uint64
+	thumbnailLoader    func(string, mediamodel.MediaKind) *canvas.Image
 	thumbnail          *canvas.Image
 	fallbackIcon       *canvas.Image
 	title              *widget.Label
@@ -707,11 +708,12 @@ func newQueueRow(screen *FyneScreen) *queueRow {
 	)
 
 	row := &queueRow{
-		screen:       screen,
-		thumbnail:    thumbnail,
-		fallbackIcon: fallbackIcon,
-		title:        title,
-		currentIcon:  widget.NewIcon(nil),
+		screen:          screen,
+		thumbnailLoader: screen.queueMediaThumbnail,
+		thumbnail:       thumbnail,
+		fallbackIcon:    fallbackIcon,
+		title:           title,
+		currentIcon:     widget.NewIcon(nil),
 	}
 	row.content = container.NewBorder(
 		nil,
@@ -789,7 +791,7 @@ func (r *queueRow) setRow(index int, item QueueItem, isCurrent bool) {
 				}
 				kind := item.MediaKind()
 				go func() {
-					apply(r.screen.queueMediaThumbnail(path, kind))
+					apply(r.thumbnailLoader(path, kind))
 				}()
 			}
 		}

internal/gui/queue_test.go

@@ -10,8 +10,10 @@ import (
 	"testing"
 
 	"github.com/alexballas/refyne/v2"
+	"github.com/alexballas/refyne/v2/canvas"
 	"github.com/alexballas/refyne/v2/test"
 	"github.com/alexballas/refyne/v2/widget"
+	"go2tv.app/go2tv/v2/internal/mediamodel"
 )
 
 func newTraversalTestScreen(t *testing.T, currentPath string) *FyneScreen {
@@ -683,6 +685,12 @@ func TestQueueRowDedupesThumbnailRequests(t *testing.T) {
 	row := newQueueRow(&FyneScreen{
 		Debug: newDebugWriter(8),
 	})
+	releaseThumbnails := make(chan struct{})
+	row.thumbnailLoader = func(string, mediamodel.MediaKind) *canvas.Image {
+		<-releaseThumbnails
+		return nil
+	}
+	defer close(releaseThumbnails)
 
 	first := testQueueItems(firstPath)[0]
 	second := testQueueItems(secondPath)[0]

soapcalls/soapcallers.go

@@ -1174,8 +1174,12 @@ func (p *TVPayload) GetProtocolInfo() error {
 
 	p.Log().Debug(string(resBytes), "Method", "GetProtocolInfo", "Action", "Response", "Status Code", strconv.Itoa(res.StatusCode), "Headers", json.RawMessage(headerBytesRes))
 
-	if err := parseProtocolInfo(resBytes, utils.DLNAResourceMediaType(p.MediaType, p.Transcode)); err != nil {
-		return fmt.Errorf("GetProtocolInfo Selected device does not support the media type: %w", err)
+	wireMediaType := utils.DLNAResourceMediaType(p.MediaType, p.Transcode)
+	if err := parseProtocolInfo(resBytes, wireMediaType); err != nil {
+		p.Log().Error("Media compatibility check failed", "Method", "GetProtocolInfo",
+			"MediaType", p.MediaType, "WireMediaType", wireMediaType,
+			"Transcode", p.Transcode, "MediaPath", p.MediaPath, "error", err)
+		return fmt.Errorf("GetProtocolInfo Selected device does not support the media type %q: %w", wireMediaType, err)
 	}
 
 	return nil
@@ -1573,8 +1577,6 @@ func parseProtocolInfo(b []byte, mt string) error {
 		return nil
 	}
 
-	mt = normalizeProtocolMediaType(mt)
-
 	if err := xml.Unmarshal(b, &respProtocolInfo); err != nil {
 		return err
 	}
@@ -1591,32 +1593,33 @@ func parseProtocolInfo(b []byte, mt string) error {
 		items := strings.SplitN(strings.TrimSpace(i), ":", 4)
 		// Here we hardcode check the http-get protocol. We would need to change that
 		// if we were to support rtp/rtsp/udp.
-		if len(items) == 4 && protocolInfoFieldMatches(items[0], "http-get") && protocolInfoFieldMatches(items[1], "*") && protocolInfoMediaTypeMatches(items[2], mt) {
+		if len(items) == 4 && protocolInfoFieldMatches(items[0], "http-get") && protocolInfoFieldMatches(items[1], "*") && protocolInfoMediaCategoryMatches(items[2], mt) {
 			return nil
 		}
 	}
 
 	return ErrNoMatchingFileType
 }
 
-func normalizeProtocolMediaType(mediaType string) string {
-	mediaType = strings.TrimSpace(mediaType)
-	if parameterStart := strings.IndexByte(mediaType, ';'); parameterStart >= 0 {
-		return strings.ToLower(mediaType[:parameterStart]) + mediaType[parameterStart:]
-	}
-	return strings.ToLower(mediaType)
-}
-
 func protocolInfoFieldMatches(advertised, requested string) bool {
 	advertised = strings.ToLower(strings.TrimSpace(advertised))
 	requested = strings.ToLower(strings.TrimSpace(requested))
 	return advertised == "*" || requested == "*" || advertised == requested
 }
 
-func protocolInfoMediaTypeMatches(advertised, requested string) bool {
-	advertised = normalizeProtocolMediaType(advertised)
-	requested = normalizeProtocolMediaType(requested)
-	return advertised == "*" || requested == "*" || advertised == requested
+// protocolInfoMediaCategoryMatches is a permissive preflight check, as in 2.5.0.
+// Renderers can omit playable formats or advertise alternate MIME names. Check
+// only the category here; let playback determine container and codec support.
+// This does not change the MIME used in HTTP headers or resource metadata.
+func protocolInfoMediaCategoryMatches(advertised, requested string) bool {
+	advertised = strings.ToLower(strings.TrimSpace(advertised))
+	requested = strings.ToLower(strings.TrimSpace(requested))
+	if advertised == "*" || requested == "*" {
+		return true
+	}
+	advertisedCategory, _, hasSubtype := strings.Cut(advertised, "/")
+	requestedCategory, _, _ := strings.Cut(requested, "/")
+	return hasSubtype && advertisedCategory != "" && advertisedCategory == requestedCategory
 }
 
 func splitProtocolInfo(value string) []string {

soapcalls/soapcallers_test.go

@@ -38,28 +38,34 @@ func TestParseProtocolInfo(t *testing.T) {
 	}
 }
 
-func TestParseProtocolInfoMatchesContentFormat(t *testing.T) {
+func TestParseProtocolInfoMatchesMediaCategory(t *testing.T) {
 	response := func(sink string) []byte {
 		return []byte(`<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"><s:Body><u:GetProtocolInfoResponse xmlns:u="urn:schemas-upnp-org:service:ConnectionManager:1"><Sink>` + sink + `</Sink></u:GetProtocolInfoResponse></s:Body></s:Envelope>`)
 	}
 
-	tests := []struct {
+	tt := []struct {
 		name string
 		sink string
 		mt   string
 		want bool
 	}{
 		{name: "exact MIME with different additional info", sink: `http-get:*:video/mp4:DLNA.ORG_CI=0`, mt: "video/mp4", want: true},
-		{name: "matching MIME parameters", sink: `http-get:*:video/mp4;profile=main:*`, mt: "video/mp4;profile=main", want: true},
-		{name: "different MIME parameters", sink: `http-get:*:video/mp4;profile=main:*`, mt: "video/mp4;profile=high", want: false},
-		{name: "case-sensitive MIME parameter", sink: `http-get:*:multipart/mixed;boundary=CaseSensitive:*`, mt: "multipart/mixed;boundary=casesensitive", want: false},
-		{name: "MIME subtype wildcard is not a wildcard", sink: `http-get:*:video/*:*`, mt: "video/x-matroska", want: false},
+		{name: "Samsung Matroska alias", sink: `http-get:*:video/x-mkv:*`, mt: "video/x-matroska", want: true},
+		{name: "unlisted video format", sink: `http-get:*:video/mpeg:*`, mt: "video/mp4", want: true},
+		{name: "unlisted audio format", sink: `http-get:*:audio/mpeg:*`, mt: "audio/flac", want: true},
+		{name: "unlisted image format", sink: `http-get:*:image/jpeg:*`, mt: "image/png", want: true},
+		{name: "category case and whitespace", sink: `http-get:*: VIDEO/MPEG :*`, mt: " Video/MP4 ", want: true},
+		{name: "MIME parameters do not restrict category", sink: `http-get:*:video/mp4;profile=main:*`, mt: "video/mp4;profile=high", want: true},
+		{name: "video category wildcard", sink: `http-get:*:video/*:*`, mt: "video/x-matroska", want: true},
 		{name: "whole MIME wildcard", sink: `http-get:*:*:*`, mt: "video/x-matroska", want: true},
 		{name: "escaped feature comma", sink: `http-get:*:video/mp4:vendor=one\,two`, mt: "video/mp4", want: true},
-		{name: "wrong MIME", sink: `http-get:*:audio/mpeg:*`, mt: "video/mp4", want: false},
+		{name: "audio renderer rejects video", sink: `http-get:*:audio/mpeg:*`, mt: "video/mp4", want: false},
+		{name: "audio wildcard rejects video", sink: `http-get:*:audio/*:*`, mt: "video/mp4", want: false},
+		{name: "video renderer rejects images", sink: `http-get:*:video/mp4:*`, mt: "image/jpeg", want: false},
+		{name: "wrong transport rejects same category", sink: `rtsp-rtp-udp:*:video/mpeg:*`, mt: "video/mp4", want: false},
 		{name: "empty Sink is permissive", sink: ``, mt: "video/mp4", want: true},
 	}
-	for _, test := range tests {
+	for _, test := range tt {
 		t.Run(test.name, func(t *testing.T) {
 			err := parseProtocolInfo(response(test.sink), test.mt)
 			if (err == nil) != test.want {
@@ -340,15 +346,18 @@ func TestGetProtocolInfoSkipsWhenConnectionManagerMissing(t *testing.T) {
 	}
 }
 
-func TestGetProtocolInfoUsesTranscodedWireMIME(t *testing.T) {
+func TestGetProtocolInfoAllowsUnlistedVideoFormat(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 		_, _ = w.Write([]byte(`<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"><s:Body><u:GetProtocolInfoResponse xmlns:u="urn:schemas-upnp-org:service:ConnectionManager:1"><Sink>http-get:*:video/mpeg:*</Sink></u:GetProtocolInfoResponse></s:Body></s:Envelope>`))
 	}))
 	defer srv.Close()
 
-	p := &TVPayload{ConnectionManagerURL: srv.URL, MediaType: "video/x-matroska", Transcode: true}
+	p := &TVPayload{ConnectionManagerURL: srv.URL, MediaType: "video/x-matroska"}
 	if err := p.GetProtocolInfo(); err != nil {
-		t.Fatalf("GetProtocolInfo() err = %v, want wire MIME match", err)
+		t.Fatalf("GetProtocolInfo() err = %v, want video category match", err)
+	}
+	if p.MediaType != "video/x-matroska" {
+		t.Fatalf("GetProtocolInfo() changed resource MIME to %q", p.MediaType)
 	}
 }
 

version.txt

@@ -1 +1 @@
-2.6.0
+2.6.1