tictacsync 0.91a0__py3-none-any.whl → 0.96a0__py3-none-any.whl

tictacsync/device_scanner.py

@@ -58,7 +58,6 @@ def print_grby(grby):
         for e in keylist:
             print(' ', e)
 
-
 @dataclass
 class Tracks:
     # track numbers start at 1 for first track (as needed by sox)
@@ -69,6 +68,7 @@ class Tracks:
     others: list #of all other tags: (tag, track#) tuples
     rawtrx: list # list of strings read from file
     error_msg: str # 'None' if none
+    lag_values: list # list of lag in ms, entry is None if not specified. 
 
 @dataclass
 class Device:
@@ -77,8 +77,9 @@ class Device:
     name: str
     dev_type: str # CAM or REC
     n_chan: int
-    ttc: int
+    ttc: int # zero based index?
     tracks: Tracks
+    sampling_freq: float # fps if cam
     def __hash__(self):
         return self.UID
     def __eq__(self, other):
@@ -93,9 +94,9 @@ class Media:
 
 def media_at_path(input_structure, p):
     # return Media object for mediafile using ffprobe
-    dev_UID, dt = get_device_ffprobe_UID(p)
+    dev_UID, dt, sf = get_device_ffprobe_UID(p)
     dev_name = None
-    logger.debug('ffprobe dev_UID:%s dt:%s'%(dev_UID, dt))
+    logger.debug('ffprobe dev_UID:%s dt:%s sf:%s'%(dev_UID, dt,sf))
     if input_structure == 'folder_is_device':
         dev_name = p.parent.name
         if dev_UID is None:
@@ -109,7 +110,13 @@ def media_at_path(input_structure, p):
             if stream['codec_type']=='audio'
             ]
         if len(audio_streams) > 1:
-            raise Exception('ffprobe gave multiple audio streams?')
+            print('for [gold1]%s[/gold1], ffprobe gave multiple audio streams, quitting.'%p)
+            quit()
+            # raise Exception('ffprobe gave multiple audio streams?')
+        if len(audio_streams) == 0:
+            print('ffprobe gave no audio stream for [gold1]%s[/gold1], quitting.'%p)
+            quit()
+            # raise Exception('ffprobe gave no audio stream for %s, quitting'%p)
         audio_str = audio_streams[0]
         n = audio_str['channels']
         # pprint(ffmpeg.probe(p))
@@ -117,7 +124,7 @@ def media_at_path(input_structure, p):
         n = sox.file_info.channels(_pathname(p)) # eg 2
     logger.debug('for file %s dev_UID established %s'%(p.name, dev_UID))
     device = Device(UID=dev_UID, folder=p.parent, name=dev_name, dev_type=dt,
-                n_chan=n, ttc=None, tracks=None)
+                n_chan=n, ttc=None, sampling_freq=sf, tracks=None)
     logger.debug('for path: %s, device:%s'%(p,device))
     return Media(p, device)
 
@@ -131,7 +138,7 @@ def get_device_ffprobe_UID(file):
     Device UIDs are used later in Montage._get_concatenated_audiofile_for()
     for grouping each audio or video clip along its own timeline track.
     
-    Returns a tuple: (UID, CAM|REC)
+    Returns a tuple: (UID, CAM|REC, sampling_freq)
     
     If an ffmpeg.Error occurs, returns (None, None)
     if no UID is found, but device type is identified, returns (None, CAM|REC)
@@ -146,15 +153,30 @@ def get_device_ffprobe_UID(file):
         print(e.stderr, file)
         return None, None #-----------------------------------------------------
         # fall back to folder name
+    logger.debug('ffprobe %s'%probe)
     streams = probe['streams']
+    video_streams = [st for st in streams if st['codec_type'] == 'video']
+    audio_streams = [st for st in streams if st['codec_type'] == 'audio']
+    if len(video_streams) > 1:
+        print('more than one video stream for %s... quitting'%file)
+        quit()
+    if len(audio_streams) != 1:
+        print('nbr of audio stream for %s not 1 ... quitting'%file)
+        quit()
     codecs = [stream['codec_type'] for stream in streams]
-    device_type = 'CAM' if 'video' in codecs else 'REC'
+    # cameras have two streams: video AND audio
+    device_type = 'CAM' if len(video_streams) == 1 else 'REC'
+    if device_type == 'CAM':
+        sampling_freq = eval(video_streams[0]['r_frame_rate'])
+    else:
+        sampling_freq = float(audio_streams[0]['sample_rate'])        
     format_dict = probe['format'] # all files should have this
     if 'tags' in format_dict:
         probe_string = pformat(format_dict['tags'])
         probe_lines = [l for l in probe_string.split('\n') 
                 if '_time' not in l 
                 and 'time_' not in l 
+                and 'location' not in l 
                 and 'date' not in l ]
         # this removes any metadata related to the file
         # but keeps metadata related to the device
