files: the player turns a phone's picture upright on the GPU, and shows HLG as it is

tonemap_vaapi refuses HLG, and the hardware path never honoured a rotation
(ffmpeg's autorotate is for frames in memory). HDR10 is still tone-mapped,
on the card and, failing that, in software before the upload.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/media/encode.go

@@ -66,9 +66,10 @@ func Ladder(i Info) []Rung {
 	}
 	vr := v.Spherical
 	steps := flatSteps
-	src := min(v.Width, v.Height) // a flat picture is named by its short side
+	w, h := v.Shown()
+	src := min(w, h) // a flat picture is named by its short side
 	if vr {
-		steps, src = vrSteps, v.Width
+		steps, src = vrSteps, w
 	}
 	// A picture between two steps (a 2292×960 capture) gets its own size on top, at the bit
 	// rate of the step above, so the best on offer is never less than the file.
@@ -94,14 +95,15 @@ func Ladder(i Info) []Rung {
 
 func rung(i Info, s step) Rung {
 	v := i.Video
+	sw, sh := v.Shown()
 	var w, h int
 	switch {
 	case v.Spherical:
-		w, h = s.size, even(float64(s.size)*float64(v.Height)/float64(v.Width))
-	case v.Width >= v.Height:
-		h, w = s.size, even(float64(s.size)*float64(v.Width)/float64(v.Height))
+		w, h = s.size, even(float64(s.size)*float64(sh)/float64(sw))
+	case sw >= sh:
+		h, w = s.size, even(float64(s.size)*float64(sw)/float64(sh))
 	default: // standing up
-		w, h = s.size, even(float64(s.size)*float64(v.Height)/float64(v.Width))
+		w, h = s.size, even(float64(s.size)*float64(sh)/float64(sw))
 	}
 	fps := v.FPS
 	if fps <= 0 {
@@ -193,7 +195,7 @@ func Devices(c Caps) []Device {
 		switch {
 		case g.API != "vaapi":
 			d.Reason = "only VAAPI devices encode here"
-		case !has(g.Encodes, "h264"):
+		case g.Encodes != nil && !has(g.Encodes, "h264"):
 			d.Reason = "doesn't encode H.264"
 		default:
 			d.OK = true
@@ -232,7 +234,9 @@ func recipes(c Caps, device string, src Info, r Rung) []Recipe {
 	if device != CPU {
 		for i := range gpus {
 			g := &gpus[i]
-			if g.API != "vaapi" || !has(g.Encodes, "h264") || (device != "" && g.Device != device) {
+			// Encodes is vainfo's answer; without vainfo there is none, and the card is tried
+			// anyway, with the next recipe behind it.
+			if g.API != "vaapi" || (g.Encodes != nil && !has(g.Encodes, "h264")) || (device != "" && g.Device != device) {
 				continue
 			}
 			video := append(append([]string{"-c:v", "h264_vaapi"}, rate...), "-bf", "0")
@@ -240,28 +244,56 @@ func recipes(c Caps, device string, src Info, r Rung) []Recipe {
 			if name == "" {
 				name = g.Device
 			}
-			scale := fmt.Sprintf("scale_vaapi=w=%d:h=%d:format=nv12", r.Width, r.Height)
+			// The card doesn't turn a phone's picture by itself (ffmpeg's own turning is for
+			// pictures in memory), so it is told to, and ffmpeg is told not to.
+			scale := turn(src) + fmt.Sprintf("scale_vaapi=w=%d:h=%d:format=nv12", r.Width, r.Height)
+			// HDR10 (PQ) is tone-mapped on the card, which needs the file's mastering data;
+			// HLG is made to look right on an ordinary screen as it is, so it is only scaled
+			// (tonemap_vaapi refuses it). Either way the next recipe tone-maps in software.
 			if src.Video != nil && has(g.Codecs, src.Video.Codec) {
 				vf := fps + scale
-				if src.HDR() {
+				if src.PQ() {
 					vf = fps + "tonemap_vaapi=format=nv12:t=bt709:p=bt709:m=bt709," + scale
 				}
-				out = append(out, Recipe{Engine: name, Device: g.Device, Pre: []string{"-hwaccel", "vaapi", "-hwaccel_device", g.Device, "-hwaccel_output_format", "vaapi"}, VF: vf, Video: video})
+				out = append(out, Recipe{Engine: name, Device: g.Device, Pre: []string{"-noautorotate", "-hwaccel", "vaapi", "-hwaccel_device", g.Device, "-hwaccel_output_format", "vaapi"}, VF: vf, Video: video})
+			}
+			cpuVF := fmt.Sprintf("%sformat=nv12,scale=%d:%d,hwupload", fps, r.Width, r.Height)
+			if src.PQ() {
+				cpuVF = fps + toneMap + fmt.Sprintf(",scale=%d:%d,format=nv12,hwupload", r.Width, r.Height)
 			}
 			out = append(out, Recipe{Engine: name + ", decoded on the CPU", Device: g.Device, Pre: []string{"-init_hw_device", "vaapi=va:" + g.Device, "-filter_hw_device", "va"},
-				VF: fmt.Sprintf("%sformat=nv12,scale=%d:%d,hwupload", fps, r.Width, r.Height), Video: video})
+				VF: cpuVF, Video: video})
 		}
 	}
 	if has(c.Encoders, "libx264") {
 		vf := fmt.Sprintf("%sscale=%d:%d,format=yuv420p", fps, r.Width, r.Height)
-		if src.HDR() {
-			vf = fmt.Sprintf("%szscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=hable,zscale=t=bt709:m=bt709,scale=%d:%d,format=yuv420p", fps, r.Width, r.Height)
+		if src.PQ() {
+			vf = fps + toneMap + fmt.Sprintf(",scale=%d:%d,format=yuv420p", r.Width, r.Height)
 		}
 		out = append(out, Recipe{Engine: "CPU (libx264)", Device: CPU, VF: vf, Video: append([]string{"-c:v", "libx264", "-preset", "veryfast", "-sc_threshold", "0"}, rate...)})
 	}
 	return out
 }
 
+// turn is the card's filter that turns a picture the way it is meant to be shown.
+func turn(src Info) string {
+	if src.Video == nil {
+		return ""
+	}
+	switch src.Video.Rotation {
+	case 90:
+		return "transpose_vaapi=dir=clock,"
+	case 180:
+		return "transpose_vaapi=dir=reversal,"
+	case 270:
+		return "transpose_vaapi=dir=cclock,"
+	}
+	return ""
+}
+
+// toneMap turns an HDR10 picture into an ordinary one, in software.
+const toneMap = "zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=hable,zscale=t=bt709:m=bt709:r=tv"
+
 // Seg is the length of a piece, in seconds.
 const Seg = 3.0