FfxController: metadata und disposition tokens krude

.gitignore

@@ -1,2 +1,3 @@
 __pycache__
 junk/
+.vscode/launch.json

bin/ffx.py

@@ -246,7 +246,6 @@ def convert(ctx,
 
 #     click.echo(f"\nVideo encoder: {video_encoder}")
     
-    ffx = FfxController()
 
     qualityTokens = quality.split(',')
     q_list = [q for q in qualityTokens if q.isnumeric()]
@@ -331,17 +330,22 @@ def convert(ctx,
         currentPattern = mediaFileProperties.getPattern()
 
         targetMediaDescriptor = currentPattern.getMediaDescriptor() if currentPattern is not None else None
-        targetMediaDescriptor.setJellyfinOrder(context['jellyfin'])
 
         click.echo(f"Pattern matching: {'No' if currentPattern is None else 'Yes'}")
 
         if not currentPattern is None:
 
+            targetMediaDescriptor.setJellyfinOrder(context['jellyfin'])
+
             click.echo(f"Input mapping tokens: {targetMediaDescriptor.getInputMappingTokens()}")
 
-            mappingTokens = ffx.generateMappingTokensFromDescriptors(currentMediaDescriptor, targetMediaDescriptor)
+            fc = FfxController(currentMediaDescriptor, targetMediaDescriptor)
 
-            click.echo(f"Mapping Tokens: {mappingTokens}")
+            mappingTokens = fc.generateMetadataTokens()
+            click.echo(f"Metadata Tokens: {mappingTokens}")
+            
+            dispositionTokens = fc.generateDispositionTokens()
+            click.echo(f"Disposition Tokens: {dispositionTokens}")
 
 
 #         # Determine season and episode if present in current filename

bin/ffx/ffx_controller.py

@@ -37,6 +37,11 @@ class FfxController():
 
     INPUT_FILE_EXTENSIONS = ['mkv', 'mp4', 'avi', 'flv', 'webm']
 
+    def __init__(self, sourceMediaDescriptor : MediaDescriptor, targetMediaDescriptor : MediaDescriptor):
+
+        self.__sourceMediaDescriptor = sourceMediaDescriptor
+        self.__targetMediaDescriptor = targetMediaDescriptor
+
 
     # def getReorderedSubstreams(subDescriptor, last):
     #     numSubStreams = len(subDescriptor)
@@ -139,120 +144,181 @@ class FfxController():
         return clearTokens
 
 
-    def getDispositionFlags(self, subStreamDescriptor):
-        return {k for (k,v) in subStreamDescriptor['disposition'].items() if v == 1} if 'disposition' in subStreamDescriptor.keys() else set()
 
-
+    def generateDispositionTokens(self):
-
-    # def generateDispositionTokens(subDescriptor):
-    def generateDispositionTokens(self, subDescriptor, modifyOrder = []):
         """-disposition:s:X default+forced"""
         
+        sourceTrackDescriptors = self.__sourceMediaDescriptor.getAllTrackDescriptors()
+        targetTrackDescriptors = self.__targetMediaDescriptor.getReorderedTrackDescriptors()
+        
+
         dispositionTokens = []
 
-        for subStreamIndex in range(len(subDescriptor)):
+        # for subStreamIndex in range(len(subDescriptor)):
+        for trackDescriptor in targetTrackDescriptors:
 
-            sourceSubStreamIndex = modifyOrder[subStreamIndex] if modifyOrder else subStreamIndex
+            # Calculate source sub index
+            changedTargetTrackDescriptor : TrackDescriptor = targetTrackDescriptors[trackDescriptor.getIndex()]
+            changedTargetTrackSourceIndex = changedTargetTrackDescriptor.getSourceIndex()
+            sourceSubIndex = sourceTrackDescriptors[changedTargetTrackSourceIndex].getSubIndex()
 
-            subStream = subDescriptor[sourceSubStreamIndex]
+            streamIndicator = trackDescriptor.getType().indicator()
+            dispositionSet = trackDescriptor.getDispositionSet()
 
-            streamType = subStream['codec_type'][0] # v|a|s
+            if dispositionSet:
-            dispositionFlags = self.getDispositionFlags(subStream)
+                dispositionTokens += [f"-disposition:{streamIndicator}:{sourceSubIndex}", '+'.join([d.label() for d in dispositionSet])]
-
-            if dispositionFlags:
-                dispositionTokens += [f"-disposition:{streamType}:{subStreamIndex}", '+'.join(dispositionFlags)]
             else:
-                dispositionTokens += [f"-disposition:{streamType}:{subStreamIndex}", '0']
+                dispositionTokens += [f"-disposition:{streamIndicator}:{sourceSubIndex}", '0']
 
         return dispositionTokens
 
 
 
-    def generateMappingTokensFromDescriptors(self, sourceMediaDescriptor : MediaDescriptor, targetMediaDescriptor : MediaDescriptor):
+    def generateMetadataTokens(self):
 
         mappingTokens = []
         
-        mediaDifferences = targetMediaDescriptor.compare(sourceMediaDescriptor)
+        # click.echo(f"source media descriptor: track indices={[d.getIndex() for d in sourceMediaDescriptor.getAllTrackDescriptors()]}")
+        # click.echo(f"target media descriptor: track indices={[d.getIndex() for d in targetMediaDescriptor.getAllTrackDescriptors()]}")
+
+                            # +jellyfin                     -jellyfin
+        mediaDifferences = self.__targetMediaDescriptor.compare(self.__sourceMediaDescriptor)
+
+        # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}}
 
         click.echo(f"media diff {mediaDifferences}")
 
         if MediaDescriptor.TAGS_KEY in mediaDifferences.keys():
 
-            sourceTags = sourceMediaDescriptor.getTags()
+            sourceTags = self.__sourceMediaDescriptor.getTags()
-            targetTags = targetMediaDescriptor.getTags()
+            targetTags = self.__targetMediaDescriptor.getTags()
 
-            if DIFF_ADDED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
-                for addedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
-                    # row = (f"added media tag: key='{addedTagKey}' value='{targetTags[addedTagKey]}'",)
-                    # self.differencesTable.add_row(*map(str, row))
-                    pass 
 
             if DIFF_REMOVED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
-                for removedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
+                # for removedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
                     # row = (f"removed media tag: key='{removedTagKey}' value='{sourceTags[removedTagKey]}'",)
                     # self.differencesTable.add_row(*map(str, row))
-                    pass
+                mappingTokens += [f"-map_metadata:g", "-1"]
                 
-            if DIFF_CHANGED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                for targetMediaTagKey in targetTags:
-                for changedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
+                    mappingTokens += [f"-metadata:g", f"{targetMediaTagKey}={targetTags[targetMediaTagKey]}"]
-                    # row = (f"changed media tag: key='{changedTagKey}' value='{sourceTags[changedTagKey]}'->'{targetTags[changedTagKey]}'",)
+
-                    # self.differencesTable.add_row(*map(str, row))
+            else:
-                    pass
+
+                if DIFF_ADDED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                    for addedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
+                        # row = (f"added media tag: key='{addedTagKey}' value='{targetTags[addedTagKey]}'",)
+                        click.echo(f"added metadata key='{addedTagKey}' value='{targetTags[addedTagKey]}'->'{targetTags[addedTagKey]}'")
+                        # self.differencesTable.add_row(*map(str, row))
+                        #pass 
+                        mappingTokens += [f"-metadata:g", f"{addedTagKey}={targetTags[addedTagKey]}"]
+
+
+
+                if DIFF_CHANGED_KEY in mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
+                    for changedTagKey in mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
+                        #row = (f"changed media tag: key='{changedTagKey}' value='{sourceTags[changedTagKey]}'->'{targetTags[changedTagKey]}'",)
+                        click.echo(f"changed metadata key='{changedTagKey}' value='{sourceTags[changedTagKey]}'->'{targetTags[changedTagKey]}'")
+                        # self.differencesTable.add_row(*map(str, row))
+                        #pass
+                        mappingTokens += [f"-metadata:g", f"{changedTagKey}={targetTags[changedTagKey]}"]
 
         if MediaDescriptor.TRACKS_KEY in mediaDifferences.keys():
 
-            sourceTracks = sourceMediaDescriptor.getAllTracks() # 0,1,2,3
+            sourceTrackDescriptors = self.__sourceMediaDescriptor.getAllTrackDescriptors()
-            targetTracks = targetMediaDescriptor.getAllTracks() # 0 <- from DB
+            targetTrackDescriptors = self.__targetMediaDescriptor.getReorderedTrackDescriptors()
 
             if DIFF_ADDED_KEY in mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
                 addedTracksIndices = mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]
-                raise click.ClickException(f"FfxController.generateMappingTokensFromDescriptors(): Adding tracks is not supported. Track indices {addedTracksIndices}")
+                raise click.ClickException(f"FfxController.generateMetadataTokens(): Adding tracks is not supported. Track indices {addedTracksIndices}")
 
                 #raise click.ClickException(f"add track {mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]}")
                 #for addedTrackIndex in mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
-                    #addedTrack : Track = targetTracks[addedTrackIndex]                        
+                    #addedTrack : Track = targetTrackDescriptors[addedTrackIndex]                        
                     # row = (f"added {addedTrack.getType().label()} track: index={addedTrackIndex} lang={addedTrack.getLanguage().threeLetter()}",)
                     # self.differencesTable.add_row(*map(str, row))  
 
             if DIFF_REMOVED_KEY in mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
                 removedTracksIndices = mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY].keys()
