tictacsync 0.95a0__tar.gz → 0.96a0__tar.gz

{tictacsync-0.95a0/tictacsync.egg-info → tictacsync-0.96a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 0.95a0
+Version: 0.96a0
 Summary: command for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz

{tictacsync-0.95a0 → tictacsync-0.96a0}/setup.py

@@ -32,7 +32,7 @@ setup(
         'multi2polywav = tictacsync.multi2polywav:main',
         ]
         },
-    version = '0.95a',
+    version = '0.96a',
     description = "command for syncing audio video recordings",
     long_description_content_type='text/markdown',
     long_description = long_descr,

{tictacsync-0.95a0 → tictacsync-0.96a0}/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)
@@ -78,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):
@@ -94,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:
@@ -124,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)
 
@@ -138,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)
@@ -155,8 +155,21 @@ def get_device_ffprobe_UID(file):
         # 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'])
@@ -174,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:
     """
@@ -486,18 +499,16 @@ class Scanner:
         read track names for naming separated ISOs
         from tracks_file.
 
-        tokens looked for: mix mixL mixR 0 ttc
+        tokens looked for: mix; L mix; R mix; 0 and TC
 
-        repeting prefixes signals a stereo track
+        repeating "mic*" pattern signals a stereo track
         and entries will correspondingly panned into
-        a stero mix named mixL.wav and mixR.wav
-
-        xyz L # spaces are ignored |
-        zyz R                      | stereo pair
-        abc L
-        abc R
+        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)
@@ -508,6 +519,12 @@ 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 != ' ']
@@ -517,15 +534,15 @@ class Scanner:
             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()
+        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 if len(l) > 0 ]
-        rawtrx = tracks_lines
+        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):
@@ -540,119 +557,120 @@ class Scanner:
             return splt
         tracks_lines, lag_values = zip(*[_detach_lag_value(l) for l 
                                                     in tracks_lines])
-        logger.debug('tracks_lines WO lag: %s'%[tracks_lines])
-        logger.debug('lag_values: %s'%[lag_values])
-        tracks_lines = [(t,ix+1) for ix,t in enumerate(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)
+        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.lag_values = lag_values
-        # 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 = (('mic1R', 1), ('mic1L', 2))
-                # returns ('mic1', (1,2))
-                first, second = p
-                mic_prefix = _WO_LR(first[0])
-                # check if first token last char 
-                if p[0][0][-1] == 'L':
-                    logger.debug('sequence %s is L+R'%[p])
-                    return (mic_prefix, (first[1], second[1]) )
-                else:
-                    logger.debug('sequence %s is R+L'%[p])
-                    return (mic_prefix, (second[1], first[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']
+        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]
+        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.unused = []
-        # sixth, check for 'others'
-        logger.debug('0s done, will continue with %s'%tracks_lines)
-        if tracks_lines:
-            output_tracks.others = tracks_lines
-        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
 
 

{tictacsync-0.95a0 → tictacsync-0.96a0}/tictacsync/entry.py

@@ -27,7 +27,8 @@ from rich.console import Console
 # from rich.text import Text
 from rich.table import Table
 from rich import print
-from pprint import pprint 
+from pprint import pprint
+import numpy as np
 
 DEL_TEMP = False
 
@@ -58,6 +59,7 @@ def process_files_with_progress_bars(medias):
     return recordings, rec_with_TTC, times
 
 def process_files(medias):
+    # maps Media objects -> Recording objects
     recordings = []
     rec_with_TTC = []
     times = []
@@ -115,6 +117,7 @@ def process_lag_adjustement(media_object):
     media_object.path.replace(backup_name)
     logger.debug('channels %s'%channels)
     def _trim(lag, chan_file):
+        # for lag
         if lag == None:
             return chan_file
         else:
@@ -181,10 +184,10 @@ def main():
         logger.add(sys.stderr, level="DEBUG")
     # logger.add(sys.stdout, filter="__main__")
     # logger.add(sys.stdout, filter="yaltc")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "process_lag_adjustement")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_dedrift_rec")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_media_and_build_devices_UID")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_parse_track_values")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_audio_for_each_videoclip")
+    # logger.debug(sys.stdout, filter=lambda r: r["function"] == "main")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_build_and_write_audio")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_build_audio_and_write_video")
     top_dir = args.path[0]
     if os.path.isfile(top_dir):
         file = top_dir
@@ -209,7 +212,35 @@ def main():
             if not all([lv == None for lv in m.device.tracks.lag_values]):
                 logger.debug('%s has lag_values %s'%(
                         m.path, m.device.tracks.lag_values))
-                process_lag_adjustement(m)                
+                process_lag_adjustement(m)
+    audio_REC_only = all([m.device.dev_type == 'REC' for m
+                                        in scanner.found_media_files])
+
+    if audio_REC_only:
+        if scanner.input_structure != 'folder_is_device':
+            print('For merging audio only, use a directory per device, quitting')
+            sys.exit(1)
+        print('\n\n\nOnly audio recordings are present')
+        print('Which device should be the reference?\n')
+        devices = scanner.get_devices()
+        maxch = len(devices)
+        for i, d in enumerate(devices):
+            print('\t%i - %s'%(i+1, d.name))
+        # while True:
+        #     print('\nEnter your choice:', end='')
+        #     choice = input()
+        #     try:
+        #         choice = int(choice)
+        #     except:
+        #         print('Please use numeric digits.')
+        #         continue
+        #     if choice not in list(range(1, maxch + 1)):
+        #         print('Please enter a number in [1..%i]'%maxch)
+        #         continue
+        #     break
+        # ref_device = list(devices)[choice - 1]
+        choice = 3
+        ref_device = list(devices)[choice - 1]
     if not args.terse:
         if scanner.input_structure == 'folder_is_device':
             print('\nDetected structured folders', end='')
@@ -226,20 +257,37 @@ def main():
             len(scanner.found_media_files)), end='')
         print('from [gold1]%i[/gold1] devices:\n'%(
             scanner.get_devices_number()))
-        for dev in scanner.get_devices():
-            print('  [gold1]%s[/gold1] with files:'%dev.name, end = ' ')
+        all_devices = scanner.get_devices()
+        for dev in all_devices:
+            dt = 'Camera' if dev.dev_type == 'CAM' else 'Recorder'
+            print('%s [gold1]%s[/gold1] with files:'%(dt, dev.name), end = ' ')
             medias = scanner.get_media_for_device(dev)
-            for m in medias[:-1]:
+            for m in medias[:-1]: # last printed out of loop
                 print('[gold1]%s[/gold1]'%m.path.name, end=', ')
             print('[gold1]%s[/gold1]'%medias[-1].path.name)
+            a_media = medias[0]
+        # check if all audio recorders have same sampling freq
+        freqs = [dev.sampling_freq for dev in all_devices if dev.dev_type == 'REC']
+        same = np.isclose(np.std(freqs),0)
+        logger.debug('sampling freqs from audio recoders %s, same:%s'%(freqs, same))
+        if not same:
+            print('some audio recorders have different sampling frequencies:')
+            print(freqs)
+            print('resulting in undefined results: quitting...')
+            quit()
         print()
-    rez = process_files(scanner.found_media_files)
-    recordings, rec_with_TTC, times = rez
+    recordings, rec_with_TTC, times = \
+            process_files(scanner.found_media_files)
     recordings_with_time =  [
         rec 
         for rec in rec_with_TTC
         if rec.get_start_time()
         ]
+    if audio_REC_only:
+        for rec in recordings:
+        # print(rec, rec.device == ref_device)
+            if rec.device == ref_device:
+                rec.is_reference = True
     if not args.terse:    
         table = Table(title="tictacsync results")
         table.add_column("Recording\n", justify="center", style='gold1')
@@ -284,7 +332,7 @@ def main():
         sys.exit(1)
     matcher = timeline.Matcher(recordings_with_time)
     matcher.scan_audio_for_each_videoclip()
-    if not matcher.video_mergers:
+    if not matcher.mergers:
         if not args.terse:
             print('\nNothing to sync, bye.\n')
         sys.exit(1)
@@ -294,17 +342,18 @@ def main():
         asked_ISOs = False
     output_dir = args.o
     # if args.verbose_output or args.terse: # verbose, so no progress bars
-    for merger in matcher.video_mergers:
-        merger.build_audio_and_write_video(top_dir, arg_out_dir,
+    for merger in matcher.mergers:
+        merger.build_audio_and_write_merged_media(top_dir, arg_out_dir,
         OUT_struct_for_mcam,
-        asked_ISOs,)
+        asked_ISOs,
+        audio_REC_only)
     if not args.terse:
         print("\n")
     # find out where files were wrtitten
-    a_merger = matcher.video_mergers[0]
+    a_merger = matcher.mergers[0]
     print('\nWrote output in folder [gold1]%s[/gold1]'%(
             a_merger.synced_clip_dir))
-    for merger in matcher.video_mergers:
+    for merger in matcher.mergers:
         print('[gold1]%s[/gold1]'%merger.videoclip.AVpath.name, end='')
         for audio in merger.get_matched_audio_recs():
             print(' + [gold1]%s[/gold1]'%audio.AVpath.name, end='')

{tictacsync-0.95a0 → tictacsync-0.96a0}/tictacsync/remergemix.py

@@ -67,7 +67,8 @@ def _join_audio2video(audio_path: Path, video: Path):
     ffmpeg_args = (
         ffmpeg
         .input(v_n)
-        .output(out_n, shortest=None, vcodec='copy')
+        .output(out_n, vcodec='copy')
+        # .output(out_n, shortest=None, vcodec='copy')
         .global_args('-i', a_n, "-hide_banner")
         .overwrite_output()
         .get_args()
@@ -77,7 +78,8 @@ def _join_audio2video(audio_path: Path, video: Path):
         _, out = (
         ffmpeg
         .input(v_n)
-        .output(out_n, shortest=None, vcodec='copy')
+        # .output(out_n, shortest=None, vcodec='copy')
+        .output(out_n, vcodec='copy')
         .global_args('-i', a_n, "-hide_banner")
         .overwrite_output()
         .run(capture_stderr=True)

tictacsync-0.96a0/tictacsync/remrgmx.py

@@ -0,0 +1,28 @@
+def is_video(f):
+    # True if name as video extension
+    name_ext = f.split('.')
+    if len(name_ext) != 2:
+        return False
+    name, ext = name_ext
+    return ext.lower() in video_extensions
+
+# def find_ISO_vids_pairs(top):
+#     # top is 
+vids = []
+ISOs = []
+for (root,dirs,files) in os.walk(Path('.'), topdown=True):
+    for d in dirs:
+        if d[-4:] == '_ISO':
+            ISOs.append(Path(root)/d)
+    for f in files:
+        if is_video(f):
+            vids.append(Path(root)/f)        
+for pair in list(itertools.product(vids, ISOs)):
+    # print(pair)
+    matches = []
+    vid, ISO = pair
+    vidname, ext = vid.name.split('.')
+    if vidname == ISO.name[:-4]:
+        matches.append(pair)
+    # print(vidname, ISO.name[:-4])
+    # return matches

{tictacsync-0.95a0 → tictacsync-0.96a0}/tictacsync/timeline.py

@@ -332,6 +332,10 @@ class AudioStitcherVideoMerger:
         videoclip : a Recording instance
             The video to which audio files are synced
 
+        ref_audio : a Recording instance
+            If no video is present, this is the reference audio to which others
+            audio files are synced
+
         soxed_audio : dict as {Recording : path}
             keys are elements of matched_audio_recordings and the value are
             the Pathlib path of the eventual edited audio(trimmed or padded).
@@ -383,6 +387,13 @@ class AudioStitcherVideoMerger:
         logger.debug('devices %s'%devices)
         return devices
 
+    def _get_secondary_audio_devices(self):
+        devices = set([r.device for r in self.get_matched_audio_recs()])
+        logger.debug('get_matched_audio_recs: %s'%
+            pprint.pformat(self.get_matched_audio_recs()))
+        logger.debug('devices %s'%devices)
+        return devices
+
     def _get_all_recordings_for(self, device):
         # return recordings for a particular device, sorted by time
         recs = [a for a in self.get_matched_audio_recs() if a.device == device]
@@ -635,11 +646,11 @@ class AudioStitcherVideoMerger:
                 leftCAM/
 
                     canon24fps01.MOV ━━━━┓ name of clip is name of folder
-                    canon24fps01.ISO/ <━━┛
+                    canon24fps01_ISO/ <━━┛
                         chan_1.wav     
                         chan_2.wav     
                     canon24fps02.MOV 
-                    canon24fps01.ISO/ 
+                    canon24fps01_ISO/ 
                         chan_1.wav
                         chan_2.wav
 
@@ -680,7 +691,7 @@ class AudioStitcherVideoMerger:
         video_stem_WO_suffix = synced_clip_file.stem
         # video_stem_WO_suffix = synced_clip_file.stem.split('.')[0]
         # OUT_DIR_DEFAULT, D2 = ISOsDIR.split('/')
-        ISOdir = synced_clip_dir/(video_stem_WO_suffix + '.ISO')
+        ISOdir = synced_clip_dir/(video_stem_WO_suffix + '_ISO')
         os.makedirs(ISOdir, exist_ok=True)
         logger.debug('edited_audio_all_devices %s'%edited_audio_all_devices)
         logger.debug('ISOdir %s'%ISOdir)
@@ -713,16 +724,16 @@ class AudioStitcherVideoMerger:
         In details:
 
         If no device tracks.txt file declared a mix track (or if tracks.txt is
-        absent), a mix is done programmatically. Two possibilities:
+        absent) a mix is done programmatically. Two possibilities:
 
             #1- no stereo pairs were declared: a global mono mix is returned.
             #2- one or more stereo pair mics were used and declared (micL, micR):
             a global stereo mix is returned with mono tracks panned 50-50
 
-        If device has an associated Tracks description AND it declares a(mono or
+        If device has an associated Tracks description AND it declares a (mono or
         stereo) mix track, this fct returns a tempfile containing the
-        corresponding tracks, simpley extarcting them from multichan_tmpfl
-        (thos covers cases #3 and #4)
+        corresponding tracks, simply extracting them from multichan_tmpfl
+        (those covers cases #3 and #4)
 
         Args:
             device : device_scanner.Device dataclass
@@ -793,12 +804,13 @@ class AudioStitcherVideoMerger:
             logger.debug('%s has mix %s'%(device.name, device.tracks.mix))
             logger.debug('device %s'%device)
             # just checking coherency
-            if 'ttc' in device.tracks.rawtrx:
-                trx_TTC_chan = device.tracks.rawtrx.index('ttc')
-            elif 'tc' in device.tracks.rawtrx:
+            if 'tc' in device.tracks.rawtrx:
                 trx_TTC_chan = device.tracks.rawtrx.index('tc')
+            elif 'TC' in device.tracks.rawtrx:
+                trx_TTC_chan = device.tracks.rawtrx.index('TC')
             else:
                 print('Error: no tc or ttc tag in track.txt')
+                print(device.tracks.rawtrx)
                 sys.exit(1)
             logger.debug('TTC chan %i, dev ttc %i'%(trx_TTC_chan, device.ttc))
             if trx_TTC_chan != device.ttc:
@@ -839,7 +851,120 @@ class AudioStitcherVideoMerger:
         stereo_files = mic_stereo_files + new_stereo_files
         return _sox_mix_files(stereo_files)
 
-    def build_audio_and_write_video(self, top_dir, output_dir,
+    def build_audio_and_write_merged_media(self, top_dir, output_dir,
+                                    write_multicam_structure,
+                                    asked_ISOs, audio_REC_only):
+        # simply bifurcates depending if ref media is video (prob 99%)
+        # (then audio_REC_only == False)
+        # or if ref media is audio (no camera detected)
+        # (with audio_REC_only == True)
+        if not audio_REC_only:
+            self._build_audio_and_write_video(top_dir, output_dir,
+                                    write_multicam_structure, asked_ISOs)
+        else:
+            self._build_and_write_audio(top_dir, output_dir)
+
+    def _build_and_write_audio(self, top_dir, output_dir):
+        """
+        This is called when only audio recorders were found (no cam).
+
+        top_dir: Path, directory where media were looked for
+
+        output_dir: str for optional folder specified as CLI argument, if
+        value is None, fall back to OUT_DIR_DEFAULT
+
+        For each audio devices found overlapping self.ref_audio: pad, trim
+        or stretch audio files by calling _get_concatenated_audiofile_for(), and
+        put them in merged_audio_files_by_device. More than one audio recorder
+        can be used for a shot: that's why merged_audio_files_by_device is a
+        list.
+
+        Returns nothing
+
+        Sets AudioStitcherVideoMerger.final_synced_file on completion to list
+        containing all the synced and patched audio files.
+        """
+        self.ref_audio = self.videoclip # ref audio was stored in videoclip
+        logger.debug('Will merge audio against %s from %s'%(self.ref_audio,
+                                                self.ref_audio.device.name))
+        # eg, suppose the user called tictacsync with 'mondayPM' as top folder
+        # to scan for dailies (and 'somefolder' for output):
+        if output_dir == None:
+            synced_clip_dir = Path(top_dir)/OUT_DIR_DEFAULT # = mondayPM/SyncedMedia
+        else:
+            synced_clip_dir = Path(output_dir)/Path(top_dir).name # = somefolder/mondayPM
+        self.synced_clip_dir = synced_clip_dir
+        os.makedirs(synced_clip_dir, exist_ok=True)
+        logger.debug('synced_clip_dir is: %s'%synced_clip_dir)
+        synced_clip_file = synced_clip_dir/\
+            Path(self.videoclip.new_rec_name).name
+        logger.debug('editing files for %s'%synced_clip_file)
+        self.ref_audio.final_synced_file = synced_clip_file # relative path
+        # Collecting edited audio by device, in (Device, tempfile) pairs:
+        # for a given self.ref_audio, each other audio device will have a sequence
+        # of matched, synced and joined audio files present in a single
+        # edited audio file, returned by _get_concatenated_audiofile_for
+        merged_audio_files_by_device = [
+                            (d, self._get_concatenated_audiofile_for(d)) 
+                            for d in self._get_secondary_audio_devices()]
+        # at this point, audio editing has been done in tempfiles
+        logger.debug('%i elements in merged_audio_files_by_device'%len(
+                                            merged_audio_files_by_device))
+        for d, f, in merged_audio_files_by_device:
+            logger.debug('device: %s'%d.name)
+            logger.debug('file %s of %i channels'%(f.name,
+                                        sox.file_info.channels(f.name)))
+        logger.debug('')
+        if not merged_audio_files_by_device:
+            # no audio file overlaps for this clip
+            return #############################################################
+        logger.debug('will output ISO files since no cam')
+        devices_and_monofiles = [(device, _split_channels(multi_chan_audio))
+                for device, multi_chan_audio
+                in merged_audio_files_by_device]
+        # add device and file from self.ref_audio
+        new_tuple = (self.ref_audio.device,
+                        _split_channels(self.ref_audio.AVpath))
+        devices_and_monofiles.append(new_tuple)
+        logger.debug('devices_and_monofiles: %s'%
+            pprint.pformat(devices_and_monofiles))
+        def _trnm(dev, idx): # used in the loop just below
+            # generates track name for later if asked_ISOs
+            # idx is from 0 to nchan-1 for this device
+            if dev.tracks == None:
+                chan_name = 'chan%s'%str(idx+1).zfill(2)
+            else:
+                # sanitize
+                symbols = set(r"""`~!@#$%^&*()_-+={[}}|\:;"'<,>.?/""")
+                chan_name = dev.tracks.rawtrx[idx]
+                logger.debug('raw chan_name %s'%chan_name)
+                chan_name = chan_name.split(';')[0] # if ex: "lav bob;25"
+                logger.debug('chan_name WO ; lag: %s'%chan_name)
+                chan_name =''.join([e if e not in symbols else ''
+                                    for e in chan_name])
+                logger.debug('chan_name WO special chars: %s'%chan_name)
+                chan_name = chan_name.replace(' ', '_')
+                logger.debug('chan_name WO spaces: %s'%chan_name)
+                chan_name += '_' + dev.name # TODO: make this an option?
+            logger.debug('track_name %s'%chan_name)
+            return chan_name #####################################################
+        # replace device, idx pair with track name (+ device name if many)
+        # loop over devices than loop over tracks
+        names_audio_tempfiles = []
+        for dev, mono_tmpfiles_list in devices_and_monofiles:
+            for idx, monotf in enumerate(mono_tmpfiles_list):
+                track_name = _trnm(dev, idx)
+                logger.debug('track_name %s'%track_name)
+                if track_name[0] == '0': # muted, skip
+                    continue
+                names_audio_tempfiles.append((track_name, monotf))
+        logger.debug('names_audio_tempfiles %s'%names_audio_tempfiles)
+        self._write_ISOs(names_audio_tempfiles)
+        logger.debug('merged_audio_files_by_device %s'%
+                            merged_audio_files_by_device)
+
+
+    def _build_audio_and_write_video(self, top_dir, output_dir,
                                     write_multicam_structure,
                                     asked_ISOs):
         """
@@ -862,12 +987,12 @@ class AudioStitcherVideoMerger:
 
         Sets AudioStitcherVideoMerger.final_synced_file on completion
         """
-        logger.debug(' fct args: top_dir: %s; output_dir: %s; write_multicam_structure: %s; asked_ISOs: %s;'%
+        logger.debug(' fct args: top_dir: %s; output_dir: %s; write_multicam_structure: %s; asked_ISOs: %s'%
             (top_dir, output_dir, write_multicam_structure, asked_ISOs))
         logger.debug('device for rec %s: %s'%(self.videoclip,
             self.videoclip.device))
-        # suppose the user called tictacsync with 'mondayPM' as top folder to
-        # scan for dailies (and 'somefolder' for output):
+        # eg, suppose the user called tictacsync with 'mondayPM' as top folder
+        # to scan for dailies (and 'somefolder' for output):
         if output_dir == None:
             synced_clip_dir = Path(top_dir)/OUT_DIR_DEFAULT # = mondayPM/SyncedMedia
         else:
@@ -882,13 +1007,18 @@ class AudioStitcherVideoMerger:
             Path(self.videoclip.new_rec_name).name
         logger.debug('editing files for %s'%synced_clip_file)
         self.videoclip.final_synced_file = synced_clip_file # relative path
-        # Collecting edited audio by device, in (Device, tempfile) pairs:
+        # Collecting edited audio by device, in (Device, tempfiles) pairs:
         # for a given self.videoclip, each audio device will have a sequence
         # of matched, synced and joined audio files present in a single
         # edited audio file, returned by _get_concatenated_audiofile_for
         merged_audio_files_by_device = [
                             (d, self._get_concatenated_audiofile_for(d)) 
                             for d in self._get_audio_devices()]
+        # at this point, audio editing has been done in multichan wav tempfiles 
+        logger.debug('merged_audio_files_by_device %s'%merged_audio_files_by_device)
+        for d, f, in merged_audio_files_by_device:
+            logger.debug('%s'%d)
+            logger.debug('file %s'%f.name)
         if len(merged_audio_files_by_device) == 0:
             # no audio file overlaps for this clip
             return #############################################################
@@ -958,21 +1088,30 @@ class AudioStitcherVideoMerger:
                 # generates track name for later if asked_ISOs
                 # idx is from 0 to nchan-1 for this device
                 if dev.tracks == None:
-                    tag = 'chan%s'%str(idx+1).zfill(2)
+                    chan_name = 'chan%s'%str(idx+1).zfill(2)
                 else:
-                    # audio_tags = [tag for tag in dev.tracks.rawtrx
-                    #     if tag not in ['ttc','0','tc']]
-                    tag = dev.tracks.rawtrx[idx]
+                    # sanitize
+                    symbols = set(r"""`~!@#$%^&*()_-+={[}}|\:;"'<,>.?/""")
+                    chan_name = dev.tracks.rawtrx[idx]
+                    logger.debug('raw chan_name %s'%chan_name)
+                    chan_name = chan_name.split(';')[0] # if ex: "lav bob;25"
+                    logger.debug('chan_name WO ; lag: %s'%chan_name)
+                    chan_name =''.join([e if e not in symbols else ''
+                                        for e in chan_name])
+                    logger.debug('chan_name WO special chars: %s'%chan_name)
+                    chan_name = chan_name.replace(' ', '_')
+                    logger.debug('chan_name WO spaces: %s'%chan_name)
                 if multiple_recorders:
