tictacsync 0.97a0__py3-none-any.whl → 0.98a0__py3-none-any.whl

tictacsync/device_scanner.py

@@ -6,7 +6,6 @@
 TRACKSFN = 'tracks.txt'
 SILENT_TRACK_TOKENS = '-0n'
 
-
 av_file_extensions = \
 """webm mkv flv flv vob ogv ogg drc gif gifv mng avi MTS M2TS TS mov qt
 wmv yuv rm rmvb viv asf amv mp4 m4p m4v mpg mp2 mpeg mpe mpv mpg mpeg m2v
@@ -40,6 +39,8 @@ try:
 except:
     import multi2polywav
 
+MCCDIR = 'SyncedMulticamClips'
+SYNCEDFOLDER = 'SyncedMedia'
 
 # utility for accessing pathnames
 def _pathname(tempfile_or_path):
@@ -73,7 +74,7 @@ class Tracks:
 @dataclass
 class Device:
     UID: int
-    folder: Path
+    folder: Path # media's parent folder
     name: str
     dev_type: str # CAM or REC
     n_chan: int
@@ -97,7 +98,7 @@ def media_at_path(input_structure, p):
     dev_UID, dt, sf = get_device_ffprobe_UID(p)
     dev_name = None
     logger.debug('ffprobe dev_UID:%s dt:%s sf:%s'%(dev_UID, dt,sf))
-    if input_structure == 'folder_is_device':
+    if input_structure == 'ordered':
         dev_name = p.parent.name
         if dev_UID is None:
             dev_UID = hash(dev_name)
@@ -132,7 +133,7 @@ def get_device_ffprobe_UID(file):
     """
     Tries to find an unique hash integer identifying the device that produced
     the file based on the string inside ffprobe metadata  without any
-    reference to date nor length nor time. Find out with ffprobe the type
+    reference to date, location, length or time. Find out with ffprobe the type
     of device: CAM or REC for videocamera or audio recorder.
 
     Device UIDs are used later in Montage._get_concatenated_audiofile_for()
@@ -192,7 +193,7 @@ def get_device_ffprobe_UID(file):
 class Scanner:
     """
     Class that encapsulates scanning of the directory given as CLI argument.
-    Depending on the input_structure detected (loose|folder_is_device), enforce
+    Depending on the input_structure detected (loose|ordered), enforce
     some directory structure (or not). Build a list of media files found and a
     try to indentify uniquely the device used to record each media file.
 
@@ -202,15 +203,15 @@ class Scanner:
             Any of:
                 'loose'
                     all files audio + video are in top folder
-                'folder_is_device'
+                'ordered'
                     eg for multicam on Davinci Resolve
             input_structure is set in scan_media_and_build_devices_UID()
 
         top_directory : string
             String of path where to start searching for media files.
 
-        top_dir_has_multicam : bool
-            If top dir is folder structures AND more than on cam
+        # top_dir_has_multicam : bool
+        #     If top dir is folder structures AND more than on cam
 
         found_media_files: list of Media objects
     """
@@ -243,6 +244,15 @@ class Scanner:
         CAMs = [d for d in devices if d.dev_type == 'CAM']
         return len(set(CAMs))
 
+    def get_device_in_path(self, a_media):
+        """
+        Return a device name taken from folders in path of a_media if and only
+        if all media files below it are from the same device. Goes up max two
+        levels from media; e.g., in /FOLDER2/FOLDER1/DSC00234.MOV will test up
+        to FOLDER2 as candidate.
+        """
+
+
     def scan_media_and_build_devices_UID(self, recursive=True):
         """
         Scans Scanner.top_directory recursively for files with known audio-video
@@ -256,7 +266,7 @@ class Scanner:
 
         Populates Scanner.found_media_files, a list of Media objects
 
-        Sets Scanner.input_structure = 'loose'|'folder_is_device'
+        Sets Scanner.input_structure = 'loose'|'ordered'
 
         """
         files = Path(self.top_directory).rglob('*.*')
@@ -264,81 +274,137 @@ class Scanner:
             p
             for p in files
             if p.suffix[1:] in av_file_extensions
-            and 'SyncedMedia' not in p.parts
+            and SYNCEDFOLDER not in p.parts # SyncedMedia
+            and MCCDIR not in p.parts # SyncedMulticamClips
         ]
         logger.debug('found media files %s'%paths)
         parents = [p.parent for p in paths]