-                raise click.ClickException(f"FfxController.generateMappingTokensFromDescriptors(): Removing tracks is not supported. Track indices {removedTracksIndices}")
+                raise click.ClickException(f"FfxController.generateMetadataTokens(): Removing tracks is not supported. Track indices {removedTracksIndices}")
                 #for removedTrackIndex in mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY]:
                     # row = (f"removed track: index={removedTrackIndex}",)
                     # self.differencesTable.add_row(*map(str, row))  
 
+            # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}}
             if DIFF_CHANGED_KEY in mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
                 for changedTrackIndex in mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].keys():
 
-                    changedTrack : Track = targetTracks[changedTrackIndex]
+                    changedTargetTrackDescriptor : TrackDescriptor = targetTrackDescriptors[changedTrackIndex]
+                    changedTargetTrackSourceIndex = changedTargetTrackDescriptor.getSourceIndex()
+                    changedTargetSourceSubIndex = sourceTrackDescriptors[changedTargetTrackSourceIndex].getSubIndex()
+                    # changedSourceTrackDescriptor : TrackDescriptor = sourceTrackDescriptors[changedTargetTrackSourceIndex]
+                    # changedSourceTrackSubIndex = changedSourceTrackDescriptor.getSubIndex()
+
                     changedTrackDiff : dict = mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY][changedTrackIndex]                        
 
                     if MediaDescriptor.TAGS_KEY in changedTrackDiff.keys():
 
