fix: video thumbnails — generate locally, blurhash fallback, settings toggle

- Generate thumbnails using AVAssetImageGenerator when the server
  provides none and the user enables 'Generate video thumbnails' in
  settings (off by default, downloads the video)
- Decode blurhash from event metadata as a lightweight placeholder
  when no thumbnail or generated image is available (no download needed)
- Refactor video download into shared downloadVideo() helper, reused
  by both playback and thumbnail generation
- Add BlurHashDecoder.swift (MIT, based on woltapp/blurhash)
- Add settings toggle in Appearance preferences

Author: beezly

Mactrix/Models/BlurHashDecoder.swift

@@ -0,0 +1,117 @@
+// BlurHash decoder for macOS
+// Based on https://github.com/woltapp/blurhash (MIT licence)
+
+import AppKit
+
+extension NSImage {
+    /// Decodes a blurhash string into an NSImage of the given size.
+    static func fromBlurHash(_ blurHash: String, size: CGSize, punch: Float = 1) -> NSImage? {
+        guard blurHash.count >= 6 else { return nil }
+        let chars = Array(blurHash)
+
+        guard let sizeFlag = decode83(chars[0]) else { return nil }
+        let numY = (sizeFlag / 9) + 1
+        let numX = (sizeFlag % 9) + 1
+        guard blurHash.count == 4 + 2 * numX * numY else { return nil }
+
+        guard let quantisedMaximumValue = decode83(chars[1]) else { return nil }
+        let maximumValue = Float(quantisedMaximumValue + 1) / 166
+
+        var colours = [(Float, Float, Float)]()
+        for i in 0..<(numX * numY) {
+            if i == 0 {
+                guard let value = decode83(Array(chars[2..<6])) else { return nil }
+                colours.append(decodeDC(value))
+            } else {
+                let start = 4 + i * 2
+                guard let value = decode83(Array(chars[start..<start + 2])) else { return nil }
+                colours.append(decodeAC(value, maximumValue: maximumValue * punch))
+            }
+        }
+
+        let width = Int(size.width)
+        let height = Int(size.height)
+        var pixels = [UInt8](repeating: 0, count: width * height * 4)
+
+        for y in 0..<height {
+            for x in 0..<width {
+                var r: Float = 0, g: Float = 0, b: Float = 0
+                for j in 0..<numY {
+                    for i in 0..<numX {
+                        let basis = cos(Float.pi * Float(i) * Float(x) / Float(width))
+                            * cos(Float.pi * Float(j) * Float(y) / Float(height))
+                        let colour = colours[i + j * numX]
+                        r += colour.0 * basis
+                        g += colour.1 * basis
+                        b += colour.2 * basis
+                    }
+                }
+                let offset = 4 * (x + y * width)
+                pixels[offset] = UInt8(linearTosRGB(r))
+                pixels[offset + 1] = UInt8(linearTosRGB(g))
+                pixels[offset + 2] = UInt8(linearTosRGB(b))
+                pixels[offset + 3] = 255
+            }
+        }
+
+        guard let provider = CGDataProvider(data: Data(pixels) as CFData),
+              let cgImage = CGImage(
+                  width: width, height: height,
+                  bitsPerComponent: 8, bitsPerPixel: 32, bytesPerRow: width * 4,
+                  space: CGColorSpace(name: CGColorSpace.sRGB)!,
+                  bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue),
+                  provider: provider, decode: nil, shouldInterpolate: true, intent: .defaultIntent
+              ) else { return nil }
+
+        return NSImage(cgImage: cgImage, size: size)
+    }
+}
+
+private let decodeCharacters: [Character: Int] = {
+    let chars = Array("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-./:;=?@[]^_{|}~")
+    return Dictionary(uniqueKeysWithValues: chars.enumerated().map { ($1, $0) })
+}()
+
+private func decode83(_ chars: [Character]) -> Int? {
+    var value = 0
+    for c in chars {
+        guard let digit = decodeCharacters[c] else { return nil }
+        value = value * 83 + digit
+    }
+    return value
+}
+
+private func decode83(_ char: Character) -> Int? {
+    decodeCharacters[char]
+}
+
+private func decodeDC(_ value: Int) -> (Float, Float, Float) {
+    (sRGBToLinear(value >> 16), sRGBToLinear((value >> 8) & 255), sRGBToLinear(value & 255))
+}
+
+private func decodeAC(_ value: Int, maximumValue: Float) -> (Float, Float, Float) {
+    let qR = value / (19 * 19)
+    let qG = (value / 19) % 19
+    let qB = value % 19
+    return (
+        signPow((Float(qR) - 9) / 9, 2) * maximumValue,
+        signPow((Float(qG) - 9) / 9, 2) * maximumValue,
+        signPow((Float(qB) - 9) / 9, 2) * maximumValue
+    )
+}
+
+private func signPow(_ value: Float, _ exp: Float) -> Float {
+    copysign(pow(abs(value), exp), value)
+}
+
+private func linearTosRGB(_ value: Float) -> Int {
+    let v = max(0, min(1, value))
+    return v <= 0.0031308
+        ? Int(v * 12.92 * 255 + 0.5)
+        : Int((1.055 * pow(v, 1 / 2.4) - 0.055) * 255 + 0.5)
+}
+
+private func sRGBToLinear(_ value: Int) -> Float {
+    let v = Float(value) / 255
+    return v <= 0.04045 ? v / 12.92 : pow((v + 0.055) / 1.055, 2.4)
+}

Mactrix/Views/ChatView/MessageVideoView.swift