-                    tag += '_' + dev.name
-                logger.debug('tag %s'%tag)
-                return tag #####################################################
+                    chan_name += '_' + dev.name # TODO: make this an option?
+                logger.debug('track_name %s'%chan_name)
+                return chan_name #####################################################
             # replace device, idx pair with track name (+ device name if many)
             # loop over devices than loop over tracks
             names_audio_tempfiles = []
             for dev, mono_tmpfiles_list in devices_and_monofiles:
                 for idx, monotf in enumerate(mono_tmpfiles_list):
                     track_name = _trnm(dev, idx)
+                    logger.debug('track_name %s'%track_name)
                     if track_name[0] == '0': # muted, skip
                         continue
                     names_audio_tempfiles.append((track_name, monotf))
@@ -1009,7 +1148,8 @@ class AudioStitcherVideoMerger:
     def _merge_audio_and_video(self):
         """      
         Calls ffmpeg to join video in self.videoclip.AVpath to
-        audio in self.videoclip.synced_audio
+        audio in self.videoclip.synced_audio. Audio in original video
+        is dropped.
 
         On entry, videoclip.final_synced_file is a Path to an non existing
         file (contrarily to videoclip.synced_audio).
@@ -1036,7 +1176,8 @@ class AudioStitcherVideoMerger:
         ffmpeg_args = (
             ffmpeg
             .input(v_n)
-            .output(out_n, shortest=None, vcodec='copy',
+            # .output(out_n, shortest=None, vcodec='copy',
+            .output(out_n, vcodec='copy',
                 timecode=timecode)
             .global_args('-i', a_n, "-hide_banner")
             .overwrite_output()
@@ -1047,7 +1188,8 @@ class AudioStitcherVideoMerger:
             _, out = (
             ffmpeg
             .input(v_n)
-            .output(out_n, shortest=None, vcodec='copy',
+            .output(out_n, vcodec='copy',
+            # .output(out_n, shortest=None, vcodec='copy',
                 # metadata='reel_name=foo', not all container support gen MD
                 timecode=timecode,
                 )
@@ -1085,7 +1227,7 @@ class Matcher:
         recordings : list of Recording instances
             all the scanned recordings with valid TicTacCode, set in __init__()
 
-        video_mergers : list
+        mergers : list
             of AudioStitcherVideoMerger Class instances, built by
             scan_audio_for_each_videoclip(); each video has a corresponding
             AudioStitcherVideoMerger object. An audio_stitch doesn't extend
@@ -1102,7 +1244,7 @@ class Matcher:
         
         """
         self.recordings = recordings_list