-                        if DIFF_ADDED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
-                            for addedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
-                                addedTagValue = changedTrack.getTags()[addedTagKey]
-                                # row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} added key={addedTagKey} value={addedTagValue}",)
-                                # self.differencesTable.add_row(*map(str, row))
-                                pass
 
                         if DIFF_REMOVED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
-                            for removedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
+                            #for removedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
-                                # row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed key={removedTagKey}",)
+                                # row = (f"changed {changedTargetTrackDescriptor.getType().label()} track index={changedTrackIndex} removed key={removedTagKey}",)
                                 # self.differencesTable.add_row(*map(str, row))
-                                pass
                                 
-                    if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys():
+                                #addedTagValue = targetTrackDescriptors[changedTargetTrackSourceIndex].getTags()[addedTagKey]
 
-                        if DIFF_ADDED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
+                            mappingTokens += [f"-map_metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}", "-1"]
-                            for addedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_ADDED_KEY]:
-                                # row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} added disposition={addedDisposition.label()}",)
-                                # self.differencesTable.add_row(*map(str, row))
-                                pass
                             
-                        if DIFF_REMOVED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
+                            for targetTrackTagKey, targetTrackTagValue in changedTargetTrackDescriptor.getTags():
-                            for removedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_REMOVED_KEY]:
+                                mappingTokens += [f"-metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}",
-                                # row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed disposition={removedDisposition.label()}",)
+                                                        f"{targetTrackTagKey}={targetTrackTagValue}"]
-                                # self.differencesTable.add_row(*map(str, row))
-                                pass
 
