ff

src/ffx/ffx_controller.py

@@ -146,93 +146,6 @@ class FfxController():
             trackSubIndex += 1
         return audioTokens
 
-# 
-#     # -disposition:s:0 default -disposition:s:1 0
-#     def generateDispositionTokens(self):
-# 
-#         targetTrackDescriptors = self.__targetMediaDescriptor.getAllTrackDescriptors()
-# 
-#         sourceTrackDescriptors = ([] if self.__sourceMediaDescriptor is None
-#                                     else self.__sourceMediaDescriptor.getAllTrackDescriptors())
-# 
-#         dispositionTokens = []
-# 
-#         for trackIndex in range(len(targetTrackDescriptors)):
-# 
-#             td = targetTrackDescriptors[trackIndex]
-# 
-#             #HINT: No dispositions for pgs subtitle tracks that have no external file source
-#             if (td.getExternalSourceFilePath()
-#                         or td.getCodec() != TrackCodec.PGS):
-# 
-#                 subIndex = td.getSubIndex()
-#                 streamIndicator = td.getType().indicator()
-#                 
-# 
-#                 sourceDispositionSet = sourceTrackDescriptors[td.getSourceIndex()].getDispositionSet() if sourceTrackDescriptors else set()
-# 
-#                 #TODO: Alles discarden was im targetDescriptor vorhanden ist (?)
-#                 sourceDispositionSet.discard(TrackDisposition.DEFAULT)
-# 
-#                 dispositionSet = td.getDispositionSet() | sourceDispositionSet
-# 
-#                 if dispositionSet:
-#                     dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '+'.join([d.label() for d in dispositionSet])]
-#                 else:
-#                     dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '0']
-# 
-#         return dispositionTokens
-# 
-# 
-#     def generateMetadataTokens(self):
-# 
-#         metadataTokens = []
-# 
-#         metadataConfiguration = self.__configurationData['metadata'] if 'metadata' in self.__configurationData.keys() else {}
-# 
-#         signatureTags = metadataConfiguration['signature'] if 'signature' in metadataConfiguration.keys() else {}
-#         removeGlobalKeys = metadataConfiguration['remove'] if 'remove' in metadataConfiguration.keys() else []
-#         removeTrackKeys = metadataConfiguration['streams']['remove'] if 'streams' in metadataConfiguration.keys() and 'remove' in metadataConfiguration['streams'].keys() else []
-# 
-#         mediaTags = {k:v for k,v in self.__targetMediaDescriptor.getTags().items() if not k in removeGlobalKeys}
-# 
-#         if (not 'no_signature' in self.__context.keys()
-#                 or not self.__context['no_signature']):
-#             outputMediaTags = mediaTags | signatureTags
-#         else:
-#             outputMediaTags = mediaTags
-# 
-#         for tagKey, tagValue in outputMediaTags.items():
-#             metadataTokens += [f"-metadata:g",
-#                                 f"{tagKey}={tagValue}"]
-# 
-#         for removeKey in removeGlobalKeys:
-#             metadataTokens += [f"-metadata:g",
-#                                 f"{removeKey}="]
-# 
-# 
-#         removeMkvmergeMetadata = (not 'keep_mkvmerge_metadata' in self.__context.keys()
-#                                     or not self.__context['keep_mkvmerge_metadata'])
-# 
-#         #HINT: With current ffmpeg version track metadata tags are not passed to the outfile
-#         for td in self.__targetMediaDescriptor.getAllTrackDescriptors():
-#             
-#             typeIndicator = td.getType().indicator()
-#             subIndex = td.getSubIndex()
-# 
-#             for tagKey, tagValue in td.getTags().items():
-# 
-#                 if not tagKey in removeTrackKeys:
-#                     metadataTokens += [f"-metadata:s:{typeIndicator}:{subIndex}",
-#                                         f"{tagKey}={tagValue}"]
-# 
-#             for removeKey in removeTrackKeys:
-#                 metadataTokens += [f"-metadata:s:{typeIndicator}:{subIndex}",
-#                                     f"{removeKey}="]
-# 
-# 
-#         return metadataTokens
-
 
     def runJob(self,
                 sourcePath,

src/ffx/helper.py

@@ -24,11 +24,11 @@ def dictDiff(a : dict, b : dict, ignoreKeys: list = [], removeKeys: list = []):
     removeKeys: Override diff calculation to remove keys certainly
     """
 
-    a_filtered = {k:v for k,v in a.items() if k not in ignoreKeys}
-    b_filtered = {k:v for k,v in b.items() if k not in ignoreKeys and k not in removeKeys}
+    a_filtered = {k:v for k,v in a.items() if not k in ignoreKeys}
+    b_filtered = {k:v for k,v in b.items() if not k in ignoreKeys and k not in removeKeys}
 
-    a_only = {k:v for k,v in a_filtered.items() if k not in b_filtered.keys()}
-    b_only = {k:v for k,v in b_filtered.items() if k not in a_filtered.keys()}
+    a_only = {k:v for k,v in a_filtered.items() if not k in b_filtered.keys()}
+    b_only = {k:v for k,v in b_filtered.items() if not k in a_filtered.keys()}
 
     a_b = set(a_filtered.keys()) & set(b_filtered.keys())
 

src/ffx/media_descriptor_change_set.py

@@ -40,86 +40,93 @@ class MediaDescriptorChangeSet():
                                     and 'ignore' in metadataConfiguration['streams'].keys() else [])
 
 
+        self.__targetTrackDescriptors = targetMediaDescriptor.getTrackDescriptors() if targetMediaDescriptor is not None else []
+        self.__sourceTrackDescriptors = sourceMediaDescriptor.getTrackDescriptors() if sourceMediaDescriptor is not None else []
+
+        targetMediaTags = targetMediaDescriptor.getTags() if targetMediaDescriptor is not None else {}
+        sourceMediaTags = sourceMediaDescriptor.getTags() if sourceMediaDescriptor is not None else {}
+
+
         self.__changeSetObj = {}
 
-        if targetMediaDescriptor is not None:
+        #if targetMediaDescriptor is not None:
 
-            sourceMediaTags = sourceMediaDescriptor.getTags() if sourceMediaDescriptor is not None else {}
-            targetMediaTags = targetMediaDescriptor.getTags()
 
-            #!!#
-            tagsDiff = dictDiff(sourceMediaTags,
-                                targetMediaTags,
-                                ignoreKeys=self.__ignoreGlobalKeys,
-                                removeKeys=self.__removeGlobalKeys)
 
-            if tagsDiff:
-                self.__changeSetObj[MediaDescriptorChangeSet.TAGS_KEY] = tagsDiff
+        #!!#
+        tagsDiff = dictDiff(sourceMediaTags,
+                            targetMediaTags,
+                            ignoreKeys=self.__ignoreGlobalKeys,
+                            removeKeys=self.__removeGlobalKeys)
 
+        if tagsDiff:
+            self.__changeSetObj[MediaDescriptorChangeSet.TAGS_KEY] = tagsDiff
 
-            self.__targetTrackDescriptors = targetMediaDescriptor.getTrackDescriptors()
-            self.__numTargetTracks = len(self.__targetTrackDescriptors)
 
-            # Current track configuration (of file)
-            self.__sourceTrackDescriptors = sourceMediaDescriptor.getTrackDescriptors() if sourceMediaDescriptor is not None else []
-            self.__numSourceTracks = len(self.__sourceTrackDescriptors)
+        
+        self.__numTargetTracks = len(self.__targetTrackDescriptors)
 
-            maxNumOfTracks = max(self.__numSourceTracks, self.__numTargetTracks)
+        # Current track configuration (of file)
+        
+        self.__numSourceTracks = len(self.__sourceTrackDescriptors)
 
-            trackCompareResult = {}
+        maxNumOfTracks = max(self.__numSourceTracks, self.__numTargetTracks)
+
+        trackCompareResult = {}
 
 
-            for trackIndex in range(maxNumOfTracks):
+        for trackIndex in range(maxNumOfTracks):
 
-                correspondingSourceTrackDescriptors = [st for st in self.__sourceTrackDescriptors if st.getIndex() == trackIndex]
-                correspondingTargetTrackDescriptors = [tt for tt in self.__targetTrackDescriptors if tt.getIndex() == trackIndex]
+            correspondingSourceTrackDescriptors = [st for st in self.__sourceTrackDescriptors if st.getIndex() == trackIndex]
+            correspondingTargetTrackDescriptors = [tt for tt in self.__targetTrackDescriptors if tt.getIndex() == trackIndex]
 
-                # Track present in target but not in source
-                if (not correspondingSourceTrackDescriptors
-                    and correspondingTargetTrackDescriptors):
+            # Track present in target but not in source
+            if (not correspondingSourceTrackDescriptors
+                and correspondingTargetTrackDescriptors):
 
-                    if DIFF_ADDED_KEY not in trackCompareResult.keys():
-                        trackCompareResult[DIFF_ADDED_KEY] = {}
+                if DIFF_ADDED_KEY not in trackCompareResult.keys():
+                    trackCompareResult[DIFF_ADDED_KEY] = {}
 
-                    trackCompareResult[DIFF_ADDED_KEY][trackIndex] = correspondingTargetTrackDescriptors[0]
-                    continue
+                trackCompareResult[DIFF_ADDED_KEY][trackIndex] = correspondingTargetTrackDescriptors[0]
+                continue
 
-                # Track present in target but not in source
-                if (correspondingSourceTrackDescriptors
-                    and not correspondingTargetTrackDescriptors):
+            # Track present in target but not in source
+            if (correspondingSourceTrackDescriptors
+                and not correspondingTargetTrackDescriptors):
 
-                    if DIFF_REMOVED_KEY not in trackCompareResult.keys():
-                        trackCompareResult[DIFF_REMOVED_KEY] = {}
+                if DIFF_REMOVED_KEY not in trackCompareResult.keys():
+                    trackCompareResult[DIFF_REMOVED_KEY] = {}
 
-                    trackCompareResult[DIFF_REMOVED_KEY][trackIndex] = correspondingSourceTrackDescriptors[0]
-                    continue
+                trackCompareResult[DIFF_REMOVED_KEY][trackIndex] = correspondingSourceTrackDescriptors[0]
+                continue
 
-                if (correspondingSourceTrackDescriptors
-                    and correspondingTargetTrackDescriptors):
+            if (correspondingSourceTrackDescriptors
+                and correspondingTargetTrackDescriptors):
 
-                    trackDiff = self.compareTracks(correspondingSourceTrackDescriptors[0], correspondingTargetTrackDescriptors[0])
+                # if correspondingTargetTrackDescriptors[0].getIndex() == 3:
+                #     raise click.ClickException(f"{correspondingSourceTrackDescriptors[0].getDispositionSet()} {correspondingTargetTrackDescriptors[0].getDispositionSet()}")
 
-                    if trackDiff:
-                        if DIFF_CHANGED_KEY not in trackCompareResult.keys():
-                            trackCompareResult[DIFF_CHANGED_KEY] = {}
 
-                        trackCompareResult[DIFF_CHANGED_KEY][trackIndex] = trackDiff
+                trackDiff = self.compareTracks(correspondingTargetTrackDescriptors[0],
+                                                correspondingSourceTrackDescriptors[0])
 
+                if trackDiff:
+                    if DIFF_CHANGED_KEY not in trackCompareResult.keys():
+                        trackCompareResult[DIFF_CHANGED_KEY] = {}
 
-            if trackCompareResult:
-                self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY] = trackCompareResult
+                    trackCompareResult[DIFF_CHANGED_KEY][trackIndex] = trackDiff
+
+
+        if trackCompareResult:
+            self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY] = trackCompareResult
 
 
     def compareTracks(self,
-                targetTrackDescriptor: TrackDescriptor,
+                targetTrackDescriptor: TrackDescriptor = None,
                 sourceTrackDescriptor: TrackDescriptor = None):
 
-        if not isinstance(targetTrackDescriptor, TrackDescriptor):
-            self.__logger.error(f"MediaDescriptorChangeSet.compareTracks(): Argument targetTrackDescriptor is required to be of type TrackDescriptor")
-            raise click.Abort()
-
         sourceTrackTags = sourceTrackDescriptor.getTags() if sourceTrackDescriptor is not None else {}
-        targetTrackTags = targetTrackDescriptor.getTags()
+        targetTrackTags = targetTrackDescriptor.getTags() if targetTrackDescriptor is not None else {}
 
         trackCompareResult = {}
 
@@ -131,17 +138,17 @@ class MediaDescriptorChangeSet():
         if tagsDiffResult:
             trackCompareResult[MediaDescriptorChangeSet.TAGS_KEY] = tagsDiffResult
 
-        sourceDispositions = sourceTrackDescriptor.getDispositionSet()
-        targetDispositions = targetTrackDescriptor.getDispositionSet()
+        sourceDispositionSet = sourceTrackDescriptor.getDispositionSet() if sourceTrackDescriptor is not None else set()
+        targetDispositionSet = targetTrackDescriptor.getDispositionSet() if targetTrackDescriptor is not None else set()
 
-        dispositionDiffResult = setDiff(sourceDispositions, targetDispositions)
+        # if targetTrackDescriptor.getIndex() == 3:
+        #     raise click.ClickException(f"{sourceDispositionSet} {targetDispositionSet}")
+
+        dispositionDiffResult = setDiff(sourceDispositionSet, targetDispositionSet)
 
         if dispositionDiffResult:
             trackCompareResult[MediaDescriptorChangeSet.DISPOSITION_SET_KEY] = dispositionDiffResult
 
-        if trackCompareResult:
-            trackCompareResult[MediaDescriptorChangeSet.TRACK_DESCRIPTOR_KEY] = targetTrackDescriptor
-
         return trackCompareResult
 
 
@@ -151,37 +158,56 @@ class MediaDescriptorChangeSet():
         """
         dispositionTokens = []
 
-        if MediaDescriptorChangeSet.TRACKS_KEY in self.__changeSetObj.keys():
-
-            if DIFF_ADDED_KEY in self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY].keys():
-                addedTracks: dict = self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY][DIFF_ADDED_KEY]
-                trackDescriptor: TrackDescriptor
-                for trackDescriptor in addedTracks.values():
-                    
-                    dispositionSet = trackDescriptor.getDispositionSet()
-
-                    if dispositionSet:
-                        dispositionTokens += [f"-disposition:{trackDescriptor.getType().indicator()}:{trackDescriptor.getSubIndex()}",
-                                                '+'.join([d.label() for d in dispositionSet])]
-
-            if DIFF_CHANGED_KEY in self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY].keys():
-                changedTracks: dict = self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY][DIFF_CHANGED_KEY]
-                trackDiffObj: dict
-                for trackDiffObj in changedTracks.values():
-
-                    addedDispositions = trackDiffObj[DIFF_ADDED_KEY] if DIFF_ADDED_KEY in trackDiffObj.keys() else set()
-                    removedDispositions = trackDiffObj[DIFF_REMOVED_KEY] if DIFF_REMOVED_KEY in trackDiffObj.keys() else set()
-                    unchangedDispositions = trackDiffObj[DIFF_UNCHANGED_KEY] if DIFF_UNCHANGED_KEY in trackDiffObj.keys() else set()
-
-                    targetDispositions = addedDispositions | unchangedDispositions
-
-                    streamIndicator = trackDescriptor.getType().indicator()
-                    subIndex = trackDescriptor.getSubIndex()
-
-                    if targetDispositions:
-                        dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '+'.join([d.label() for d in targetDispositions])]
-                    if not targetDispositions and removedDispositions:
-                        dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '0']
+#         if MediaDescriptorChangeSet.TRACKS_KEY in self.__changeSetObj.keys():
+# 
+#             if DIFF_ADDED_KEY in self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY].keys():
+#                 addedTracks: dict = self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY][DIFF_ADDED_KEY]
+#                 trackDescriptor: TrackDescriptor
+#                 for trackDescriptor in addedTracks.values():
+#                     
+#                     dispositionSet = trackDescriptor.getDispositionSet()
+# 
+#                     if dispositionSet:
+#                         dispositionTokens += [f"-disposition:{trackDescriptor.getType().indicator()}:{trackDescriptor.getSubIndex()}",
+#                                                 '+'.join([d.label() for d in dispositionSet])]
+# 
+#             if DIFF_CHANGED_KEY in self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY].keys():
+#                 changedTracks: dict = self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY][DIFF_CHANGED_KEY]
+#                 trackDiffObj: dict
+# 
+# 
+#                 for trackIndex, trackDiffObj in changedTracks.items():
+# 
+#                     if MediaDescriptorChangeSet.DISPOSITION_SET_KEY in trackDiffObj.keys():
+# 
+#                         dispositionDiffObj: dict = trackDiffObj[MediaDescriptorChangeSet.DISPOSITION_SET_KEY]
+# 
+#                         addedDispositions = dispositionDiffObj[DIFF_ADDED_KEY] if DIFF_ADDED_KEY in dispositionDiffObj.keys() else set()
+#                         removedDispositions = dispositionDiffObj[DIFF_REMOVED_KEY] if DIFF_REMOVED_KEY in dispositionDiffObj.keys() else set()
+#                         unchangedDispositions = dispositionDiffObj[DIFF_UNCHANGED_KEY] if DIFF_UNCHANGED_KEY in dispositionDiffObj.keys() else set()
+# 
+#                         targetDispositions = addedDispositions | unchangedDispositions
+# 
+#                         trackDescriptor = self.__targetTrackDescriptors[trackIndex]
+#                         streamIndicator = trackDescriptor.getType().indicator()
+#                         subIndex = trackDescriptor.getSubIndex()
+# 
+#                         if targetDispositions:
+#                             dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '+'.join([d.label() for d in targetDispositions])]
+#                         # if not targetDispositions and removedDispositions:
+#                         else:
+#                             dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '0']
+        for ttd in self.__targetTrackDescriptors:
+
+            targetDispositions = ttd.getDispositionSet()
+            streamIndicator = ttd.getType().indicator()
+            subIndex = ttd.getSubIndex()
+            
+            if targetDispositions:
+                dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '+'.join([d.label() for d in targetDispositions])]
+            # if not targetDispositions and removedDispositions:
+            else:
+                dispositionTokens += [f"-disposition:{streamIndicator}:{subIndex}", '0']
 
         return dispositionTokens
 
