优化

internal/service/adult_image_crop.go

@@ -7,8 +7,16 @@ import (
 	"image/jpeg"
 	_ "image/png" // register PNG decoder
 	"strings"
+
+	"github.com/metatube-community/metatube-sdk-go/detector"
 )
 
+const adultPosterRatio = 2.0 / 3.0
+
+var findPrimaryFaceAxisRatio = func(img image.Image, ratio float64, advanced bool) (float64, bool) {
+	return detector.FindPrimaryFaceAxisRatio(img, ratio, advanced)
+}
+
 // IsAdultMediaPathOrMetadata reports whether media is adult based on path, mediaType, nsfw flag, or adult code.
 func IsAdultMediaPathOrMetadata(path, mediaType string, nsfw bool) bool {
 	if nsfw {
@@ -38,7 +46,8 @@ func IsAdultArtworkURL(raw string) bool {
 }
 
 // CropAdultCoverPoster checks if the image data is a wide full-jacket DVD cover (width > height * 1.15).
-// If so, it crops the right portion (the front cover poster) and returns the encoded JPEG bytes.
+// If so, it uses MetaTube's Pigo face detector to position a 2:3 poster crop.
+// When no face is detected, it falls back to the conventional right-side front cover.
 // If the image is already portrait or cannot be decoded, it safely returns the original data.
 func CropAdultCoverPoster(data []byte) ([]byte, string, error) {
 	if len(data) == 0 {
@@ -59,32 +68,11 @@ func CropAdultCoverPoster(data []byte) ([]byte, string, error) {
 		return data, format, nil
 	}
 
-	// Front cover width is typically ~0.70-0.72 of the height (or right ~50-52% of total width)
-	cropWidth := int(float64(height) * 0.71)
-	maxCropWidth := int(float64(width) * 0.53)
-	if cropWidth > maxCropWidth {
-		cropWidth = maxCropWidth
-	}
-	if cropWidth <= 0 {
-		cropWidth = width / 2
-	}
-	minX := bounds.Max.X - cropWidth
-	if minX < bounds.Min.X {
-		minX = bounds.Min.X
-	}
-
-	cropRect := image.Rect(minX, bounds.Min.Y, bounds.Max.X, bounds.Max.Y)
-	type subImager interface {
-		SubImage(r image.Rectangle) image.Image
-	}
-	var cropped image.Image
-	if si, ok := src.(subImager); ok {
-		cropped = si.SubImage(cropRect)
-	} else {
-		dst := image.NewRGBA(image.Rect(0, 0, cropRect.Dx(), cropRect.Dy()))
-		draw.Draw(dst, dst.Bounds(), src, cropRect.Min, draw.Src)
-		cropped = dst
+	position := 1.0
+	if detected, ok := findPrimaryFaceAxisRatio(src, adultPosterRatio, true); ok {
+		position = detected
 	}
+	cropped := cropImageAtPosition(src, adultPosterRatio, position)
 
 	var buf bytes.Buffer
 	if err := jpeg.Encode(&buf, cropped, &jpeg.Options{Quality: 92}); err != nil {
@@ -92,3 +80,29 @@ func CropAdultCoverPoster(data []byte) ([]byte, string, error) {
 	}
 	return buf.Bytes(), "image/jpeg", nil
 }
+
+func cropImageAtPosition(src image.Image, ratio, position float64) image.Image {
+	bounds := src.Bounds()
+	width := bounds.Dx()
+	height := bounds.Dy()
+	cropWidth, cropHeight := width, height
+	x, y := 0, 0
+	if candidate := int(float64(height) * ratio); candidate < width {
+		cropWidth = candidate
+		x = max(min(int(float64(width)*position)-cropWidth/2, width-cropWidth), 0)
+	} else if candidate := int(float64(width) / ratio); candidate < height {
+		cropHeight = candidate
+		y = max(min(int(float64(height)*position)-cropHeight/2, height-cropHeight), 0)
+	}
+	cropRect := image.Rect(0, 0, cropWidth, cropHeight).
+		Add(image.Pt(x, y)).
+		Add(bounds.Min)
+	if sub, ok := src.(interface {
+		SubImage(image.Rectangle) image.Image
+	}); ok {
+		return sub.SubImage(cropRect)
+	}
+	dst := image.NewRGBA(image.Rect(0, 0, cropRect.Dx(), cropRect.Dy()))
+	draw.Draw(dst, dst.Bounds(), src, cropRect.Min, draw.Src)
+	return dst
+}

internal/service/adult_image_crop_test.go

@@ -44,10 +44,10 @@ func TestCropAdultCoverPosterWideLandscape(t *testing.T) {
 	if croppedWidth <= 0 || croppedWidth >= 800 {
 		t.Fatalf("unexpected cropped width: %d", croppedWidth)
 	}
-	// Verify aspect ratio is roughly standard portrait (~0.68 - 0.73)
+	// MetaTube's default primary-image ratio is 2:3.
 	ratio := float64(croppedWidth) / float64(croppedHeight)
-	if ratio < 0.65 || ratio > 0.75 {
-		t.Fatalf("expected portrait ratio ~0.71, got %f (%dx%d)", ratio, croppedWidth, croppedHeight)
+	if ratio < 0.65 || ratio > 0.68 {
+		t.Fatalf("expected portrait ratio ~0.667, got %f (%dx%d)", ratio, croppedWidth, croppedHeight)
 	}
 
 	// Verify the cropped image contains the right side color (blue), not the left side color (red)
@@ -58,6 +58,30 @@ func TestCropAdultCoverPosterWideLandscape(t *testing.T) {
 	}
 }
 
+func TestCropAdultCoverPosterCentersDetectedFace(t *testing.T) {
+	originalDetector := findPrimaryFaceAxisRatio
+	findPrimaryFaceAxisRatio = func(image.Image, float64, bool) (float64, bool) {
+		return 0.25, true
+	}
+	defer func() {
+		findPrimaryFaceAxisRatio = originalDetector
+	}()
+
+	origBytes := createTestImage(900, 600, color.RGBA{R: 255, A: 255}, color.RGBA{B: 255, A: 255})
+	croppedBytes, _, err := CropAdultCoverPoster(origBytes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	croppedImg, _, err := image.Decode(bytes.NewReader(croppedBytes))
+	if err != nil {
+		t.Fatal(err)
+	}
+	r, _, b, _ := croppedImg.At(croppedImg.Bounds().Dx()/2, croppedImg.Bounds().Dy()/2).RGBA()
+	if r <= b {
+		t.Fatalf("face-positioned crop did not follow detected left-side axis: r=%d b=%d", r, b)
+	}
+}
+
 func TestCropAdultCoverPosterKeepsPortrait(t *testing.T) {
 	// Create an already vertical portrait image (500x700)
 	origBytes := createTestImage(500, 700, color.RGBA{R: 255, A: 255}, color.RGBA{B: 255, A: 255})

internal/service/adult_scraper.go

@@ -290,12 +290,46 @@ func (p *AdultProvider) searchBuiltin(ctx context.Context, code string) (*Match,
 			match.OriginalName = code
 			match.Title = FormatAdultTitle(code, match.Title)
 			match.NSFW = true
+			p.applyMetaTubeFaceAwareArtwork(ctx, code, match)
 			return match, nil
 		}
 	}
 	return nil, lastErr
 }
 
+func (p *AdultProvider) applyMetaTubeFaceAwareArtwork(ctx context.Context, code string, match *Match) {
+	if p == nil || p.metatube == nil || match == nil || strings.TrimSpace(match.PosterURL) == "" {
+		return
+	}
+	// In explicit built-in mode MetaTube remains useful as an image processor:
+	// its primary endpoint performs the same automatic face-aware crop used by
+	// the official Jellyfin plugin. Auto mode already tried MetaTube metadata,
+	// so avoid repeating the same failed request during fallback.
+	if strings.ToLower(p.getSetting(ctx, "adult.scraper.engine", "builtin")) != "builtin" {
+		return
+	}
+	cfg := p.ResolveMetaTubeConfig(ctx)
+	if cfg.ServerURL == "" || !cfg.CropCover {
+		return
+	}
+	candidates, err := p.metatube.Search(ctx, cfg, code)
+	if err != nil {
+		return
+	}
+	for _, candidate := range candidates {
+		if candidate == nil || normalizeAdultCode(candidate.OriginalName) != code {
+			continue
+		}
+		if candidate.PosterURL != "" {
+			match.PosterURL = candidate.PosterURL
+		}
+		if candidate.BackdropURL != "" {
+			match.BackdropURL = candidate.BackdropURL
+		}
+		return
+	}
+}
+
 func (p *AdultProvider) resolveBases(ctx context.Context) []string {
 	customJavDB := p.getSetting(ctx, "adult.scraper.builtin_javdb_url", "")
 	customJavBus := p.getSetting(ctx, "adult.scraper.builtin_javbus_url", "")

internal/service/adult_scraper_routing_test.go

@@ -96,7 +96,7 @@ func TestAdultProviderRouting(t *testing.T) {
 	if len(candidates) != 1 {
 		t.Fatalf("expected 1 candidate, got %d", len(candidates))
 	}
-	wantPoster := mtServer.URL + "/v1/images/primary/javdb/999?auto=false&pos=-1&quality=90&ratio=0.6666666666666666"
+	wantPoster := mtServer.URL + "/v1/images/primary/javdb/999?auto=true&pos=1&quality=90&ratio=-1&url=https%3A%2F%2Fexample.com%2Fposter.jpg"
 	wantBackdrop := mtServer.URL + "/v1/images/backdrop/javdb/999?quality=90"
 	if candidates[0].PosterURL != wantPoster || candidates[0].BackdropURL != wantBackdrop {
 		t.Fatalf("candidate artwork was not enriched: %#v", candidates[0])
@@ -110,3 +110,68 @@ func TestAdultProviderRouting(t *testing.T) {
 		t.Errorf("expected nil for nonexistent in auto mode when sources unavailable")
 	}
 }
+
+func TestBuiltinAdultScrapeUsesMetaTubeFaceAwareArtwork(t *testing.T) {
+	builtinServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/search":
+			_, _ = w.Write([]byte(`<a class="box" href="/v/local"><strong>SSIS-001 本地候选</strong></a>`))
+		case "/v/local":
+			_, _ = w.Write([]byte(`<h2>SSIS-001 本地标题</h2><img class="video-cover" src="/wide-cover.jpg">`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer builtinServer.Close()
+
+	metaTubeServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/movies/search" || r.URL.Query().Get("q") != "SSIS-001" {
+			http.NotFound(w, r)
+			return
+		}
+		_ = json.NewEncoder(w).Encode(struct {
+			Data []MetaTubeSearchResult `json:"data"`
+		}{
+			Data: []MetaTubeSearchResult{{
+				ID:       "999",
+				Number:   "SSIS-001",
+				Title:    "MetaTube candidate",
+				Provider: "AVE",
+				CoverURL: "https://example.com/wide-cover.jpg",
+			}},
+		})
+	}))
+	defer metaTubeServer.Close()
+
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(&model.Setting{}, &model.APIConfig{}); err != nil {
+		t.Fatal(err)
+	}
+	repos := repository.New(db)
+	for key, value := range map[string]string{
+		"adult.scraper.engine":            "builtin",
+		"adult.scraper.builtin_javdb_url": builtinServer.URL,
+		"adult.scraper.metatube_server":   metaTubeServer.URL,
+		"adult.scraper.crop_cover":        "true",
+	} {
+		if err := repos.Setting.Set(t.Context(), key, value); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	provider := NewAdultProvider(zap.NewNop(), nil, repos)
+	match, err := provider.Search(t.Context(), "SSIS-001")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if match == nil {
+		t.Fatal("expected built-in match")
+	}
+	wantPoster := metaTubeServer.URL + "/v1/images/primary/AVE/999?auto=true&pos=1&quality=90&ratio=-1&url=https%3A%2F%2Fexample.com%2Fwide-cover.jpg"
+	if match.PosterURL != wantPoster {
+		t.Fatalf("built-in poster = %q, want face-aware URL %q", match.PosterURL, wantPoster)
+	}
+}

internal/service/manual_scrape_test.go

@@ -93,7 +93,7 @@ func TestManualAdultMatchUsesSelectedMetaTubeDetailsAndRealBackdrop(t *testing.T
 	if detailCalls.Load() != 1 {
 		t.Fatalf("selected MetaTube detail calls = %d, want 1", detailCalls.Load())
 	}
-	wantPoster := upstream.URL + "/v1/images/primary/AVE/94600?auto=false&pos=-1&quality=90&ratio=0.6666666666666666"
+	wantPoster := upstream.URL + "/v1/images/primary/AVE/94600?auto=true&pos=1&quality=90&ratio=-1&url=https%3A%2F%2Fexample.com%2Fposter.jpg"
 	if match.PosterURL != wantPoster {
 		t.Fatalf("selected poster = %q, want %q", match.PosterURL, wantPoster)
 	}

internal/service/metatube.go

@@ -300,7 +300,8 @@ func (p *MetaTubeProvider) convertSearchResultToMatch(cfg MetaTubeConfig, query
 		}
 	}
 
-	posterURL, backdropURL := metaTubeArtworkURLs(cfg, res.Provider, res.ID)
+	posterSource := firstNonEmpty(res.BigCoverURL, res.CoverURL, res.BigThumbURL, res.ThumbURL)
+	posterURL, backdropURL := metaTubeArtworkURLs(cfg, res.Provider, res.ID, posterSource)
 	if posterURL == "" {
 		posterURL = firstNonEmpty(res.BigThumbURL, res.ThumbURL, res.BigCoverURL, res.CoverURL)
 	}
@@ -342,7 +343,8 @@ func (p *MetaTubeProvider) convertMovieInfoToMatch(cfg MetaTubeConfig, movie *Me
 
 	year := parseYearFromDate(movie.ReleaseDate)
 
-	posterURL, backdropURL := metaTubeArtworkURLs(cfg, movie.Provider, movie.ID)
+	posterSource := firstNonEmpty(movie.BigCoverURL, movie.CoverURL, movie.BigThumbURL, movie.ThumbURL)
+	posterURL, backdropURL := metaTubeArtworkURLs(cfg, movie.Provider, movie.ID, posterSource)
 	if posterURL == "" {
 		posterURL = firstNonEmpty(movie.BigThumbURL, movie.ThumbURL, movie.BigCoverURL, movie.CoverURL)
 	}
@@ -397,7 +399,7 @@ func (p *MetaTubeProvider) convertMovieInfoToMatch(cfg MetaTubeConfig, movie *Me
 	}
 }
 
-func metaTubeArtworkURLs(cfg MetaTubeConfig, provider, id string) (string, string) {
+func metaTubeArtworkURLs(cfg MetaTubeConfig, provider, id, posterSource string) (string, string) {
 	serverURL := strings.TrimRight(strings.TrimSpace(cfg.ServerURL), "/")
 	provider = strings.TrimSpace(provider)
 	id = strings.TrimSpace(id)
@@ -410,12 +412,16 @@ func metaTubeArtworkURLs(cfg MetaTubeConfig, provider, id string) (string, strin
 		values := url.Values{}
 		values.Set("quality", "90")
 		if primary {
-			values.Set("pos", "-1")
-			values.Set("auto", "false")
+			values.Set("ratio", "-1")
+			if strings.TrimSpace(posterSource) != "" {
+				values.Set("url", strings.TrimSpace(posterSource))
+			}
 			if cfg.CropCover {
-				values.Set("ratio", strconv.FormatFloat(2.0/3.0, 'f', -1, 64))
+				values.Set("pos", "1")
+				values.Set("auto", "true")
 			} else {
-				values.Set("ratio", "-1")
+				values.Set("pos", "-1")
+				values.Set("auto", "false")
 			}
 		}
 		return base + "?" + values.Encode()

internal/service/metatube_test.go

@@ -74,7 +74,7 @@ func TestMetaTubeProviderSearch(t *testing.T) {
 	if len(m.Genres) != 1 || m.Genres[0] != "相沢みなみ" {
 		t.Errorf("unexpected genres: %v", m.Genres)
 	}
-	if want := server.URL + "/v1/images/primary/javdb/123456?auto=false&pos=-1&quality=90&ratio=-1"; m.PosterURL != want {
+	if want := server.URL + "/v1/images/primary/javdb/123456?auto=false&pos=-1&quality=90&ratio=-1&url=https%3A%2F%2Fexample.com%2Fcover.jpg"; m.PosterURL != want {
 		t.Errorf("poster URL = %q, want %q", m.PosterURL, want)
 	}
 	if want := server.URL + "/v1/images/backdrop/javdb/123456?quality=90"; m.BackdropURL != want {
@@ -131,7 +131,7 @@ func TestMetaTubeProviderGetMovie(t *testing.T) {
 	if match.Overview != "超绝美少女相沢みなみ出道作品！" {
 		t.Errorf("unexpected overview: %s", match.Overview)
 	}
-	if want := server.URL + "/v1/images/primary/javdb/123456?auto=false&pos=-1&quality=90&ratio=0.6666666666666666"; match.PosterURL != want {
+	if want := server.URL + "/v1/images/primary/javdb/123456?auto=true&pos=1&quality=90&ratio=-1&url=https%3A%2F%2Fexample.com%2Fbig_cover.jpg"; match.PosterURL != want {
 		t.Errorf("poster URL = %q, want %q", match.PosterURL, want)
 	}
 	if want := server.URL + "/v1/images/backdrop/javdb/123456?quality=90"; match.BackdropURL != want {

internal/service/scraper_write_metadata_files.go

@@ -45,19 +45,32 @@ func (s *ScraperService) writeMediaArtworkFilesAfterScrape(ctx context.Context,
 		return
 	}
 	isAdult := shouldCropAdultPoster(refreshed, lib)
+	artworkUpdates := map[string]any{}
 	if refreshed.PosterURL != "" {
-		s.downloadArtworkToPathWithOptions(ctx, dir, base+"-poster", refreshed.PosterURL, isAdult)
+		if dst := s.downloadArtworkToPathWithOptions(ctx, dir, base+"-poster", refreshed.PosterURL, isAdult); dst != "" {
+			artworkUpdates["poster_url"] = filepath.Join(filepath.Dir(refreshed.Path), filepath.Base(dst))
+		}
 	}
 	if refreshed.BackdropURL != "" {
-		s.downloadArtworkToPathWithOptions(ctx, dir, base+"-backdrop", refreshed.BackdropURL, false)
+		if dst := s.downloadArtworkToPathWithOptions(ctx, dir, base+"-backdrop", refreshed.BackdropURL, false); dst != "" {
+			artworkUpdates["backdrop_url"] = filepath.Join(filepath.Dir(refreshed.Path), filepath.Base(dst))
+		}
 	} else if isAdult && refreshed.PosterURL != "" {
 		// 番号海报原图为完整封套横图，在无独立背景图时直接作为背景图写出
-		s.downloadArtworkToPathWithOptions(ctx, dir, base+"-backdrop", refreshed.PosterURL, false)
+		if dst := s.downloadArtworkToPathWithOptions(ctx, dir, base+"-backdrop", refreshed.PosterURL, false); dst != "" {
+			artworkUpdates["backdrop_url"] = filepath.Join(filepath.Dir(refreshed.Path), filepath.Base(dst))
+		}
+	}
+	if len(artworkUpdates) > 0 {
+		if err := s.repo.DB.WithContext(ctx).Model(&model.Media{}).
+			Where("id = ?", refreshed.ID).Updates(artworkUpdates).Error; err != nil {
+			s.log.Warn("save local scraped artwork paths failed", zap.String("media_id", refreshed.ID), zap.Error(err))
+		}
 	}
 }
 
-func (s *ScraperService) downloadArtworkToPath(ctx context.Context, dir, name, raw string) {
-	s.downloadArtworkToPathWithOptions(ctx, dir, name, raw, false)
+func (s *ScraperService) downloadArtworkToPath(ctx context.Context, dir, name, raw string) string {
+	return s.downloadArtworkToPathWithOptions(ctx, dir, name, raw, false)
 }
 
 // shouldCropAdultPoster keeps adult-cover handling independent of which
@@ -77,9 +90,9 @@ func shouldCropAdultPoster(media *model.Media, lib *model.Library) bool {
 
 // downloadArtworkToPathWithOptions fetches an artwork URL via the image proxy cache and
 // writes it under dir/<name>.<ext>. For adult posters, it crops the right half of the cover.
-func (s *ScraperService) downloadArtworkToPathWithOptions(ctx context.Context, dir, name, raw string, cropAdultPoster bool) {
+func (s *ScraperService) downloadArtworkToPathWithOptions(ctx context.Context, dir, name, raw string, cropAdultPoster bool) string {
 	if !isHTTPish(raw) {
-		return
+		return ""
 	}
 	data, ctype, err := s.images.Fetch(ctx, raw)
 	if err != nil || len(data) == 0 {
@@ -87,10 +100,10 @@ func (s *ScraperService) downloadArtworkToPathWithOptions(ctx context.Context, d
 			zap.String("name", name),
 			zap.String("url", raw),
 			zap.Error(err))
-		return
+		return ""
 	}
 	if !isImageContentType(ctype) || isTransparentPlaceholderData(data) {
-		return
+		return ""
 	}
 	if cropAdultPoster {
 		if cropped, croppedType, err := CropAdultCoverPoster(data); err == nil && len(cropped) > 0 {
@@ -98,7 +111,7 @@ func (s *ScraperService) downloadArtworkToPathWithOptions(ctx context.Context, d
 			ctype = croppedType
 		}
 	}
-	s.writeArtworkDataToPath(dir, name, ctype, data)
+	return s.writeArtworkDataToPath(dir, name, ctype, data)
 }
 
 // writeArtworkDataToPath writes in-memory artwork bytes to dir/<name>.<ext>

internal/service/scraper_write_metadata_files_test.go

@@ -1,13 +1,22 @@
 package service
 
 import (
+	"bytes"
+	"image"
+	"image/color"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/glebarez/sqlite"
 	"go.uber.org/zap"
+	"gorm.io/gorm"
 
+	"github.com/truewhile/MeBox/internal/config"
 	"github.com/truewhile/MeBox/internal/model"
+	"github.com/truewhile/MeBox/internal/repository"
 )
 
 // TestWriteArtworkDataToPathWritesJellyfinSidecar verifies that in-memory
@@ -128,3 +137,65 @@ func TestSameDirectoryMediaUsesBaseScopedSidecars(t *testing.T) {
 		t.Fatalf("base = %q, want A-poster.jpg", filepath.Base(dst))
 	}
 }
+
+func TestLocalAdultArtworkStoresFaceAwarePosterPath(t *testing.T) {
+	wideCover := createTestImage(
+		900,
+		600,
+		color.RGBA{R: 255, A: 255},
+		color.RGBA{B: 255, A: 255},
+	)
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "image/jpeg")
+		_, _ = w.Write(wideCover)
+	}))
+	defer upstream.Close()
+
+	cfg := &config.Config{}
+	cfg.Cache.CacheDir = t.TempDir()
+	images := NewImageProxy(cfg, zap.NewNop())
+	images.allowedRemoteHostsFn = func() []string { return []string{"127.0.0.1"} }
+
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(&model.Media{}); err != nil {
+		t.Fatal(err)
+	}
+	repos := repository.New(db)
+	mediaDir := t.TempDir()
+	media := model.Media{
+		Title:        "IPX-235",
+		Path:         filepath.Join(mediaDir, "IPX-235.mp4"),
+		PosterURL:    upstream.URL + "/cover.jpg",
+		NSFW:         true,
+		ScrapeStatus: "matched",
+	}
+	if err := repos.DB.Create(&media).Error; err != nil {
+		t.Fatal(err)
+	}
+
+	scraper := &ScraperService{cfg: cfg, log: zap.NewNop(), repo: repos, images: images}
+	scraper.writeMediaArtworkFilesAfterScrape(t.Context(), &media, &model.Library{Type: "adult"})
+
+	var got model.Media
+	if err := repos.DB.First(&got, "id = ?", media.ID).Error; err != nil {
+		t.Fatal(err)
+	}
+	if filepath.Base(got.PosterURL) != "IPX-235-poster.jpg" {
+		t.Fatalf("poster URL = %q, want local face-aware sidecar", got.PosterURL)
+	}
+	data, err := os.ReadFile(got.PosterURL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cropped, _, err := image.Decode(bytes.NewReader(data))
+	if err != nil {
+		t.Fatal(err)
+	}
+	ratio := float64(cropped.Bounds().Dx()) / float64(cropped.Bounds().Dy())
+	if ratio < 0.65 || ratio > 0.68 {
+		t.Fatalf("local poster ratio = %.3f, want MetaTube primary ratio", ratio)
+	}
+}