+                        else:
+
+                            # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}}
+                            if DIFF_ADDED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
+                                for addedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
+
+                                    addedTagValue = targetTrackDescriptors[changedTargetTrackSourceIndex].getTags()[addedTagKey]
+                                    
+                                    # addedTagValue = changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY][addedTagKey]
+
+                                    # click.echo(f"addedTagValue={addedTagValue}")
+                                    # click.echo(f"sourceTrackDescriptors: subindex={[s.getSubIndex() for s in sourceTrackDescriptors]} sourceindex={[s.getSourceIndex() for s in sourceTrackDescriptors]} tags={[s.getTags() for s in sourceTrackDescriptors]}")
+                                    # click.echo(f"targetTrackDescriptors: subindex={[t.getSubIndex() for t in targetTrackDescriptors]} sourceindex={[t.getSourceIndex() for t in targetTrackDescriptors]} tags={[t.getTags() for t in targetTrackDescriptors]}")
+                                    # click.echo(f"changed track_index={changedTrackIndex} indicator={changedTargetTrackDescriptor.getType().indicator()} key={addedTagKey} value={addedTagValue} source_index={changedSourceTrackIndex}")
+                                    
+                                    mappingTokens += [f"-metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}",
+                                                        f"{addedTagKey}={addedTagValue}"]
+
+                            # media diff {'tracks': {'changed': {4: {'tags': {'added': {'Yolo'}}}}}}
+                            if DIFF_CHANGED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
+                                for changedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
+
+                                    changedTagValue = targetTrackDescriptors[changedTargetTrackSourceIndex].getTags()[changedTagKey]
+                                    # sourceSubIndex = sourceTrackDescriptors[changedTargetTrackSourceIndex].getSubIndex()
+                                    # addedTagValue = changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY][addedTagKey]
+
+                                    # click.echo(f"addedTagValue={addedTagValue}")
+                                    # click.echo(f"sourceTrackDescriptors: subindex={[s.getSubIndex() for s in sourceTrackDescriptors]} sourceindex={[s.getSourceIndex() for s in sourceTrackDescriptors]} tags={[s.getTags() for s in sourceTrackDescriptors]}")
+                                    # click.echo(f"targetTrackDescriptors: subindex={[t.getSubIndex() for t in targetTrackDescriptors]} sourceindex={[t.getSourceIndex() for t in targetTrackDescriptors]} tags={[t.getTags() for t in targetTrackDescriptors]}")
+                                    # click.echo(f"changed track_index={changedTrackIndex} indicator={changedTargetTrackDescriptor.getType().indicator()} key={addedTagKey} value={addedTagValue} source_index={changedSourceTrackIndex}")
+                                    
+                                    mappingTokens += [f"-metadata:s:{changedTargetTrackDescriptor.getType().indicator()}:{changedTargetSourceSubIndex}",
+                                                        f"{changedTagKey}={changedTagValue}"]
+
+#                     if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys():
+# 
+#                         if DIFF_ADDED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
+#                             for addedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_ADDED_KEY]:
+#                                 # row = (f"changed {changedTargetTrackDescriptor.getType().label()} track index={changedTrackIndex} added disposition={addedDisposition.label()}",)
+#                                 # self.differencesTable.add_row(*map(str, row))
+#                                 pass
+# 
+#                         if DIFF_REMOVED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
+#                             for removedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_REMOVED_KEY]:
+#                                 # row = (f"changed {changedTargetTrackDescriptor.getType().label()} track index={changedTrackIndex} removed disposition={removedDisposition.label()}",)
+#                                 # self.differencesTable.add_row(*map(str, row))
+#                                 pass
+
+        return mappingTokens