-        logger.debug('found parents %s'%parents)
-        def _list_all_the_same(a_list):
-            return a_list.count(a_list[0]) == len(a_list)
-        all_parents_are_the_same = _list_all_the_same(parents)
-        logger.debug('all_parents_are_the_same %s'%all_parents_are_the_same)
-        if all_parents_are_the_same:
+        logger.debug('found parents %s'%pformat(parents))
+        # True if all elements are identical
+        AV_files_have_same_parent = parents.count(parents[0]) == len(parents)
+        logger.debug('AV_files_have_same_parent %s'%AV_files_have_same_parent)
+        if AV_files_have_same_parent:
             # all media (video + audio) are in a same folder, so this is loose
             self.input_structure = 'loose'
             # for now (TO DO?) 'loose' == no multi-cam
-            self.top_dir_has_multicam = False
+            # self.top_dir_has_multicam = False
         else:
-            # check later if inside each folder, media have same device,
-            # for now, we'll guess structure is 'folder_is_device'
-            self.input_structure = 'folder_is_device'
+            # check later if inside each folder, media have same device
+            # for now, we'll guess structure is 'ordered'
+            self.input_structure = 'ordered'
         for p in paths:
             new_media = media_at_path(self.input_structure, p) # dev UID set here
             self.found_media_files.append(new_media)
-        def _try_name(medias):
+        # for non UIDed try building UID from filenam
+        def _try_name_from_files(medias):
             # return common first strings in filename
+            def _all_identical(a_list):
+                return a_list.count(a_list[0]) == len(a_list)
             names = [m.path.name for m in medias]
             transposed_names = list(map(list, zip(*names)))
-            same = list(map(_list_all_the_same, transposed_names))
+            same = list(map(_all_identical, transposed_names))
             try:
                 first_diff = same.index(False)
             except:
                 return names[0].split('.')[0]
             return names[0][:first_diff]
-        no_device_UID_media = [m for m in self.found_media_files
+        no_device_UID_medias = [m for m in self.found_media_files
                     if not m.device.UID]
-        if no_device_UID_media:
-            logger.debug('no_device_UID_media %s'%no_device_UID_media)
-            start_string = _try_name(no_device_UID_media)
+        logger.debug('those media have no device UID %s'%no_device_UID_medias)
+        if no_device_UID_medias:
+            # will guess a device name from media filenames
+            logger.debug('no_device_UID_medias %s'%no_device_UID_medias)
+            start_string = _try_name_from_files(no_device_UID_medias)
             if len(start_string) < 2:
                 print('\nError, cant identify the device for those files:')
-                [print('%s, '%m.path.name, end='') for m in no_device_UID_media]
+                [print('%s, '%m.path.name, end='') for m in no_device_UID_medias]
                 print('\n')
                 sys.exit(1)
-            one_device = no_device_UID_media[0].device
+            one_device = no_device_UID_medias[0].device
             one_device.name = start_string
             if not one_device.UID:
                 one_device.UID = hash(start_string)
             print('\nWarning, guessing a device ID for those files:')
             [print('[gold1]%s[/gold1], '%m.path.name, end='') for m
-                                            in no_device_UID_media]
+                                            in no_device_UID_medias]
             print('UID: [gold1]%s[/gold1]'%start_string)
-            for m in no_device_UID_media:
+            for m in no_device_UID_medias:
                 m.device = one_device
             logger.debug('new device added %s'%self.found_media_files)
-        logger.debug('Scanner.found_media_files = %s'%self.found_media_files)
-        if self.input_structure == 'folder_is_device':
-            self._check_folders_have_same_device()
+        logger.debug('Scanner.found_media_files = %s'%pformat(self.found_media_files))
+        if self.input_structure == 'ordered':
+            self._confirm_folders_have_same_device()
             # self._use_folder_as_device_name()
             devices = set([m.device for m in self.found_media_files])
             audio_devices = [d for d in devices if d.dev_type == 'REC']
             for recorder in audio_devices:
+                # process tracks.txt for audio recorders
                 recorder.tracks = self._get_tracks_from_file(recorder)
+                # logging only:
                 if recorder.tracks:
                     if not all([lv == None for lv in recorder.tracks.lag_values]):
                         logger.debug('%s has lag_values %s'%(
                                 recorder.name, recorder.tracks.lag_values))
