2256 lines
53 KiB
Go
2256 lines
53 KiB
Go
// backend/preview.go
|
||
package main
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"crypto/sha1"
|
||
"embed"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"html"
|
||
"image"
|
||
"image/color"
|
||
"image/draw"
|
||
"image/jpeg"
|
||
"image/png"
|
||
"io"
|
||
"math/rand"
|
||
"net/http"
|
||
"net/url"
|
||
"os"
|
||
"os/exec"
|
||
"path"
|
||
"path/filepath"
|
||
"reflect"
|
||
"regexp"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"syscall"
|
||
"time"
|
||
|
||
"golang.org/x/image/font"
|
||
"golang.org/x/image/font/basicfont"
|
||
"golang.org/x/image/math/fixed"
|
||
)
|
||
|
||
// NOTE:
|
||
// Diese Datei ist ein "Zusammenzug" deiner bisherigen preview_* Dateien.
|
||
// Sie referenziert weiterhin vorhandene Functions/Globals aus deinem Backend, z.B.:
|
||
// - resolvePathRelativeToApp, getSettings, ensureAssetsForVideo, generatedThumbFile
|
||
// - atomicWriteFile, ensureGeneratedDirs, ensureGeneratedDir
|
||
// - durationSecondsCached, parseFFmpegOutTime, ffmpegInputTol
|
||
// - jobs, jobsMu, RecordJob, previewSem, thumbSem, JobRunning
|
||
// - sanitizeID, findFinishedFileByID, stripHotPrefix, assetIDForJob, generatedThumbJPGFile
|
||
// Bitte diese Abhängigkeiten NICHT löschen – preview.go nutzt sie.
|
||
|
||
// ============================================================
|
||
// Shared wiring
|
||
// ============================================================
|
||
|
||
// coverModelStore wird von routes.go gesetzt (du rufst setCoverModelStore(store)).
|
||
var coverModelStore *ModelStore
|
||
|
||
func setCoverModelStore(s *ModelStore) { coverModelStore = s }
|
||
|
||
var errCoverNotSupported = errors.New("cover not supported")
|
||
|
||
//go:embed assets/img/cb.jpg assets/img/mfc.jpg
|
||
var embeddedFallbackImages embed.FS
|
||
|
||
// ============================================================
|
||
// Covers: generated/covers/<category>.<ext> + info.json
|
||
// Routes:
|
||
// - /api/generated/cover?category=...&refresh=1&model=...&src=...
|
||
// - /api/generated/coverinfo/list
|
||
// ============================================================
|
||
|
||
type coverInfo struct {
|
||
Category string `json:"category"`
|
||
Model string `json:"model,omitempty"`
|
||
Src string `json:"src,omitempty"`
|
||
GeneratedAt string `json:"generatedAt"`
|
||
}
|
||
|
||
func normalizeCoverSrc(s string) string {
|
||
s = strings.TrimSpace(s)
|
||
if s == "" {
|
||
return ""
|
||
}
|
||
// Windows -> URL-artig
|
||
s2 := strings.ReplaceAll(s, "\\", "/")
|
||
|
||
// Wenn es schon wie ein Web-Pfad aussieht, so lassen
|
||
if strings.HasPrefix(s2, "/generated/") || strings.HasPrefix(s2, "http://") || strings.HasPrefix(s2, "https://") {
|
||
return s2
|
||
}
|
||
|
||
// Wenn es ein lokaler Pfad ist, versuche den /generated/ Teil zu extrahieren
|
||
if i := strings.Index(s2, "/generated/"); i >= 0 {
|
||
return s2[i:]
|
||
}
|
||
return s2
|
||
}
|
||
|
||
func coversRoot() (string, error) {
|
||
return resolvePathRelativeToApp(filepath.Join("generated", "covers"))
|
||
}
|
||
|
||
func ensureCoversDir() (string, error) {
|
||
root, err := coversRoot()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if strings.TrimSpace(root) == "" {
|
||
return "", appErrorf("covers root ist leer")
|
||
}
|
||
if err := os.MkdirAll(root, 0o755); err != nil {
|
||
return "", err
|
||
}
|
||
return root, nil
|
||
}
|
||
|
||
func coverInfoPathForKey(key string) (string, error) {
|
||
root, err := coversRoot()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return filepath.Join(root, key+".info.json"), nil
|
||
}
|
||
|
||
func writeCoverInfoBestEffort(key string, info coverInfo) {
|
||
p, err := coverInfoPathForKey(key)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
b, err := json.MarshalIndent(info, "", " ")
|
||
if err != nil {
|
||
return
|
||
}
|
||
_ = os.MkdirAll(filepath.Dir(p), 0o755)
|
||
_ = os.WriteFile(p, b, 0o644)
|
||
}
|
||
|
||
func readCoverInfoBestEffort(key string) (coverInfo, bool) {
|
||
p, err := coverInfoPathForKey(key)
|
||
if err != nil {
|
||
return coverInfo{}, false
|
||
}
|
||
b, err := os.ReadFile(p)
|
||
if err != nil || len(b) == 0 {
|
||
return coverInfo{}, false
|
||
}
|
||
var ci coverInfo
|
||
if json.Unmarshal(b, &ci) != nil {
|
||
return coverInfo{}, false
|
||
}
|
||
return ci, true
|
||
}
|
||
|
||
func drawLabel(img draw.Image, text string) {
|
||
text = strings.TrimSpace(text)
|
||
if text == "" {
|
||
return
|
||
}
|
||
|
||
face := basicfont.Face7x13
|
||
|
||
// Layout
|
||
const margin = 10
|
||
const padX = 10
|
||
const padY = 8
|
||
|
||
b := img.Bounds()
|
||
|
||
maxTextW := (b.Dx() - 2*margin) - 2*padX
|
||
if maxTextW <= 0 {
|
||
return
|
||
}
|
||
|
||
measure := func(s string) int {
|
||
d := &font.Drawer{Face: face}
|
||
return d.MeasureString(s).Ceil()
|
||
}
|
||
|
||
label := text
|
||
if w := measure(label); w > maxTextW {
|
||
ellipsis := "…"
|
||
rs := []rune(text)
|
||
if len(rs) == 0 {
|
||
return
|
||
}
|
||
lo, hi := 0, len(rs)
|
||
best := ""
|
||
for lo <= hi {
|
||
mid := (lo + hi) / 2
|
||
cand := string(rs[:mid]) + ellipsis
|
||
if measure(cand) <= maxTextW {
|
||
best = cand
|
||
lo = mid + 1
|
||
} else {
|
||
hi = mid - 1
|
||
}
|
||
}
|
||
if best == "" {
|
||
label = ellipsis
|
||
} else {
|
||
label = best
|
||
}
|
||
}
|
||
|
||
d := &font.Drawer{Face: face}
|
||
textW := d.MeasureString(label).Ceil()
|
||
textH := face.Metrics().Height.Ceil()
|
||
ascent := face.Metrics().Ascent.Ceil()
|
||
|
||
x0 := b.Min.X + margin
|
||
y1 := b.Max.Y - margin
|
||
y0 := y1 - (textH + 2*padY)
|
||
x1 := x0 + (textW + 2*padX)
|
||
|
||
maxX1 := b.Max.X - margin
|
||
if x1 > maxX1 {
|
||
shift := x1 - maxX1
|
||
x0 -= shift
|
||
x1 -= shift
|
||
if x0 < b.Min.X+margin {
|
||
x0 = b.Min.X + margin
|
||
x1 = maxX1
|
||
}
|
||
}
|
||
|
||
minY0 := b.Min.Y + margin
|
||
if y0 < minY0 {
|
||
y0 = minY0
|
||
y1 = y0 + (textH + 2*padY)
|
||
if y1 > b.Max.Y-margin {
|
||
return
|
||
}
|
||
}
|
||
|
||
rect := image.Rect(x0, y0, x1, y1)
|
||
|
||
bg := image.NewUniform(color.RGBA{0, 0, 0, 170})
|
||
draw.Draw(img, rect, bg, image.Point{}, draw.Over)
|
||
|
||
border := image.NewUniform(color.RGBA{255, 255, 255, 35})
|
||
draw.Draw(img, image.Rect(rect.Min.X, rect.Min.Y, rect.Max.X, rect.Min.Y+1), border, image.Point{}, draw.Over)
|
||
draw.Draw(img, image.Rect(rect.Min.X, rect.Max.Y-1, rect.Max.X, rect.Max.Y), border, image.Point{}, draw.Over)
|
||
draw.Draw(img, image.Rect(rect.Min.X, rect.Min.Y, rect.Min.X+1, rect.Max.Y), border, image.Point{}, draw.Over)
|
||
draw.Draw(img, image.Rect(rect.Max.X-1, rect.Min.Y, rect.Max.X, rect.Max.Y), border, image.Point{}, draw.Over)
|
||
|
||
tx := x0 + padX
|
||
ty := y0 + padY + ascent
|
||
|
||
shadow := &font.Drawer{Dst: img, Src: image.NewUniform(color.RGBA{0, 0, 0, 200}), Face: face, Dot: fixed.P(tx+1, ty+1)}
|
||
shadow.DrawString(label)
|
||
|
||
fg := &font.Drawer{Dst: img, Src: image.NewUniform(color.RGBA{255, 255, 255, 235}), Face: face, Dot: fixed.P(tx, ty)}
|
||
fg.DrawString(label)
|
||
}
|
||
|
||
func splitTagsLoose(raw string) []string {
|
||
raw = strings.TrimSpace(raw)
|
||
if raw == "" {
|
||
return nil
|
||
}
|
||
parts := strings.FieldsFunc(raw, func(r rune) bool {
|
||
switch r {
|
||
case '\n', ',', ';', '|':
|
||
return true
|
||
}
|
||
return false
|
||
})
|
||
out := make([]string, 0, len(parts))
|
||
seen := map[string]struct{}{}
|
||
for _, p := range parts {
|
||
t := strings.TrimSpace(p)
|
||
if t == "" {
|
||
continue
|
||
}
|
||
low := strings.ToLower(t)
|
||
if _, ok := seen[low]; ok {
|
||
continue
|
||
}
|
||
seen[low] = struct{}{}
|
||
out = append(out, t)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func hasTag(tagsRaw string, want string) bool {
|
||
want = strings.ToLower(strings.TrimSpace(want))
|
||
if want == "" {
|
||
return false
|
||
}
|
||
for _, t := range splitTagsLoose(tagsRaw) {
|
||
if strings.ToLower(strings.TrimSpace(t)) == want {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
type coverModel struct {
|
||
Key string
|
||
Tags string
|
||
}
|
||
|
||
func listModelsForCovers() ([]coverModel, error) {
|
||
if coverModelStore == nil {
|
||
return nil, appErrorf("model store not set")
|
||
}
|
||
|
||
ms := coverModelStore.List()
|
||
out := make([]coverModel, 0, len(ms))
|
||
for _, m := range ms {
|
||
key := strings.TrimSpace(m.ModelKey)
|
||
if key == "" {
|
||
continue
|
||
}
|
||
out = append(out, coverModel{Key: key, Tags: m.Tags})
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func pickRandomThumbForCategory(ctx context.Context, category string) (thumbPath string, err error) {
|
||
category = strings.TrimSpace(category)
|
||
if category == "" {
|
||
return "", appErrorf("category empty")
|
||
}
|
||
|
||
select {
|
||
case <-ctx.Done():
|
||
return "", ctx.Err()
|
||
default:
|
||
}
|
||
|
||
models, err := listModelsForCovers()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
cands := make([]coverModel, 0, 64)
|
||
for _, m := range models {
|
||
key := strings.TrimSpace(m.Key)
|
||
if key == "" {
|
||
continue
|
||
}
|
||
if hasTag(m.Tags, category) {
|
||
cands = append(cands, coverModel{Key: key, Tags: m.Tags})
|
||
}
|
||
}
|
||
if len(cands) == 0 {
|
||
return "", appErrorf("no model with tag")
|
||
}
|
||
|
||
rand.Shuffle(len(cands), func(i, j int) { cands[i], cands[j] = cands[j], cands[i] })
|
||
|
||
s := getSettings()
|
||
doneAbs, derr := resolvePathRelativeToApp(s.DoneDir)
|
||
if derr != nil || strings.TrimSpace(doneAbs) == "" {
|
||
return "", appErrorf("doneDir resolve failed: %v", derr)
|
||
}
|
||
|
||
type candFile struct {
|
||
videoPath string
|
||
id string
|
||
}
|
||
|
||
isVideo := func(name string) bool {
|
||
low := strings.ToLower(name)
|
||
if strings.Contains(low, ".part") || strings.Contains(low, ".tmp") {
|
||
return false
|
||
}
|
||
ext := strings.ToLower(filepath.Ext(name))
|
||
return ext == ".mp4"
|
||
}
|
||
|
||
for _, m := range cands {
|
||
select {
|
||
case <-ctx.Done():
|
||
return "", ctx.Err()
|
||
default:
|
||
}
|
||
|
||
modelKey := strings.TrimSpace(m.Key)
|
||
if modelKey == "" {
|
||
continue
|
||
}
|
||
|
||
dirs := []string{filepath.Join(doneAbs, modelKey), filepath.Join(doneAbs, "keep", modelKey)}
|
||
files := make([]candFile, 0, 128)
|
||
for _, d := range dirs {
|
||
ents, err := os.ReadDir(d)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
for _, e := range ents {
|
||
if e.IsDir() {
|
||
continue
|
||
}
|
||
name := e.Name()
|
||
if !isVideo(name) {
|
||
continue
|
||
}
|
||
full := filepath.Join(d, name)
|
||
stem := strings.TrimSuffix(name, filepath.Ext(name))
|
||
id := stripHotPrefix(strings.TrimSpace(stem))
|
||
if id == "" {
|
||
continue
|
||
}
|
||
files = append(files, candFile{videoPath: full, id: id})
|
||
}
|
||
}
|
||
|
||
if len(files) == 0 {
|
||
continue
|
||
}
|
||
|
||
cf := files[rand.Intn(len(files))]
|
||
_ = ensureAssetsForVideo(cf.videoPath)
|
||
|
||
tp, terr := generatedThumbFile(cf.id)
|
||
if terr != nil {
|
||
continue
|
||
}
|
||
if fi, serr := os.Stat(tp); serr == nil && !fi.IsDir() && fi.Size() > 0 {
|
||
return tp, nil
|
||
}
|
||
}
|
||
|
||
return "", appErrorf("no downloads/thumbs for category")
|
||
}
|
||
|
||
var coverKeyRe = regexp.MustCompile(`[^a-z0-9._-]+`)
|
||
|
||
func sanitizeCoverKey(category string) (string, error) {
|
||
c := strings.ToLower(strings.TrimSpace(category))
|
||
if c == "" {
|
||
sum := sha1.Sum([]byte(category))
|
||
c = "tag_" + hex.EncodeToString(sum[:8])
|
||
}
|
||
if c == "" {
|
||
return "", appErrorf("category fehlt")
|
||
}
|
||
c = strings.ReplaceAll(c, " ", "_")
|
||
c = coverKeyRe.ReplaceAllString(c, "_")
|
||
c = strings.Trim(c, "._-")
|
||
if c == "" {
|
||
return "", appErrorf("category ungültig")
|
||
}
|
||
if len(c) > 120 {
|
||
c = c[:120]
|
||
}
|
||
return c, nil
|
||
}
|
||
|
||
func detectImageExt(contentType string, b []byte) (ext string, ct string) {
|
||
ct = strings.ToLower(strings.TrimSpace(contentType))
|
||
switch {
|
||
case strings.Contains(ct, "image/jpeg") || strings.Contains(ct, "image/jpg"):
|
||
return ".jpg", "image/jpeg"
|
||
case strings.Contains(ct, "image/png"):
|
||
return ".png", "image/png"
|
||
case strings.Contains(ct, "image/gif"):
|
||
return ".gif", "image/gif"
|
||
}
|
||
if len(b) >= 3 && b[0] == 0xFF && b[1] == 0xD8 && b[2] == 0xFF {
|
||
return ".jpg", "image/jpeg"
|
||
}
|
||
if len(b) >= 8 && bytes.Equal(b[:8], []byte{0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A}) {
|
||
return ".png", "image/png"
|
||
}
|
||
if len(b) >= 12 && string(b[:4]) == "RIFF" && string(b[8:12]) == "WEBP" {
|
||
return ".jpg", "image/jpeg"
|
||
}
|
||
if len(b) >= 6 && (string(b[:6]) == "GIF87a" || string(b[:6]) == "GIF89a") {
|
||
return ".gif", "image/gif"
|
||
}
|
||
return ".jpg", "image/jpeg"
|
||
}
|
||
|
||
func coverPathForCategory(key string, ext string) (string, error) {
|
||
root, err := coversRoot()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if strings.TrimSpace(root) == "" {
|
||
return "", appErrorf("covers root ist leer")
|
||
}
|
||
if ext == "" {
|
||
ext = ".jpg"
|
||
}
|
||
return filepath.Join(root, key+ext), nil
|
||
}
|
||
|
||
func findExistingCoverFile(key string) (string, os.FileInfo, bool) {
|
||
root, err := coversRoot()
|
||
if err != nil || strings.TrimSpace(root) == "" {
|
||
return "", nil, false
|
||
}
|
||
ext := []string{".jpg", ".png", ".gif"}
|
||
for _, e := range ext {
|
||
p := filepath.Join(root, key+e)
|
||
if fi, err := os.Stat(p); err == nil && !fi.IsDir() && fi.Size() > 0 {
|
||
return p, fi, true
|
||
}
|
||
}
|
||
return "", nil, false
|
||
}
|
||
|
||
func downloadBytes(ctx context.Context, rawURL string, ua string) ([]byte, string, error) {
|
||
rawURL = strings.TrimSpace(rawURL)
|
||
if rawURL == "" {
|
||
return nil, "", appErrorf("src fehlt")
|
||
}
|
||
|
||
// local: only /generated/...
|
||
if strings.HasPrefix(rawURL, "/") {
|
||
clean := path.Clean(rawURL)
|
||
if !strings.HasPrefix(clean, "/generated/") {
|
||
return nil, "", appErrorf("src ungültig")
|
||
}
|
||
if strings.Contains(clean, "..") {
|
||
return nil, "", appErrorf("src ungültig")
|
||
}
|
||
|
||
rel := strings.TrimPrefix(clean, "/")
|
||
abs, err := resolvePathRelativeToApp(rel)
|
||
if err != nil || strings.TrimSpace(abs) == "" {
|
||
return nil, "", appErrorf("src ungültig")
|
||
}
|
||
|
||
f, err := os.Open(abs)
|
||
if err != nil {
|
||
return nil, "", appErrorf("download failed: %v", err)
|
||
}
|
||
defer f.Close()
|
||
|
||
b, err := io.ReadAll(io.LimitReader(f, 10*1024*1024))
|
||
if err != nil {
|
||
return nil, "", appErrorf("download failed: %v", err)
|
||
}
|
||
if len(b) == 0 {
|
||
return nil, "", appErrorf("download empty")
|
||
}
|
||
|
||
ext := strings.ToLower(filepath.Ext(abs))
|
||
ct := "application/octet-stream"
|
||
switch ext {
|
||
case ".jpg", ".jpeg":
|
||
ct = "image/jpeg"
|
||
case ".png":
|
||
ct = "image/png"
|
||
case ".gif":
|
||
ct = "image/gif"
|
||
}
|
||
|
||
return b, ct, nil
|
||
}
|
||
|
||
u, err := url.Parse(rawURL)
|
||
if err != nil || u.Scheme == "" || u.Host == "" {
|
||
return nil, "", appErrorf("src ungültig")
|
||
}
|
||
if u.Scheme != "http" && u.Scheme != "https" {
|
||
return nil, "", appErrorf("src schema nicht erlaubt")
|
||
}
|
||
|
||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
|
||
if err != nil {
|
||
return nil, "", err
|
||
}
|
||
if strings.TrimSpace(ua) == "" {
|
||
ua = "Mozilla/5.0"
|
||
}
|
||
req.Header.Set("User-Agent", ua)
|
||
req.Header.Set("Accept", "image/*,*/*;q=0.8")
|
||
|
||
client := &http.Client{Timeout: 12 * time.Second}
|
||
resp, err := client.Do(req)
|
||
if err != nil {
|
||
return nil, "", err
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
if resp.StatusCode != http.StatusOK {
|
||
return nil, "", appErrorf("download failed: HTTP %d", resp.StatusCode)
|
||
}
|
||
|
||
b, err := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024))
|
||
if err != nil {
|
||
return nil, "", err
|
||
}
|
||
if len(b) == 0 {
|
||
return nil, "", appErrorf("download empty")
|
||
}
|
||
|
||
return b, resp.Header.Get("Content-Type"), nil
|
||
}
|
||
|
||
var coverBatchMu sync.Mutex
|
||
|
||
var (
|
||
coverBatchInflight int
|
||
coverBatchStarted time.Time
|
||
|
||
coverBatchTotal int
|
||
coverBatchForced int
|
||
coverBatchMiss int
|
||
coverBatchErrors int
|
||
coverBatchNoThumb int
|
||
coverBatchDecodeErr int
|
||
)
|
||
|
||
func coverBatchEnter(force bool) {
|
||
coverBatchMu.Lock()
|
||
defer coverBatchMu.Unlock()
|
||
|
||
if coverBatchInflight == 0 {
|
||
coverBatchStarted = time.Now()
|
||
coverBatchTotal = 0
|
||
coverBatchForced = 0
|
||
coverBatchMiss = 0
|
||
coverBatchErrors = 0
|
||
coverBatchNoThumb = 0
|
||
coverBatchDecodeErr = 0
|
||
}
|
||
|
||
coverBatchInflight++
|
||
coverBatchTotal++
|
||
if force {
|
||
coverBatchForced++
|
||
} else {
|
||
coverBatchMiss++
|
||
}
|
||
}
|
||
|
||
func coverBatchLeave(outcome string, status int) {
|
||
coverBatchMu.Lock()
|
||
defer coverBatchMu.Unlock()
|
||
|
||
if status >= 400 {
|
||
coverBatchErrors++
|
||
}
|
||
switch outcome {
|
||
case "no-thumb":
|
||
coverBatchNoThumb++
|
||
case "decode-failed-no-overlay":
|
||
coverBatchDecodeErr++
|
||
}
|
||
|
||
coverBatchInflight--
|
||
}
|
||
|
||
var reModelFromStem = regexp.MustCompile(`^(.*?)_\d{1,2}_\d{1,2}_\d{4}__\d{1,2}-\d{2}-\d{2}`)
|
||
|
||
func inferModelFromStem(stem string) string {
|
||
stem = stripHotPrefix(strings.TrimSpace(stem))
|
||
if stem == "" {
|
||
return ""
|
||
}
|
||
m := reModelFromStem.FindStringSubmatch(stem)
|
||
if len(m) >= 2 {
|
||
return strings.TrimSpace(m[1])
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func inferModelFromThumbLike(srcOrPath string) string {
|
||
s := strings.TrimSpace(srcOrPath)
|
||
if s == "" {
|
||
return ""
|
||
}
|
||
|
||
s = strings.ReplaceAll(s, `\\`, `/`)
|
||
if u, err := url.Parse(s); err == nil && u != nil && u.Scheme != "" && u.Host != "" {
|
||
s = u.Path
|
||
}
|
||
|
||
base := path.Base(s)
|
||
lb := strings.ToLower(base)
|
||
if strings.HasPrefix(lb, "thumbs.") {
|
||
id := path.Base(path.Dir(s))
|
||
return inferModelFromStem(id)
|
||
}
|
||
|
||
stem := strings.TrimSuffix(base, path.Ext(base))
|
||
return inferModelFromStem(stem)
|
||
}
|
||
|
||
type coverInfoListItem struct {
|
||
Category string `json:"category"`
|
||
Model string `json:"model,omitempty"`
|
||
GeneratedAt string `json:"generatedAt,omitempty"`
|
||
HasCover bool `json:"hasCover"`
|
||
}
|
||
|
||
func generatedCoverInfoList(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method != http.MethodGet && r.Method != http.MethodHead {
|
||
http.Error(w, "Nur GET/HEAD erlaubt", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
root, err := coversRoot()
|
||
if err != nil {
|
||
http.Error(w, "covers root: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
entries, err := os.ReadDir(root)
|
||
if err != nil {
|
||
http.Error(w, "covers dir: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
byKey := map[string]*coverInfoListItem{}
|
||
ensure := func(key string) *coverInfoListItem {
|
||
if v, ok := byKey[key]; ok {
|
||
return v
|
||
}
|
||
v := &coverInfoListItem{Category: key}
|
||
byKey[key] = v
|
||
return v
|
||
}
|
||
|
||
isCoverExt := func(ext string) bool {
|
||
switch strings.ToLower(ext) {
|
||
case ".jpg", ".jpeg", ".png", ".gif":
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
for _, e := range entries {
|
||
name := e.Name()
|
||
lower := strings.ToLower(name)
|
||
|
||
if strings.HasSuffix(lower, ".info.json") {
|
||
key := strings.TrimSuffix(name, ".info.json")
|
||
if ci, ok := readCoverInfoBestEffort(key); ok {
|
||
v := ensure(key)
|
||
if strings.TrimSpace(ci.Category) != "" {
|
||
v.Category = strings.TrimSpace(ci.Category)
|
||
}
|
||
if strings.TrimSpace(ci.Model) != "" {
|
||
v.Model = strings.TrimSpace(ci.Model)
|
||
}
|
||
if strings.TrimSpace(ci.GeneratedAt) != "" {
|
||
v.GeneratedAt = strings.TrimSpace(ci.GeneratedAt)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
ext := filepath.Ext(name)
|
||
if isCoverExt(ext) {
|
||
key := strings.TrimSuffix(name, ext)
|
||
v := ensure(key)
|
||
v.HasCover = true
|
||
}
|
||
}
|
||
|
||
for _, v := range byKey {
|
||
if !v.HasCover {
|
||
v.Model = ""
|
||
v.GeneratedAt = ""
|
||
}
|
||
if strings.TrimSpace(v.Category) == "" {
|
||
v.Category = ""
|
||
}
|
||
}
|
||
|
||
keys := make([]string, 0, len(byKey))
|
||
for k := range byKey {
|
||
keys = append(keys, k)
|
||
}
|
||
sort.Strings(keys)
|
||
|
||
out := make([]coverInfoListItem, 0, len(keys))
|
||
for _, k := range keys {
|
||
out = append(out, *byKey[k])
|
||
}
|
||
|
||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
if r.Method == http.MethodHead {
|
||
w.WriteHeader(http.StatusOK)
|
||
return
|
||
}
|
||
_ = json.NewEncoder(w).Encode(out)
|
||
}
|
||
|
||
func generatedCover(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method != http.MethodGet && r.Method != http.MethodHead {
|
||
http.Error(w, "Nur GET/HEAD erlaubt", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
category := r.URL.Query().Get("category")
|
||
key, err := sanitizeCoverKey(category)
|
||
if err != nil {
|
||
http.Error(w, "category ungültig: "+err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
refresh := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("refresh")))
|
||
force := refresh == "1" || refresh == "true" || refresh == "yes"
|
||
|
||
modelQ := strings.TrimSpace(r.URL.Query().Get("model"))
|
||
modelExplicit := modelQ != ""
|
||
model := modelQ
|
||
|
||
src := strings.TrimSpace(r.URL.Query().Get("src"))
|
||
|
||
fallbackModel := ""
|
||
if ci, ok := readCoverInfoBestEffort(key); ok {
|
||
if m := strings.TrimSpace(ci.Model); m != "" {
|
||
fallbackModel = m
|
||
}
|
||
}
|
||
if model == "" {
|
||
model = fallbackModel
|
||
}
|
||
if !modelExplicit && src != "" {
|
||
if m := inferModelFromThumbLike(src); m != "" {
|
||
model = m
|
||
}
|
||
}
|
||
|
||
reqID := strconv.FormatInt(time.Now().UnixNano(), 36)
|
||
setDebugHeaders := func(cache string) {
|
||
w.Header().Set("X-Cover-Key", key)
|
||
w.Header().Set("X-Cover-Category", category)
|
||
if model != "" {
|
||
w.Header().Set("X-Cover-Model", model)
|
||
}
|
||
w.Header().Set("X-Cover-Cache", cache)
|
||
w.Header().Set("X-Request-Id", reqID)
|
||
}
|
||
|
||
if !force {
|
||
if model != "" {
|
||
if ci, ok := readCoverInfoBestEffort(key); ok {
|
||
if strings.TrimSpace(ci.Model) != model {
|
||
force = true
|
||
}
|
||
} else {
|
||
force = true
|
||
}
|
||
}
|
||
|
||
if !force {
|
||
if p, fi, ok := findExistingCoverFile(key); ok {
|
||
setDebugHeaders("HIT")
|
||
|
||
if model != "" {
|
||
ci, ok := readCoverInfoBestEffort(key)
|
||
if !ok {
|
||
ci = coverInfo{Category: category}
|
||
}
|
||
ci.Category = category
|
||
ci.Model = strings.TrimSpace(model)
|
||
ci.GeneratedAt = time.Now().UTC().Format(time.RFC3339Nano)
|
||
writeCoverInfoBestEffort(key, ci)
|
||
}
|
||
|
||
w.Header().Set("Cache-Control", "public, max-age=31536000")
|
||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||
|
||
ext := strings.ToLower(filepath.Ext(p))
|
||
switch ext {
|
||
case ".png":
|
||
w.Header().Set("Content-Type", "image/png")
|
||
case ".jpg", ".jpeg":
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
case ".gif":
|
||
w.Header().Set("Content-Type", "image/gif")
|
||
default:
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
}
|
||
|
||
if r.Method == http.MethodHead {
|
||
w.WriteHeader(http.StatusOK)
|
||
return
|
||
}
|
||
|
||
f, err := os.Open(p)
|
||
if err != nil {
|
||
http.NotFound(w, r)
|
||
return
|
||
}
|
||
defer f.Close()
|
||
|
||
http.ServeContent(w, r, filepath.Base(p), fi.ModTime(), f)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
cacheStatus := "MISS"
|
||
if force {
|
||
cacheStatus = "FORCED"
|
||
}
|
||
setDebugHeaders(cacheStatus)
|
||
coverBatchEnter(force)
|
||
|
||
start := time.Now()
|
||
status := http.StatusOK
|
||
outcome := "ok"
|
||
defer func() {
|
||
w.Header().Set("X-Cover-Gen-Ms", strconv.FormatInt(time.Since(start).Milliseconds(), 10))
|
||
coverBatchLeave(outcome, status)
|
||
}()
|
||
|
||
if _, err := ensureCoversDir(); err != nil {
|
||
status = http.StatusInternalServerError
|
||
outcome = "covers-dir"
|
||
http.Error(w, "covers-dir nicht verfügbar: "+err.Error(), status)
|
||
return
|
||
}
|
||
|
||
ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
|
||
defer cancel()
|
||
|
||
var (
|
||
raw []byte
|
||
mimeType string
|
||
ext string
|
||
)
|
||
|
||
thumbPath := ""
|
||
usedSrc := ""
|
||
|
||
if src != "" {
|
||
var derr error
|
||
raw, mimeType, derr = downloadBytes(ctx, src, r.Header.Get("User-Agent"))
|
||
usedSrc = normalizeCoverSrc(src)
|
||
if derr != nil {
|
||
status = http.StatusBadRequest
|
||
outcome = "src-download"
|
||
http.Error(w, "src download failed: "+derr.Error(), status)
|
||
return
|
||
}
|
||
ext, mimeType = detectImageExt(mimeType, raw)
|
||
if len(raw) == 0 {
|
||
status = http.StatusBadRequest
|
||
outcome = "src-empty"
|
||
http.Error(w, "src leer", status)
|
||
return
|
||
}
|
||
if model == "" {
|
||
if m := inferModelFromThumbLike(src); m != "" {
|
||
model = m
|
||
w.Header().Set("X-Cover-Model", model)
|
||
}
|
||
}
|
||
} else {
|
||
var perr error
|
||
thumbPath, perr = pickRandomThumbForCategory(ctx, category)
|
||
if perr != nil {
|
||
if p, fi, ok := findExistingCoverFile(key); ok {
|
||
outcome = "fallback-existing-cover"
|
||
status = http.StatusOK
|
||
|
||
w.Header().Set("Cache-Control", "public, max-age=600")
|
||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||
|
||
ext2 := strings.ToLower(filepath.Ext(p))
|
||
switch ext2 {
|
||
case ".png":
|
||
w.Header().Set("Content-Type", "image/png")
|
||
case ".jpg":
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
case ".gif":
|
||
w.Header().Set("Content-Type", "image/gif")
|
||
default:
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
}
|
||
|
||
if r.Method == http.MethodHead {
|
||
w.WriteHeader(http.StatusOK)
|
||
return
|
||
}
|
||
|
||
f, err := os.Open(p)
|
||
if err != nil {
|
||
servePreviewStatusSVG(w, "No Cover", status)
|
||
return
|
||
}
|
||
defer f.Close()
|
||
http.ServeContent(w, r, filepath.Base(p), fi.ModTime(), f)
|
||
return
|
||
}
|
||
|
||
outcome = "no-thumb"
|
||
status = http.StatusNotFound
|
||
if r.Method == http.MethodHead {
|
||
w.WriteHeader(status)
|
||
return
|
||
}
|
||
servePreviewStatusSVG(w, "No Cover", status)
|
||
return
|
||
}
|
||
|
||
usedSrc = normalizeCoverSrc(thumbPath)
|
||
raw, err = os.ReadFile(thumbPath)
|
||
if err != nil || len(raw) == 0 {
|
||
status = http.StatusInternalServerError
|
||
outcome = "thumb-read"
|
||
http.Error(w, "cover read fehlgeschlagen", status)
|
||
return
|
||
}
|
||
ext = ".jpg"
|
||
mimeType = "image/jpeg"
|
||
if model == "" {
|
||
if m := inferModelFromThumbLike(thumbPath); m != "" {
|
||
model = m
|
||
w.Header().Set("X-Cover-Model", model)
|
||
}
|
||
}
|
||
}
|
||
|
||
if !modelExplicit {
|
||
if m := inferModelFromThumbLike(usedSrc); m != "" {
|
||
model = m
|
||
w.Header().Set("X-Cover-Model", model)
|
||
}
|
||
}
|
||
|
||
img, _, derr := image.Decode(bytes.NewReader(raw))
|
||
if derr == nil && img != nil {
|
||
rgba := image.NewRGBA(img.Bounds())
|
||
draw.Draw(rgba, rgba.Bounds(), img, img.Bounds().Min, draw.Src)
|
||
if strings.TrimSpace(model) != "" {
|
||
drawLabel(rgba, model)
|
||
}
|
||
|
||
var buf bytes.Buffer
|
||
switch strings.ToLower(ext) {
|
||
case ".png":
|
||
_ = png.Encode(&buf, rgba)
|
||
raw = buf.Bytes()
|
||
ext = ".png"
|
||
mimeType = "image/png"
|
||
default:
|
||
_ = jpeg.Encode(&buf, rgba, &jpeg.Options{Quality: 85})
|
||
raw = buf.Bytes()
|
||
ext = ".jpg"
|
||
mimeType = "image/jpeg"
|
||
}
|
||
} else {
|
||
outcome = "decode-failed-no-overlay"
|
||
}
|
||
|
||
root, _ := coversRoot()
|
||
for _, e := range []string{".jpg", ".png", ".gif"} {
|
||
_ = os.Remove(filepath.Join(root, key+e))
|
||
}
|
||
_ = os.Remove(filepath.Join(root, key+".info.json"))
|
||
|
||
dst, err := coverPathForCategory(key, ext)
|
||
if err != nil {
|
||
status = http.StatusInternalServerError
|
||
outcome = "cover-path"
|
||
http.Error(w, "cover path: "+err.Error(), status)
|
||
return
|
||
}
|
||
if err := atomicWriteFile(dst, raw); err != nil {
|
||
status = http.StatusInternalServerError
|
||
outcome = "cover-write"
|
||
http.Error(w, "cover write: "+err.Error(), status)
|
||
return
|
||
}
|
||
|
||
writeCoverInfoBestEffort(key, coverInfo{
|
||
Category: category,
|
||
Model: strings.TrimSpace(model),
|
||
Src: strings.TrimSpace(usedSrc),
|
||
GeneratedAt: time.Now().UTC().Format(time.RFC3339Nano),
|
||
})
|
||
|
||
w.Header().Set("Cache-Control", "public, max-age=600")
|
||
w.Header().Set("Content-Type", mimeType)
|
||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||
w.Header().Set("X-Cover-Bytes", strconv.Itoa(len(raw)))
|
||
|
||
if r.Method == http.MethodHead {
|
||
w.WriteHeader(http.StatusOK)
|
||
return
|
||
}
|
||
|
||
w.WriteHeader(http.StatusOK)
|
||
_, _ = w.Write(raw)
|
||
}
|
||
|
||
// ============================================================
|
||
// Status SVG (Preview placeholder)
|
||
// ============================================================
|
||
|
||
func servePreviewStatusSVG(w http.ResponseWriter, label string, status int) {
|
||
w.Header().Set("Content-Type", "image/svg+xml; charset=utf-8")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||
|
||
if status <= 0 {
|
||
status = http.StatusOK
|
||
}
|
||
|
||
title := html.EscapeString(strings.TrimSpace(label))
|
||
if title == "" {
|
||
title = "Preview"
|
||
}
|
||
|
||
svg := `<?xml version="1.0" encoding="UTF-8"?>
|
||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 180" preserveAspectRatio="xMidYMid slice">
|
||
<defs>
|
||
<linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
|
||
<stop offset="0" stop-color="rgba(99,102,241,0.10)"/>
|
||
<stop offset="1" stop-color="rgba(14,165,233,0.08)"/>
|
||
</linearGradient>
|
||
<radialGradient id="vig" cx="50%" cy="45%" r="75%">
|
||
<stop offset="0" stop-color="rgba(0,0,0,0)"/>
|
||
<stop offset="1" stop-color="rgba(0,0,0,0.18)"/>
|
||
</radialGradient>
|
||
<filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
|
||
<feDropShadow dx="0" dy="6" stdDeviation="8" flood-color="rgba(0,0,0,0.18)"/>
|
||
</filter>
|
||
</defs>
|
||
|
||
<rect x="0" y="0" width="320" height="180" rx="18" fill="rgba(17,24,39,0.06)"/>
|
||
<rect x="0" y="0" width="320" height="180" rx="18" fill="url(#bg)"/>
|
||
<rect x="0" y="0" width="320" height="180" rx="18" fill="url(#vig)"/>
|
||
|
||
<g filter="url(#shadow)">
|
||
<rect x="18" y="18" width="284" height="144" rx="16"
|
||
fill="rgba(255,255,255,0.72)"
|
||
stroke="rgba(0,0,0,0.08)"/>
|
||
<rect x="18" y="18" width="284" height="144" rx="16"
|
||
fill="rgba(255,255,255,0)"
|
||
stroke="rgba(99,102,241,0.18)"
|
||
stroke-width="2"
|
||
stroke-dasharray="6 6"/>
|
||
</g>
|
||
|
||
<g transform="translate(160 70)">
|
||
<circle r="20" fill="rgba(17,24,39,0.08)" stroke="rgba(0,0,0,0.08)"/>
|
||
<path d="M-10 6 L-4 0 L2 6 L10 -2" fill="none" stroke="rgba(17,24,39,0.55)" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"/>
|
||
<path d="M-10 -6 H10" fill="none" stroke="rgba(17,24,39,0.35)" stroke-width="2.4" stroke-linecap="round"/>
|
||
<path d="M-12 12 L12 -12" fill="none" stroke="rgba(239,68,68,0.55)" stroke-width="2.6" stroke-linecap="round"/>
|
||
</g>
|
||
|
||
<text x="160" y="118" text-anchor="middle"
|
||
font-family="ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto"
|
||
font-size="16" font-weight="750"
|
||
fill="rgba(17,24,39,0.88)">` + title + `</text>
|
||
|
||
<text x="160" y="140" text-anchor="middle"
|
||
font-family="ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto"
|
||
font-size="11.5" font-weight="650"
|
||
fill="rgba(75,85,99,0.82)">Preview nicht verfügbar</text>
|
||
</svg>
|
||
`
|
||
|
||
w.WriteHeader(status)
|
||
_, _ = w.Write([]byte(svg))
|
||
}
|
||
|
||
func shortFFmpegStderr(raw string) string {
|
||
raw = strings.TrimSpace(raw)
|
||
if raw == "" {
|
||
return ""
|
||
}
|
||
|
||
lines := strings.Split(raw, "\n")
|
||
clean := make([]string, 0, len(lines))
|
||
|
||
for _, line := range lines {
|
||
line = strings.TrimSpace(line)
|
||
if line == "" {
|
||
continue
|
||
}
|
||
clean = append(clean, line)
|
||
}
|
||
|
||
if len(clean) == 0 {
|
||
return ""
|
||
}
|
||
|
||
want := []string{
|
||
"Error while opening encoder",
|
||
"Could not open encoder",
|
||
"Invalid argument",
|
||
"Nothing was written into output file",
|
||
"Non full-range YUV",
|
||
"moov atom not found",
|
||
"Invalid data found",
|
||
"Error opening input",
|
||
}
|
||
|
||
for _, needle := range want {
|
||
needleLower := strings.ToLower(needle)
|
||
|
||
for _, line := range clean {
|
||
if strings.Contains(strings.ToLower(line), needleLower) {
|
||
if len(clean) > 1 {
|
||
return fmt.Sprintf("%s … (+%d Zeilen)", line, len(clean)-1)
|
||
}
|
||
return line
|
||
}
|
||
}
|
||
}
|
||
|
||
if len(clean) == 1 {
|
||
return clean[0]
|
||
}
|
||
|
||
return fmt.Sprintf("%s … (+%d Zeilen)", clean[len(clean)-1], len(clean)-1)
|
||
}
|
||
|
||
func ffmpegPreviewError(label string, err error, stderr string) error {
|
||
msg := shortFFmpegStderr(stderr)
|
||
if msg == "" {
|
||
return appErrorf("%s: %w", label, err)
|
||
}
|
||
|
||
return appErrorf("%s: %w: %s", label, err, msg)
|
||
}
|
||
|
||
// ============================================================
|
||
// JPG extraction + preview endpoint
|
||
// Route:
|
||
// - /api/preview?id=<jobID> (returns preview.jpg / 204 / svg)
|
||
// - /api/preview?id=<jobID>&file=preview.jpg
|
||
// ============================================================
|
||
|
||
// --- JPG extraction helpers ---
|
||
|
||
func extractLastFrameJPG(path string) ([]byte, error) {
|
||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
||
defer cancel()
|
||
|
||
cmd := exec.CommandContext(
|
||
ctx,
|
||
ffmpegPath,
|
||
"-hide_banner",
|
||
"-loglevel", "error",
|
||
"-sseof", "-0.25",
|
||
"-i", path,
|
||
"-map", "0:v:0",
|
||
"-an",
|
||
"-sn",
|
||
"-dn",
|
||
"-frames:v", "1",
|
||
"-vf", "scale=720:-2:flags=fast_bilinear",
|
||
"-vcodec", "mjpeg",
|
||
"-pix_fmt", "yuvj420p",
|
||
"-threads", "1",
|
||
"-q:v", "4",
|
||
"-f", "image2pipe",
|
||
"pipe:1",
|
||
)
|
||
cmd.SysProcAttr = &syscall.SysProcAttr{
|
||
HideWindow: true,
|
||
CreationFlags: 0x08000000, // CREATE_NO_WINDOW
|
||
}
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
|
||
if err := cmd.Run(); err != nil {
|
||
if ctx.Err() == context.DeadlineExceeded {
|
||
return nil, appErrorf("ffmpeg last-frame jpg: timeout")
|
||
}
|
||
return nil, ffmpegPreviewError("ffmpeg last-frame jpg", err, stderr.String())
|
||
}
|
||
|
||
b := out.Bytes()
|
||
if len(b) == 0 {
|
||
return nil, appErrorf("ffmpeg last-frame jpg: empty output")
|
||
}
|
||
|
||
return b, nil
|
||
}
|
||
|
||
func extractFrameAtTimeJPG(path string, seconds float64) ([]byte, error) {
|
||
if seconds < 0 {
|
||
seconds = 0
|
||
}
|
||
seek := fmt.Sprintf("%.3f", seconds)
|
||
|
||
cmd := exec.Command(
|
||
ffmpegPath,
|
||
"-hide_banner", "-loglevel", "error",
|
||
"-ss", seek,
|
||
"-i", path,
|
||
"-frames:v", "1",
|
||
"-vf", "scale=720:-2",
|
||
"-vcodec", "mjpeg",
|
||
"-pix_fmt", "yuvj420p",
|
||
"-threads", "1",
|
||
"-q:v", "4",
|
||
"-f", "image2pipe",
|
||
"pipe:1",
|
||
)
|
||
cmd.SysProcAttr = &syscall.SysProcAttr{
|
||
HideWindow: true,
|
||
CreationFlags: 0x08000000, // CREATE_NO_WINDOW
|
||
}
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
if err := cmd.Run(); err != nil {
|
||
return nil, ffmpegPreviewError("ffmpeg frame-at-time jpg", err, stderr.String())
|
||
}
|
||
b := out.Bytes()
|
||
if len(b) == 0 {
|
||
return nil, appErrorf("ffmpeg frame-at-time jpg: empty output")
|
||
}
|
||
return b, nil
|
||
}
|
||
|
||
func extractLastFrameJPGScaled(path string, width int, quality int) ([]byte, error) {
|
||
if width <= 0 {
|
||
width = 320
|
||
}
|
||
if quality <= 0 || quality > 100 {
|
||
quality = 70
|
||
}
|
||
|
||
qv := "5"
|
||
if quality >= 80 {
|
||
qv = "3"
|
||
} else if quality >= 65 {
|
||
qv = "5"
|
||
} else {
|
||
qv = "7"
|
||
}
|
||
|
||
cmd := exec.Command(
|
||
ffmpegPath,
|
||
"-hide_banner", "-loglevel", "error",
|
||
"-sseof", "-0.25",
|
||
"-i", path,
|
||
"-frames:v", "1",
|
||
"-vf", fmt.Sprintf("scale=%d:-2", width),
|
||
"-vcodec", "mjpeg",
|
||
"-pix_fmt", "yuvj420p",
|
||
"-threads", "1",
|
||
"-q:v", qv,
|
||
"-f", "image2pipe",
|
||
"pipe:1",
|
||
)
|
||
cmd.SysProcAttr = &syscall.SysProcAttr{
|
||
HideWindow: true,
|
||
CreationFlags: 0x08000000, // CREATE_NO_WINDOW
|
||
}
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
if err := cmd.Run(); err != nil {
|
||
return nil, ffmpegPreviewError("ffmpeg last-frame scaled jpg", err, stderr.String())
|
||
}
|
||
b := out.Bytes()
|
||
if len(b) == 0 {
|
||
return nil, appErrorf("ffmpeg last-frame scaled jpg: empty output")
|
||
}
|
||
return b, nil
|
||
}
|
||
|
||
func extractFirstFrameJPGScaled(path string, width int, quality int) ([]byte, error) {
|
||
if width <= 0 {
|
||
width = 320
|
||
}
|
||
if quality <= 0 || quality > 100 {
|
||
quality = 70
|
||
}
|
||
|
||
cmd := exec.Command(
|
||
ffmpegPath,
|
||
"-hide_banner", "-loglevel", "error",
|
||
"-ss", "0",
|
||
"-i", path,
|
||
"-frames:v", "1",
|
||
"-vf", fmt.Sprintf("scale=%d:-2", width),
|
||
"-vcodec", "mjpeg",
|
||
"-pix_fmt", "yuvj420p",
|
||
"-threads", "1",
|
||
"-q:v", "5",
|
||
"-f", "image2pipe",
|
||
"pipe:1",
|
||
)
|
||
cmd.SysProcAttr = &syscall.SysProcAttr{
|
||
HideWindow: true,
|
||
CreationFlags: 0x08000000, // CREATE_NO_WINDOW
|
||
}
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
if err := cmd.Run(); err != nil {
|
||
return nil, ffmpegPreviewError("ffmpeg first-frame scaled jpg", err, stderr.String())
|
||
}
|
||
b := out.Bytes()
|
||
if len(b) == 0 {
|
||
return nil, appErrorf("ffmpeg first-frame scaled jpg: empty output")
|
||
}
|
||
return b, nil
|
||
}
|
||
|
||
func extractLiveFrameFromM3U8ThumbJPG(ctx context.Context, m3u8URL, cookie, userAgent string) ([]byte, error) {
|
||
m3u8URL = strings.TrimSpace(m3u8URL)
|
||
if m3u8URL == "" {
|
||
return nil, appErrorf("m3u8 leer")
|
||
}
|
||
|
||
if strings.TrimSpace(userAgent) == "" {
|
||
userAgent = "Mozilla/5.0"
|
||
}
|
||
|
||
args := []string{
|
||
"-hide_banner",
|
||
"-loglevel", "error",
|
||
}
|
||
|
||
if strings.TrimSpace(userAgent) != "" {
|
||
args = append(args, "-user_agent", strings.TrimSpace(userAgent))
|
||
}
|
||
|
||
if strings.TrimSpace(cookie) != "" {
|
||
args = append(args, "-headers", fmt.Sprintf("Cookie: %s\r\n", strings.TrimSpace(cookie)))
|
||
}
|
||
|
||
args = append(args,
|
||
"-i", m3u8URL,
|
||
"-frames:v", "1",
|
||
"-vf", "scale=320:-2",
|
||
"-vcodec", "mjpeg",
|
||
"-pix_fmt", "yuvj420p",
|
||
"-threads", "1",
|
||
"-q:v", "6",
|
||
"-f", "image2pipe",
|
||
"pipe:1",
|
||
)
|
||
|
||
cmd := exec.CommandContext(ctx, ffmpegPath, args...)
|
||
cmd.SysProcAttr = &syscall.SysProcAttr{
|
||
HideWindow: true,
|
||
CreationFlags: 0x08000000, // CREATE_NO_WINDOW
|
||
}
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
|
||
if err := cmd.Run(); err != nil {
|
||
return nil, ffmpegPreviewError("ffmpeg live m3u8 jpg failed", err, stderr.String())
|
||
}
|
||
|
||
b := out.Bytes()
|
||
if len(b) == 0 {
|
||
return nil, appErrorf("ffmpeg live m3u8 jpg: empty output")
|
||
}
|
||
|
||
return b, nil
|
||
}
|
||
|
||
func serveLivePreviewJPGFile(w http.ResponseWriter, r *http.Request, path string) {
|
||
f, err := os.Open(path)
|
||
if err != nil {
|
||
http.NotFound(w, r)
|
||
return
|
||
}
|
||
defer f.Close()
|
||
|
||
st, err := f.Stat()
|
||
if err != nil || st.IsDir() || st.Size() == 0 {
|
||
http.NotFound(w, r)
|
||
return
|
||
}
|
||
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
http.ServeContent(w, r, "preview.jpg", st.ModTime(), f)
|
||
}
|
||
|
||
func servePreviewJPGFile(w http.ResponseWriter, r *http.Request, path string) {
|
||
f, err := os.Open(path)
|
||
if err != nil {
|
||
http.NotFound(w, r)
|
||
return
|
||
}
|
||
defer f.Close()
|
||
|
||
st, err := f.Stat()
|
||
if err != nil || st.IsDir() || st.Size() == 0 {
|
||
http.NotFound(w, r)
|
||
return
|
||
}
|
||
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
w.Header().Set("Cache-Control", "public, max-age=600")
|
||
http.ServeContent(w, r, filepath.Base(path), st.ModTime(), f)
|
||
}
|
||
|
||
func servePreviewJPGBytes(w http.ResponseWriter, b []byte) {
|
||
if len(b) == 0 {
|
||
w.WriteHeader(http.StatusNoContent)
|
||
return
|
||
}
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
w.Header().Set("Cache-Control", "public, max-age=60")
|
||
w.WriteHeader(http.StatusOK)
|
||
_, _ = w.Write(b)
|
||
}
|
||
|
||
func serveLivePreviewJPGBytes(w http.ResponseWriter, b []byte) {
|
||
if len(b) == 0 {
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.WriteHeader(http.StatusNoContent)
|
||
return
|
||
}
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.WriteHeader(http.StatusOK)
|
||
_, _ = w.Write(b)
|
||
}
|
||
|
||
func detectPreviewProvider(job *RecordJob, outPath string) string {
|
||
if job != nil {
|
||
sourceURL := strings.ToLower(strings.TrimSpace(job.SourceURL))
|
||
|
||
switch {
|
||
case strings.Contains(sourceURL, "chaturbate.com"):
|
||
return "chaturbate"
|
||
case strings.Contains(sourceURL, "myfreecams.com"):
|
||
return "mfc"
|
||
}
|
||
}
|
||
|
||
modelKey := strings.TrimSpace(inferModelFromThumbLike(outPath))
|
||
if modelKey == "" || coverModelStore == nil {
|
||
return ""
|
||
}
|
||
modelKey = strings.ToLower(modelKey)
|
||
|
||
models := coverModelStore.List()
|
||
for _, m := range models {
|
||
if strings.ToLower(strings.TrimSpace(m.ModelKey)) != modelKey {
|
||
continue
|
||
}
|
||
|
||
host := strings.ToLower(strings.TrimSpace(m.Host))
|
||
input := strings.ToLower(strings.TrimSpace(m.Input))
|
||
|
||
switch {
|
||
case strings.Contains(host, "chaturbate"), strings.Contains(input, "chaturbate.com"):
|
||
return "chaturbate"
|
||
case strings.Contains(host, "myfreecams"), strings.Contains(input, "myfreecams.com"):
|
||
return "mfc"
|
||
}
|
||
}
|
||
|
||
return ""
|
||
}
|
||
|
||
func fallbackPreviewImageAssetPathForProvider(provider string) (string, error) {
|
||
switch strings.ToLower(strings.TrimSpace(provider)) {
|
||
case "chaturbate":
|
||
return "assets/img/cb.jpg", nil
|
||
case "mfc":
|
||
return "assets/img/mfc.jpg", nil
|
||
default:
|
||
return "", appErrorf("unknown provider")
|
||
}
|
||
}
|
||
|
||
func serveFallbackPreviewImage(w http.ResponseWriter, r *http.Request, job *RecordJob, outPath string) bool {
|
||
provider := detectPreviewProvider(job, outPath)
|
||
if provider == "" {
|
||
return false
|
||
}
|
||
|
||
assetPath, err := fallbackPreviewImageAssetPathForProvider(provider)
|
||
if err != nil {
|
||
return false
|
||
}
|
||
|
||
b, err := embeddedFallbackImages.ReadFile(assetPath)
|
||
if err != nil || len(b) == 0 {
|
||
return false
|
||
}
|
||
|
||
ext := strings.ToLower(filepath.Ext(assetPath))
|
||
switch ext {
|
||
case ".png":
|
||
w.Header().Set("Content-Type", "image/png")
|
||
default:
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
}
|
||
|
||
w.Header().Set("Cache-Control", "public, max-age=60")
|
||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||
|
||
if r.Method == http.MethodHead {
|
||
w.WriteHeader(http.StatusOK)
|
||
return true
|
||
}
|
||
|
||
w.WriteHeader(http.StatusOK)
|
||
_, _ = w.Write(b)
|
||
return true
|
||
}
|
||
|
||
func serveProviderFallbackOrStatus(w http.ResponseWriter, r *http.Request, job *RecordJob, outPath string, label string, status int) {
|
||
if serveFallbackPreviewImage(w, r, job, outPath) {
|
||
return
|
||
}
|
||
servePreviewStatusSVG(w, label, status)
|
||
}
|
||
|
||
func serveRunningJobPreview(w http.ResponseWriter, r *http.Request, job *RecordJob) bool {
|
||
if job == nil {
|
||
return false
|
||
}
|
||
|
||
provider := detectPreviewProvider(job, job.Output)
|
||
previewState := previewStateForJob(job)
|
||
imageURL := strings.TrimSpace(previewImageURLForJob(job))
|
||
previewM3U8 := strings.TrimSpace(job.PreviewM3U8)
|
||
previewCookie := strings.TrimSpace(job.PreviewCookie)
|
||
previewUA := strings.TrimSpace(job.PreviewUA)
|
||
outPath := strings.TrimSpace(job.Output)
|
||
|
||
// Chaturbate: immer CDN bevorzugen, nichts auf Platte schreiben
|
||
if provider == "chaturbate" && imageURL != "" {
|
||
ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
|
||
defer cancel()
|
||
|
||
if img, err := downloadPreviewImageJPG(ctx, imageURL, previewUA); err == nil && len(img) > 0 {
|
||
job.previewMu.Lock()
|
||
job.previewJPG = append([]byte(nil), img...)
|
||
job.previewJPGAt = time.Now()
|
||
job.previewMu.Unlock()
|
||
|
||
serveLivePreviewJPGBytes(w, img)
|
||
return true
|
||
}
|
||
}
|
||
|
||
job.previewMu.Lock()
|
||
cached := append([]byte(nil), job.previewJPG...)
|
||
cachedAt := job.previewJPGAt
|
||
fresh := len(cached) > 0 && !cachedAt.IsZero() && time.Since(cachedAt) < 18*time.Second
|
||
canSpawn := !fresh && !job.previewGen && provider != "chaturbate"
|
||
if canSpawn {
|
||
job.previewGen = true
|
||
}
|
||
job.previewMu.Unlock()
|
||
|
||
if fresh || (provider == "chaturbate" && len(cached) > 0) {
|
||
serveLivePreviewJPGBytes(w, cached)
|
||
return true
|
||
}
|
||
|
||
// Für Nicht-Chaturbate darf weiterhin in-memory erzeugt werden, aber nicht als preview.jpg speichern
|
||
if canSpawn {
|
||
go func(j *RecordJob, previewState, imageURL, previewM3U8, previewCookie, previewUA, outPath string) {
|
||
defer func() {
|
||
j.previewMu.Lock()
|
||
j.previewGen = false
|
||
j.previewMu.Unlock()
|
||
}()
|
||
|
||
var img []byte
|
||
|
||
if previewState == "public" && imageURL != "" {
|
||
if b, err := downloadPreviewImageJPG(context.Background(), imageURL, previewUA); err == nil && len(b) > 0 {
|
||
img = b
|
||
}
|
||
}
|
||
|
||
if len(img) == 0 && previewM3U8 != "" {
|
||
if b, err := extractLiveFrameFromM3U8ThumbJPG(context.Background(), previewM3U8, previewCookie, previewUA); err == nil && len(b) > 0 {
|
||
img = b
|
||
}
|
||
}
|
||
|
||
if len(img) == 0 && outPath != "" {
|
||
if b, err := extractLastFrameJPGScaled(outPath, 720, 75); err == nil && len(b) > 0 {
|
||
img = b
|
||
}
|
||
}
|
||
|
||
if len(img) == 0 {
|
||
return
|
||
}
|
||
|
||
j.previewMu.Lock()
|
||
j.previewJPG = append([]byte(nil), img...)
|
||
j.previewJPGAt = time.Now()
|
||
j.previewMu.Unlock()
|
||
}(job, previewState, imageURL, previewM3U8, previewCookie, previewUA, outPath)
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
func servePreviewJPGAlias(w http.ResponseWriter, r *http.Request, id string) {
|
||
jobsMu.RLock()
|
||
job := jobs[id]
|
||
jobsMu.RUnlock()
|
||
|
||
if job != nil {
|
||
if job.Status == JobRunning {
|
||
if serveRunningJobPreview(w, r, job) {
|
||
return
|
||
}
|
||
serveProviderFallbackOrStatus(w, r, job, job.Output, "Preview", http.StatusOK)
|
||
return
|
||
}
|
||
|
||
assetID := assetIDForJob(job)
|
||
if assetID != "" {
|
||
if jpgPath, err := generatedThumbJPGFile(assetID); err == nil {
|
||
if st, err := os.Stat(jpgPath); err == nil && !st.IsDir() && st.Size() > 0 {
|
||
servePreviewJPGFile(w, r, jpgPath)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
serveProviderFallbackOrStatus(w, r, job, job.Output, "Preview", http.StatusOK)
|
||
return
|
||
}
|
||
|
||
assetID := stripHotPrefix(strings.TrimSpace(id))
|
||
if assetID == "" {
|
||
http.NotFound(w, r)
|
||
return
|
||
}
|
||
if jpgPath, err := generatedThumbJPGFile(assetID); err == nil {
|
||
if st, err := os.Stat(jpgPath); err == nil && !st.IsDir() && st.Size() > 0 {
|
||
servePreviewJPGFile(w, r, jpgPath)
|
||
return
|
||
}
|
||
}
|
||
http.NotFound(w, r)
|
||
}
|
||
|
||
func recordPreview(w http.ResponseWriter, r *http.Request) {
|
||
// Standard: rewrite soll auf /api/preview zeigen
|
||
recordPreviewWithBase(w, r, "/api/preview")
|
||
}
|
||
|
||
func recordPreviewWithBase(w http.ResponseWriter, r *http.Request, basePath string) {
|
||
if r.Method != http.MethodGet && r.Method != http.MethodHead {
|
||
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
id := strings.TrimSpace(r.URL.Query().Get("id"))
|
||
if id == "" {
|
||
id = strings.TrimSpace(r.URL.Query().Get("name"))
|
||
}
|
||
if id == "" {
|
||
http.Error(w, "id fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
fallbackOnlyRaw := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("fallbackOnly")))
|
||
fallbackOnly := fallbackOnlyRaw == "1" || fallbackOnlyRaw == "true" || fallbackOnlyRaw == "yes"
|
||
|
||
if fallbackOnly {
|
||
jobsMu.RLock()
|
||
job, ok := jobs[id]
|
||
jobsMu.RUnlock()
|
||
|
||
if ok {
|
||
if serveFallbackPreviewImage(w, r, job, job.Output) {
|
||
return
|
||
}
|
||
servePreviewStatusSVG(w, "Preview", http.StatusOK)
|
||
return
|
||
}
|
||
|
||
assetID := stripHotPrefix(strings.TrimSpace(id))
|
||
if assetID != "" {
|
||
if outPath, err := findFinishedFileByID(assetID); err == nil {
|
||
if serveFallbackPreviewImage(w, r, nil, outPath) {
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
servePreviewStatusSVG(w, "Preview", http.StatusOK)
|
||
return
|
||
}
|
||
|
||
// file serving
|
||
if file := strings.TrimSpace(r.URL.Query().Get("file")); file != "" {
|
||
low := strings.ToLower(strings.TrimSpace(file))
|
||
|
||
if low == "preview.jpg" {
|
||
jobsMu.RLock()
|
||
job := jobs[id]
|
||
jobsMu.RUnlock()
|
||
|
||
if job != nil && job.Status == JobRunning {
|
||
startLiveThumbJPGLoop(context.Background(), job)
|
||
}
|
||
|
||
servePreviewJPGAlias(w, r, id)
|
||
return
|
||
}
|
||
|
||
recordPreviewFile(w, r)
|
||
return
|
||
}
|
||
|
||
// JPG preview (running jobs have live thumb behavior)
|
||
jobsMu.RLock()
|
||
job, ok := jobs[id]
|
||
jobsMu.RUnlock()
|
||
|
||
if ok {
|
||
if job.Status == JobRunning {
|
||
if serveRunningJobPreview(w, r, job) {
|
||
return
|
||
}
|
||
|
||
state := strings.TrimSpace(previewStateForJob(job))
|
||
if state == "private" {
|
||
serveProviderFallbackOrStatus(w, r, job, job.Output, "Private", http.StatusOK)
|
||
return
|
||
}
|
||
if state == "offline" {
|
||
serveProviderFallbackOrStatus(w, r, job, job.Output, "Offline", http.StatusOK)
|
||
return
|
||
}
|
||
|
||
serveProviderFallbackOrStatus(w, r, job, job.Output, "Preview", http.StatusOK)
|
||
return
|
||
}
|
||
|
||
assetID := assetIDForJob(job)
|
||
if assetID != "" {
|
||
if jpgPath, err := generatedThumbJPGFile(assetID); err == nil {
|
||
if st, err := os.Stat(jpgPath); err == nil && !st.IsDir() && st.Size() > 0 {
|
||
servePreviewJPGFile(w, r, jpgPath)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
serveProviderFallbackOrStatus(w, r, job, job.Output, "Preview", http.StatusOK)
|
||
return
|
||
}
|
||
|
||
// Finished file preview
|
||
servePreviewForFinishedFile(w, r, id)
|
||
}
|
||
|
||
func reflectStringField(v any, names ...string) string {
|
||
rv := reflect.ValueOf(v)
|
||
if !rv.IsValid() {
|
||
return ""
|
||
}
|
||
if rv.Kind() == reflect.Pointer {
|
||
if rv.IsNil() {
|
||
return ""
|
||
}
|
||
rv = rv.Elem()
|
||
}
|
||
if !rv.IsValid() || rv.Kind() != reflect.Struct {
|
||
return ""
|
||
}
|
||
|
||
for _, name := range names {
|
||
f := rv.FieldByName(name)
|
||
if !f.IsValid() || f.Kind() != reflect.String {
|
||
continue
|
||
}
|
||
s := strings.TrimSpace(f.String())
|
||
if s != "" {
|
||
return s
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func inferModelFromSourceURL(raw string) string {
|
||
raw = strings.TrimSpace(raw)
|
||
if raw == "" {
|
||
return ""
|
||
}
|
||
|
||
u, err := url.Parse(raw)
|
||
if err != nil || u == nil {
|
||
return ""
|
||
}
|
||
|
||
host := strings.ToLower(strings.TrimPrefix(u.Hostname(), "www."))
|
||
switch {
|
||
case strings.Contains(host, "chaturbate.com"):
|
||
parts := strings.Split(strings.Trim(u.Path, "/"), "/")
|
||
if len(parts) > 0 {
|
||
return strings.ToLower(strings.TrimSpace(parts[0]))
|
||
}
|
||
case strings.Contains(host, "myfreecams.com"):
|
||
hash := strings.TrimPrefix(strings.TrimSpace(u.Fragment), "/")
|
||
if hash != "" {
|
||
parts := strings.Split(hash, "/")
|
||
last := strings.TrimSpace(parts[len(parts)-1])
|
||
if last != "" {
|
||
return strings.ToLower(last)
|
||
}
|
||
}
|
||
parts := strings.Split(strings.Trim(u.Path, "/"), "/")
|
||
if len(parts) > 0 {
|
||
last := strings.TrimSpace(parts[len(parts)-1])
|
||
if last != "" {
|
||
return strings.ToLower(last)
|
||
}
|
||
}
|
||
}
|
||
|
||
return ""
|
||
}
|
||
|
||
func previewModelKeyForJob(job *RecordJob) string {
|
||
if job == nil {
|
||
return ""
|
||
}
|
||
|
||
if s := reflectStringField(job, "Model", "ModelKey"); s != "" {
|
||
return strings.ToLower(strings.TrimSpace(s))
|
||
}
|
||
|
||
if s := reflectStringField(job, "SourceURL", "SourceUrl"); s != "" {
|
||
if mk := inferModelFromSourceURL(s); mk != "" {
|
||
return mk
|
||
}
|
||
}
|
||
|
||
if s := reflectStringField(job, "Output"); s != "" {
|
||
if mk := inferModelFromThumbLike(s); mk != "" {
|
||
return strings.ToLower(strings.TrimSpace(mk))
|
||
}
|
||
}
|
||
|
||
return ""
|
||
}
|
||
|
||
func previewStateForJob(job *RecordJob) string {
|
||
if job == nil {
|
||
return ""
|
||
}
|
||
|
||
if s := reflectStringField(job,
|
||
"PreviewState",
|
||
"RoomStatus",
|
||
"ModelStatus",
|
||
"CurrentShow",
|
||
"Show",
|
||
"StatusText",
|
||
); s != "" {
|
||
return strings.ToLower(strings.TrimSpace(s))
|
||
}
|
||
|
||
modelKey := previewModelKeyForJob(job)
|
||
if modelKey == "" || coverModelStore == nil {
|
||
return ""
|
||
}
|
||
|
||
models := coverModelStore.List()
|
||
for _, m := range models {
|
||
mk := strings.ToLower(strings.TrimSpace(reflectStringField(m, "ModelKey")))
|
||
if mk == "" || mk != modelKey {
|
||
continue
|
||
}
|
||
|
||
if s := reflectStringField(m,
|
||
"RoomStatus",
|
||
"CurrentShow",
|
||
"Status",
|
||
"ModelStatus",
|
||
); s != "" {
|
||
return strings.ToLower(strings.TrimSpace(s))
|
||
}
|
||
}
|
||
|
||
return ""
|
||
}
|
||
|
||
func previewImageURLForJob(job *RecordJob) string {
|
||
if job == nil {
|
||
return ""
|
||
}
|
||
|
||
if s := reflectStringField(job,
|
||
"ModelImageURL",
|
||
"ModelImageUrl",
|
||
"ImageURL",
|
||
"ImageUrl",
|
||
"PreviewImageURL",
|
||
"PreviewImageUrl",
|
||
); s != "" {
|
||
return s
|
||
}
|
||
|
||
modelKey := previewModelKeyForJob(job)
|
||
if modelKey == "" || coverModelStore == nil {
|
||
return ""
|
||
}
|
||
|
||
models := coverModelStore.List()
|
||
for _, m := range models {
|
||
mk := strings.ToLower(strings.TrimSpace(reflectStringField(m, "ModelKey")))
|
||
if mk == "" || mk != modelKey {
|
||
continue
|
||
}
|
||
|
||
if s := reflectStringField(m,
|
||
"ImageURL",
|
||
"ImageUrl",
|
||
"ModelImageURL",
|
||
"ModelImageUrl",
|
||
); s != "" {
|
||
return s
|
||
}
|
||
}
|
||
|
||
return ""
|
||
}
|
||
|
||
func imageBytesToJPG(raw []byte, quality int) ([]byte, error) {
|
||
if len(raw) == 0 {
|
||
return nil, appErrorf("empty image")
|
||
}
|
||
if quality <= 0 || quality > 100 {
|
||
quality = 80
|
||
}
|
||
|
||
img, _, err := image.Decode(bytes.NewReader(raw))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var buf bytes.Buffer
|
||
if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality}); err != nil {
|
||
return nil, err
|
||
}
|
||
if buf.Len() == 0 {
|
||
return nil, appErrorf("jpeg encode returned empty data")
|
||
}
|
||
return buf.Bytes(), nil
|
||
}
|
||
|
||
func downloadPreviewImageJPG(ctx context.Context, rawURL, ua string) ([]byte, error) {
|
||
raw, _, err := downloadBytes(ctx, rawURL, ua)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return imageBytesToJPG(raw, 82)
|
||
}
|
||
|
||
func updateLiveThumbJPGOnce(ctx context.Context, job *RecordJob) {
|
||
jobsMu.RLock()
|
||
status := job.Status
|
||
previewM3U8 := strings.TrimSpace(job.PreviewM3U8)
|
||
previewCookie := strings.TrimSpace(job.PreviewCookie)
|
||
previewUA := strings.TrimSpace(job.PreviewUA)
|
||
out := job.Output
|
||
jobsMu.RUnlock()
|
||
|
||
if status != JobRunning {
|
||
return
|
||
}
|
||
|
||
job.previewMu.Lock()
|
||
lastAt := job.previewJPGAt
|
||
job.previewMu.Unlock()
|
||
|
||
if !lastAt.IsZero() && time.Since(lastAt) < 18*time.Second {
|
||
return
|
||
}
|
||
|
||
if thumbSem != nil {
|
||
thumbCtx, cancel := context.WithTimeout(ctx, 8*time.Second)
|
||
defer cancel()
|
||
if err := thumbSem.Acquire(thumbCtx); err != nil {
|
||
return
|
||
}
|
||
defer thumbSem.Release()
|
||
}
|
||
|
||
var img []byte
|
||
|
||
provider := detectPreviewProvider(job, out)
|
||
previewState := previewStateForJob(job)
|
||
imageURL := strings.TrimSpace(previewImageURLForJob(job))
|
||
|
||
if provider == "chaturbate" {
|
||
if imageURL != "" {
|
||
if b, err := downloadPreviewImageJPG(ctx, imageURL, previewUA); err == nil && len(b) > 0 {
|
||
img = b
|
||
}
|
||
}
|
||
} else {
|
||
if previewState == "public" && imageURL != "" {
|
||
if b, err := downloadPreviewImageJPG(ctx, imageURL, previewUA); err == nil && len(b) > 0 {
|
||
img = b
|
||
}
|
||
}
|
||
|
||
if len(img) == 0 && previewM3U8 != "" {
|
||
if b, err := extractLiveFrameFromM3U8ThumbJPG(ctx, previewM3U8, previewCookie, previewUA); err == nil && len(b) > 0 {
|
||
img = b
|
||
}
|
||
}
|
||
|
||
if len(img) == 0 && out != "" {
|
||
if b, err := extractLastFrameJPGScaled(out, 320, 70); err == nil && len(b) > 0 {
|
||
img = b
|
||
}
|
||
}
|
||
}
|
||
|
||
if len(img) == 0 {
|
||
return
|
||
}
|
||
|
||
job.previewMu.Lock()
|
||
job.previewJPG = append([]byte(nil), img...)
|
||
job.previewJPGAt = time.Now()
|
||
job.previewMu.Unlock()
|
||
}
|
||
|
||
func startLiveThumbJPGLoop(ctx context.Context, job *RecordJob) {
|
||
jobsMu.Lock()
|
||
if job.LiveThumbStarted {
|
||
jobsMu.Unlock()
|
||
return
|
||
}
|
||
job.LiveThumbStarted = true
|
||
jobsMu.Unlock()
|
||
|
||
go func() {
|
||
updateLiveThumbJPGOnce(ctx, job)
|
||
for {
|
||
select {
|
||
case <-ctx.Done():
|
||
return
|
||
case <-time.After(20 * time.Second):
|
||
jobsMu.RLock()
|
||
st := job.Status
|
||
jobsMu.RUnlock()
|
||
if st != JobRunning {
|
||
return
|
||
}
|
||
updateLiveThumbJPGOnce(ctx, job)
|
||
}
|
||
}
|
||
}()
|
||
}
|
||
|
||
func servePreviewForFinishedFile(w http.ResponseWriter, r *http.Request, id string) {
|
||
var err error
|
||
id, err = sanitizeID(id)
|
||
if err != nil {
|
||
http.Error(w, err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
outPath, err := findFinishedFileByID(id)
|
||
if err != nil {
|
||
http.Error(w, "preview nicht verfügbar", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
if err := ensureGeneratedDirs(); err != nil {
|
||
http.Error(w, "generated-dir nicht verfügbar: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
assetID := stripHotPrefix(id)
|
||
if assetID == "" {
|
||
assetID = id
|
||
}
|
||
|
||
assetDir, err := ensureGeneratedDir(assetID)
|
||
if err != nil {
|
||
http.Error(w, "generated-dir nicht verfügbar: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
if tStr := strings.TrimSpace(r.URL.Query().Get("t")); tStr != "" {
|
||
if sec, err := strconv.ParseFloat(tStr, 64); err == nil && sec >= 0 {
|
||
if sec < 0 {
|
||
sec = 0
|
||
}
|
||
|
||
img, err := extractFrameAtTimeJPG(outPath, sec)
|
||
if err == nil && len(img) > 0 {
|
||
servePreviewJPGBytes(w, img)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
thumbPath := filepath.Join(assetDir, "preview.jpg")
|
||
if fi, err := os.Stat(thumbPath); err == nil && !fi.IsDir() && fi.Size() > 0 {
|
||
servePreviewJPGFile(w, r, thumbPath)
|
||
return
|
||
}
|
||
|
||
// Wenn noch kein generiertes preview.jpg existiert, Provider-Fallbackbild liefern
|
||
if serveFallbackPreviewImage(w, r, nil, outPath) {
|
||
return
|
||
}
|
||
|
||
genCtx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
|
||
defer cancel()
|
||
|
||
// ✅ Immer letztes Frame bevorzugen
|
||
img, err := extractLastFrameJPG(outPath)
|
||
|
||
if err != nil || len(img) == 0 {
|
||
// Fallback: kurz vor Ende, falls Duration verfügbar
|
||
if dur, derr := durationSecondsCached(genCtx, outPath); derr == nil && dur > 0 {
|
||
t := dur - 0.25
|
||
if t < 0 {
|
||
t = 0
|
||
}
|
||
img, err = extractFrameAtTimeJPG(outPath, t)
|
||
}
|
||
|
||
// Letzter Fallback: erstes Frame
|
||
if err != nil || len(img) == 0 {
|
||
img, err = extractFirstFrameJPGScaled(outPath, 720, 75)
|
||
if err != nil || len(img) == 0 {
|
||
http.Error(w, "konnte preview nicht erzeugen", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
_ = atomicWriteFile(thumbPath, img)
|
||
servePreviewJPGBytes(w, img)
|
||
}
|