arr-tui/internal/ui/cover.go

package ui

import (
	"bytes"
	"context"
	"fmt"
	"image"
	"image/color"
	_ "image/jpeg" // poster formats
	_ "image/png"
	"strings"
	"time"

	"github.com/gdamore/tcell/v2"
	"github.com/rivo/tview"

	"git.stinnesbeck.com/nils/arr-tui/internal/arr"
)

const (
	maxCoverPixels    = 25_000_000 // refuse decompression bombs
	storedCoverHeight = 160        // a small copy is plenty for a terminal thumbnail
	coverFailureTTL   = 2 * time.Minute
	maxCoverCache     = 300
	coverFetchLimit   = 4
)

// decodeCover decodes a JPEG or PNG poster and keeps a small copy.
func decodeCover(data []byte) (*image.RGBA, error) {
	cfg, _, err := image.DecodeConfig(bytes.NewReader(data))
	if err != nil {
		return nil, fmt.Errorf("not a supported image: %w", err)
	}
	if cfg.Width <= 0 || cfg.Height <= 0 || cfg.Width*cfg.Height > maxCoverPixels {
		return nil, fmt.Errorf("image dimensions %dx%d not supported", cfg.Width, cfg.Height)
	}
	img, _, err := image.Decode(bytes.NewReader(data))
	if err != nil {
		return nil, err
	}
	b := img.Bounds()
	if b.Dy() <= storedCoverHeight {
		return boxScale(img, b.Dx(), b.Dy()), nil
	}
	return boxScale(img, max(1, b.Dx()*storedCoverHeight/b.Dy()), storedCoverHeight), nil
}

// boxScale resizes src to w×h by averaging the source pixels under every
// target pixel (good for shrinking; upscaling degrades to nearest neighbour).
func boxScale(src image.Image, w, h int) *image.RGBA {
	b := src.Bounds()
	dst := image.NewRGBA(image.Rect(0, 0, w, h))
	for y := 0; y < h; y++ {
		y0 := b.Min.Y + y*b.Dy()/h
		y1 := max(b.Min.Y+(y+1)*b.Dy()/h, y0+1)
		for x := 0; x < w; x++ {
			x0 := b.Min.X + x*b.Dx()/w
			x1 := max(b.Min.X+(x+1)*b.Dx()/w, x0+1)
			var r, g, bl, n uint64
			for sy := y0; sy < y1; sy++ {
				for sx := x0; sx < x1; sx++ {
					pr, pg, pb, _ := src.At(sx, sy).RGBA()
					r, g, bl, n = r+uint64(pr), g+uint64(pg), bl+uint64(pb), n+1
				}
			}
			i := dst.PixOffset(x, y)
			dst.Pix[i], dst.Pix[i+1], dst.Pix[i+2], dst.Pix[i+3] = uint8(r/n>>8), uint8(g/n>>8), uint8(bl/n>>8), 255
		}
	}
	return dst
}

// coverStyle is a way to draw a poster with block characters: every cell
// shows sw×sh pixels in two colors, the best split of its pixels into a
// foreground and a background group.
type coverStyle struct {
	name   string
	sw, sh int
	glyph  func(mask int) rune // mask: bit i = pixel i (row-major) is foreground
}

var (
	// quadrantStyle (2×2 pixels): the glyphs are in the Block Elements range
	// that every terminal font has.
	quadrantStyle = coverStyle{"quadrant", 2, 2, func(mask int) rune { return quadrants[mask] }}
	// sextantStyle (2×3 pixels): sharper, but the glyphs live in the Symbols
	// for Legacy Computing block, which many fonts lack.
	sextantStyle = coverStyle{"sextant", 2, 3, sextantGlyph}
)

// quadrants[mask] is the glyph that fills the quadrants set in mask
// (bit 0 top left, 1 top right, 2 bottom left, 3 bottom right).
var quadrants = [16]rune{' ', '▘', '▝', '▀', '▖', '▌', '▞', '▛', '▗', '▚', '▐', '▜', '▄', '▙', '▟', '█'}

// sextantGlyph maps a 2×3 pixel mask (bit 0 top left, 1 top right, 2 middle
// left, ... 5 bottom right) to its character. Unicode lists the 60 sextants
// in mask order but leaves out the empty and full cell and the two halves,
// which already exist as space, full block and the half blocks.
func sextantGlyph(mask int) rune {
	switch mask {
	case 0:
		return ' '
	case 63:
		return '█'
	case 21:
		return '▌'
	case 42:
		return '▐'
	}
	idx := mask - 1
	if mask > 21 {
		idx--
	}
	if mask > 42 {
		idx--
	}
	return rune(0x1FB00 + idx)
}

