Shaders: Anime4K at full precision on OpenGL ES; sharp video renders the fitted picture

Colours and grid: media_kit renders through OpenGL ES, where mpv's
mediump samplers made Anime4K's networks compute at half precision
(fp16 on NVIDIA); the VL networks of HQ overflow and round there,
strongest once the upscalers run at screen size. The extracted copies
route every network read through a highp identity function; on GLES the
result now equals desktop OpenGL's.

Resize: the output is the picture fitted in the view (no bars, centred
on whole pixels), so Flutter scales the last texture to the new view
without the shrink-then-jump; the resize wait is 120 ms.

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

apps/desktop/lib/src/platform/desktop/media_kit_host.dart

@@ -569,7 +569,10 @@ class _MkVideo implements HostedVideo {
           // NativeVideoController (Linux, Windows): not exported, reached
           // through its public fields.
           final dynamic native = await controller.platform.future;
-          final want = player.host._outputSize;
+          final view = player.host._outputSize;
+          final params = player.mk.state.videoParams;
+          final dw = params.dw ?? 0, dh = params.dh ?? 0;
+          final want = view == null ? null : fitOutputSize(view, dw > 0 && dh > 0 ? (dw, dh) : null);
           if (_sized && want == _sent && !again) return;
           if (want == null) {
             if (!_sized) return; // never resized: already the video's size

apps/desktop/lib/src/platform/ports/player_host.dart

@@ -148,10 +148,11 @@ abstract interface class PlayerHost {
   /// start).
   HostedVideo video(HostedPlayer player, {bool probe = false});
 
-  /// The pixel size every video output renders at: the view's, so mpv
-  /// scales the picture and draws subtitles at screen resolution
-  /// (Settings → Player, "Sharp video"). Null: each output at its video's
-  /// own size. Applies to live outputs and to new ones once they are up.
+  /// The view's pixel size: every video output renders the picture fitted
+  /// in it ([fitOutputSize]), so mpv scales the picture and draws
+  /// subtitles at screen resolution (Settings → Player, "Sharp video").
+  /// Null: each output at its video's own size. Applies to live outputs
+  /// and to new ones once they are up.
   void setOutputSize(int? width, int? height);
 
   /// How video renders, as last learned (kept after leaving).
@@ -203,3 +204,26 @@ bool mpvLoadFailed(PlayerLogLine log, Duration duration) {
   return duration == Duration.zero &&
       ((log.prefix == 'cplayer' && log.level == 'fatal') || (log.prefix == 'demux' && log.level == 'error'));
 }
+
+/// The size a video output renders at for a [view] of that many pixels:
+/// the [video]'s picture (its display size, aspect included) fitted
+/// inside, no letterbox. The texture then has the picture's aspect, so
+/// while a resize settles Flutter scales the last one to the new view
+/// with no jump (a texture of the whole view would shrink inside its own
+/// black bars until the new one came). Drawn 1:1: the fitted side is the
+/// view's, the other is rounded down to the view's parity, so the
+/// picture sits on whole pixels when centred (a half-pixel offset would
+/// blur every line). Unknown video: the view.
+(int, int) fitOutputSize((int, int) view, (int, int)? video) {
+  final (vw, vh) = view;
+  if (video == null || video.$1 <= 0 || video.$2 <= 0) return view;
+  final aspect = video.$1 / video.$2;
+  int under(double x, int full) {
+    var n = x.floor().clamp(1, full);
+    if ((full - n).isOdd) n = n > 1 ? n - 1 : n;
+    return n;
+  }
+
+  if (vw / vh > aspect) return (under(vh * aspect, vw), vh); // pillarbox
+  return (vw, under(vw / aspect, vh)); // letterbox (or exact)
+}

apps/desktop/lib/src/shaders/shader_assets.dart

@@ -1,3 +1,4 @@
+import 'dart:convert';
 import 'dart:io';
 
 import 'package:flutter/services.dart';
@@ -7,8 +8,13 @@ import 'shader_presets.dart';
 
 const anime4kAssetDir = 'assets/shaders/anime4k';
 
+/// The extracted copy's layout: bumped when [highpAnime4k] changes what
+/// is written, so an older copy is written again.
+const anime4kCopyRevision = 'hp1';
+
 /// mpv needs real files: copies the shipped Anime4K shaders out of the
-/// asset bundle into `<supportDir>/shaders/anime4k-<version>`, once per
+/// asset bundle into `<supportDir>/shaders/anime4k-<version>-<revision>`,
+/// each made full precision on OpenGL ES ([highpAnime4k]), once per
 /// version (a `.complete` marker is written last, so a cut-short copy is
 /// redone). Returns that directory.
 Future<Directory> extractAnime4k(
@@ -17,7 +23,7 @@ Future<Directory> extractAnime4k(
 }) async {
   final dir = Directory(
       '${supportDir.path}${Platform.pathSeparator}shaders'
-      '${Platform.pathSeparator}anime4k-$anime4kVersion');
+      '${Platform.pathSeparator}anime4k-$anime4kVersion-$anime4kCopyRevision');
   final marker = File('${dir.path}${Platform.pathSeparator}.complete');
   final files = anime4kAllFiles;
   if (await marker.exists() &&
@@ -28,14 +34,68 @@ Future<Directory> extractAnime4k(
   final b = bundle ?? rootBundle;
   for (final name in [...files, 'LICENSE']) {
     final data = await b.load('$anime4kAssetDir/$name');
+    final bytes = data.buffer.asUint8List(data.offsetInBytes, data.lengthInBytes);
     await File(_join(dir, name)).writeAsBytes(
-        data.buffer.asUint8List(data.offsetInBytes, data.lengthInBytes),
+        name.endsWith('.glsl') ? utf8.encode(highpAnime4k(utf8.decode(bytes))) : bytes,
         flush: true);
   }
   await marker.writeAsString(anime4kVersion, flush: true);
+  // Older copies (another version or revision) are not read again.
+  try {
+    await for (final e in dir.parent.list()) {
+      final name = e.uri.pathSegments.where((s) => s.isNotEmpty).last;
+      if (e is Directory && name.startsWith('anime4k-') && e.path != dir.path) {
+        await e.delete(recursive: true);
+      }
+    }
+  } catch (_) {}
   return dir;
 }
 
+/// The name of the helper [highpAnime4k] adds to each pass.
+const _hp = 'starsync_hp';
+
+/// [glsl] (an Anime4K file) with its convolutions computed at full
+/// precision on an OpenGL ES context, as they are on desktop OpenGL.
+///
+/// media_kit renders through OpenGL ES (EGL on Linux, ANGLE on Windows),
+/// where mpv declares `precision mediump sampler2D`: a texture read is
+/// mediump, and Anime4K's weights are bare literals, so every
+/// `mat4(...) * go_0(...)` of a network ran at half precision (fp16 on
+/// NVIDIA). The large (VL) networks overflow and round there: shifted
+/// colours, posterised areas and a regular grid, worse once the
+/// upscalers run at screen size. Each pass gets an identity function
+/// with a highp parameter and result, and every `go_N` / `g_N` read goes
+/// through it, so the products and sums that follow are highp. Desktop
+/// GLSL ignores precision qualifiers, so nothing changes there. Anything
+/// that is not such a read is left as it is.
+String highpAnime4k(String glsl) {
+  final read = RegExp(r'\b\w+_tex(?:Off)?\((?:[^()]|\([^()]*\))*\)');
+  final define = RegExp(r'^#define g(?:o)?_\d+\b');
+  final out = <String>[];
+  var inHeader = false, helper = false;
+  for (final line in const LineSplitter().convert(glsl)) {
+    if (line.startsWith('//!')) {
+      // A new pass starts at the first `//!` line after code.
+      if (!inHeader) helper = false;
+      inHeader = true;
+      out.add(line);
+      continue;
+    }
+    inHeader = false;
+    if (define.hasMatch(line)) {
+      if (!helper) {
+        out.add('highp vec4 $_hp(highp vec4 v) { return v; }');
+        helper = true;
+      }
+      out.add(line.replaceAllMapped(read, (m) => '$_hp(${m[0]})'));
+      continue;
+    }
+    out.add(line);
+  }
+  return '${out.join('\n')}\n';
+}
+
 /// Absolute paths of [preset]'s Anime4K files inside [dir].
 List<String> anime4kPaths(
         Directory dir, ShaderPreset preset, ShaderQuality quality) =>

apps/desktop/lib/src/shell/video_view.dart

@@ -12,7 +12,8 @@ import '../playback/playback_controller.dart';
 // bottom subtitles move up while something covers the bottom of the
 // picture (the quick chat box; the control bar when chosen).
 
-/// The video output's size for a view of [logical] size at [dpr]: its
+/// The view size the host fits each video output into ([fitOutputSize])
+/// for a view of [logical] size at [dpr]: its
 /// physical pixels when [on] and video renders on the GPU, else null (the
 /// video's own size). Software rendering keeps the video's size: every
 /// pixel there is CPU work.
@@ -26,7 +27,7 @@ import '../playback/playback_controller.dart';
 /// How long a view size must hold before the output follows it (a
 /// window drag resizes many times a second; each resize reallocates the
 /// output's texture).
-const outputResizeDelay = Duration(milliseconds: 180);
+const outputResizeDelay = Duration(milliseconds: 120);
 
 /// Sends the size of the view around [child] to the player host (see
 /// [videoOutputSize]): at once the first time, then once a resize has