-        self.video_mergers = []
+        self.mergers = []
 
     def _rename_all_recs(self):
         """
@@ -1150,12 +1292,12 @@ class Matcher:
                     logger.debug('recording %s overlaps,'%(audio))
                     # print('  recording [gold1]%s[/gold1] overlaps,'%(audio))
             if len(audio_stitch.get_matched_audio_recs()) > 0:
-                self.video_mergers.append(audio_stitch)
+                self.mergers.append(audio_stitch)
             else:
                 logger.debug('\n  nothing\n')
                 print('No overlap found for %s'%videoclip.AVpath.name)
                 del audio_stitch
-        logger.debug('%i video_mergers created'%len(self.video_mergers))
+        logger.debug('%i mergers created'%len(self.mergers))
 
     def _does_overlap(self, videoclip, audio_rec):
         A1, A2 = audio_rec.get_start_time(), audio_rec.get_end_time()
@@ -1194,7 +1336,7 @@ Moves clusters at the timelineoffset
         Returns nothing, changes are done in the video files metadata
         (each referenced by Recording.final_synced_file)
         """
-        vids = [m.videoclip for m in self.video_mergers]
+        vids = [m.videoclip for m in self.mergers]
         logger.debug('vids %s'%vids)
         if len(vids) == 1:
             logger.debug('just one take, no gap to shrink')