@@ -235,29 +261,29 @@ class MediaDescriptorChangeSet():
             if DIFF_CHANGED_KEY in self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY].keys():
                 changedTracks: dict = self.__changeSetObj[MediaDescriptorChangeSet.TRACKS_KEY][DIFF_CHANGED_KEY]
                 trackDiffObj: dict
-                for trackDiffObj in changedTracks.values():
+                for trackIndex, trackDiffObj in changedTracks.items():
+
+                    if MediaDescriptorChangeSet.TAGS_KEY in trackDiffObj.keys():
 
-                    addedTrackTags = trackDiffObj[DIFF_ADDED_KEY] if DIFF_ADDED_KEY in trackDiffObj.keys() else {}
-                    changedTrackTags = trackDiffObj[DIFF_CHANGED_KEY] if DIFF_CHANGED_KEY in trackDiffObj.keys() else {}
-                    removedTrackTags = trackDiffObj[DIFF_REMOVED_KEY] if DIFF_REMOVED_KEY in trackDiffObj.keys() else {}
+                        tagsDiffObj = trackDiffObj[MediaDescriptorChangeSet.TAGS_KEY]
 
-                    # outputTrackTags = {k:v for k,v in (addedTrackTags | changedTrackTags).items() if k not in self.__removeTrackKeys}
-                    outputTrackTags = addedTrackTags | changedTrackTags
+                        addedTrackTags = tagsDiffObj[DIFF_ADDED_KEY] if DIFF_ADDED_KEY in tagsDiffObj.keys() else {}
+                        changedTrackTags = tagsDiffObj[DIFF_CHANGED_KEY] if DIFF_CHANGED_KEY in tagsDiffObj.keys() else {}
+                        removedTrackTags = tagsDiffObj[DIFF_REMOVED_KEY] if DIFF_REMOVED_KEY in tagsDiffObj.keys() else {}
 