+            # check if device is in fact two parents up (and parent = ROLLxx):
+            # Group media by folder 2up and verify all media for each
+            # group have same device.
+            folder2up = lambda m: m.path.parent.parent
+            # logger.debug('folder2up: %s'%pformat([folder2up(m) for m
+            #                                 in self.found_media_files]))
+            medias = sorted(self.found_media_files, key=folder2up)
+            # build lists for multiple reference of iterators
+            media_grouped_by_folder2up = [ (k, list(iterator)) for k, iterator
+                            in groupby(medias, folder2up)]
+            logger.debug('media_grouped_by_folder2up: %s'%pformat(
+                                            media_grouped_by_folder2up))
+            folder_and_UIDs = [(f, [m.device.UID for m in medias])
+                        for f, medias in media_grouped_by_folder2up]
+            logger.debug('devices: %s'%pformat(folder_and_UIDs))
+            def _multiple_and_same(a_list):
+                same = a_list.count(a_list[0]) == len(a_list)
+                return len(a_list) > 1 and same
+            folders_with_same_dev = [(f.name, UIDs[0]) for f, UIDs 
+                                            in folder_and_UIDs
+                                         if _multiple_and_same(UIDs)]
+            logger.debug('folders_with_same_dev: %s'%pformat(folders_with_same_dev))
+            for name, UID in folders_with_same_dev:
+                for m in self.found_media_files:
+                    if m.device.UID == UID:
+                        m.device.name = name
+        # logger.debug('renamed device media: %s'%pformat(self.found_media_files))
         no_name_devices = [m.device for m in self.found_media_files
-            if not m.device.name]
+                                            if not m.device.name]
+                            # possible if self.input_structure == 'loose'
+        def _try_name_from_metadata(media):
+            # search model and make from fprobe
+            file = Path(media.path)
+            logger.debug('trying to find maker model for %s'%file)
+            try:
+                probe = ffmpeg.probe(file)
+            except ffmpeg.Error as e:
+                print('ffmpeg.probe error')
+                print(e.stderr, file)
+                return None, None #-----------------------------------------------------
+                # fall back to folder name
+            logger.debug('ffprobe %s'%pformat(probe))
+            # [TO BE COMPLETED]
+            # could reside in ['format','tags','com.apple.quicktime.model'],
+            # or ['format','tags','model'],
+            # or ['streams'][0]['tags']['vendor_id'])  :-(
+
         for anon_dev in no_name_devices:
             medias = self.get_media_for_device(anon_dev)
-            guess_name = _try_name(medias)
+            guess_name = _try_name_from_files(medias)
             # print('dev %s has no name, guessing %s'%(anon_dev, guess_name))
             logger.debug('dev %s has no name, guessing %s'%(anon_dev, guess_name))
             anon_dev.name = guess_name
         pprint_found_media_files = pformat(self.found_media_files)
         logger.debug('scanner.found_media_files = %s'%pprint_found_media_files)
         logger.debug('all devices %s'%[m.device for m in self.found_media_files])
+        dev_is_REC = [m.device.dev_type == 'REC' for m in self.found_media_files]
+        if not any(dev_is_REC): # no audio recordings!
+            print('\rNo audio recording found, nothing to sync, bye.')
+            sys.exit(0)
         # print('devices 312 %s'%set([m.device for m in self.found_media_files]))
 
     def _get_tracks_from_file(self, device) -> Tracks:
@@ -384,60 +450,69 @@ class Scanner:
             logger.debug('no tracks.txt file found')
             return None
 
-    def _check_folders_have_same_device(self):
+    def _confirm_folders_have_same_device(self):
         """
-        Since input_structure == 'folder_is_device,
+        Since input_structure == 'ordered',
         checks for files in self.found_media_files for structure as following.
 
         Warns user and quit program for:
           A- folders with mix of video and audio
           B- folders with mix of uniquely identified devices and unUIDied ones
-          C- folders with mixed audio (or video) devices
+          C- folders with mixed audio an video files
         
         Warns user but proceeds for:
           D- folder with only unUIDied files (overlaps will be check later)
         
+        Changes self.input_structure to 'loose' if a folder contains files
+        from different devices.
+
         Proceeds silently if 
           E- all files in the folder are from the same device
 
         Returns nothing
         """