{tictacsync-0.95a0 → tictacsync-0.96a0}/tictacsync/yaltc.py

@@ -35,7 +35,6 @@ TEENSY_MAX_LAG = 1.01*128/44100 # sec, duration of a default length audio block
 
 CACHING = True
 DEL_TEMP = False
-DB_RMS_SILENCE_SOX = -58
 MAXDRIFT = 15e-3 # in sec, for end of clip
 
 
@@ -566,25 +565,24 @@ class Recording:
             implicitly True for each video recordings (but not set)
 
         device_relative_speed : float
-Set by 
             the ratio of the recording device clock speed relative to the
             video recorder clock device, in order to correct clock drift with
             pysox tempo transform. If value < 1.0 then the recording is
             slower than video recorder. Updated by each
-            AudioStitcherVideoMerger instance so the value can change
+            MediaMerger instance so the value can change
             depending on the video recording . A mean is calculated for all
             recordings of the same device in
-            AudioStitcherVideoMerger._get_concatenated_audiofile_for()
+            MediaMerger._get_concatenated_audiofile_for()
 
         time_position : float
             The time (in seconds) at which the recording starts relative to the
-            video recording. Updated by each AudioStitcherVideoMerger
+            video recording. Updated by each MediaMerger
             instance so the value can change depending on the video
             recording (a video or main sound).
 
         final_synced_file : a pathlib.Path
             contains the path of the merged video file after the call to