-                    for tagKey, tagValue in outputTrackTags.items():
-                        metadataTokens += [f"-metadata:s:{trackDescriptor.getType().indicator()}"
-                                            + f":{trackDescriptor.getSubIndex()}",
-                                            f"{tagKey}={tagValue}"]
+                        outputTrackTags = addedTrackTags | changedTrackTags
 
-                    for tagKey, tagValue in changedTrackTags.items():
-                        metadataTokens += [f"-metadata:s:{trackDescriptor.getType().indicator()}"
-                                            + f":{trackDescriptor.getSubIndex()}",
-                                            f"{tagKey}={tagValue}"]
+                        trackDescriptor = self.__targetTrackDescriptors[trackIndex]
+
+                        for tagKey, tagValue in outputTrackTags.items():
+                            metadataTokens += [f"-metadata:s:{trackDescriptor.getType().indicator()}"
+                                                + f":{trackDescriptor.getSubIndex()}",
+                                                f"{tagKey}={tagValue}"]
 
-                    for removeKey in removedTrackTags.keys():
-                        metadataTokens += [f"-metadata:s:{trackDescriptor.getType().indicator()}"
-                                            + f":{trackDescriptor.getSubIndex()}",
-                                            f"{removeKey}="]
+                        for removeKey in removedTrackTags.keys():
+                            metadataTokens += [f"-metadata:s:{trackDescriptor.getType().indicator()}"
+                                                + f":{trackDescriptor.getSubIndex()}",
+                                                f"{removeKey}="]
 
         return metadataTokens
 