-        def _list_duplicates(seq):
-          seen = set()
-          seen_add = seen.add
-          # adds all elements it doesn't know yet to seen and all other to seen_twice
-          seen_twice = set( x for x in seq if x in seen or seen_add(x) )
-          # turn the set into a list (as requested)
-          return list( seen_twice )
-        folder_key = lambda m: m.path.parent
-        medias = sorted(self.found_media_files, key=folder_key)
-        # build lists for multiple reference of iterators
-        media_grouped_by_folder = [ (k, list(iterator)) for k, iterator
-                        in groupby(medias, folder_key)]
-        logger.debug('media_grouped_by_folder %s'%media_grouped_by_folder)
-        complete_path_folders = [e[0] for e in media_grouped_by_folder]
-        name_of_folders = [p.name for p in complete_path_folders]
-        logger.debug('complete_path_folders with media files %s'%complete_path_folders)
-        logger.debug('name_of_folders with media files %s'%name_of_folders)
-        # unique_folder_names = set(name_of_folders)
-        repeated_folders = _list_duplicates(name_of_folders)
-        logger.debug('repeated_folders %s'%repeated_folders)
-        if repeated_folders:
-            print('There are conflicts for some repeated folder names:')
-            for f in [str(p) for p in repeated_folders]:
-                print(' [gold1]%s[/gold1]'%f)
-            print('Here are the complete paths:')
-            for f in [str(p) for p in complete_path_folders]:
-                print(' [gold1]%s[/gold1]'%f)
-            print('please rename and rerun. Quitting..')
-            sys.exit(1)
-        # print(media_grouped_by_folder)
+        def _exit_on_folder_name_clash():
+            # Check media parent folders are unique
+            # returns media_grouped_by_folder
+            def _list_duplicates(seq):
+              seen = set()
+              seen_add = seen.add
+              # adds all elements it doesn't know yet to seen and all other to seen_twice
+              seen_twice = set( x for x in seq if x in seen or seen_add(x) )
+              # turn the set into a list (as requested)
+              return list( seen_twice )
+            folder_key = lambda m: m.path.parent
+            medias = sorted(self.found_media_files, key=folder_key)
+            # build lists for multiple reference of iterators
+            media_grouped_by_folder = [ (k, list(iterator)) for k, iterator
+                            in groupby(medias, folder_key)]
+            logger.debug('media_grouped_by_folder %s'%pformat(
+                                                media_grouped_by_folder))
+            complete_path_folders = [e[0] for e in media_grouped_by_folder]
+            name_of_folders = [p.name for p in complete_path_folders]
+            logger.debug('complete_path_folders with media files %s'%
+                                                    complete_path_folders)
+            logger.debug('name_of_folders with media files %s'%name_of_folders)
+            # unique_folder_names = set(name_of_folders) [TODO] is this useful ?
+            # repeated_folders = _list_duplicates(name_of_folders)
+            # logger.debug('repeated_folders %s'%repeated_folders)
+            # if repeated_folders:
+            #     print('There are conflicts for some repeated folder names:')
+            #     for f in [str(p) for p in repeated_folders]:
+            #         print(' [gold1]%s[/gold1]'%f)
+            #     print('Here are the complete paths:')
+            #     for f in [str(p) for p in complete_path_folders]:
+            #         print(' [gold1]%s[/gold1]'%f)
+            #     print('please rename and rerun. Quitting..')
+            #     sys.exit(1) ####################################################
+            return media_grouped_by_folder
+        media_grouped_by_folder = _exit_on_folder_name_clash()
         n_CAM_folder = 0
         for folder, list_of_medias_in_folder in media_grouped_by_folder:
             # check all medias are either video or audio recordings in folder
             # if not, warn user and quit.
             dev_types = set([m.device.dev_type for m in list_of_medias_in_folder])
-            logger.debug('dev_types %s'%dev_types)
+            logger.debug('dev_types for folder%s: %s'%(folder,dev_types))
             if dev_types == {'CAM'}:
                 n_CAM_folder += 1
             if len(dev_types) != 1:
@@ -446,14 +521,14 @@ class Scanner:
                 [print('[gold1]%s[/gold1]'%m.path.name, end =', ')
                     for m in list_of_medias_in_folder]
                 print('\nplease move them in exclusive folders and rerun.\n')
-                sys.exit(1)
+                sys.exit(1) ######################################################
             unidentified = [m for m in list_of_medias_in_folder
                 if m.device.UID == None]
             UIDed = [m for m in list_of_medias_in_folder
                 if m.device.UID != None]
             logger.debug('devices in folder %s:'%folder)
-            logger.debug('  media with unknown devices %s'%unidentified)
-            logger.debug('  media with UIDed devices %s'%UIDed)
+            logger.debug('  media with unknown devices %s'%pformat(unidentified))
+            logger.debug('  media with UIDed devices %s'%pformat(UIDed))
             if len(unidentified) != 0 and len(UIDed) != 0:
                 print('\nProblem while grouping files in [gold1]%s[/gold1]:'%folder)
                 print('There is a mix of unidentifiable and identified devices.')