-            AudioStitcher.build_audio_and_write_video if the Recording is a
+            AudioStitcher.build_audio_and_write_merged_media if the Recording is a
             video recording, relative to the working directory
             
         synced_audio : pathlib.Path
@@ -792,8 +790,8 @@ Set by
     def get_corrected_duration(self):
         """
         uses device_relative_speed to compute corrected duration. Updated by
-        each AudioStitcherVideoMerger object in
-        AudioStitcherVideoMerger._get_concatenated_audiofile_for()
+        each MediaMerger object in
+        MediaMerger._get_concatenated_audiofile_for()
         """
         return self.get_duration()/self.device_relative_speed
 
@@ -928,7 +926,7 @@ Set by
     def set_time_position_to(self, video_clip):
         """
         Sets self.time_position, the time (in seconds) at which the recording
-        starts relative to the video recording. Updated by each AudioStitcherVideoMerger
+        starts relative to the video recording. Updated by each MediaMerger
         instance so the value can change depending on the video
         recording (a video or main sound).
 
@@ -1074,13 +1072,12 @@ Set by
         return ratio/ratio_ref
 
     def get_samplerate(self):
-        # return int samplerate (nominal)
+        # returns int samplerate (nominal)
         string = self._ffprobe_audio_stream()['sample_rate']
         logger.debug('ffprobe samplerate: %s'%string)
-        return eval(string) # eg eval(24000/1001)
+        return eval(string)
 
     def get_framerate(self):
-        # return int samplerate (nominal)
         string = self._ffprobe_video_stream()['avg_frame_rate']
         return eval(string) # eg eval(24000/1001)
 

{tictacsync-0.95a0 → tictacsync-0.96a0/tictacsync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 0.95a0
+Version: 0.96a0
 Summary: command for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz

{tictacsync-0.95a0 → tictacsync-0.96a0}/tictacsync.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ tictacsync/device_scanner.py
 tictacsync/entry.py
 tictacsync/multi2polywav.py
 tictacsync/remergemix.py
+tictacsync/remrgmx.py
 tictacsync/timeline.py
 tictacsync/yaltc.py
 tictacsync.egg-info/PKG-INFO