src/ffx/media_details_screen.py

@@ -211,7 +211,7 @@ class MediaDetailsScreen(Screen):
     def loadProperties(self):
 
         self.__mediaFileProperties = FileProperties(self.context, self.__mediaFilename)
-        self.__currentMediaDescriptor = self.__mediaFileProperties.getMediaDescriptor()
+        self.__sourceMediaDescriptor = self.__mediaFileProperties.getMediaDescriptor()
 
         #HINT: This is None if the filename did not match anything in database
         self.__currentPattern = self.__mediaFileProperties.getPattern()
@@ -222,7 +222,10 @@ class MediaDetailsScreen(Screen):
         # Enumerating differences between media descriptors
         # from file (=current) vs from stored in database (=target)
         try:
-            mdcs = MediaDescriptorChangeSet(self.context, self.__targetMediaDescriptor, self.__currentMediaDescriptor)
+            mdcs = MediaDescriptorChangeSet(self.context,
+                                            self.__targetMediaDescriptor,
+                                            self.__sourceMediaDescriptor)
+
             self.__mediaChangeSetObj = mdcs.getChangeSetObj()
         except ValueError:
             self.__mediaChangeSetObj = {}
@@ -328,7 +331,7 @@ class MediaDetailsScreen(Screen):
             row = (int(show.id), show.name, show.year) # Convert each element to a string before adding
             self.showsTable.add_row(*map(str, row))
 