bin/ffx/helper.py

@@ -1,6 +1,7 @@
 DIFF_ADDED_KEY = 'added'
 DIFF_REMOVED_KEY = 'removed'
 DIFF_CHANGED_KEY = 'changed'
+DIFF_UNCHANGED_KEY = 'unchanged'
 
 def dictDiff(a : dict, b : dict):
 
@@ -15,8 +16,10 @@ def dictDiff(a : dict, b : dict):
 
     diffResult = {}
 
+
     if a_only:
         diffResult[DIFF_REMOVED_KEY] = a_only
+        diffResult[DIFF_UNCHANGED_KEY] = b_keys
     if b_only:
         diffResult[DIFF_ADDED_KEY] = b_only
     if changed:

bin/ffx/media_descriptor.py

@@ -27,6 +27,10 @@ class MediaDescriptor():
 
     JELLYFIN_ORDER_FLAG_KEY = 'jellyfin_order'
     
+    EXCLUDED_MEDIA_TAGS = [
+            'creation_time'
+    ]
+
     def __init__(self, **kwargs):
 
         if MediaDescriptor.TAGS_KEY in kwargs.keys():
@@ -139,7 +143,7 @@ class MediaDescriptor():
         return self.__mediaTags
 
 
-    def getAllTracks(self) -> List[TrackDescriptor]:
+    def getAllTrackDescriptors(self) -> List[TrackDescriptor]:
         return self.getVideoTracks() + self.getAudioTracks() + self.getSubtitleTracks()
 
     def getVideoTracks(self) -> List[TrackDescriptor]:
@@ -175,12 +179,22 @@ class MediaDescriptor():
     def getClearTags(self):
         return self.__clearTags
 
+
+
     def compare(self, vsMediaDescriptor : Self):
 
         if not isinstance(vsMediaDescriptor, self.__class__):
                 raise click.ClickException(f"MediaDescriptor.compare(): Argument is required to be of type {self.__class__}")
 
-        tagsDiff = dictDiff(vsMediaDescriptor.getTags(), self.getTags())
+        vsTags = vsMediaDescriptor.getTags()
+        tags = self.getTags()
+        
+        #HINT: Some tags differ per file, for example creation_time, so these are removed before diff
+        for emt in MediaDescriptor.EXCLUDED_MEDIA_TAGS:
+                del tags[emt]
+                del vsTags[emt]
+
+        tagsDiff = dictDiff(vsTags, tags)
 
         compareResult = {}
 
@@ -189,12 +203,12 @@ class MediaDescriptor():
 
 
         # Target track configuration (from DB)
-        #tracks = self.getAllTracks()
+        #tracks = self.getAllTrackDescriptors()
         tracks = self.getReorderedTrackDescriptors()
         numTracks = len(tracks)
 
         # Current track configuration (of file)
-        vsTracks = vsMediaDescriptor.getAllTracks()
+        vsTracks = vsMediaDescriptor.getAllTrackDescriptors()
         numVsTracks = len(vsTracks)
 
         maxNumOfTracks = max(numVsTracks, numTracks)
@@ -204,6 +218,13 @@ class MediaDescriptor():
 
         for tp in range(maxNumOfTracks):
                 
+                # if self.__jellyfinOrder:
+                #         vsTrackIndex = tracks[tp].getSourceIndex()
+                # else:
+                #         vsTrackIndex = tp
+                
+                vsTrackIndex = tracks[tp].getSourceIndex()
+
                 # Will trigger if tracks are missing in file
                 if tp > (numVsTracks - 1):
                         if DIFF_ADDED_KEY not in trackCompareResult.keys():