@@ -466,16 +541,38 @@ class Scanner:
                 elif answer.upper() in ["N", "NO"]:
                     # Do action you need
                     print('please move the following files in a folder named appropriately:\n')
-                    sys.exit(1)
+                    sys.exit(1) ################################################
             # if, in a folder, there's a mix of different identified devices,
             # Warn user and quit.
+            UIDs = [m.device.UID for m in UIDed]
+            all_same_device = UIDs.count(UIDs[0]) == len(UIDs)
+            logger.debug('UIDs in %s: %s. all_same_device %s'%(folder,
+                                        pformat(UIDs), all_same_device))
+            if not all_same_device:
+                self.input_structure = 'loose'
+                # self.top_dir_has_multicam = False
+                logger.debug('changed input_structure to loose')
+                # device name should be generated (it isn't the folder name...)
+                distinct_UIDS = set(UIDs)
+                n_UIDs = len(distinct_UIDS)
+                logger.debug('There are %i UIDs: %s'%(n_UIDs, distinct_UIDS))
+                # Buid CAM01, CAM02 or REC01, REC02.
+                # Get dev type from first media in list
+                devT = UIDed[0].device.dev_type # 'CAM' or 'REC'
+                generic_names = [devT + str(i).zfill(2) for i in range(n_UIDs)]
+                devUIDs_names = dict(zip(distinct_UIDS, generic_names))
+                logger.debug('devUIDs_names %s'%pformat(devUIDs_names))
+                # rename
+                for m in UIDed:
+                    m.device.name = devUIDs_names[m.device.UID]
+                    logger.debug('new name %s'%m.device.name)
             if len(dev_types) != 1:
                 print('\nProblem while scanning for media files. In [gold1]%s[/gold1]:'%folder)
                 print('There is a mix of files from different devices:')
                 [print('[gold1]%s[/gold1]'%m.path.name, end =', ')
                     for m in list_of_medias_in_folder]
                 print('\nplease move them in exclusive folders and rerun.\n')
-                sys.exit(1)
+                sys.exit(1) ####################################################
             if len(unidentified) == len(list_of_medias_in_folder):
                 # all unidentified
                 if len(unidentified) > 1:
@@ -487,11 +584,6 @@ class Scanner:
             #   all files in folder are from unidentified device or
             #   all files in folder are from the same identified device
         logger.debug('n_CAM_folder %i'%n_CAM_folder)
-        if n_CAM_folder > 1 :
-            self.top_dir_has_multicam = True
-        else:
-            self.top_dir_has_multicam = False
-        logger.debug('top_dir_has_multicam: %s'%self.top_dir_has_multicam)
         return
 
     def _parse_track_values(self, tracks_file) -> Tracks:
@@ -499,16 +591,16 @@ class Scanner:
         read track names for naming separated ISOs
         from tracks_file.
 
-        tokens looked for: mix; L mix; R mix; 0 and TC
+        tokens looked for: mix; mix L; mix R; 0 and TC
 
         repeating "mic*" pattern signals a stereo track
         and entries will correspondingly panned into
-        a stero mix named Lmix.wav and Rmix.wav
+        a stero mix named mixL.wav and mixL.wav
 
-        L mic # spaces are ignored |
-        R mic                      | stereo pair
-        L micB
-        R micB
+        mic L # spaces are ignored |
+        mic R                      | stereo pair
+        micB L
+        micB R
 
         Returns: a Tracks instance:
                 # track numbers start at 1 for first track (as needed by sox)
@@ -523,22 +615,22 @@ class Scanner:
                         unused=[],
                         stereomics=[('mic', (4, 3)), ('mic2', (6, 5))],
                         mix=[], others=[('clics', 1)],
