fix: improve media release quality ranking

Author: InuYashaYa

doc/auto-media-design.md

@@ -320,6 +320,8 @@ struct ReleaseInfo {
     resolution: Option<String>,
     codec: Option<String>,
     source: Option<String>,
+    hdr_formats: Vec<String>,
+    bit_depth: Option<u8>,
     revision: Option<String>,
     release_group: Option<String>,
     matched_rule: String,
@@ -333,7 +335,7 @@ struct ReleaseInfo {
 3. 动画字幕组 + 绝对集、绝对集范围。
 4. 季包/全集。
 5. 电影标题 + 年份。
-6. 独立质量、编码、来源和 revision 解析。
+6. 独立质量、编码、来源、HDR / Dolby Vision、位深和 revision 解析。
 
 范围展开必须限制最大长度，反向范围直接拒绝。数字标题如 `The 100`、`3x3 Eyes`、`Blade Runner 2049` 必须有专门回归测试。
 
@@ -372,15 +374,22 @@ struct ReleaseInfo {
 
 ```text
 accepted DESC,
-score DESC,
-quality_rank DESC,
+resolution_rank DESC,
+source_rank DESC,
+size_fitness DESC,
+video_feature_rank DESC,
+codec_rank DESC,
 seeders DESC,
+score DESC,
 publish_time DESC,
 site_priority ASC,
 stable_release_key ASC
 ```
 
-最后的稳定键保证不同网络返回顺序不会改变最佳资源。
+`size_fitness` 按媒体类型、分辨率、集数和编码效率计算 0..1000 的体积充足度，达到参考体积后封顶，
+避免把文件大小当成无限增益。只有 `size_fitness = 1000` 时才启用 `video_feature_rank`，依次区分
+Dolby Vision（带 HDR 回退优先）、HDR10+、HDR10、HLG / HDR 和 10bit。片长不可用时体积充足度只是软排序信号，
+不作为拒绝条件。最后的稳定键保证不同网络返回顺序不会改变最佳资源。
 
 ## 7. 搜索查询生成
 

doc/openapi.yaml

@@ -1307,7 +1307,7 @@ components:
 
     ReleaseInfo:
       type: object
-      required: [raw_title, title, alternate_titles, year, season, episodes, absolute_episodes, full_season, resolution, codec, source, revision, release_group, matched_rule]
+      required: [raw_title, title, alternate_titles, year, season, episodes, absolute_episodes, full_season, resolution, codec, source, hdr_formats, bit_depth, revision, release_group, matched_rule]
       properties:
         raw_title: {type: string}
         title: {type: string}
@@ -1320,6 +1320,10 @@ components:
         resolution: {type: string, nullable: true}
         codec: {type: string, nullable: true}
         source: {type: string, nullable: true}
+        hdr_formats:
+          type: array
+          items: {type: string, enum: [Dolby Vision, HDR10+, HDR10, HLG, HDR]}
+        bit_depth: {type: integer, format: int32, nullable: true, enum: [8, 10, 12]}
         revision: {type: string, nullable: true}
         release_group: {type: string, nullable: true}
         matched_rule: {type: string}
@@ -1358,11 +1362,22 @@ components:
 
     SortKey:
       type: object
-      required: [accepted, score, quality_rank, seeders, publish_time, site_priority, stable_release_key]
+      description: >-
+        Deterministic best-first key. Ordering is accepted, resolution, source, size
+        fitness, eligible video features, codec, seeders, score, publish time, site
+        priority, stable key. Video features rank as zero until size fitness reaches 1000.
+      required: [accepted, score, quality_rank, resolution_rank, video_feature_rank, source_rank, size_fitness, size_per_item, size_target, codec_rank, seeders, publish_time, site_priority, stable_release_key]
       properties:
         accepted: {type: boolean}
         score: {type: integer, format: int32, minimum: 0}
         quality_rank: {type: integer, format: int64, minimum: 0}
+        resolution_rank: {type: integer, format: int64, minimum: 0}
+        video_feature_rank: {type: integer, format: int32, minimum: 0}
+        source_rank: {type: integer, format: int64, minimum: 0}
+        size_fitness: {type: integer, format: int32, minimum: 0, maximum: 1000}
+        size_per_item: {type: integer, format: int64, minimum: 0}
+        size_target: {type: integer, format: int64, minimum: 1}
+        codec_rank: {type: integer, format: int64, minimum: 0}
         seeders: {type: integer, format: int32, minimum: 0}
         publish_time: {type: string, format: date-time, nullable: true}
         site_priority: {type: integer, format: int32, minimum: 0}

frontend/src/pages/media-page.tsx

@@ -248,6 +248,8 @@ type ReleaseInfo = {
   resolution: string | null;
   codec: string | null;
   source: string | null;
+  hdr_formats: string[];
+  bit_depth: number | null;
   revision: string | null;
   release_group: string | null;
   matched_rule: string;
@@ -268,13 +270,24 @@ type MatchDecision = {
   explanations: string[];
 };
 
+type CandidateSortKey = {
+  resolution_rank: number;
+  video_feature_rank: number;
+  source_rank: number;
+  size_fitness: number;
+  size_per_item: number;
+  size_target: number;
+  codec_rank: number;
+};
+
 type ResourceCandidate = {
   candidateId: string;
   key: string;
   result: IndexerResult;
   release: ReleaseInfo | null;
   parseError: string | null;
   decision: MatchDecision | null;
+  sortKey: CandidateSortKey | null;
   rank: number;
   raw: Record<string, unknown>;
 };
@@ -769,7 +782,15 @@ function compactEpisodeList(episodes: number[], prefix = ""): string {
 
 function releaseQualityFields(release: ReleaseInfo | null | undefined): string[] {
   if (!release) return [];
-  return [release.resolution, release.source, release.codec, release.revision, releaseScopeLabel(release)]
+  return [
+    release.resolution,
+    ...(release.hdr_formats ?? []),
+    release.bit_depth ? `${release.bit_depth}bit` : null,
+    release.source,
+    release.codec,
+    release.revision,
+    releaseScopeLabel(release),
+  ]
     .filter((field): field is string => Boolean(field));
 }
 
@@ -875,6 +896,8 @@ function normalizeCandidate(value: unknown, index: number): ResourceCandidate |
       resolution: optionalString(value.release.resolution),
       codec: optionalString(value.release.codec),
       source: optionalString(value.release.source),
+      hdr_formats: stringList(value.release.hdr_formats),
+      bit_depth: value.release.bit_depth == null ? null : numberValue(value.release.bit_depth),
       revision: optionalString(value.release.revision),
       release_group: optionalString(value.release.release_group),
       matched_rule: optionalString(value.release.matched_rule) ?? "unknown",
@@ -906,13 +929,27 @@ function normalizeCandidate(value: unknown, index: number): ResourceCandidate |
     };
   }
 
+  const sortKeyRaw = isRecord(value.sort_key) ? value.sort_key : null;
+  const sortKey: CandidateSortKey | null = sortKeyRaw
+    ? {
+        resolution_rank: numberValue(sortKeyRaw.resolution_rank),
+        video_feature_rank: numberValue(sortKeyRaw.video_feature_rank),
+        source_rank: numberValue(sortKeyRaw.source_rank),
+        size_fitness: numberValue(sortKeyRaw.size_fitness),
+        size_per_item: numberValue(sortKeyRaw.size_per_item),
+        size_target: numberValue(sortKeyRaw.size_target),
+        codec_rank: numberValue(sortKeyRaw.codec_rank),
+      }
+    : null;
+
   return {
     candidateId,
     key: candidateId,
     result,
     release,
     parseError: value.parse_error == null ? null : describeUnknown(value.parse_error),
     decision,
+    sortKey,
     rank: numberValue(value.rank, index + 1),
     raw: value,
   };
@@ -2151,7 +2188,7 @@ export function MediaPage() {
               <div className="min-w-0">
                 <div className="text-sm font-semibold">当前会优先寻找</div>
                 <div className="mt-2 flex flex-wrap gap-2"><TokenList values={[...splitValues(qualityForm.resolutionOrder).slice(0, 2), ...splitValues(qualityForm.sourceOrder).slice(0, 2), ...splitValues(qualityForm.codecOrder).slice(0, 1)]} /></div>
-                <p className="mt-2 text-xs leading-5 text-muted">原盘 / REMUX、DIY、HDR、杜比视界、杜比全景声、10bit 等特性仍会保留在资源标题中供你确认；当前自动筛选以分辨率、片源和视频编码为准。</p>
+                <p className="mt-2 text-xs leading-5 text-muted">自动排序依次比较分辨率、片源、体积充足度、杜比视界 / HDR / 位深、视频编码和做种数；只有体积达到参考线后才启用视频特性加成。</p>
               </div>
             </div>
           </div>
@@ -3374,7 +3411,7 @@ function candidateProcessingOutcome(
     return { label: "未下载", detail: `标题解析失败：${candidate.parseError}`, tone: "negative" };
   }
   if (candidate.decision?.accepted) {
-    return { label: "符合但未选", detail: "通过全部规则，但综合排序低于最终选择。", tone: "neutral" };
+    return { label: "符合但未选", detail: "通过全部规则，但在分辨率、片源、体积充足度、视频特性、编码或做种数的逐级排序中低于最终选择。", tone: "neutral" };
   }
   if (candidate.decision) {
     return {
@@ -3746,8 +3783,7 @@ function ReleaseSummary({ candidate }: { candidate: ResourceCandidate }) {
     return <div className="max-w-56 text-xs text-destructive">解析失败：{candidate.parseError}</div>;
   }
   if (!candidate.release) return <span className="text-xs text-muted">无解析数据</span>;
-  const episode = releaseScopeLabel(candidate.release);
-  const fields = [candidate.release.resolution, candidate.release.source, candidate.release.codec, episode].filter(Boolean);
+  const fields = releaseQualityFields(candidate.release);
   return (
     <div className="max-w-56 text-xs">
       <div className="flex flex-wrap gap-1.5">
@@ -3791,6 +3827,7 @@ function DecisionSummary({ candidate }: { candidate: ResourceCandidate }) {
       <div className="max-w-64 text-xs">
         <DecisionBadge candidate={candidate} />
         {breakdown ? <div className="mt-1.5 text-muted">{breakdown}</div> : null}
+        <CandidateRankingSummary candidate={candidate} />
       </div>
     );
   }
@@ -3804,6 +3841,26 @@ function DecisionSummary({ candidate }: { candidate: ResourceCandidate }) {
   );
 }
 
+function CandidateRankingSummary({ candidate }: { candidate: ResourceCandidate }) {
+  const sortKey = candidate.sortKey;
+  if (!sortKey || sortKey.size_target <= 0) return null;
+  const fitness = Math.max(0, Math.min(100, Math.floor(sortKey.size_fitness / 10)));
+  const normalized = sortKey.size_per_item === candidate.result.size ? "体积" : "单集体积";
+  const hasVideoFeatures = Boolean(candidate.release?.hdr_formats.length)
+    || (candidate.release?.bit_depth ?? 0) >= 10;
+  const featureStatus = hasVideoFeatures
+    ? ` · 视频特性加成${sortKey.video_feature_rank > 0 ? "已启用" : "未启用"}`
+    : "";
+  return (
+    <div
+      className="mt-1.5 text-muted"
+      title={`${normalized} ${formatBytes(sortKey.size_per_item)}，充足参考 ${formatBytes(sortKey.size_target)}`}
+    >
+      {normalized}充足度 {fitness}%{featureStatus} · {candidate.result.seeders} 做种
+    </div>
+  );
+}
+
 function decisionBreakdownLabel(name: string): string {
   const labels: Record<string, string> = {
     title: "标题",

src/media/domain/quality.rs

@@ -163,11 +163,23 @@ impl QualityProfile {
 
     #[allow(dead_code)]
     pub fn quality_rank(&self, release: &ReleaseInfo) -> u64 {
-        let resolution = preference_rank(&self.resolution_order, release.resolution.as_deref());
-        let source = preference_rank(&self.source_order, release.source.as_deref());
-        let codec = preference_rank(&self.codec_order, release.codec.as_deref());
+        combined_rank(
+            self.resolution_rank(release),
+            self.source_rank(release),
+            self.codec_rank(release),
+        )
+    }
+
+    pub fn resolution_rank(&self, release: &ReleaseInfo) -> u64 {
+        preference_rank(&self.resolution_order, release.resolution.as_deref())
+    }
+
+    pub fn source_rank(&self, release: &ReleaseInfo) -> u64 {
+        preference_rank(&self.source_order, release.source.as_deref())
+    }
 
-        combined_rank(resolution, source, codec)
+    pub fn codec_rank(&self, release: &ReleaseInfo) -> u64 {
+        preference_rank(&self.codec_order, release.codec.as_deref())
     }
 
     fn unknown_or_allowed(&self, release: &ReleaseInfo) -> QualityAssessment {
@@ -328,6 +340,8 @@ mod tests {
             resolution: resolution.map(str::to_owned),
             codec: codec.map(str::to_owned),
             source: source.map(str::to_owned),
+            hdr_formats: Vec::new(),
+            bit_depth: None,
             revision: None,
             release_group: None,
             matched_rule: "quality_only".into(),