@@ -6,10 +6,14 @@ import SwiftUI
 
 struct MessageVideoView: View {
     @Environment(AppState.self) private var appState
+    @AppStorage("generateVideoThumbnails") var generateVideoThumbnails: Bool = false
     let content: VideoMessageContent
 
     @State private var fileHandle: MediaFileHandle?
     @State private var video: AVPlayer?
+    @State private var generatedThumbnail: Image?
+
+    private enum VideoError: Error { case noClient }
 
     var aspectRatio: CGFloat? {
         guard let info = content.info,
@@ -24,37 +28,87 @@ struct MessageVideoView: View {
         return min(CGFloat(height), 300)
     }
 
-    func loadVideo() async {
-        guard let client = appState.matrixClient?.client else { return }
-
-        do {
-            let handle = try await client.getMediaFile(
-                mediaSource: content.source,
-                filename: content.filename,
-                mimeType: content.info?.mimetype ?? "",
-                useCache: true,
-                tempDir: NSTemporaryDirectory()
-            )
+    private func downloadVideo() async throws -> URL {
+        guard let client = appState.matrixClient?.client else {
+            throw VideoError.noClient
+        }
 
-            fileHandle = handle
-            let path = try handle.path()
-            let url = URL(filePath: path, directoryHint: .notDirectory)
+        let handle = try await client.getMediaFile(
+            mediaSource: content.source,
+            filename: content.filename,
+            mimeType: content.info?.mimetype ?? "",
+            useCache: true,
+            tempDir: NSTemporaryDirectory()
+        )
+        fileHandle = handle
+        let path = try handle.path()
+        return URL(filePath: path, directoryHint: .notDirectory)
+    }
 
+    func loadVideo(autoplay: Bool = true) async {
+        do {
+            let url: URL
+            if let handle = fileHandle {
+                url = URL(filePath: try handle.path(), directoryHint: .notDirectory)
+            } else {
+                url = try await downloadVideo()
+            }
             video = AVPlayer(url: url)
-            video?.play()
+            if autoplay { video?.play() }
         } catch {
             Logger.viewCycle.error("Failed to load video: \(error)")
         }
     }
 
+    private func generateThumbnail() async {
+        let cacheKey = NSString(string: "thumb:" + content.source.url())
+        if let cached = MatrixClient.imageCache.object(forKey: cacheKey) {
+            generatedThumbnail = Image(nsImage: cached)
+            return
+        }
+
+        do {
+            let url = try await downloadVideo()
+
+            let asset = AVURLAsset(url: url)
+            let generator = AVAssetImageGenerator(asset: asset)
+            generator.appliesPreferredTrackTransform = true
+            generator.maximumSize = CGSize(width: 600, height: 600)
+
+            let cgImage = try await generator.image(at: .zero).image
+            let nsImage = NSImage(cgImage: cgImage, size: NSSize(width: cgImage.width, height: cgImage.height))
+            MatrixClient.imageCache.setObject(nsImage, forKey: cacheKey)
+            generatedThumbnail = Image(nsImage: nsImage)
+        } catch {
+            Logger.viewCycle.error("Failed to generate video thumbnail: \(error)")
+        }
+    }
+
+    @ViewBuilder
+    var thumbnailView: some View {
+        if let thumbnailSource = content.info?.thumbnailSource {
+            MatrixImageView(mediaSource: thumbnailSource, mimeType: content.info?.thumbnailInfo?.mimetype)
+        } else if let generatedThumbnail {
+            generatedThumbnail.resizable().scaledToFit()
+        } else if let blurhash = content.info?.blurhash,
+                  let info = content.info,
+                  let w = info.width, w > 0,
+                  let h = info.height, h > 0,
+                  let nsImage = NSImage.fromBlurHash(blurhash, size: CGSize(width: 32, height: Int(32 * CGFloat(h) / CGFloat(w)))) {
+            Image(nsImage: nsImage).resizable().scaledToFit()
+        } else {
+            Rectangle().fill(Color.gray.opacity(0.3))
+        }
+    }
+
     var body: some View {
         VStack {
             if let video {
                 TimelineVideoPlayer(videoPlayer: video)
                     .cornerRadius(6)
             } else {
                 Button(action: { Task { await loadVideo() } }) {
-                    MatrixImageView(mediaSource: content.info?.thumbnailSource, mimeType: content.info?.thumbnailInfo?.mimetype)
+                    thumbnailView
                         .overlay {
                             Image(systemName: "play.fill")
                                 .resizable()
@@ -73,6 +127,11 @@ struct MessageVideoView: View {
         }
         .aspectRatio(aspectRatio, contentMode: .fit)
         .frame(maxHeight: maxHeight)
-        .frame(minHeight: content.info?.thumbnailSource == nil ? maxHeight : nil)
+        .frame(minHeight: content.info?.thumbnailSource == nil && generatedThumbnail == nil ? maxHeight : nil)
+        .task(id: content.source.url()) {
+            if content.info?.thumbnailSource == nil && generateVideoThumbnails {
+                await generateThumbnail()
+            }
+        }
     }
 }

Mactrix/Views/Settings/AppearanceSettingsView.swift

@@ -2,7 +2,8 @@ import SwiftUI
 
 struct AppearanceSettingsView: View {
     @AppStorage("fontSize") var fontSize: Int = 13
-    
+    @AppStorage("generateVideoThumbnails") var generateVideoThumbnails: Bool = false
+
     var body: some View {
         Form {
             Picker("Font size", selection: $fontSize) {
@@ -11,6 +12,8 @@ struct AppearanceSettingsView: View {
                         .tag($0)
                 }
             }
+            Toggle("Generate video thumbnails", isOn: $generateVideoThumbnails)
+                .help("Downloads videos to generate thumbnails when the server doesn't provide one. Also pre-caches videos for instant playback.")
         }
     }
 }