-                        rawtrx=['clics', 'TC', 'L mic', 'R mic', 'L mic2;1000', 'R mic2;1000', 'Lmix', 'Rmix'],
+                        rawtrx=['clics', 'TC', 'micL', 'micR', 'mic2L;1000', 'mic2R;1000', 'mixL', 'mixR'],
                         error_msg=None, lag_values=[None, None, None, None, '1000', '1000', None, None])
         """
         def _WOspace(chaine):
             ch = [c for c in chaine if c != ' ']
             return ''.join(ch)
-        def _WO_LR(chaine):
-            ch = [c for c in chaine if c not in 'LR']
-            return ''.join(ch)
-        def _seemsStereoMic(tag):
-            # is tag likely a stereo pair tag?
-            # should ends with 'mic' and starts with 'l' or 'r'
-            return tag[1:4]=='mic' and tag[0] in 'lr'
+        # def _WO_LR(chaine):
+        #     ch = [c for c in chaine if c not in 'LR']
+        #     return ''.join(ch)
+        # def _seemsStereoMic(tag):
+        #     # is tag likely a stereo pair tag?
+        #     # should starts with 'mic' and ends with 'l' or 'r'
+        #     return tag[1:4]=='mic' and tag[0] in 'lr'
         file=open(tracks_file,"r")
         whole_txt = file.read()
-        logger.debug('all_lines:\n%s'%whole_txt)
+        logger.debug('file %s all_lines:\n%s'%(tracks_file, whole_txt))
         tracks_lines_wspaces = [l.split('#')[0] for l in whole_txt.splitlines()
                                         if len(l) > 0 ]
         tracks_lines = [_WOspace(l) for l in tracks_lines_wspaces if len(l) > 0 ]
@@ -552,7 +644,7 @@ class Scanner:
                 splt += [None]
                 if len(splt) != 2:
                     # error
-                    print('Text error in %s, line %s has too many ";"'%(
+                    print('\nText error in %s, line %s has too many ";"'%(
                             tracks_file, line))
             return splt
         tracks_lines, lag_values = zip(*[_detach_lag_value(l) for l 
@@ -563,11 +655,10 @@ class Scanner:
         logger.debug('tracks_lines lower case: %s'%tracks_lines)
         # print(lag_values)
         logger.debug('lag_values: %s'%lag_values)
-        tagsWOl_r = [e[1:] for e in tracks_lines] # skip first letter
-        logger.debug('tags WO 1st letter %s'%tagsWOl_r)
+        tagsWOl_r = [e[:-1] for e in tracks_lines] # skip last letter
+        logger.debug('tags WO LR letter %s'%tagsWOl_r)
         # find idx of start of pairs
-        # ['clics', 'TC', 'Lmic', 'Rmic', 'Lmic2', 'Lmic2', 'Lmix', 'Rmix']
-        #                   ^                ^                ^
+        # ['clics', 'TC', 'micL', 'micR', 'mic2L', 'mic2R', 'mixL', 'mixR']
         def _micOrmix(a,b):
             # test if same and mic mic or mix mix
             if len(a) == 0:
@@ -577,9 +668,10 @@ class Scanner:
                         in zip(tagsWOl_r,tagsWOl_r[1:])]) if same]
         logger.debug('pair_idx_start %s'%pair_idx_start)
         def LR_OK(idx):
-            # in tracks_lines, check if idx start a LR pair
-            a = tracks_lines[idx][0]
-            b = tracks_lines[idx+1][0]
+            # in tracks_lines, check if idx ends a LR pair
+            # delays, if any, have been removed
+            a = tracks_lines[idx][-1]
+            b = tracks_lines[idx+1][-1]
             return a+b in ['lr', 'rl']
         LR_OKs = [LR_OK(p) for p in pair_idx_start]
         logger.debug('LR_OKs %s'%LR_OKs)
@@ -625,11 +717,11 @@ class Scanner:
         def _findLR(i_first):
             # returns L R indexes (+1 for sox non zero based indexing)
             i_2nd = i_first + 1
-            a = tracks_lines[i_first][0]
-            b = tracks_lines[i_2nd][0]
+            a = tracks_lines[i_first][-1] # l|r at end
+            b = tracks_lines[i_2nd][-1] # l|r at end
             if a == 'l':
                 if b == 'r':
-                    # sequence is Lmix Rmix
+                    # sequence is mixL mixR
                     return i_first+1, i_2nd+1
                 else:
                     print('\nError in %s'%tracks_file)
@@ -638,7 +730,7 @@ class Scanner:
                     quit()
             elif a == 'r':
                 if b == 'l':
-                    # sequence is Rmix Lmix
+                    # sequence is mixR mixL
                     return i_2nd+1, i_first+1
                 else:
                     print('\nError in %s'%tracks_file)
@@ -666,7 +758,7 @@ class Scanner:
         # those are stereo pairs
         stereo_pairs = []
         for first_in_pair in pair_idx_start:
-            suffix = tracks_lines[first_in_pair][1:]
+            suffix = tracks_lines[first_in_pair][:-1]
             stereo_pairs.append((suffix, _findLR(first_in_pair)))
         logger.debug('stereo_pairs %s'%stereo_pairs)
         output_tracks.stereomics = stereo_pairs