-        for mediaTagKey, mediaTagValue in self.__currentMediaDescriptor.getTags().items():
+        for mediaTagKey, mediaTagValue in self.__sourceMediaDescriptor.getTags().items():
 
             textColor = None
             if mediaTagKey in self.__ignoreGlobalKeys:
@@ -370,7 +373,7 @@ class MediaDetailsScreen(Screen):
 
         self.tracksTable.clear()
 
-        trackDescriptorList = self.__currentMediaDescriptor.getAllTrackDescriptors()
+        trackDescriptorList = self.__sourceMediaDescriptor.getAllTrackDescriptors()
 
         typeCounter = {}
 
@@ -517,12 +520,12 @@ class MediaDetailsScreen(Screen):
 
         if event.button.id == "select_default_button":
             selectedTrackDescriptor = self.getSelectedTrackDescriptor()
-            self.__currentMediaDescriptor.setDefaultSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
+            self.__sourceMediaDescriptor.setDefaultSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
             self.updateTracks()
 
         if event.button.id == "select_forced_button":
             selectedTrackDescriptor = self.getSelectedTrackDescriptor()
-            self.__currentMediaDescriptor.setForcedSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
+            self.__sourceMediaDescriptor.setForcedSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
             self.updateTracks()
 
 
@@ -602,13 +605,13 @@ class MediaDetailsScreen(Screen):
             if patternId:
                 self.highlightPattern(False)
 