// coverStyleFor resolves the configured style. "auto" picks sextants on
// terminals known to have the glyphs and quadrants everywhere else.
func coverStyleFor(setting string, env func(string) string) coverStyle {
	switch setting {
	case "sextant":
		return sextantStyle
	case "quadrant":
		return quadrantStyle
	}
	term, program := strings.ToLower(env("TERM")), strings.ToLower(env("TERM_PROGRAM"))
	for _, known := range []string{"kitty", "foot", "ghostty", "wezterm"} {
		if strings.Contains(term, known) || strings.Contains(program, known) {
			return sextantStyle
		}
	}
	if env("KITTY_WINDOW_ID") != "" || env("WEZTERM_PANE") != "" {
		return sextantStyle
	}
	return quadrantStyle
}

// flatPixelError is the squared RGB distance per pixel below which a cell is
// drawn flat: smooth areas and noise should not turn into patterns.
const flatPixelError = 150

// bestCell picks the glyph and the two colors that best reproduce the pixels
// of one cell. Only masks without the last pixel are tried, because a mask
// and its complement draw the same picture with the colors swapped.
func (st coverStyle) bestCell(p []color.RGBA) (ch rune, fg, bg color.RGBA) {
	n := len(p)
	type sum struct{ r, g, b, n float64 }
	var all sum
	for _, c := range p {
		all.r, all.g, all.b, all.n = all.r+float64(c.R), all.g+float64(c.G), all.b+float64(c.B), all.n+1
	}
	avg := func(s sum) [3]float64 {
		if s.n == 0 {
			return [3]float64{}
		}
		return [3]float64{s.r / s.n, s.g / s.n, s.b / s.n}
	}
	dist := func(c color.RGBA, m [3]float64) float64 {
		dr, dg, db := float64(c.R)-m[0], float64(c.G)-m[1], float64(c.B)-m[2]
		return dr*dr + dg*dg + db*db
	}
	toRGBA := func(m [3]float64) color.RGBA {
		return color.RGBA{uint8(m[0] + .5), uint8(m[1] + .5), uint8(m[2] + .5), 255}
	}

	flat := avg(all)
	var flatErr float64
	for _, c := range p {
		flatErr += dist(c, flat)
	}
	if flatErr < flatPixelError*float64(n) {
		c := toRGBA(flat)
		return ' ', c, c
	}

	best, bestErr := 0, flatErr*0.6 // a split must clearly beat the flat cell
	var bestFg, bestBg [3]float64
	for mask := 1; mask < 1<<(n-1); mask++ {
		var f, b sum
		for i, c := range p {
			t := &b
			if mask>>i&1 == 1 {
				t = &f
			}
			t.r, t.g, t.b, t.n = t.r+float64(c.R), t.g+float64(c.G), t.b+float64(c.B), t.n+1
		}
		fm, bm := avg(f), avg(b)
		var e float64
		for i, c := range p {
			if mask>>i&1 == 1 {
				e += dist(c, fm)
			} else {
				e += dist(c, bm)
			}
			if e >= bestErr {
				break
			}
		}
		if e < bestErr {
			best, bestErr, bestFg, bestBg = mask, e, fm, bm
		}
	}
	if best == 0 {
		c := toRGBA(flat)
		return ' ', c, c
	}
	return st.glyph(best), toRGBA(bestFg), toRGBA(bestBg)
}

// coverView draws a poster, see coverStyle. It works in any terminal with
// colors, also over SSH.
type coverView struct {
	*tview.Box
	style coverStyle
	img   *image.RGBA
	note  string // shown instead of the image: "loading…", "no cover"

	// The cells for the last drawn size.
	cols, rows int
	cells      []styledCell
}

type styledCell struct {
	ch     rune
	fg, bg tcell.Color
}

func newCoverView(style coverStyle) *coverView { return &coverView{Box: tview.NewBox(), style: style} }

func (c *coverView) setImage(img *image.RGBA) { c.img, c.note, c.cells = img, "", nil }
func (c *coverView) setNote(note string)      { c.img, c.note, c.cells = nil, note, nil }

// aspect returns the width and height of the poster (2:3 until one is loaded).
func (c *coverView) aspect() (w, h int) {
	if c.img == nil {
		return 2, 3
	}
	b := c.img.Bounds()
	return b.Dx(), b.Dy()
}

// coverCells returns how many columns and rows a poster of the given aspect
// needs inside w×h cells. A cell is about twice as tall as it is wide.
func coverCells(imgW, imgH, w, h int) (cols, rows int) {
	cols = w
	rows = cols * imgH / imgW / 2
	if rows > h {
		rows = h
		cols = rows * 2 * imgW / imgH
	}
	return max(cols, 0), max(rows, 0)
}