@@ -216,16 +237,16 @@ class MediaDescriptor():
                 if tp > (numTracks - 1):
                         if DIFF_REMOVED_KEY not in trackCompareResult.keys():
                                 trackCompareResult[DIFF_REMOVED_KEY] = {}
-                        trackCompareResult[DIFF_REMOVED_KEY][vsTracks[tp].getIndex()] = vsTracks[tp]
+                        trackCompareResult[DIFF_REMOVED_KEY][vsTracks[vsTrackIndex].getIndex()] = vsTracks[vsTrackIndex]
                         continue
 
                 # assumption is made here that the track order will not change for all files of a sequence
-                trackDiff = tracks[tp].compare(vsTracks[tp])
+                trackDiff = tracks[tp].compare(vsTracks[vsTrackIndex])
 
                 if trackDiff:
                         if DIFF_CHANGED_KEY not in trackCompareResult.keys():
                                 trackCompareResult[DIFF_CHANGED_KEY] = {}
-                        trackCompareResult[DIFF_CHANGED_KEY][vsTracks[tp].getIndex()] = trackDiff
+                        trackCompareResult[DIFF_CHANGED_KEY][vsTracks[vsTrackIndex].getIndex()] = trackDiff
 
         if trackCompareResult:
               compareResult[MediaDescriptor.TRACKS_KEY] = trackCompareResult
@@ -233,6 +254,7 @@ class MediaDescriptor():
         return compareResult
 
 
+
     def getInputMappingTokens(self, use_sub_index : bool = True):
 
         reorderedTrackDescriptors = self.getReorderedTrackDescriptors()

bin/ffx/media_details_screen.py

@@ -188,8 +188,8 @@ class MediaDetailsScreen(Screen):
 
         if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():
 
-            currentTracks = self.__currentMediaDescriptor.getAllTracks() # 0,1,2,3
+            currentTracks = self.__currentMediaDescriptor.getAllTrackDescriptors() # 0,1,2,3
-            targetTracks = self.__targetMediaDescriptor.getAllTracks() # 0 <- from DB
+            targetTracks = self.__targetMediaDescriptor.getAllTrackDescriptors() # 0 <- from DB
 
             if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
 
@@ -281,7 +281,7 @@ class MediaDetailsScreen(Screen):
 
         self.tracksTable.clear()
 
-        trackDescriptorList = self.__currentMediaDescriptor.getAllTracks()
+        trackDescriptorList = self.__currentMediaDescriptor.getAllTrackDescriptors()
 
         typeCounter = {}
 
@@ -501,7 +501,7 @@ class MediaDetailsScreen(Screen):
             if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
 
                 for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
-                    targetTracks = [t for t in self.__targetMediaDescriptor.getAllTracks() if t.getIndex() == addedTrackIndex]
+                    targetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == addedTrackIndex]
                     if targetTracks:
                         self.__tc.deleteTrack(targetTracks[0].getId()) # id
 
@@ -514,11 +514,11 @@ class MediaDetailsScreen(Screen):
                 # [vsTracks[tp].getIndex()] = trackDiff
                 for changedTrackIndex, changedTrackDiff in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].items():
 
-                    changedTargetTracks = [t for t in self.__targetMediaDescriptor.getAllTracks() if t.getIndex() == changedTrackIndex]
+                    changedTargetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
                     changedTargeTrackId = changedTargetTracks[0].getId() if changedTargetTracks else None
                     changedTargetTrackIndex = changedTargetTracks[0].getIndex() if changedTargetTracks else None
 
-                    changedCurrentTracks = [t for t in self.__currentMediaDescriptor.getAllTracks() if t.getIndex() == changedTrackIndex]
+                    changedCurrentTracks = [t for t in self.__currentMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
                     # changedCurrentTrackId #HINT: Undefined as track descriptors do not come from file with track_id 
 
                     if TrackDescriptor.TAGS_KEY in changedTrackDiff.keys():