-                for tagKey, tagValue in self.__currentMediaDescriptor.getTags().items():
+                for tagKey, tagValue in self.__sourceMediaDescriptor.getTags().items():
 
                     # Filter tags that make no sense to preserve
                     if tagKey not in self.__ignoreGlobalKeys and not tagKey in self.__removeGlobalKeys:
                         self.__tac.updateMediaTag(patternId, tagKey, tagValue)
 
-                for trackDescriptor in self.__currentMediaDescriptor.getAllTrackDescriptors():
+                for trackDescriptor in self.__sourceMediaDescriptor.getAllTrackDescriptors():
                     self.__tc.addTrack(trackDescriptor, patternId = patternId)
 
 
@@ -650,13 +653,13 @@ class MediaDetailsScreen(Screen):
 
             if DIFF_REMOVED_KEY in self.__mediaChangeSetObj[MediaDescriptorChangeSet.TAGS_KEY].keys():
                 for removedTagKey in self.__mediaChangeSetObj[MediaDescriptorChangeSet.TAGS_KEY][DIFF_REMOVED_KEY].keys():
-                    currentTags = self.__currentMediaDescriptor.getTags()
+                    currentTags = self.__sourceMediaDescriptor.getTags()
                     # click.ClickException(f"delete media tag patternId={self.__currentPattern.getId()} removedTagKey={removedTagKey} currentTags={currentTags[removedTagKey]}")
                     self.__tac.updateMediaTag(self.__currentPattern.getId(), removedTagKey, currentTags[removedTagKey])
 
             if DIFF_CHANGED_KEY in self.__mediaChangeSetObj[MediaDescriptorChangeSet.TAGS_KEY].keys():
                 for changedTagKey in self.__mediaChangeSetObj[MediaDescriptorChangeSet.TAGS_KEY][DIFF_CHANGED_KEY].keys():
-                    currentTags = self.__currentMediaDescriptor.getTags()
+                    currentTags = self.__sourceMediaDescriptor.getTags()
                     # click.ClickException(f"delete media tag patternId={self.__currentPattern.getId()} changedTagKey={changedTagKey} currentTags={currentTags[changedTagKey]}")
                     self.__tac.updateMediaTag(self.__currentPattern.getId(), changedTagKey, currentTags[changedTagKey])
 
@@ -687,7 +690,7 @@ class MediaDetailsScreen(Screen):
                     targetTrackId = targetTracks[0].getId() if targetTracks else None
                     targetTrackIndex = targetTracks[0].getIndex() if targetTracks else None
 
-                    changedCurrentTracks = [t for t in self.__currentMediaDescriptor.getTrackDescriptors() if t.getIndex() == trackIndex]
+                    changedCurrentTracks = [t for t in self.__sourceMediaDescriptor.getTrackDescriptors() if t.getIndex() == trackIndex]
                     # changedCurrentTrackId #HINT: Undefined as track descriptors do not come from file with track_id 
 
                     if TrackDescriptor.TAGS_KEY in trackDiff.keys():