func (c *coverView) Draw(screen tcell.Screen) {
	c.Box.DrawForSubclass(screen, c)
	x, y, w, h := c.GetInnerRect()
	if w < 1 || h < 1 {
		return
	}
	if c.img == nil {
		if c.note != "" {
			tview.Print(screen, "[gray]"+c.note, x, y, w, tview.AlignLeft, tcell.ColorGray)
		}
		return
	}

	b := c.img.Bounds()
	cols, rows := coverCells(b.Dx(), b.Dy(), w, h)
	if cols < 1 || rows < 1 {
		return
	}
	if c.cells == nil || c.cols != cols || c.rows != rows {
		c.cols, c.rows, c.cells = cols, rows, c.build(cols, rows)
	}
	// Right-align the poster inside its area, so a narrower poster sits against the edge.
	x += w - cols
	for row := 0; row < rows; row++ {
		for col := 0; col < cols; col++ {
			cell := c.cells[row*cols+col]
			screen.SetContent(x+col, y+row, cell.ch, nil, tcell.StyleDefault.Foreground(cell.fg).Background(cell.bg))
		}
	}
}

// build renders the poster into cols×rows cells.
func (c *coverView) build(cols, rows int) []styledCell {
	st := c.style
	scaled := boxScale(c.img, cols*st.sw, rows*st.sh)
	cells := make([]styledCell, 0, cols*rows)
	px := make([]color.RGBA, st.sw*st.sh)
	for row := 0; row < rows; row++ {
		for col := 0; col < cols; col++ {
			for sy := 0; sy < st.sh; sy++ {
				for sx := 0; sx < st.sw; sx++ {
					i := scaled.PixOffset(col*st.sw+sx, row*st.sh+sy)
					px[sy*st.sw+sx] = color.RGBA{scaled.Pix[i], scaled.Pix[i+1], scaled.Pix[i+2], 255}
				}
			}
			ch, fg, bg := st.bestCell(px)
			cells = append(cells, styledCell{ch,
				tcell.NewRGBColor(int32(fg.R), int32(fg.G), int32(fg.B)),
				tcell.NewRGBColor(int32(bg.R), int32(bg.G), int32(bg.B))})
		}
	}
	return cells
}

// coverRef says where a poster comes from. The zero value means "no poster".
type coverRef struct {
	key   string // identifies the poster in the cache
	fetch func(ctx context.Context) ([]byte, error)
}

// coverFor builds the poster reference of a title from its image list.
func coverFor(c *arr.Client, images []arr.Image, inLibrary bool) coverRef {
	key, fetch, ok := c.Poster(images, inLibrary)
	if !ok {
		return coverRef{}
	}
	return coverRef{key: key, fetch: fetch}
}

// coverCache holds decoded posters and the downloads in flight. UI goroutine only.
type coverCache struct {
	imgs    map[string]*image.RGBA
	failed  map[string]time.Time
	waiting map[string][]func(*image.RGBA, error)
	slots   chan struct{}
}

func newCoverCache() *coverCache {
	return &coverCache{
		imgs:    map[string]*image.RGBA{},
		failed:  map[string]time.Time{},
		waiting: map[string][]func(*image.RGBA, error){},
		slots:   make(chan struct{}, coverFetchLimit),
	}
}

// loadCover delivers the poster to done on the UI goroutine, downloading it in
// the background when it is not cached. Failures are remembered for a while so
// an unreachable image host is not retried on every selection.
func (a *App) loadCover(ref coverRef, done func(*image.RGBA, error)) {
	c := a.coverCache
	if img, ok := c.imgs[ref.key]; ok {
		done(img, nil)
		return
	}
	if t, ok := c.failed[ref.key]; ok && time.Since(t) < coverFailureTTL {
		done(nil, fmt.Errorf("no cover"))
		return
	}
	if _, inflight := c.waiting[ref.key]; inflight {
		c.waiting[ref.key] = append(c.waiting[ref.key], done)
		return
	}
	c.waiting[ref.key] = []func(*image.RGBA, error){done}

	go func() {
		c.slots <- struct{}{}
		defer func() { <-c.slots }()
		ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
		defer cancel()
		var img *image.RGBA
		data, err := ref.fetch(ctx)
		if err == nil {
			img, err = decodeCover(data)
		}
		a.post(func() {
			waiters := c.waiting[ref.key]
			delete(c.waiting, ref.key)
			if err != nil {
				c.failed[ref.key] = time.Now()
			} else {
				if len(c.imgs) >= maxCoverCache {
					c.imgs = map[string]*image.RGBA{} // simple bound; posters are cheap to fetch again
				}
				c.imgs[ref.key] = img
			}
			for _, w := range waiters {
				w(img, err)
			}
		})
	}()
}