-
Kodierung
- {canResumeReady ? (
-
-
- ) : null}
- {typeof onRestartEncode === 'function' ? (
-
-
- ) : null}
- {typeof onRestartReview === 'function' ? (
-
-
- ) : null}
-
-
+ ) : null
)}
- {!isCd && !isAudiobook && typeof onAssignOmdb === 'function' ? (
+ {!isCd && !isAudiobook && !isConverter && typeof onAssignOmdb === 'function' ? (
Metadaten
@@ -1389,47 +1646,49 @@ export default function JobDetailDialog({
) : null}
-
-
Dateien löschen
-
-
+ ) : null}
)}
diff --git a/frontend/src/components/MediaInfoReviewPanel.jsx b/frontend/src/components/MediaInfoReviewPanel.jsx
index fa5b8d0..c0166c7 100644
--- a/frontend/src/components/MediaInfoReviewPanel.jsx
+++ b/frontend/src/components/MediaInfoReviewPanel.jsx
@@ -65,21 +65,246 @@ function isBurnedSubtitleTrack(track) {
);
}
-function isForcedOnlySubtitleTrack(track) {
- const summary = `${track?.title || ''} ${track?.description || ''} ${track?.languageLabel || ''}`.toLowerCase();
- return Boolean(
- track?.forcedTrack
- || /forced only/.test(summary)
- || /nur erzwungen/.test(summary)
- || /\berzwungen\b/.test(summary)
- );
+function isDuplicateSubtitleTrack(track) {
+ return Boolean(track?.duplicate);
}
-function hasForcedSubtitleAvailable(track) {
- const sourceTrackIds = normalizeTrackIdList(
- Array.isArray(track?.forcedSourceTrackIds) ? track.forcedSourceTrackIds : []
+function normalizeTrackIdSequence(values, options = {}) {
+ const list = Array.isArray(values) ? values : [];
+ const dedupe = options?.dedupe !== false;
+ const seen = new Set();
+ const output = [];
+ for (const value of list) {
+ const normalized = normalizeTrackId(value);
+ if (normalized === null) {
+ continue;
+ }
+ const key = String(normalized);
+ if (dedupe && seen.has(key)) {
+ continue;
+ }
+ if (dedupe) {
+ seen.add(key);
+ }
+ output.push(normalized);
+ }
+ return output;
+}
+
+function normalizeSubtitleLanguage(value) {
+ const raw = String(value || '').trim().toLowerCase();
+ if (!raw) {
+ return 'und';
+ }
+ if (raw.length >= 3) {
+ return raw.slice(0, 3);
+ }
+ return raw;
+}
+
+function normalizeSubtitleLanguageOrder(rawOrder = []) {
+ const list = Array.isArray(rawOrder) ? rawOrder : [];
+ const seen = new Set();
+ const output = [];
+ for (const item of list) {
+ const language = normalizeSubtitleLanguage(item);
+ if (!language || seen.has(language)) {
+ continue;
+ }
+ seen.add(language);
+ output.push(language);
+ }
+ return output;
+}
+
+function normalizeSubtitleVariantSelectionMap(rawSelection) {
+ const map = {};
+ if (!rawSelection || typeof rawSelection !== 'object') {
+ return map;
+ }
+ for (const [language, value] of Object.entries(rawSelection)) {
+ const normalizedLanguage = normalizeSubtitleLanguage(language);
+ map[normalizedLanguage] = {
+ full: Boolean(value?.full),
+ forced: Boolean(value?.forced)
+ };
+ }
+ return map;
+}
+
+function normalizeSubtitleConfidenceValue(value) {
+ const raw = String(value || '').trim().toLowerCase();
+ if (raw === 'high' || raw === 'medium' || raw === 'low') {
+ return raw;
+ }
+ return 'low';
+}
+
+function subtitleConfidenceScore(value) {
+ const normalized = normalizeSubtitleConfidenceValue(value);
+ if (normalized === 'high') {
+ return 3;
+ }
+ if (normalized === 'medium') {
+ return 2;
+ }
+ return 1;
+}
+
+function resolveSubtitleTrackVariantFlags(track) {
+ const subtitleType = String(track?.subtitleType || '').trim().toLowerCase();
+ const isForcedOnly = Boolean(
+ track?.isForcedOnly
+ ?? track?.subtitlePreviewForcedOnly
+ ?? track?.forcedOnly
+ ?? subtitleType === 'forced'
);
- return Boolean(track?.forcedAvailable || sourceTrackIds.length > 0);
+ const fullHasForced = !isForcedOnly && Boolean(
+ track?.fullHasForced
+ ?? track?.subtitleFullHasForced
+ ?? track?.hasForcedVariant
+ );
+ return { isForcedOnly, fullHasForced };
+}
+
+function compareForcedSubtitleCandidate(a, b) {
+ const defaultDiff = Number(Boolean(b?.defaultFlag)) - Number(Boolean(a?.defaultFlag));
+ if (defaultDiff !== 0) {
+ return defaultDiff;
+ }
+ const confidenceDiff = subtitleConfidenceScore(b?.confidence) - subtitleConfidenceScore(a?.confidence);
+ if (confidenceDiff !== 0) {
+ return confidenceDiff;
+ }
+ if (a.id !== b.id) {
+ return a.id - b.id;
+ }
+ return a.originalIndex - b.originalIndex;
+}
+
+function compareFullSubtitleCandidate(a, b) {
+ const defaultDiff = Number(Boolean(b?.defaultFlag)) - Number(Boolean(a?.defaultFlag));
+ if (defaultDiff !== 0) {
+ return defaultDiff;
+ }
+ if (a.id !== b.id) {
+ return a.id - b.id;
+ }
+ return a.originalIndex - b.originalIndex;
+}
+
+function resolveDeterministicSubtitleCliSelectionForPreview({
+ subtitleTracks,
+ subtitleVariantSelection,
+ subtitleLanguageOrder
+}) {
+ const tracks = (Array.isArray(subtitleTracks) ? subtitleTracks : [])
+ .map((track, index) => {
+ const id = normalizeTrackId(track?.id ?? track?.sourceTrackId);
+ if (id === null) {
+ return null;
+ }
+ if (isBurnedSubtitleTrack(track) || isDuplicateSubtitleTrack(track)) {
+ return null;
+ }
+ const flags = resolveSubtitleTrackVariantFlags(track);
+ return {
+ id,
+ language: normalizeSubtitleLanguage(track?.language || track?.languageLabel || 'und'),
+ isForcedOnly: flags.isForcedOnly,
+ fullHasForced: flags.fullHasForced,
+ defaultFlag: Boolean(track?.defaultFlag ?? track?.subtitlePreviewDefaultTrack ?? track?.defaultTrack),
+ confidence: normalizeSubtitleConfidenceValue(track?.sourceConfidence || track?.confidence),
+ selectedForEncode: Boolean(track?.selectedForEncode),
+ originalIndex: index
+ };
+ })
+ .filter(Boolean);
+
+ const grouped = new Map();
+ for (const track of tracks) {
+ if (!grouped.has(track.language)) {
+ grouped.set(track.language, []);
+ }
+ grouped.get(track.language).push(track);
+ }
+
+ const normalizedVariantSelection = normalizeSubtitleVariantSelectionMap(subtitleVariantSelection || {});
+ const hasExplicitVariantSelection = Object.keys(normalizedVariantSelection).length > 0;
+ const normalizedLanguageOrder = normalizeSubtitleLanguageOrder(subtitleLanguageOrder || []);
+ const sortedLanguages = Array.from(grouped.entries())
+ .map(([language, languageTracks]) => ({
+ language,
+ minId: languageTracks.reduce((minValue, track) => Math.min(minValue, track.id), Number.MAX_SAFE_INTEGER)
+ }))
+ .sort((a, b) => a.minId - b.minId || a.language.localeCompare(b.language))
+ .map((item) => item.language);
+
+ const order = [];
+ const seen = new Set();
+ const pushLanguage = (language) => {
+ if (!grouped.has(language) || seen.has(language)) {
+ return;
+ }
+ seen.add(language);
+ order.push(language);
+ };
+ normalizedLanguageOrder.forEach(pushLanguage);
+ sortedLanguages.forEach(pushLanguage);
+
+ const subtitleTrackIds = [];
+ const subtitleForcedTrackIndexes = [];
+ for (const language of order) {
+ const languageTracks = grouped.get(language) || [];
+ const forcedOnly = languageTracks.filter((track) => track.isForcedOnly).sort(compareForcedSubtitleCandidate)[0] || null;
+ const fullTracks = languageTracks.filter((track) => !track.isForcedOnly).sort(compareFullSubtitleCandidate);
+ const bestFull = fullTracks[0] || null;
+ const bestFullHasForced = fullTracks.filter((track) => track.fullHasForced).sort(compareFullSubtitleCandidate)[0] || null;
+
+ const explicit = normalizedVariantSelection[language] || null;
+ const fallbackFull = languageTracks.some((track) => track.selectedForEncode && !track.isForcedOnly) || Boolean(bestFull);
+ const fallbackForced = languageTracks.some((track) => track.selectedForEncode && track.isForcedOnly) || Boolean(forcedOnly);
+ const requestedFull = explicit
+ ? Boolean(explicit.full)
+ : (hasExplicitVariantSelection ? false : fallbackFull);
+ const requestedForced = explicit
+ ? Boolean(explicit.forced)
+ : (hasExplicitVariantSelection ? false : fallbackForced);
+ if (!requestedFull && !requestedForced) {
+ continue;
+ }
+
+ if (forcedOnly) {
+ subtitleTrackIds.push(forcedOnly.id);
+ if (requestedFull && bestFull) {
+ subtitleTrackIds.push(bestFull.id);
+ }
+ continue;
+ }
+
+ if (bestFullHasForced) {
+ if (requestedFull && requestedForced) {
+ subtitleTrackIds.push(bestFullHasForced.id);
+ subtitleTrackIds.push(bestFullHasForced.id);
+ subtitleForcedTrackIndexes.push(subtitleTrackIds.length);
+ } else if (requestedForced) {
+ subtitleTrackIds.push(bestFullHasForced.id);
+ subtitleForcedTrackIndexes.push(subtitleTrackIds.length);
+ } else if (requestedFull) {
+ subtitleTrackIds.push(bestFullHasForced.id);
+ }
+ continue;
+ }
+
+ if (requestedFull && bestFull) {
+ subtitleTrackIds.push(bestFull.id);
+ }
+ }
+
+ return {
+ subtitleTrackIds,
+ subtitleForcedTrackIndexes
+ };
}
function splitArgs(input) {
@@ -191,6 +416,8 @@ function buildHandBrakeCommandPreview({
title,
selectedAudioTrackIds,
selectedSubtitleTrackIds,
+ selectedSubtitleVariantSelection = {},
+ selectedSubtitleLanguageOrder = [],
commandOutputPath = null,
presetOverride = null
}) {
@@ -211,7 +438,19 @@ function buildHandBrakeCommandPreview({
? Math.trunc(rawMappedTitleId)
: null;
- const selectedSubtitleSet = new Set(normalizeTrackIdList(selectedSubtitleTrackIds).map((id) => String(id)));
+ const resolvedSubtitleSelection = resolveDeterministicSubtitleCliSelectionForPreview({
+ subtitleTracks: Array.isArray(title?.subtitleTracks) ? title.subtitleTracks : [],
+ subtitleVariantSelection: selectedSubtitleVariantSelection,
+ subtitleLanguageOrder: selectedSubtitleLanguageOrder
+ });
+ const normalizedSelectedVariantSelection = normalizeSubtitleVariantSelectionMap(selectedSubtitleVariantSelection || {});
+ const hasExplicitSelectedVariantSelection = Object.keys(normalizedSelectedVariantSelection).length > 0;
+ const subtitleTrackIds = resolvedSubtitleSelection.subtitleTrackIds.length > 0
+ ? resolvedSubtitleSelection.subtitleTrackIds
+ : (hasExplicitSelectedVariantSelection
+ ? []
+ : normalizeTrackIdSequence(selectedSubtitleTrackIds, { dedupe: false }));
+ const selectedSubtitleSet = new Set(normalizeTrackIdList(subtitleTrackIds).map((id) => String(id)));
const selectedSubtitleTracks = (Array.isArray(title?.subtitleTracks) ? title.subtitleTracks : []).filter((track) => {
const id = normalizeTrackId(track?.id);
return id !== null && selectedSubtitleSet.has(String(id));
@@ -223,10 +462,6 @@ function buildHandBrakeCommandPreview({
const subtitleDefaultTrackId = normalizeTrackIdList(
selectedSubtitleTracks.filter((track) => Boolean(track?.subtitlePreviewDefaultTrack || track?.defaultTrack)).map((track) => track?.id)
)[0] || null;
- const subtitleForcedTrackId = normalizeTrackIdList(
- selectedSubtitleTracks.filter((track) => Boolean(track?.subtitlePreviewForced || track?.forced)).map((track) => track?.id)
- )[0] || null;
- const subtitleForcedOnly = selectedSubtitleTracks.some((track) => Boolean(track?.subtitlePreviewForcedOnly || track?.forcedOnly));
const baseArgs = [
'-i',
@@ -248,7 +483,7 @@ function buildHandBrakeCommandPreview({
'-a',
normalizeTrackIdList(selectedAudioTrackIds).join(',') || 'none',
'-s',
- normalizeTrackIdList(selectedSubtitleTrackIds).join(',') || 'none'
+ subtitleTrackIds.length > 0 ? subtitleTrackIds.join(',') : 'none'
];
if (subtitleBurnTrackId !== null) {
@@ -257,10 +492,8 @@ function buildHandBrakeCommandPreview({
if (subtitleDefaultTrackId !== null) {
overrideArgs.push(`--subtitle-default=${subtitleDefaultTrackId}`);
}
- if (subtitleForcedTrackId !== null) {
- overrideArgs.push(`--subtitle-forced=${subtitleForcedTrackId}`);
- } else if (subtitleForcedOnly) {
- overrideArgs.push('--subtitle-forced');
+ if (resolvedSubtitleSelection.subtitleForcedTrackIndexes.length > 0) {
+ overrideArgs.push(`--subtitle-forced=${resolvedSubtitleSelection.subtitleForcedTrackIndexes.join(',')}`);
}
const finalArgs = [...baseArgs, ...filteredExtra, ...overrideArgs];
@@ -637,11 +870,191 @@ function TrackList({
type = 'generic',
allowSelection = false,
selectedTrackIds = [],
+ selectedSubtitleVariantSelection = {},
+ selectedSubtitleLanguageOrder = [],
onToggleTrack = null,
+ onToggleSubtitleVariant = null,
audioSelector = null
}) {
+ const orderedTracks = (Array.isArray(tracks) ? [...tracks] : [])
+ .sort((a, b) => {
+ const aId = normalizeTrackId(a?.id) ?? Number.MAX_SAFE_INTEGER;
+ const bId = normalizeTrackId(b?.id) ?? Number.MAX_SAFE_INTEGER;
+ if (aId !== bId) {
+ return aId - bId;
+ }
+ return String(a?.language || '').localeCompare(String(b?.language || ''));
+ });
+
+ if (type === 'subtitle') {
+ const selectedVariants = normalizeSubtitleVariantSelectionMap(selectedSubtitleVariantSelection || {});
+ const sortedSubtitleTracks = orderedTracks
+ .filter((track) => !isDuplicateSubtitleTrack(track));
+
+ const renderVariantRow = ({
+ key,
+ checked,
+ disabled,
+ onChange,
+ text,
+ confidence = null,
+ indent = false
+ }) => {
+ const confidenceColor = confidence === 'high'
+ ? '#2e7d32'
+ : confidence === 'medium'
+ ? '#f57c00'
+ : '#c62828';
+
+ return (
+
+
+
+ );
+ };
+ const resolveSubtitleActionInfo = (track, selected) => {
+ const base = String(track?.subtitlePreviewSummary || track?.subtitleActionSummary || '').trim();
+ if (allowSelection) {
+ return selected ? 'Übernehmen' : 'Nicht übernommen';
+ }
+ return base || (selected ? 'Übernehmen' : 'Nicht übernommen');
+ };
+
+ return (
+
+
{title}
+ {!tracks || tracks.length === 0 ? (
+
Keine Einträge.
+ ) : (
+
+ {sortedSubtitleTracks.map((track) => {
+ const burned = isBurnedSubtitleTrack(track);
+ const language = normalizeSubtitleLanguage(track?.language || track?.languageLabel || 'und');
+ const displayLanguage = toLang2(track?.language || track?.languageLabel || 'und');
+ const displayCodec = simplifyCodec('subtitle', track?.format, track?.description || track?.title);
+ const flags = resolveSubtitleTrackVariantFlags(track);
+ const confidenceRaw = String(track?.sourceConfidence || '').trim().toLowerCase();
+ const confidence = confidenceRaw === 'high' || confidenceRaw === 'medium' || confidenceRaw === 'low'
+ ? confidenceRaw
+ : 'low';
+ const languageSelection = selectedVariants[language] || { full: false, forced: false };
+
+ if (flags.isForcedOnly) {
+ const checked = allowSelection ? Boolean(languageSelection.forced) : Boolean(track?.selectedForEncode);
+ const disabled = !allowSelection || burned;
+ const actionInfo = resolveSubtitleActionInfo(track, checked);
+ return (
+
+ {renderVariantRow({
+ key: `${title}-${track.id}-forced-only`,
+ checked,
+ disabled,
+ onChange: (event) => {
+ if (disabled || typeof onToggleSubtitleVariant !== 'function') {
+ return;
+ }
+ onToggleSubtitleVariant(language, 'forced', event.target.checked);
+ },
+ text: `#${track.id} | ${displayLanguage} | Automatische Übersetzungen (${displayCodec})`,
+ confidence
+ })}
+ Untertitel: {actionInfo}
+
+ );
+ }
+
+ if (flags.fullHasForced) {
+ const checkedFull = allowSelection ? Boolean(languageSelection.full) : Boolean(track?.selectedForEncode);
+ const checkedForced = allowSelection ? Boolean(languageSelection.forced) : false;
+ const disabled = !allowSelection || burned;
+ const actionInfo = resolveSubtitleActionInfo(track, checkedFull || checkedForced);
+ return (
+
+
+ {`#${track.id} | ${displayLanguage}`}
+
+ {renderVariantRow({
+ key: `${title}-${track.id}-combo-full`,
+ checked: checkedFull,
+ disabled,
+ onChange: (event) => {
+ if (disabled || typeof onToggleSubtitleVariant !== 'function') {
+ return;
+ }
+ onToggleSubtitleVariant(language, 'full', event.target.checked);
+ },
+ text: `Komplette Untertitel (${displayCodec})`,
+ indent: true
+ })}
+ {renderVariantRow({
+ key: `${title}-${track.id}-combo-forced`,
+ checked: checkedForced,
+ disabled,
+ onChange: (event) => {
+ if (disabled || typeof onToggleSubtitleVariant !== 'function') {
+ return;
+ }
+ onToggleSubtitleVariant(language, 'forced', event.target.checked);
+ },
+ text: `Automatische Übersetzungen (${displayCodec})`,
+ confidence,
+ indent: true
+ })}
+
Untertitel: {actionInfo}
+
+ );
+ }
+
+ const checked = allowSelection ? Boolean(languageSelection.full) : Boolean(track?.selectedForEncode);
+ const disabled = !allowSelection || burned;
+ const actionInfo = resolveSubtitleActionInfo(track, checked);
+ return (
+
+ {renderVariantRow({
+ key: `${title}-${track.id}-full`,
+ checked,
+ disabled,
+ onChange: (event) => {
+ if (disabled || typeof onToggleSubtitleVariant !== 'function') {
+ return;
+ }
+ onToggleSubtitleVariant(language, 'full', event.target.checked);
+ },
+ text: `#${track.id} | ${displayLanguage} | Komplette Untertitel (${displayCodec})`
+ })}
+ Untertitel: {actionInfo}
+
+ );
+ })}
+
+ )}
+
+
+ Automatische Übersetzungen werden nur eingeblendet, wenn im Film eine andere Sprache gesprochen wird. Komplette Untertitel zeigen alle Dialoge an. Blu-ray Untertitel liegen meist als PGS (Bildformat) vor.
+
+
+ Confidence-Index (nur für Automatische Übersetzungen): ● high = explizites Track-Signal erkannt, ● medium = "forced" im Titel erkannt, ● low = heuristische Einschätzung.
+
+
+
+
+ );
+ }
+
const selectedIds = normalizeTrackIdList(selectedTrackIds);
- const checkedTrackOrder = (Array.isArray(tracks) ? tracks : [])
+ const checkedTrackOrder = orderedTracks
.map((track) => normalizeTrackId(track?.id))
.filter((trackId, index) => {
if (trackId === null) {
@@ -650,7 +1063,7 @@ function TrackList({
if (allowSelection) {
return selectedIds.includes(trackId);
}
- const track = tracks[index];
+ const track = orderedTracks[index];
return Boolean(track?.selectedForEncode);
});
@@ -661,11 +1074,10 @@ function TrackList({
Keine Einträge.
) : (
- {tracks.map((track) => {
+ {orderedTracks.map((track) => {
const trackId = normalizeTrackId(track.id);
- const burned = type === 'subtitle' ? isBurnedSubtitleTrack(track) : false;
const checked = allowSelection
- ? (trackId !== null && selectedIds.includes(trackId) && !(type === 'subtitle' && burned))
+ ? (trackId !== null && selectedIds.includes(trackId))
: Boolean(track.selectedForEncode);
const selectedIndex = trackId !== null
? checkedTrackOrder.indexOf(trackId)
@@ -686,23 +1098,14 @@ function TrackList({
return base || buildAudioActionPreviewSummary(track, selectedIndex, audioSelector);
})()
: 'Nicht übernommen')
- : type === 'subtitle'
- ? (checked
- ? (() => {
- const base = String(track.subtitlePreviewSummary || track.subtitleActionSummary || '').trim();
- return /^nicht übernommen$/i.test(base) ? 'Übernehmen' : (base || 'Übernehmen');
- })()
- : 'Nicht übernommen')
- : null;
+ : null;
const displayLanguage = toLang2(track.language || track.languageLabel || 'und');
const displayHint = track.description || track.title;
const displayCodec = simplifyCodec(type, track.format, displayHint);
const displayChannelCount = channelCount(track.channels);
const displayAudioTitle = audioChannelLabel(track.channels);
const audioVariant = type === 'audio' ? extractAudioVariant(displayHint) : '';
- const disabled = !allowSelection || (type === 'subtitle' && burned);
- const forcedOnlyTrack = type === 'subtitle' ? isForcedOnlySubtitleTrack(track) : false;
- const forcedAvailable = type === 'subtitle' ? hasForcedSubtitleAvailable(track) : false;
+ const disabled = !allowSelection;
let displayText = `#${track.id} | ${displayLanguage} | ${displayCodec}`;
if (type === 'audio') {
@@ -716,14 +1119,6 @@ function TrackList({
displayText += ` | ${audioVariant}`;
}
}
- if (type === 'subtitle' && burned) {
- displayText += ' | burned';
- } else if (type === 'subtitle' && forcedOnlyTrack) {
- displayText += ' | forced-only';
- } else if (type === 'subtitle' && forcedAvailable) {
- displayText += ' | forced verfügbar';
- }
-
return (
{actionInfo ? Encode: {actionInfo} : null}
@@ -804,6 +1201,7 @@ export default function MediaInfoReviewPanel({
allowTrackSelection = false,
trackSelectionByTitle = {},
onTrackSelectionChange = null,
+ onSubtitleVariantSelectionChange = null,
availableScripts = [],
availableChains = [],
preEncodeItems = [],
@@ -934,7 +1332,7 @@ export default function MediaInfoReviewPanel({
Audio Copy-Mask: {(effectiveAudioSelector?.copyMask || []).join(', ') || '-'}
Audio Fallback: {effectiveAudioSelector?.fallbackEncoder || '-'}
Subtitle Auswahl: {review.selectors?.subtitle?.mode || '-'}
-
Subtitle Flags: {review.selectors?.subtitle?.forcedOnly ? 'forced-only' : '-'}{review.selectors?.subtitle?.burnBehavior === 'first' ? ' + burned(first)' : ''}
+
Subtitle Flags: {review.selectors?.subtitle?.burnBehavior === 'first' ? 'burned(first)' : '-'}
{review.partial ? (
@@ -1213,18 +1611,44 @@ export default function MediaInfoReviewPanel({
const titleSelectionEntry = trackSelectionByTitle?.[title.id] || trackSelectionByTitle?.[String(title.id)] || {};
const subtitleTracks = Array.isArray(title.subtitleTracks) ? title.subtitleTracks : [];
const selectableSubtitleTrackIds = subtitleTracks
- .filter((track) => !isBurnedSubtitleTrack(track))
+ .filter((track) => !isBurnedSubtitleTrack(track) && !isDuplicateSubtitleTrack(track))
.map((track) => normalizeTrackId(track?.id))
.filter((id) => id !== null);
const selectableSubtitleTrackIdSet = new Set(selectableSubtitleTrackIds.map((id) => String(id)));
+ const sortedSelectableSubtitleTracks = subtitleTracks
+ .filter((track) => !isBurnedSubtitleTrack(track) && !isDuplicateSubtitleTrack(track))
+ .slice()
+ .sort((a, b) => (normalizeTrackId(a?.id) || Number.MAX_SAFE_INTEGER) - (normalizeTrackId(b?.id) || Number.MAX_SAFE_INTEGER));
const defaultAudioTrackIds = (Array.isArray(title.audioTracks) ? title.audioTracks : [])
.filter((track) => Boolean(track?.selectedByRule))
.map((track) => normalizeTrackId(track?.id))
.filter((id) => id !== null);
const defaultSubtitleTrackIds = subtitleTracks
- .filter((track) => Boolean(track?.selectedByRule) && !isBurnedSubtitleTrack(track))
+ .filter((track) => Boolean(track?.selectedByRule) && !isBurnedSubtitleTrack(track) && !isDuplicateSubtitleTrack(track))
.map((track) => normalizeTrackId(track?.id))
.filter((id) => id !== null);
+ const defaultSubtitleVariantSelection = {};
+ const defaultSubtitleLanguageOrder = [];
+ const subtitleLanguageOrderSeen = new Set();
+ for (const track of sortedSelectableSubtitleTracks) {
+ const language = normalizeSubtitleLanguage(track?.language || track?.languageLabel || 'und');
+ if (!subtitleLanguageOrderSeen.has(language)) {
+ subtitleLanguageOrderSeen.add(language);
+ defaultSubtitleLanguageOrder.push(language);
+ }
+ if (!Boolean(track?.selectedByRule)) {
+ continue;
+ }
+ if (!defaultSubtitleVariantSelection[language]) {
+ defaultSubtitleVariantSelection[language] = { full: false, forced: false };
+ }
+ const flags = resolveSubtitleTrackVariantFlags(track);
+ if (flags.isForcedOnly) {
+ defaultSubtitleVariantSelection[language].forced = true;
+ } else {
+ defaultSubtitleVariantSelection[language].full = true;
+ }
+ }
const selectedAudioTrackIds = normalizeTrackIdList(
Array.isArray(titleSelectionEntry?.audioTrackIds)
? titleSelectionEntry.audioTrackIds
@@ -1235,6 +1659,14 @@ export default function MediaInfoReviewPanel({
? titleSelectionEntry.subtitleTrackIds
: defaultSubtitleTrackIds
).filter((id) => selectableSubtitleTrackIdSet.has(String(id)));
+ const selectedSubtitleVariantSelection = normalizeSubtitleVariantSelectionMap(
+ titleSelectionEntry?.subtitleVariantSelection || defaultSubtitleVariantSelection
+ );
+ const selectedSubtitleLanguageOrder = normalizeSubtitleLanguageOrder(
+ Array.isArray(titleSelectionEntry?.subtitleLanguageOrder)
+ ? titleSelectionEntry.subtitleLanguageOrder
+ : defaultSubtitleLanguageOrder
+ );
const allowTrackSelectionForTitle = Boolean(
allowTrackSelection
&& allowTitleSelection
@@ -1302,15 +1734,19 @@ export default function MediaInfoReviewPanel({
/>
!isBurnedSubtitleTrack(track)) : subtitleTracks}
+ tracks={allowTrackSelectionForTitle
+ ? subtitleTracks.filter((track) => !isBurnedSubtitleTrack(track))
+ : subtitleTracks}
type="subtitle"
allowSelection={allowTrackSelectionForTitle}
selectedTrackIds={selectedSubtitleTrackIds}
- onToggleTrack={(trackId, checked) => {
- if (!allowTrackSelectionForTitle || typeof onTrackSelectionChange !== 'function') {
+ selectedSubtitleVariantSelection={selectedSubtitleVariantSelection}
+ selectedSubtitleLanguageOrder={selectedSubtitleLanguageOrder}
+ onToggleSubtitleVariant={(language, variant, checked) => {
+ if (!allowTrackSelectionForTitle || typeof onSubtitleVariantSelectionChange !== 'function') {
return;
}
- onTrackSelectionChange(title.id, 'subtitle', trackId, checked);
+ onSubtitleVariantSelectionChange(title.id, language, variant, checked);
}}
/>
@@ -1320,6 +1756,8 @@ export default function MediaInfoReviewPanel({
title,
selectedAudioTrackIds,
selectedSubtitleTrackIds,
+ selectedSubtitleVariantSelection,
+ selectedSubtitleLanguageOrder,
commandOutputPath,
presetOverride: effectivePresetOverride
});
diff --git a/frontend/src/components/PipelineStatusCard.jsx b/frontend/src/components/PipelineStatusCard.jsx
index 33a9be3..a5252d0 100644
--- a/frontend/src/components/PipelineStatusCard.jsx
+++ b/frontend/src/components/PipelineStatusCard.jsx
@@ -15,6 +15,14 @@ function normalizeTitleId(value) {
return Math.trunc(parsed);
}
+function normalizeJobId(value) {
+ const parsed = Number(value);
+ if (!Number.isFinite(parsed) || parsed <= 0) {
+ return null;
+ }
+ return Math.trunc(parsed);
+}
+
function normalizePlaylistId(value) {
const raw = String(value || '').trim().toLowerCase();
if (!raw) {
@@ -155,10 +163,119 @@ function isBurnedSubtitleTrack(track) {
);
}
+function isDuplicateSubtitleTrack(track) {
+ return Boolean(track?.duplicate);
+}
+
+function normalizeSubtitleLanguage(value) {
+ const raw = String(value || '').trim().toLowerCase();
+ if (!raw) {
+ return 'und';
+ }
+ if (raw.length >= 3) {
+ return raw.slice(0, 3);
+ }
+ return raw;
+}
+
+function normalizeSubtitleVariantSelectionMap(rawSelection) {
+ const map = {};
+ if (!rawSelection || typeof rawSelection !== 'object') {
+ return map;
+ }
+ for (const [language, value] of Object.entries(rawSelection)) {
+ const normalizedLanguage = normalizeSubtitleLanguage(language);
+ const full = Boolean(value?.full);
+ const forced = Boolean(value?.forced);
+ map[normalizedLanguage] = { full, forced };
+ }
+ return map;
+}
+
+function normalizeSubtitleLanguageOrder(rawOrder = []) {
+ const list = Array.isArray(rawOrder) ? rawOrder : [];
+ const seen = new Set();
+ const output = [];
+ for (const value of list) {
+ const language = normalizeSubtitleLanguage(value);
+ if (!language || seen.has(language)) {
+ continue;
+ }
+ seen.add(language);
+ output.push(language);
+ }
+ return output;
+}
+
+function resolveSubtitleTrackVariantFlags(track) {
+ const subtitleType = String(track?.subtitleType || '').trim().toLowerCase();
+ const isForcedOnly = Boolean(
+ track?.isForcedOnly
+ ?? track?.subtitlePreviewForcedOnly
+ ?? track?.forcedOnly
+ ?? subtitleType === 'forced'
+ );
+ const fullHasForced = !isForcedOnly && Boolean(
+ track?.fullHasForced
+ ?? track?.subtitleFullHasForced
+ ?? track?.hasForcedVariant
+ );
+ return { isForcedOnly, fullHasForced };
+}
+
+function buildDefaultSubtitleVariantSelection(subtitleTracks, selectedTracks) {
+ const tracks = Array.isArray(subtitleTracks) ? subtitleTracks : [];
+ const selected = Array.isArray(selectedTracks) ? selectedTracks : [];
+ const orderedTracks = [...tracks].sort((a, b) => {
+ const aId = normalizeTrackId(a?.id) ?? Number.MAX_SAFE_INTEGER;
+ const bId = normalizeTrackId(b?.id) ?? Number.MAX_SAFE_INTEGER;
+ if (aId !== bId) {
+ return aId - bId;
+ }
+ return String(a?.language || a?.languageLabel || '').localeCompare(String(b?.language || b?.languageLabel || ''));
+ });
+
+ const order = [];
+ const orderSeen = new Set();
+ for (const track of orderedTracks) {
+ const language = normalizeSubtitleLanguage(track?.language || track?.languageLabel || 'und');
+ if (!orderSeen.has(language)) {
+ orderSeen.add(language);
+ order.push(language);
+ }
+ }
+
+ const selectionMap = {};
+ for (const track of selected) {
+ if (isBurnedSubtitleTrack(track) || isDuplicateSubtitleTrack(track)) {
+ continue;
+ }
+ const language = normalizeSubtitleLanguage(track?.language || track?.languageLabel || 'und');
+ if (!selectionMap[language]) {
+ selectionMap[language] = { full: false, forced: false };
+ }
+ const flags = resolveSubtitleTrackVariantFlags(track);
+ if (flags.isForcedOnly) {
+ selectionMap[language].forced = true;
+ } else {
+ selectionMap[language].full = true;
+ }
+ }
+
+ return {
+ subtitleVariantSelection: selectionMap,
+ subtitleLanguageOrder: order
+ };
+}
+
function buildDefaultTrackSelection(review) {
const titles = Array.isArray(review?.titles) ? review.titles : [];
const selection = {};
const reviewEncodeInputTitleId = normalizeTitleId(review?.encodeInputTitleId);
+ const manualSelection = review?.manualTrackSelection && typeof review.manualTrackSelection === 'object'
+ ? review.manualTrackSelection
+ : null;
+ const manualTitleId = normalizeTitleId(manualSelection?.titleId);
for (const title of titles) {
const titleId = normalizeTitleId(title?.id);
@@ -179,16 +296,49 @@ function buildDefaultTrackSelection(review) {
const subtitleSelectionSource = isEncodeInputTitle
? subtitleTracks.filter((track) => Boolean(track?.selectedForEncode))
: subtitleTracks.filter((track) => Boolean(track?.selectedByRule));
+ const defaultSubtitleVariantSelection = buildDefaultSubtitleVariantSelection(
+ subtitleTracks,
+ subtitleSelectionSource
+ );
+ const manualSelectionMatchesTitle = Boolean(
+ isEncodeInputTitle
+ && manualSelection
+ && (!manualTitleId || manualTitleId === titleId)
+ );
+ const manualAudioTrackIds = manualSelectionMatchesTitle
+ ? normalizeTrackIdList(manualSelection?.audioTrackIds || [])
+ : [];
+ const manualSubtitleTrackIds = manualSelectionMatchesTitle
+ ? normalizeTrackIdList(
+ Array.isArray(manualSelection?.subtitleTrackIdsOrdered)
+ ? manualSelection.subtitleTrackIdsOrdered
+ : manualSelection?.subtitleTrackIds || []
+ )
+ : [];
+ const manualSubtitleVariantSelection = manualSelectionMatchesTitle
+ ? normalizeSubtitleVariantSelectionMap(manualSelection?.subtitleVariantSelection || {})
+ : {};
+ const manualSubtitleLanguageOrder = manualSelectionMatchesTitle
+ ? normalizeSubtitleLanguageOrder(manualSelection?.subtitleLanguageOrder || [])
+ : [];
selection[titleId] = {
- audioTrackIds: normalizeTrackIdList(
- audioSelectionSource.map((track) => track?.id)
- ),
- subtitleTrackIds: normalizeTrackIdList(
- subtitleSelectionSource
- .filter((track) => !isBurnedSubtitleTrack(track))
- .map((track) => track?.id)
- )
+ audioTrackIds: manualAudioTrackIds.length > 0
+ ? manualAudioTrackIds
+ : normalizeTrackIdList(audioSelectionSource.map((track) => track?.id)),
+ subtitleTrackIds: manualSubtitleTrackIds.length > 0
+ ? manualSubtitleTrackIds
+ : normalizeTrackIdList(
+ subtitleSelectionSource
+ .filter((track) => !isBurnedSubtitleTrack(track) && !isDuplicateSubtitleTrack(track))
+ .map((track) => track?.id)
+ ),
+ subtitleVariantSelection: Object.keys(manualSubtitleVariantSelection).length > 0
+ ? manualSubtitleVariantSelection
+ : defaultSubtitleVariantSelection.subtitleVariantSelection,
+ subtitleLanguageOrder: manualSubtitleLanguageOrder.length > 0
+ ? manualSubtitleLanguageOrder
+ : defaultSubtitleVariantSelection.subtitleLanguageOrder
};
}
@@ -197,7 +347,12 @@ function buildDefaultTrackSelection(review) {
function defaultTrackSelectionForTitle(review, titleId) {
const defaults = buildDefaultTrackSelection(review);
- return defaults[titleId] || defaults[String(titleId)] || { audioTrackIds: [], subtitleTrackIds: [] };
+ return defaults[titleId] || defaults[String(titleId)] || {
+ audioTrackIds: [],
+ subtitleTrackIds: [],
+ subtitleVariantSelection: {},
+ subtitleLanguageOrder: []
+ };
}
function buildSettingsMap(categories) {
@@ -299,6 +454,7 @@ function buildOutputPathPreview(settings, mediaProfile, metadata, fallbackJobId
}
export default function PipelineStatusCard({
+ jobId = null,
pipeline,
onAnalyze,
onReanalyze,
@@ -321,7 +477,9 @@ export default function PipelineStatusCard({
const stateLabel = getStatusLabel(state);
const progress = Number(pipeline?.progress || 0);
const running = state === 'ANALYZING' || state === 'RIPPING' || state === 'ENCODING' || state === 'MEDIAINFO_CHECK';
- const retryJobId = pipeline?.context?.jobId;
+ const explicitJobId = normalizeJobId(jobId);
+ const contextJobId = normalizeJobId(pipeline?.context?.jobId);
+ const retryJobId = explicitJobId || contextJobId;
const queueLocked = Boolean(isQueued && retryJobId);
const selectedMetadata = pipeline?.context?.selectedMetadata || null;
const mediaInfoReview = pipeline?.context?.mediaInfoReview || null;
@@ -435,7 +593,12 @@ export default function PipelineStatusCard({
}
const defaults = buildDefaultTrackSelection(mediaInfoReview);
- const fallback = defaults[currentTitleId] || { audioTrackIds: [], subtitleTrackIds: [] };
+ const fallback = defaults[currentTitleId] || {
+ audioTrackIds: [],
+ subtitleTrackIds: [],
+ subtitleVariantSelection: {},
+ subtitleLanguageOrder: []
+ };
return {
...prev,
[currentTitleId]: fallback
@@ -639,7 +802,12 @@ export default function PipelineStatusCard({
: null;
const fallbackSelection = encodeTitleId
? defaultTrackSelectionForTitle(mediaInfoReview, encodeTitleId)
- : { audioTrackIds: [], subtitleTrackIds: [] };
+ : {
+ audioTrackIds: [],
+ subtitleTrackIds: [],
+ subtitleVariantSelection: {},
+ subtitleLanguageOrder: []
+ };
const effectiveSelection = selectionEntry || fallbackSelection;
const encodeTitle = encodeTitleId
? (Array.isArray(mediaInfoReview?.titles)
@@ -648,17 +816,39 @@ export default function PipelineStatusCard({
: null;
const blockedSubtitleTrackIds = new Set(
(Array.isArray(encodeTitle?.subtitleTracks) ? encodeTitle.subtitleTracks : [])
- .filter((track) => isBurnedSubtitleTrack(track))
+ .filter((track) => isBurnedSubtitleTrack(track) || isDuplicateSubtitleTrack(track))
.map((track) => normalizeTrackId(track?.id))
.filter((id) => id !== null)
.map((id) => String(id))
);
+ const availableSubtitleLanguages = new Set(
+ (Array.isArray(encodeTitle?.subtitleTracks) ? encodeTitle.subtitleTracks : [])
+ .filter((track) => !isBurnedSubtitleTrack(track) && !isDuplicateSubtitleTrack(track))
+ .map((track) => normalizeSubtitleLanguage(track?.language || track?.languageLabel || 'und'))
+ );
+ const normalizedVariantSelection = normalizeSubtitleVariantSelectionMap(effectiveSelection?.subtitleVariantSelection || {});
+ const filteredVariantSelection = {};
+ for (const [language, value] of Object.entries(normalizedVariantSelection)) {
+ if (!availableSubtitleLanguages.has(language)) {
+ continue;
+ }
+ filteredVariantSelection[language] = {
+ full: Boolean(value?.full),
+ forced: Boolean(value?.forced)
+ };
+ }
+ const normalizedLanguageOrder = normalizeSubtitleLanguageOrder(effectiveSelection?.subtitleLanguageOrder || [])
+ .filter((language) => availableSubtitleLanguages.has(language));
+ const hasExplicitVariantSelection = Object.keys(filteredVariantSelection).length > 0;
+ const filteredSubtitleTrackIds = normalizeTrackIdList(effectiveSelection?.subtitleTrackIds || [])
+ .filter((id) => !blockedSubtitleTrackIds.has(String(id)));
const selectedTrackSelection = encodeTitleId
? {
[encodeTitleId]: {
audioTrackIds: normalizeTrackIdList(effectiveSelection?.audioTrackIds || []),
- subtitleTrackIds: normalizeTrackIdList(effectiveSelection?.subtitleTrackIds || [])
- .filter((id) => !blockedSubtitleTrackIds.has(String(id)))
+ subtitleTrackIds: hasExplicitVariantSelection ? [] : filteredSubtitleTrackIds,
+ subtitleVariantSelection: filteredVariantSelection,
+ subtitleLanguageOrder: normalizedLanguageOrder
}
}
: null;
@@ -1032,7 +1222,9 @@ export default function PipelineStatusCard({
setTrackSelectionByTitle((prev) => {
const current = prev?.[normalizedTitleId] || prev?.[String(normalizedTitleId)] || {
audioTrackIds: [],
- subtitleTrackIds: []
+ subtitleTrackIds: [],
+ subtitleVariantSelection: {},
+ subtitleLanguageOrder: []
};
const key = trackType === 'subtitle' ? 'subtitleTrackIds' : 'audioTrackIds';
const existing = normalizeTrackIdList(current?.[key] || []);
@@ -1049,6 +1241,53 @@ export default function PipelineStatusCard({
};
});
}}
+ onSubtitleVariantSelectionChange={(titleId, language, variant, checked) => {
+ const normalizedTitleId = normalizeTitleId(titleId);
+ const normalizedLanguage = normalizeSubtitleLanguage(language);
+ const normalizedVariant = String(variant || '').trim().toLowerCase() === 'forced' ? 'forced' : 'full';
+ if (!normalizedTitleId || !normalizedLanguage) {
+ return;
+ }
+
+ setTrackSelectionByTitle((prev) => {
+ const current = prev?.[normalizedTitleId] || prev?.[String(normalizedTitleId)] || {
+ audioTrackIds: [],
+ subtitleTrackIds: [],
+ subtitleVariantSelection: {},
+ subtitleLanguageOrder: []
+ };
+ const currentMap = normalizeSubtitleVariantSelectionMap(current?.subtitleVariantSelection || {});
+ const nextMap = { ...currentMap };
+ const currentEntry = nextMap[normalizedLanguage] || { full: false, forced: false };
+ nextMap[normalizedLanguage] = {
+ ...currentEntry,
+ [normalizedVariant]: Boolean(checked)
+ };
+ const existingOrder = normalizeSubtitleLanguageOrder(current?.subtitleLanguageOrder || []);
+ const fallbackOrder = normalizeSubtitleLanguageOrder(
+ defaultTrackSelectionForTitle(mediaInfoReview, normalizedTitleId)?.subtitleLanguageOrder || []
+ );
+ let nextOrder = existingOrder.length > 0
+ ? existingOrder
+ : fallbackOrder;
+ if (nextOrder.length === 0) {
+ nextOrder = [normalizedLanguage];
+ } else if (!nextOrder.includes(normalizedLanguage) && fallbackOrder.includes(normalizedLanguage)) {
+ nextOrder = fallbackOrder;
+ } else if (!nextOrder.includes(normalizedLanguage)) {
+ nextOrder = [...nextOrder, normalizedLanguage];
+ }
+
+ return {
+ ...prev,
+ [normalizedTitleId]: {
+ ...current,
+ subtitleVariantSelection: nextMap,
+ subtitleLanguageOrder: nextOrder
+ }
+ };
+ });
+ }}
availableScripts={scriptCatalog}
availableChains={chainCatalog}
preEncodeItems={preEncodeItems}
diff --git a/frontend/src/pages/ConverterPage.jsx b/frontend/src/pages/ConverterPage.jsx
index 436fc48..41cd078 100644
--- a/frontend/src/pages/ConverterPage.jsx
+++ b/frontend/src/pages/ConverterPage.jsx
@@ -1,30 +1,51 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { Button } from 'primereact/button';
import { Card } from 'primereact/card';
import { Toast } from 'primereact/toast';
-import { Divider } from 'primereact/divider';
import { Badge } from 'primereact/badge';
+import { Divider } from 'primereact/divider';
import { Dialog } from 'primereact/dialog';
+import { Dropdown } from 'primereact/dropdown';
import { RadioButton } from 'primereact/radiobutton';
import { api } from '../api/client';
import { useWebSocket } from '../hooks/useWebSocket';
import ConverterFileExplorer from '../components/ConverterFileExplorer';
import ConverterUploadPanel from '../components/ConverterUploadPanel';
import ConverterJobCard from '../components/ConverterJobCard';
+import JobDetailDialog from '../components/JobDetailDialog';
const AUDIO_EXTS = new Set(['.flac', '.mp3', '.aac', '.wav', '.m4a', '.ogg', '.opus', '.wma', '.ape']);
+const VIDEO_EXTS = new Set(['.mkv', '.mp4', '.avi', '.mov', '.wmv', '.ts', '.m2ts', '.iso', '.m4v', '.flv', '.webm']);
+
function isAudioEntry(e) {
+ if (e.detectedMediaType === 'audio') return true;
const p = (e.relPath || '').toLowerCase();
const dot = p.lastIndexOf('.');
if (dot === -1) return false;
return AUDIO_EXTS.has(p.slice(dot));
}
+function isVideoEntry(e) {
+ if (e.detectedMediaType === 'video' || e.detectedMediaType === 'iso') return true;
+ const p = (e.relPath || '').toLowerCase();
+ const dot = p.lastIndexOf('.');
+ if (dot === -1) return false;
+ return VIDEO_EXTS.has(p.slice(dot));
+}
+
function normalizeJobId(value) {
const n = Number(value);
return Number.isFinite(n) && n > 0 ? Math.trunc(n) : null;
}
+function parseConverterPlan(job) {
+ try {
+ return JSON.parse(job?.encode_plan_json || '{}');
+ } catch (_err) {
+ return {};
+ }
+}
+
export default function ConverterPage() {
const toastRef = useRef(null);
const [jobs, setJobs] = useState([]);
@@ -35,7 +56,20 @@ export default function ConverterPage() {
const [selectedEntries, setSelectedEntries] = useState([]);
const [jobModeVisible, setJobModeVisible] = useState(false);
const [audioMode, setAudioMode] = useState('individual');
+ const [jobModalAction, setJobModalAction] = useState('create');
+ const [assignTargetJobId, setAssignTargetJobId] = useState(null);
const [creatingJobs, setCreatingJobs] = useState(false);
+ const [jobEntries, setJobEntries] = useState([]);
+ const [detailVisible, setDetailVisible] = useState(false);
+ const [detailLoading, setDetailLoading] = useState(false);
+ const [selectedJob, setSelectedJob] = useState(null);
+ const [logLoadingMode, setLogLoadingMode] = useState(null);
+ const [deleteEntryBusy, setDeleteEntryBusy] = useState(false);
+ const [cancelDetailBusy, setCancelDetailBusy] = useState(false);
+ const [expandedJobId, setExpandedJobId] = useState(undefined);
+ // Entries werden beim Öffnen des Modals gesichert, damit ein außerhalb-Click
+ // die Selection nicht löscht bevor die Jobs erstellt werden
+ const jobEntriesRef = useRef([]);
const loadJobs = useCallback(async () => {
setLoadingJobs(true);
@@ -55,53 +89,91 @@ export default function ConverterPage() {
return () => clearInterval(interval);
}, [loadJobs]);
- useWebSocket((message) => {
- if (!message?.type || !message?.payload) return;
+ useWebSocket({
+ onMessage: (message) => {
+ if (!message?.type || !message?.payload) return;
- if (message.type === 'PIPELINE_PROGRESS') {
- const payload = message.payload;
- const jobId = normalizeJobId(payload?.activeJobId);
- if (jobId) {
- setJobProgress((prev) => ({
- ...prev,
- [jobId]: {
- progress: payload?.progress ?? null,
- eta: payload?.eta ?? null,
- statusText: payload?.statusText ?? null,
- state: payload?.state ?? null
- }
- }));
+ if (message.type === 'PIPELINE_PROGRESS') {
+ const payload = message.payload;
+ const jobId = normalizeJobId(payload?.activeJobId);
+ if (jobId) {
+ setJobProgress((prev) => ({
+ ...prev,
+ [jobId]: {
+ progress: payload?.progress ?? null,
+ eta: payload?.eta ?? null,
+ statusText: payload?.statusText ?? null,
+ state: payload?.state ?? null
+ }
+ }));
+ }
}
- }
- if (message.type === 'PIPELINE_UPDATE' || message.type === 'CONVERTER_SCAN_UPDATE') {
- loadJobs();
- if (message.type === 'CONVERTER_SCAN_UPDATE') {
- setExplorerRefreshToken((t) => t + 1);
+ if (
+ message.type === 'PIPELINE_UPDATE' ||
+ message.type === 'PIPELINE_STATE_CHANGED' ||
+ message.type === 'CONVERTER_SCAN_UPDATE'
+ ) {
+ loadJobs();
+ if (message.type === 'CONVERTER_SCAN_UPDATE' || message.type === 'PIPELINE_STATE_CHANGED') {
+ setExplorerRefreshToken((t) => t + 1);
+ }
}
}
});
+ const assignableJobs = useMemo(() => (
+ jobs
+ .map((job) => ({ job, plan: parseConverterPlan(job) }))
+ .filter(({ job, plan }) => {
+ const status = String(job?.status || '').trim().toUpperCase();
+ const mediaType = String(plan?.converterMediaType || '').trim().toLowerCase();
+ return status === 'READY_TO_START' && mediaType === 'audio' && !Boolean(plan?.isFolder);
+ })
+ .map(({ job, plan }) => {
+ const rawTitle = String(job?.title || '').trim();
+ const title = rawTitle ? `#${job.id} | ${rawTitle}` : `#${job.id}`;
+ const fileCount = Array.isArray(plan?.inputPaths) && plan.inputPaths.length > 0
+ ? plan.inputPaths.length
+ : (plan?.inputPath ? 1 : 0);
+ return {
+ label: `${title}${fileCount > 0 ? ` (${fileCount} Datei${fileCount !== 1 ? 'en' : ''})` : ''}`,
+ value: job.id
+ };
+ })
+ ), [jobs]);
+
const handleSelectionChange = (entries) => setSelectedEntries(entries || []);
const handleOpenJobModal = () => {
- const hasAudio = selectedEntries.some(isAudioEntry);
- if (!hasAudio) {
- // Keine Audio-Dateien (nur Videos/Ordner) → kein Modal, direkt Einzeljobs
+ // Explorer expandiert Ordner bereits zu Einzel-Dateien
+ const entries = [...selectedEntries];
+ jobEntriesRef.current = entries;
+ setJobEntries(entries);
+
+ const hasAudio = entries.some(isAudioEntry);
+ const hasAssignableJobs = assignableJobs.length > 0;
+ if (!hasAudio && !hasAssignableJobs) {
+ // Nur Videos oder sonstige Dateien → direkt individual erstellen
handleCreateJobsFromSelection('individual');
return;
}
+
setAudioMode('individual');
+ setJobModalAction('create');
+ setAssignTargetJobId(assignableJobs[0]?.value || null);
setJobModeVisible(true);
};
- const handleCreateJobsFromSelection = async (explicitMode) => {
- if (selectedEntries.length === 0) return;
+ const handleCreateJobsFromSelection = async (explicitAudioMode) => {
+ const entries = jobEntriesRef.current;
+ if (entries.length === 0) return;
+ const resolvedAudioMode = typeof explicitAudioMode === 'string' ? explicitAudioMode : audioMode;
setCreatingJobs(true);
setJobModeVisible(false);
try {
- const relPaths = selectedEntries.map((e) => e.relPath).filter(Boolean);
- const result = await api.converterCreateJobsFromSelection(relPaths, explicitMode ?? audioMode);
+ const relPaths = entries.map((e) => e.relPath).filter(Boolean);
+ const result = await api.converterCreateJobsFromSelection(relPaths, resolvedAudioMode);
const newJobs = result?.jobs || [];
toastRef.current?.show({
severity: 'success',
@@ -109,6 +181,8 @@ export default function ConverterPage() {
detail: `${newJobs.length} Converter-Job${newJobs.length !== 1 ? 's' : ''} erstellt.`,
life: 3500
});
+ jobEntriesRef.current = [];
+ setJobEntries([]);
setSelectedEntries([]);
setExplorerRefreshToken((t) => t + 1);
await loadJobs();
@@ -124,10 +198,54 @@ export default function ConverterPage() {
}
};
+ const handleAssignSelectionToJob = async (targetJobId) => {
+ const entries = jobEntriesRef.current;
+ if (entries.length === 0) return;
+ const normalizedJobId = Number(targetJobId);
+ if (!Number.isFinite(normalizedJobId) || normalizedJobId <= 0) return;
+
+ setCreatingJobs(true);
+ setJobModeVisible(false);
+ try {
+ const relPaths = entries.map((e) => e.relPath).filter(Boolean);
+ const result = await api.converterAssignFilesToJob(normalizedJobId, relPaths);
+ const addedCount = Array.isArray(result?.addedRelPaths) ? result.addedRelPaths.length : 0;
+ toastRef.current?.show({
+ severity: 'success',
+ summary: 'Dateien zugewiesen',
+ detail: addedCount > 0
+ ? `${addedCount} Datei${addedCount !== 1 ? 'en' : ''} zu Job #${normalizedJobId} hinzugefügt.`
+ : `Keine neuen Dateien zu Job #${normalizedJobId} hinzugefügt.`,
+ life: 3600
+ });
+ jobEntriesRef.current = [];
+ setJobEntries([]);
+ setSelectedEntries([]);
+ setExplorerRefreshToken((t) => t + 1);
+ await loadJobs();
+ } catch (err) {
+ toastRef.current?.show({
+ severity: 'error',
+ summary: 'Fehler',
+ detail: err.message || 'Dateien konnten dem Job nicht zugewiesen werden.',
+ life: 4600
+ });
+ } finally {
+ setCreatingJobs(false);
+ }
+ };
+
+ const handleJobModeConfirm = async ({ action, audioMode: selectedAudioMode, jobId }) => {
+ if (action === 'assign') {
+ await handleAssignSelectionToJob(jobId || assignTargetJobId);
+ return;
+ }
+ await handleCreateJobsFromSelection(selectedAudioMode || audioMode);
+ };
+
const handleUploaded = (folders) => {
setExplorerRefreshToken((t) => t + 1);
if (folders?.length > 0) {
- // Explorer in den ersten hochgeladenen Ordner navigieren
setExplorerNavigateTo({ path: folders[0].folderRelPath, ts: Date.now() });
toastRef.current?.show({
severity: 'success',
@@ -148,6 +266,135 @@ export default function ConverterPage() {
});
};
+ const handleOpenJobDetails = async (row) => {
+ const jobId = Number(row?.id || 0);
+ if (!jobId) {
+ return;
+ }
+
+ setSelectedJob({
+ ...row,
+ logs: [],
+ log: '',
+ logMeta: {
+ loaded: false,
+ total: Number(row?.log_count || 0),
+ returned: 0,
+ truncated: false
+ }
+ });
+ setDetailVisible(true);
+ setDetailLoading(true);
+
+ try {
+ const response = await api.getJob(jobId, { includeLogs: false, forceRefresh: true });
+ setSelectedJob(response.job);
+ } catch (error) {
+ toastRef.current?.show({
+ severity: 'error',
+ summary: 'Details konnten nicht geladen werden',
+ detail: error.message || 'Unbekannter Fehler',
+ life: 4200
+ });
+ } finally {
+ setDetailLoading(false);
+ }
+ };
+
+ const handleLoadDetailLog = async (job, mode = 'tail') => {
+ const jobId = Number(job?.id || selectedJob?.id || 0);
+ if (!jobId) {
+ return;
+ }
+ setLogLoadingMode(mode);
+ try {
+ const response = await api.getJob(jobId, {
+ includeLogs: true,
+ includeAllLogs: mode === 'all',
+ logTailLines: mode === 'all' ? null : 800
+ });
+ setSelectedJob(response.job);
+ } catch (error) {
+ toastRef.current?.show({
+ severity: 'error',
+ summary: 'Log konnte nicht geladen werden',
+ detail: error.message || 'Unbekannter Fehler',
+ life: 4200
+ });
+ } finally {
+ setLogLoadingMode(null);
+ }
+ };
+
+ const handleDeleteDetailEntry = async (job) => {
+ const jobId = Number(job?.id || 0);
+ if (!jobId) {
+ return;
+ }
+ const confirmed = window.confirm(`Historieneintrag Job #${jobId} löschen?`);
+ if (!confirmed) {
+ return;
+ }
+ setDeleteEntryBusy(true);
+ try {
+ await api.deleteConverterJob(jobId);
+ handleJobDeleted(jobId);
+ setDetailVisible(false);
+ setSelectedJob(null);
+ toastRef.current?.show({
+ severity: 'success',
+ summary: 'Eintrag gelöscht',
+ detail: `Job #${jobId} wurde entfernt.`,
+ life: 3200
+ });
+ await loadJobs();
+ } catch (error) {
+ toastRef.current?.show({
+ severity: 'error',
+ summary: 'Löschen fehlgeschlagen',
+ detail: error.message || 'Unbekannter Fehler',
+ life: 4200
+ });
+ } finally {
+ setDeleteEntryBusy(false);
+ }
+ };
+
+ const handleCancelDetailJob = async (job) => {
+ const jobId = Number(job?.id || selectedJob?.id || 0);
+ if (!jobId) {
+ return;
+ }
+ const confirmed = window.confirm(`Job #${jobId} abbrechen?`);
+ if (!confirmed) {
+ return;
+ }
+ setCancelDetailBusy(true);
+ try {
+ await api.cancelConverterJob(jobId);
+ toastRef.current?.show({
+ severity: 'success',
+ summary: 'Abbruch gesendet',
+ detail: `Job #${jobId} wird abgebrochen.`,
+ life: 2800
+ });
+ await loadJobs();
+ if (detailVisible) {
+ const response = await api.getJob(jobId, { includeLogs: false, forceRefresh: true });
+ setSelectedJob(response.job);
+ }
+ } catch (error) {
+ toastRef.current?.show({
+ severity: 'error',
+ summary: 'Abbruch fehlgeschlagen',
+ detail: error.message || 'Unbekannter Fehler',
+ life: 4200
+ });
+ } finally {
+ setCancelDetailBusy(false);
+ }
+ };
+
const handleJobDeleted = (jobId) => {
setJobs((prev) => prev.filter((j) => j.id !== jobId));
setJobProgress((prev) => {
@@ -155,12 +402,32 @@ export default function ConverterPage() {
delete next[jobId];
return next;
});
+ setExplorerRefreshToken((t) => t + 1);
+ if (Number(selectedJob?.id || 0) === Number(jobId || 0)) {
+ setDetailVisible(false);
+ setSelectedJob(null);
+ setDetailLoading(false);
+ setLogLoadingMode(null);
+ }
};
const handleJobCancelled = () => setTimeout(loadJobs, 1000);
+ const handleJobInputsChanged = async (_jobId, _payload) => {
+ setExplorerRefreshToken((t) => t + 1);
+ await loadJobs();
+ };
- const activeJobs = jobs.filter((j) => !['DONE', 'ERROR', 'CANCELLED'].includes(String(j.status || '').toUpperCase()));
- const finishedJobs = jobs.filter((j) => ['DONE', 'ERROR', 'CANCELLED'].includes(String(j.status || '').toUpperCase()));
+ const activeJobs = jobs.filter((j) => !['DONE', 'FINISHED', 'ERROR', 'CANCELLED'].includes(String(j.status || '').toUpperCase()));
+
+ // Auto-expand: ersten Job aufklappen, wenn keiner expanded ist (außer user hat explizit zugeklappt)
+ useEffect(() => {
+ const normalizedExpanded = Number(expandedJobId) || null;
+ const hasExpanded = activeJobs.some((j) => Number(j.id) === normalizedExpanded);
+ if (hasExpanded) return;
+ if (expandedJobId === null) return; // explizit vom User zugeklappt
+ if (activeJobs.length === 0) return;
+ setExpandedJobId(Number(activeJobs[0].id));
+ }, [activeJobs, expandedJobId]);
const jobsCardHeader = (
@@ -192,6 +459,7 @@ export default function ConverterPage() {
onSelectionChange={handleSelectionChange}
refreshToken={explorerRefreshToken}
navigateToPath={explorerNavigateTo}
+ onAssignmentChanged={loadJobs}
/>
{selectedEntries.length > 0 && (
@@ -210,46 +478,28 @@ export default function ConverterPage() {
{/* Jobs */}
- {jobs.length === 0 ? (
+ {activeJobs.length === 0 ? (
- Keine Jobs vorhanden. Dateien im Import-Ordner auswählen oder per Upload hochladen.
+ Keine aktiven Converter-Jobs vorhanden. Abgeschlossene Jobs findest du in der Historie.
) : (
- <>
- {activeJobs.length > 0 && (
- <>
- Aktiv
-
- {activeJobs.map((job) => (
-
- ))}
-
-
- )}
- {activeJobs.length > 0 && finishedJobs.length > 0 && }
- {finishedJobs.length > 0 && (
- <>
- Abgeschlossen
-
- {finishedJobs.slice(0, 20).map((job) => (
-
- ))}
-
-
- )}
-
+
+ {activeJobs.map((job) => (
+ setExpandedJobId(Number(job.id))}
+ onCollapse={() => setExpandedJobId(null)}
+ onStarted={handleJobStarted}
+ onDeleted={handleJobDeleted}
+ onCancelled={handleJobCancelled}
+ onOpenDetails={handleOpenJobDetails}
+ onInputsChanged={handleJobInputsChanged}
+ />
+ ))}
+
)}
@@ -260,39 +510,83 @@ export default function ConverterPage() {
setJobModeVisible(false)}
/>
+
+ {
+ setDetailVisible(false);
+ setSelectedJob(null);
+ setDetailLoading(false);
+ setLogLoadingMode(null);
+ setDeleteEntryBusy(false);
+ setCancelDetailBusy(false);
+ }}
+ />
);
}
// ── Job-Modus-Dialog ──────────────────────────────────────────────────────────
-function JobModeDialog({ visible, entries, audioMode, onAudioModeChange, busy, onConfirm, onHide }) {
+function JobModeDialog({
+ visible,
+ entries,
+ audioMode,
+ onAudioModeChange,
+ action,
+ onActionChange,
+ assignableJobs,
+ assignJobId,
+ onAssignJobIdChange,
+ busy,
+ onConfirm,
+ onHide
+}) {
const audioEntries = entries.filter(isAudioEntry);
- const nonAudioEntries = entries.filter((e) => !isAudioEntry(e));
- const hasAudio = audioEntries.length > 0;
- const hasNonAudio = nonAudioEntries.length > 0;
- const onlyAudio = hasAudio && !hasNonAudio;
- const mixed = hasAudio && hasNonAudio;
+ const videoEntries = entries.filter(isVideoEntry);
+ const otherEntries = entries.filter((e) => !isAudioEntry(e) && !isVideoEntry(e));
- // Anzahl der Jobs die entstehen werden
+ const hasAudio = audioEntries.length > 0;
+ const hasVideo = videoEntries.length > 0;
+ const hasOther = otherEntries.length > 0;
+ const hasAssignableJobs = Array.isArray(assignableJobs) && assignableJobs.length > 0;
+
+ // Videos immer individual, audio per Modus
const audioJobCount = audioMode === 'shared' ? 1 : audioEntries.length;
- const totalJobs = nonAudioEntries.length + audioJobCount;
+ const totalJobs = videoEntries.length + otherEntries.length + audioJobCount;
+ const isAssignMode = action === 'assign';
+ const confirmLabel = isAssignMode
+ ? 'Dateien zuweisen'
+ : `${totalJobs} Job${totalJobs !== 1 ? 's' : ''} anlegen`;
const footer = (
);
@@ -306,26 +600,27 @@ function JobModeDialog({ visible, entries, audioMode, onAudioModeChange, busy, o
style={{ width: '440px' }}
modal
>
- {/* Nur Videos / Ordner gewählt */}
- {!hasAudio && (
-
- Für jede ausgewählte Datei / jeden Ordner wird ein eigener Job angelegt.
-
- {nonAudioEntries.length} Job{nonAudioEntries.length !== 1 ? 's' : ''} werden erstellt.
+ {/* Videos / Sonstige immer individual */}
+ {(hasVideo || hasOther) && (
+
+ Videos / Sonstige ({videoEntries.length + otherEntries.length}): Je eine Datei ein eigener Job.
)}
- {/* Nur Audio gewählt */}
- {onlyAudio && (
+ {hasAudio && (hasVideo || hasOther) &&
}
+
+ {/* Audio: Abfrage */}
+ {hasAudio && (
Wie sollen die {audioEntries.length} Audiodatei{audioEntries.length !== 1 ? 'en' : ''} verarbeitet werden?
-
+
)}
- {/* Gemischte Auswahl */}
- {mixed && (
-
-
- Videos/Ordner ({nonAudioEntries.length}): Für jede Datei ein eigener Job.
-
-
-
- Audiodateien ({audioEntries.length}): Wie verarbeiten?
-
-
-
+
)}
);
diff --git a/frontend/src/pages/DashboardPage.jsx b/frontend/src/pages/DashboardPage.jsx
index 463f254..f575a96 100644
--- a/frontend/src/pages/DashboardPage.jsx
+++ b/frontend/src/pages/DashboardPage.jsx
@@ -832,22 +832,25 @@ function buildPipelineFromJob(job, currentPipeline, currentPipelineJobId) {
const existingContext = currentPipeline?.context && typeof currentPipeline.context === 'object'
? currentPipeline.context
: {};
+ const mergedCurrentContext = {
+ ...computedContext,
+ ...existingContext,
+ rawPath: existingContext.rawPath || computedContext.rawPath,
+ outputPath: existingContext.outputPath || computedContext.outputPath,
+ tracks: (Array.isArray(existingContext.tracks) && existingContext.tracks.length > 0)
+ ? existingContext.tracks
+ : computedContext.tracks,
+ selectedMetadata: existingContext.selectedMetadata || computedContext.selectedMetadata,
+ canRestartEncodeFromLastSettings:
+ existingContext.canRestartEncodeFromLastSettings ?? computedContext.canRestartEncodeFromLastSettings,
+ canRestartReviewFromRaw:
+ existingContext.canRestartReviewFromRaw ?? computedContext.canRestartReviewFromRaw
+ };
+ // The card always represents `job.id`; never let stale live context override it.
+ mergedCurrentContext.jobId = jobId;
return {
...currentPipeline,
- context: {
- ...computedContext,
- ...existingContext,
- rawPath: existingContext.rawPath || computedContext.rawPath,
- outputPath: existingContext.outputPath || computedContext.outputPath,
- tracks: (Array.isArray(existingContext.tracks) && existingContext.tracks.length > 0)
- ? existingContext.tracks
- : computedContext.tracks,
- selectedMetadata: existingContext.selectedMetadata || computedContext.selectedMetadata,
- canRestartEncodeFromLastSettings:
- existingContext.canRestartEncodeFromLastSettings ?? computedContext.canRestartEncodeFromLastSettings,
- canRestartReviewFromRaw:
- existingContext.canRestartReviewFromRaw ?? computedContext.canRestartReviewFromRaw
- }
+ context: mergedCurrentContext
};
}
@@ -878,6 +881,8 @@ function buildPipelineFromJob(job, currentPipeline, currentPipelineJobId) {
cdRipConfig: liveContext.cdRipConfig || computedContext.cdRipConfig
}
: computedContext;
+ // The card always represents `job.id`; never let stale live context override it.
+ mergedContext.jobId = jobId;
return {
state: ignoreStaleLiveProgress ? jobStatus : (liveJobProgress?.state || jobStatus),
@@ -1073,6 +1078,21 @@ export default function DashboardPage({
setQueueState(normalizeQueue(queueResponse.value?.queue));
}
const shouldDisplayOnDashboard = (job) => {
+ const rawMediaType = String(job?.media_type || '').trim().toLowerCase();
+ const resolvedMediaType = String(job?.mediaType || '').trim().toLowerCase();
+ const planMediaProfile = String(job?.encodePlan?.mediaProfile || '').trim().toLowerCase();
+ const converterPlanType = String(job?.encodePlan?.converterMediaType || '').trim().toLowerCase();
+ const isConverterJob = (
+ rawMediaType === 'converter'
+ || resolvedMediaType === 'converter'
+ || planMediaProfile === 'converter'
+ || converterPlanType === 'audio'
+ || converterPlanType === 'video'
+ || converterPlanType === 'iso'
+ );
+ if (isConverterJob) {
+ return false;
+ }
const normalizedStatus = String(job?.status || '').trim().toUpperCase();
if (!dashboardStatuses.has(normalizedStatus)) {
return false;
@@ -1980,7 +2000,7 @@ export default function DashboardPage({
setJobBusy(normalizedJobId, true);
try {
- const response = await api.restartReviewFromRaw(normalizedJobId);
+ const response = await api.restartReviewFromRaw(normalizedJobId, { reuseCurrentJob: true });
const result = getQueueActionResult(response);
const replacementJobId = normalizeJobId(result?.jobId) || normalizedJobId;
await refreshPipeline();
@@ -2935,6 +2955,7 @@ export default function DashboardPage({
})()}
{!isCdJob && !isAudiobookJob ? (
@@ -3051,6 +3075,9 @@ export default function DashboardPage({
{item.hasChains ?
: null}
{getStatusLabel(item.status)}
+ {clampedQueueProgress > 0 && (
+
+ )}