@@ -165,7 +187,7 @@ def get_device_ffprobe_UID(file):
     if UID == 0: # empty probe_lines from Audacity ?!?
         UID = None
     logger.debug('ffprobe_UID is: %s'%UID)
-    return UID, device_type
+    return UID, device_type, sampling_freq
 
 class Scanner:
     """
@@ -302,12 +324,12 @@ class Scanner:
             audio_devices = [d for d in devices if d.dev_type == 'REC']
             for recorder in audio_devices:
                 recorder.tracks = self._get_tracks_from_file(recorder)
+                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))
         no_name_devices = [m.device for m in self.found_media_files
             if not m.device.name]
-        # if no_name_devices:
-        #     pprint_no_name = pformat([(d, self.get_media_for_device(d)) for d in no_name_devices])
-        #     print('those are anon devices%s\n'%pprint_no_name)
-        #     logger.debug('those media have anon device%s'%no_name_devices)
         for anon_dev in no_name_devices:
             medias = self.get_media_for_device(anon_dev)
             guess_name = _try_name(medias)
@@ -321,7 +343,7 @@ class Scanner:
 
     def _get_tracks_from_file(self, device) -> Tracks:
         """        
-        Look for track names in TRACKSFN file, possibly stored inside the
+        Look for eventual track names in TRACKSFN file, stored inside the
         recorder folder alongside the audio files. If there, returns a Tracks
         object, if not returns None. 
         """        
@@ -477,16 +499,16 @@ class Scanner:
         read track names for naming separated ISOs
         from tracks_file.
 
-        repeting prefixes signals a stereo track
-        and entries will correspondingly panned into
-        a stero mix named mixL.wav and mixR.wav
+        tokens looked for: mix; L mix; R mix; 0 and TC
 
-        mic1 L # space is optionnal and will be removed
-        mic1 R
-        mic2 L
-        mic2 R
+        repeating "mic*" pattern signals a stereo track
+        and entries will correspondingly panned into
+        a stero mix named Lmix.wav and Rmix.wav
 
-        mixL
+        L mic # spaces are ignored |
+        R mic                      | stereo pair
+        L micB
+        R micB
 
         Returns: a Tracks instance:
                 # track numbers start at 1 for first track (as needed by sox)
@@ -497,130 +519,158 @@ class Scanner:
                 others: list #of all other tags: (tag, track#) tuples
                 rawtrx: list # list of strings read from file
                 error_msg: str # 'None' if none
+        e.g.: Tracks(   ttc=2,
+                        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'],
+                        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']
+            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 start with 'mic' and end with 'l' or 'r'
-            return tag[:3]=='mic' and tag[-1] in 'lr'
+            # should ends with 'mic' and starts 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)
-        tracks_lines = [l.split('#')[0] for l in whole_txt.splitlines() if len(l) > 0 ]
-        tracks_lines = [_WOspace(l).lower() for l in tracks_lines if len(l) > 0 ]
-        rawtrx = tracks_lines
-        tracks_lines = [(t,ix+1) for ix,t in enumerate(tracks_lines)]
-        # tracks_lines = [l for l in tracks_lines if l not in ['ttc', '0']]
-        # track_names = [l.split()[0] for l in tracks_lines if l != 'ttc']
-        logger.debug('tracks_lines: %s'%tracks_lines)
-        # first check for stereo mic pairs (could be more than one pair):
-        spairs = [e for e in tracks_lines if _seemsStereoMic(e[0])]
-        # spairs is stereo pairs candidates
-        msg = 'Confusing stereo pair tags: %s'%' '.join([e[0]
-                                                for e in spairs])
-        error_output_stereo = Tracks(None,[],[],[],[],[],msg)
-        if len(spairs)%2 == 1: # not pairs?, quit.
-            return error_output_stereo
-        logger.debug('_seemsStereoM: %s'%spairs)
-        output_tracks = Tracks(None,[],[],[],[],rawtrx,None)
-        def _LR(p):
-            # p = (('mic1l', 1), ('mic1r', 2))
-            # check if L then R
-            p1, p2 = p
-            return p1[0][-1] == 'l' and p2[0][-1] == 'r'
-        if spairs:
-            even_idxes = range(0,len(spairs),2)
-            paired = [(spairs[i], spairs[i+1]) for i in even_idxes]
-            # eg [(('mic1l', 1), ('mic1r', 2)), (('mic2l', 3), ('mic2r', 4))]
-            def _mic_same(p):
-                # p = (('mic1l', 1), ('mic1r', 2))
-                # check if mic1 == mic1
-                p1, p2 = p
-                return _WO_LR(p1[0]) == _WO_LR(p2[0])
-            mic_prefix_OK = all([_mic_same(p) for p in paired])
-            logger.debug('mic_prefix_OK: %s'%mic_prefix_OK)
-            if not mic_prefix_OK:
-                return error_output_stereo
-            mic_LR_OK = all([_LR(p) for p in paired])
-            logger.debug('mic_LR_OK %s'%mic_LR_OK)
-            if not mic_LR_OK:
-                return error_output_stereo
-            def _stereo_mic_pref_chan(p):
-                # p = (('mic1l', 1), ('mic1r', 2))
-                # returns ('mic1', (1,2))
-                first, second = p
-                mic_prefix = _WO_LR(first[0])
-                return (mic_prefix, (first[1], second[1]) )
-            grouped_stereo_mic_channels = [_stereo_mic_pref_chan(p) for p
-                                            in paired]
-            logger.debug('grouped_stereo_mic_channels: %s'%
-                                        grouped_stereo_mic_channels)
-            output_tracks.stereomics = grouped_stereo_mic_channels
-        [tracks_lines.remove(e) for e in spairs]
-        logger.debug('stereo mic pairs done, continue with %s'%tracks_lines)
-        # second, check for stereo mix down (one mixL mixR pair)
-        def _seemsStereoMix(tag):
-            # is tag likely a stereo pair tag?
-            # should start with 'mic' and end with 'l' or 'r'
-            return tag[:3]=='mix' and tag[-1] in 'lr'
-        stereo_mix_tags = [e for e in tracks_lines if _seemsStereoMix(e[0])]
-        logger.debug('stereo_mix_tags: %s'%stereo_mix_tags)
-        str_msg = 'Confusing mix pair tags: %s L should appear before R'%' '.join([e[0]
-                                            for e in stereo_mix_tags])
-        # error_output = Tracks(None,[],[],[],[],msg)
-        def _error_Track(msg):
-            return Tracks(None,[],[],[],[],[],msg)
-        if stereo_mix_tags: 
-            if len(stereo_mix_tags) != 2:
-                return _error_Track(str_msg)
-            mix_LR_OK = _LR(stereo_mix_tags)
-            logger.debug('mix_LR_OK %s'%mix_LR_OK)
-            if not mix_LR_OK:
-                return _error_Track(str_msg)
-            stereo_mix_channels = [t[1] for t in stereo_mix_tags]
-            output_tracks.mix = stereo_mix_channels
-            logger.debug('output_tracks.mix %s'%stereo_mix_channels)
-        [tracks_lines.remove(e) for e in stereo_mix_tags]
-        logger.debug('stereo mix done, will continue with %s'%tracks_lines)
-        # third, check for a mono mix
-        mono_mix_tags = [e for e in tracks_lines if e[0] == 'mix']
-        if not output_tracks.mix and mono_mix_tags:
-            logger.debug('mono_mix_tags: %s'%mono_mix_tags)
-            if len(mono_mix_tags) != 1:
-                return _error_Track('more than one "mix" token')
-            output_tracks.mix = [mono_mix_tags[0][1]]
-        [tracks_lines.remove(e) for e in mono_mix_tags]
-        logger.debug('mono mix done, will continue with %s'%tracks_lines)
-        # fourth, look for 'ttc'
-        ttc_chan = [idx for tag, idx in tracks_lines if tag == 'ttc']
-        if ttc_chan:
-            if len(ttc_chan) > 1:
-                return _error_Track('more than one "ttc" token')
-            output_tracks.ttc = ttc_chan[0]
-            tracks_lines.remove(('ttc', ttc_chan[0]))
-        else:
-            return _error_Track('no "ttc" token')
-        # fifth, check for '0'
-        logger.debug('ttc done, will continue with %s'%tracks_lines)
-        zeroed = [idx for tag, idx in tracks_lines if tag == '0']
+        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 ]
+        rawtrx = [l for l in tracks_lines_wspaces if len(l) > 0 ]
+        # add index with tuples, starting at 1
+        logger.debug('tracks_lines whole: %s'%tracks_lines)
+        def _detach_lag_value(line):
+            # look for ";number" ending any line, returns a two-list
+            splt = line.split(';')
+            if len(splt) == 1:
+                splt += [None]
+                if len(splt) != 2:
+                    # error
+                    print('Text error in %s, line %s has too many ";"'%(
+                            tracks_file, line))
+            return splt
+        tracks_lines, lag_values = zip(*[_detach_lag_value(l) for l 
+                                                    in tracks_lines])
+        lag_values = [e for e in lag_values] # from tuple to list
+        # logger.debug('tracks_lines WO lag: %s'%tracks_lines)
+        tracks_lines = [l.lower() for l in tracks_lines]
+        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)
+        # find idx of start of pairs
+        # ['clics', 'TC', 'Lmic', 'Rmic', 'Lmic2', 'Lmic2', 'Lmix', 'Rmix']
+        #                   ^                ^                ^
+        def _micOrmix(a,b):
+            # test if same and mic mic or mix mix
+            if len(a) == 0:
+                return False
+            return (a == b) and (a in 'micmix')
+        pair_idx_start =[i for i, same in enumerate([_micOrmix(a,b) for a,b
+                        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]
+            return a+b in ['lr', 'rl']
+        LR_OKs = [LR_OK(p) for p in pair_idx_start]
+        logger.debug('LR_OKs %s'%LR_OKs)
+        if not all(LR_OKs):
+            print('Error in %s'%tracks_file)
+            print('Some tracks are paired but not L and R: %s'%rawtrx)
+            print('quitting...')
+            quit()
+        complete_pairs_idx = pair_idx_start + [i + 1 for i in pair_idx_start]
+        singles = set(range(len(tracks_lines))).difference(complete_pairs_idx)
+        logger.debug('complete_pairs_idx %s'%complete_pairs_idx)
+        logger.debug('singles %s'%singles)
+        singles_tag = [tracks_lines[i] for i in singles]
+        logger.debug('singles_tag %s'%singles_tag)
+        n_tc_token = sum([t == 'tc' for t in singles_tag])
+        logger.debug('n tc tags %s'%n_tc_token)
+        if n_tc_token == 0:
+            print('Error in %s'%tracks_file)
+            print('with %s'%rawtrx)
+            print('no TC track found, quitting...')
+            quit()
+        if n_tc_token > 1:
+            print('Error in %s'%tracks_file)
+            print('with %s'%rawtrx)
+            print('more than one TC track, quitting...')
+            quit()
+        output_tracks = Tracks(None,[],[],[],[],rawtrx,None,[])
+        output_tracks.ttc = tracks_lines.index('tc') + 1 # 1st = 1
+        logger.debug('ttc_chan %s'%output_tracks.ttc)
+        zeroed = [i+1 for i, t in enumerate(tracks_lines) if t == '0']
         logger.debug('zeroed %s'%zeroed)
-        if zeroed:
-            output_tracks.unused = zeroed
-            [tracks_lines.remove(('0',i)) for i in zeroed]
-        else:
-            output_tracks.unused = []
-        # sixth, check for 'others'
-        logger.debug('0s done, will continue with %s'%tracks_lines)
-        if tracks_lines:
-            output_tracks.others = tracks_lines
+        output_tracks.unused = zeroed
+        output_tracks.others = [(st, tracks_lines.index(st)+1) for st
+                                in singles_tag if st not
+                                in ['tc', 'monomix', '0']]
+        logger.debug('output_tracks.others %s'%output_tracks.others)
+        # check for monomix
+        if 'monomix' in tracks_lines:
+            output_tracks.mix = [tracks_lines.index('monomix')+1]
         else:
-            output_tracks.others = []
-        logger.debug('Tracks %s'%output_tracks)
+            output_tracks.mix = []
+        # check for stereo mix
+        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]
+            if a == 'l':
+                if b == 'r':
+                    # sequence is Lmix Rmix
+                    return i_first+1, i_2nd+1
+                else:
+                    print('Error in %s'%tracks_file)
+                    print('with %s'%rawtrx)
+                    print('can not find stereo mix')
+                    quit()
+            elif a == 'r':
+                if b == 'l':
+                    # sequence is Rmix Lmix
+                    return i_2nd+1, i_first+1
+                else:
+                    print('Error in %s'%tracks_file)
+                    print('with %s'%rawtrx)
+                    print('can not find stereo mix')
+                    quit()
+        logger.debug('for now, output_tracks.mix %s'%output_tracks.mix)
+        mix_pair = [p for p in pair_idx_start if tracks_lines[p][1:] == 'mix']
+        if len(mix_pair) == 1:
+            # one stereo mix, remove it from other pairs
+            i = mix_pair[0]
+            LR_pair =  _findLR(i)
+            logger.debug('LR_pair %s'%str(LR_pair))
+            pair_idx_start.remove(i)
+            # consistency check
+            if output_tracks.mix != []:
+                # already found a mono mix above!
+                print('Error in %s'%tracks_file)
+                print('with %s'%rawtrx)
+                print('found a mono mix AND a stereo mix')
+                quit()
+            output_tracks.mix = LR_pair
+        logger.debug('finally, output_tracks.mix %s'%str(output_tracks.mix))
+        logger.debug('remaining pairs %s'%pair_idx_start)
+        # those are stereo pairs
+        stereo_pairs = []
+        for first_in_pair in pair_idx_start:
+            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
+        logger.debug('finished: %s'%output_tracks)
         return output_tracks