tictacsync 0.91a0__tar.gz → 0.95a0__tar.gz

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

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

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

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

{tictacsync-0.91a0 → tictacsync-0.95a0}/tictacsync/device_scanner.py

@@ -69,6 +69,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:
@@ -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))
@@ -146,6 +153,7 @@ 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']
     codecs = [stream['codec_type'] for stream in streams]
     device_type = 'CAM' if 'video' in codecs else 'REC'
@@ -155,6 +163,7 @@ def get_device_ffprobe_UID(file):
         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
@@ -302,12 +311,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 +330,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,14 +486,16 @@ class Scanner:
         read track names for naming separated ISOs
         from tracks_file.
 
+        tokens looked for: mix mixL mixR 0 ttc
+
         repeting prefixes signals a stereo track
         and entries will correspondingly panned into
         a stero mix named mixL.wav and mixR.wav
 
-        mic1 L # space is optionnal and will be removed
-        mic1 R
-        mic2 L
-        mic2 R
+        xyz L # spaces are ignored |
+        zyz R                      | stereo pair
+        abc L
+        abc R
 
         mixL
 
@@ -502,41 +513,56 @@ class Scanner:
             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 start with 'mic' and end with 'L' or 'R'
+            return tag[:3]=='mic' and tag[-1] 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 ]
+        tracks_lines = [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
+        # 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])
+        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)]
-        # 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)
+        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'
+        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))]
+            # eg [(('mic1L', 1), ('mic1R', 2)), (('mic2L', 3), ('mic2R', 4))]
             def _mic_same(p):
                 # p = (('mic1l', 1), ('mic1r', 2))
                 # check if mic1 == mic1
@@ -546,16 +572,22 @@ class Scanner:
             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
+            # 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))
+                # p = (('mic1R', 1), ('mic1L', 2))
                 # returns ('mic1', (1,2))
                 first, second = p
                 mic_prefix = _WO_LR(first[0])
-                return (mic_prefix, (first[1], second[1]) )
+                # 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'%

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

@@ -1,4 +1,4 @@
-# print('Loading modules...', end='')
+print('Loading modules...', end='')
 
 # I know, the following is ugly, but I need those try's to
 # run the command in my dev setting AND from
@@ -16,11 +16,11 @@ except:
     import timeline
     import multi2polywav
 
-import argparse
+import argparse, tempfile
 from loguru import logger
 from pathlib import Path
 # import os, sys
-import os, sys
+import os, sys, sox
 from rich.progress import track
 # from pprint import pprint
 from rich.console import Console
@@ -29,6 +29,8 @@ from rich.table import Table
 from rich import print
 from pprint import pprint 
 
+DEL_TEMP = False
+
 av_file_extensions = \
 """MOV 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,7 +42,7 @@ logger.level("DEBUG", color="<yellow>")
 
 def process_files_with_progress_bars(medias):
     recordings = []
-    rec_with_yaltc = []
+    rec_with_TTC = []
     times = []
     for m in track(medias,
             description="1/4 Initializing Recordings:"):
@@ -49,25 +51,25 @@ def process_files_with_progress_bars(medias):
     for r in track(recordings,
             description="2/4  Looking for TicTacCode:"):
         if r.seems_to_have_TicTacCode_at_beginning():
-            rec_with_yaltc.append(r)
-    for r in track(rec_with_yaltc,
+            rec_with_TTC.append(r)
+    for r in track(rec_with_TTC,
             description="3/4     Finding start times:"):
         times.append(r.get_start_time())
-    return recordings, rec_with_yaltc, times
+    return recordings, rec_with_TTC, times
 
 def process_files(medias):
     recordings = []
-    rec_with_yaltc = []
+    rec_with_TTC = []
     times = []
     for m in medias:
         recordings.append(yaltc.Recording(m))
     for r in recordings:
         # print('%s duration %.2fs'%(r.AVpath.name, r.get_duration()))
         if r.seems_to_have_TicTacCode_at_beginning():
-            rec_with_yaltc.append(r)
-    for r in rec_with_yaltc:
+            rec_with_TTC.append(r)
+    for r in rec_with_TTC:
         times.append(r.get_start_time())
-    return recordings, rec_with_yaltc, times
+    return recordings, rec_with_TTC, times
 
 def process_single(file, args):
     # argument is a single file
@@ -97,6 +99,42 @@ def process_single(file, args):
             print('Start time couldnt be determined')
     sys.exit(1)
 
+def process_lag_adjustement(media_object):
+    # trim channels that are lagging (as stated in tracks.txt)
+    # replace the old file, and rename the old one with .wavbk
+    # if .wavbk exist, process was done already, so dont process
+    # returns nothing
+    lags = media_object.device.tracks.lag_values
+    logger.debug('will process %s lags'%[lags])
+    channels = timeline._split_channels(media_object.path)
+    # add bk to file on filesystem, but media_object.path is unchanged (?)
+    backup_name = str(media_object.path) + 'bk'
+    if Path(backup_name).exists():
+        logger.debug('%s exists, so return now.'%backup_name)
+        return
+    media_object.path.replace(backup_name)
+    logger.debug('channels %s'%channels)
+    def _trim(lag, chan_file):
+        if lag == None:
+            return chan_file
+        else:
+            logger.debug('process %s for lag of %s'%(chan_file, lag))            
+            sox_transform = sox.Transformer()
+            sox_transform.trim(float(lag)*1e-3)
+            output_fh = tempfile.NamedTemporaryFile(suffix='.wav', delete=DEL_TEMP)
+            out_file = timeline._pathname(output_fh)
+            input_file = timeline._pathname(chan_file)
+            logger.debug('sox in and out files: %s %s'%(input_file, out_file))
+            logger.debug('calling sox_transform.build()')
+            status = sox_transform.build(input_file, out_file, return_output=True )
+            logger.debug('sox.build exit code %s'%str(status))
+        return output_fh
+    new_channels = [_trim(*e) for e in zip(lags, channels)]
+    logger.debug('new_channels %s'%new_channels)
+    trimmed_multichanfile = timeline._sox_combine(new_channels)
+    logger.debug('trimmed_multichanfile %s'%timeline._pathname(trimmed_multichanfile))
+    Path(timeline._pathname(trimmed_multichanfile)).replace(media_object.path)
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument(
@@ -107,32 +145,46 @@ def main():
                 )
     # parser.add_argument("directory", nargs="?", help="path of media directory")
     # parser.add_argument('-v', action='store_true')
-    parser.add_argument('-v', action='store_true', default=False,
-                    dest='verbose_output',
-                    help='Set verbose ouput')
+    parser.add_argument('-v',
+                        action='store_true',  #ie default False
+                        dest='verbose_output',
+                        help='Set verbose ouput')
     parser.add_argument('-o', nargs=1,
                     help='Where to write the SyncedMedia folder [default to "path" ]')
-    parser.add_argument('-p', action='store_true', default=False,
+    parser.add_argument('-t','--timelineoffset',
+                    nargs=1,
+                    default=['00:00:00:00'],
+                    dest='timelineoffset',
+                    help='When processing multicam, where to place clips on NLE timeline (HH:MM:SS:FF)')
+    parser.add_argument('-p',
+                    action='store_true',
                     dest='plotting',
                     help='Produce plots')
-    parser.add_argument('--isos', action='store_true', default=False,
+    parser.add_argument('--isos',
+                    action='store_true',
                     dest='write_ISOs',
                     help='Write ISO sound files')
-    parser.add_argument('--nosync', action='store_true',
+    parser.add_argument('--nosync',
+                    action='store_true',
                     dest='nosync',
                     help='Just scan and decode')
-    parser.add_argument('--terse', action='store_true',
+    parser.add_argument('--terse',
+                    action='store_true',
                     dest='terse',
                     help='Terse output')
     args = parser.parse_args()
+    # print(args)
+    if len(args.timelineoffset) != 1:
+        print('--timelineoffset needs one value, got %s'%args.timelineoffset)
+        quit()
     if args.verbose_output:
         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"] == "get_start_time")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_detect_sync_pulse_position")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_device_mix")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_sox_mix_files")
+    # 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")
     top_dir = args.path[0]
     if os.path.isfile(top_dir):
         file = top_dir
@@ -151,7 +203,13 @@ def main():
         sys.exit(1)
     multi2polywav.poly_all(top_dir)
     scanner = device_scanner.Scanner(top_dir, stay_silent=args.terse)
-    scanner.scan_media_and_build_devices_UID() 
+    scanner.scan_media_and_build_devices_UID()
+    for m in scanner.found_media_files:
+        if m.device.tracks:
+            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)                
     if not args.terse:
         if scanner.input_structure == 'folder_is_device':
             print('\nDetected structured folders', end='')
@@ -162,10 +220,8 @@ def main():
         else:
             print('\nDetected loose structure')
             if scanner.CAM_numbers() > 1:
-                print('\nNote: different CAMs are present, will sync audio')
-                print('for each of them but if you want to set their')
-                print('respective timecode for NLE timeline alignement')
-                print('you should regroup clips by CAM under their own DIR.')
+                print('\nNote: different CAMs are present, will sync audio for each of them but if you want to set their')
+                print('respective timecode for NLE timeline alignement you should regroup clips by CAM under their own DIR.')
         print('\nFound [gold1]%i[/gold1] media files '%(
             len(scanner.found_media_files)), end='')
         print('from [gold1]%i[/gold1] devices:\n'%(
@@ -177,15 +233,11 @@ def main():
                 print('[gold1]%s[/gold1]'%m.path.name, end=', ')
             print('[gold1]%s[/gold1]'%medias[-1].path.name)
         print()
-    # if args.verbose_output or args.terse: # verbose or terse, so no progress bars
-    #     rez = process_files(scanner.found_media_files)
-    # else: 
-    #     rez = process_files_with_progress_bars(scanner.found_media_files)
     rez = process_files(scanner.found_media_files)
-    recordings, rec_with_yaltc, times = rez
+    recordings, rec_with_TTC, times = rez
     recordings_with_time =  [
         rec 
-        for rec in rec_with_yaltc
+        for rec in rec_with_TTC
         if rec.get_start_time()
         ]
     if not args.terse:    
@@ -199,7 +251,7 @@ def main():
         table.add_column("Date\n", justify="center", style='gold1')
         rec_WO_time = [
             rec.AVpath.name
-            for rec in rec_with_yaltc
+            for rec in rec_with_TTC
             if not rec.get_start_time()
             ]
         if rec_WO_time:
@@ -226,9 +278,6 @@ def main():
         print()
     n_devices = scanner.get_devices_number()
     OUT_struct_for_mcam = scanner.top_dir_has_multicam
-    # if n_devices > 2:
-    #     print('\nMerging for more than 2 devices is not implemented yet, quitting...')
-    #     sys.exit(1)
     if len(recordings_with_time) < 2:
         if not args.terse:
             print('\nNothing to sync, exiting.\n')
@@ -245,31 +294,24 @@ def main():
         asked_ISOs = False
     output_dir = args.o
     # if args.verbose_output or args.terse: # verbose, so no progress bars
-    for stitcher in matcher.video_mergers:
-        stitcher.build_audio_and_write_video(top_dir, arg_out_dir,
+    for merger in matcher.video_mergers:
+        merger.build_audio_and_write_video(top_dir, arg_out_dir,
         OUT_struct_for_mcam,
         asked_ISOs,)
-    # else:
-    #     print() 
-    #     for stitcher in track(matcher.video_mergers,
-    #         description="4/4         Merging sound to videos:"):
-    #         stitcher.build_audio_and_write_video(top_dir, arg_out_dir,
-    #                 OUT_struct_for_mcam,
-    #                 asked_ISOs,)
     if not args.terse:
         print("\n")
     # find out where files were wrtitten
-    a_stitcher = matcher.video_mergers[0]
+    a_merger = matcher.video_mergers[0]
     print('\nWrote output in folder [gold1]%s[/gold1]'%(
-            a_stitcher.synced_clip_dir))
-    for stitcher in matcher.video_mergers:
-        print('[gold1]%s[/gold1]'%stitcher.videoclip.AVpath.name, end='')
-        for audio in stitcher.get_matched_audio_recs():
+            a_merger.synced_clip_dir))
+    for merger in matcher.video_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='')
-        new_file = stitcher.videoclip.final_synced_file.parts
-        print(' became [gold1]%s[/gold1]'%stitcher.videoclip.final_synced_file.name)
+        new_file = merger.videoclip.final_synced_file.parts
+        print(' became [gold1]%s[/gold1]'%merger.videoclip.final_synced_file.name)
         # matcher._build_otio_tracks_for_cam()
-    matcher.shrink_gaps_between_takes()
+    matcher.shrink_gaps_between_takes(args.timelineoffset)
     sys.exit(0)
     
 if __name__ == '__main__':

{tictacsync-0.91a0 → tictacsync-0.95a0}/tictacsync/multi2polywav.py

@@ -1,4 +1,4 @@
-import argparse, wave, subprocess
+import argparse, wave, subprocess, sys
 from loguru import logger
 from pathlib import Path
 from itertools import groupby

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

@@ -303,7 +303,7 @@ class AudioStitcherVideoMerger:
     Typically each found video is associated with an AudioStitcherVideoMerger
     instance. AudioStitcherVideoMerger does the actual audio-video file
     processing of merging AudioStitcherVideoMerger.videoclip (gen. a video)
-    with all audio files in  AudioStitcherVideoMerger.edited_audio as
+    with all audio files in  AudioStitcherVideoMerger.soxed_audio as
     determined by the Matcher object (Matcher instanciates and manages
     AudioStitcherVideoMerger objects).
 
@@ -317,46 +317,54 @@ class AudioStitcherVideoMerger:
     project.
 
 
+    Class attribute
+
+        tempoed_recs : dict as {Recording : path}
+
+            a cache for already time-stretched audio files. Keys are elements
+            of matched_audio_recordings and the value are tuples:
+            (factor, file_handle), the file_handle points to the precedently
+            produced NamedTemporaryFile; factor is the value that was used in
+            the sox tempo transform.
+
     Attributes:
 
         videoclip : a Recording instance
             The video to which audio files are synced
 
-        edited_audio : dict as {Recording : path}
-            keys are elements of matched_audio_recordings of class Recording
-            and the value stores the Pathlib path of the eventual edited
-            audio (trimmed , padded or time stretched). Before building the
-            audio_montage, path points to the initial
-            Recording.valid_sound
+        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).
 
         synced_clip_dir : Path
             where synced clips are written
 
     """
+    tempoed_recs = {}
 
     def __init__(self, video_clip):
         self.videoclip = video_clip
         # self.matched_audio_recordings = []
-        self.edited_audio = {}
+        self.soxed_audio = {}
         logger.debug('instantiating AudioStitcherVideoMerger for %s'%
                             video_clip)
 
     def add_matched_audio(self, audio_rec):
         """
-        Populates AudioStitcherVideoMerger.edited_audio,
+        Populates AudioStitcherVideoMerger.soxed_audio,
         a dict as {Recording : path}
 
         This fct is called
         within Matcher.scan_audio_for_each_videoclip()
 
-        Returns nothing, fills self.edited_audio dict with
+        Returns nothing, fills self.soxed_audio dict with
         matched audio.
 
         """
-        self.edited_audio[audio_rec] = audio_rec.AVpath
+        self.soxed_audio[audio_rec] = audio_rec.AVpath
         """
-        Here at this point, self.edited_audio[audio_rec] is unedited but
-        after a call to _edit_audio_file(), edited_audio[audio_rec] points to
+        Here at this point, self.soxed_audio[audio_rec] is unedited but
+        after a call to _edit_audio_file(), soxed_audio[audio_rec] points to
         a new file and audio_rec.AVpath is unchanged.
         """
         return
@@ -364,9 +372,9 @@ class AudioStitcherVideoMerger:
     def get_matched_audio_recs(self):
         """
         Returns audio recordings that overlap self.videoclip.
-        Simply keys of self.edited_audio dict
+        Simply keys of self.soxed_audio dict
         """
-        return list(self.edited_audio.keys())
+        return list(self.soxed_audio.keys())
 
     def _get_audio_devices(self):
         devices = set([r.device for r in self.get_matched_audio_recs()])
@@ -382,58 +390,77 @@ class AudioStitcherVideoMerger:
         return recs
 
     def _dedrift_rec(self, rec):
-        initial_duration = sox.file_info.duration(
-            _pathname(rec.AVpath))
-        sox_transform = sox.Transformer()
-        # tempo_scale_factor = rec.device_relative_speed
+        # instanciates a sox.Transformer() with tempo() effect
+        # add applies it via a call to _edit_audio_file(rec, sox_transform)
         tempo_scale_factor = rec.device_relative_speed
         audio_dev = rec.device.name
         video_dev = self.videoclip.device.name
+        print('when merging with [gold1]%s[/gold1].'%self.videoclip)
         if tempo_scale_factor > 1:
-            print('[gold1]%s[/gold1] clock too fast relative to [gold1]%s[/gold1] so file is too long by a %f factor;\n'%
+            print('Because [gold1]%s[/gold1] clock too fast relative to [gold1]%s[/gold1]: file is too long by a %.12f factor;'%
                 (audio_dev, video_dev, tempo_scale_factor))
         else:
-            print('hence [gold1]%s[/gold1] clock too slow relative to [gold1]%s[/gold1] so file is short by a %f factor\n'%
+            print('Because [gold1]%s[/gold1] clock too slow relative to [gold1]%s[/gold1]: file is short by a %.12f factor'%
                 (audio_dev, video_dev, tempo_scale_factor))
-        sox_transform.tempo(tempo_scale_factor)
-        # scaled_file = self._get_soxed_file(rec, sox_transform)
-        logger.debug('sox_transform %s'%sox_transform.effects)
-        self._edit_audio_file(rec, sox_transform)
-        scaled_file_name = _pathname(self.edited_audio[rec])
-        new_duration = sox.file_info.duration(scaled_file_name)
-        # goal_duration = rec.get_corrected_duration()
-        logger.debug('initial_duration %f new_duration %f ratio:%f'%(
-            initial_duration, new_duration, initial_duration/new_duration))
+        logger.debug('tempoed_recs dict:%s'%AudioStitcherVideoMerger.tempoed_recs)
+        if rec in AudioStitcherVideoMerger.tempoed_recs:
+            logger.debug('%s already tempoed'%rec)
+            cached_factor, cached_file = AudioStitcherVideoMerger.tempoed_recs[rec]
+            error_factor = tempo_scale_factor/cached_factor
+            logger.debug('tempo factors, needed: %f cached %f'%(tempo_scale_factor,cached_factor))
+            delta_cache = abs((1 - error_factor)*rec.get_original_duration())
+            logger.debug('error if cache is used: %f ms'%(delta_cache*1e3))
+            delta_cache_is_ok = delta_cache < yaltc.MAXDRIFT
+        else:
+            delta_cache_is_ok = False
+        if delta_cache_is_ok:
+            logger.debug('ok, will use %s'%cached_file)
+            self.soxed_audio[rec] = cached_file
+        else:
+            logger.debug('%s not tempoed yet'%rec)            
+            sox_transform = sox.Transformer()
+            sox_transform.tempo(tempo_scale_factor)
+            # scaled_file = self._get_soxed_file(rec, sox_transform)
+            logger.debug('sox_transform %s'%sox_transform.effects)
+            soxed_fh = self._edit_audio_file(rec, sox_transform)
+            scaled_file_name = _pathname(soxed_fh)
+            AudioStitcherVideoMerger.tempoed_recs[rec] = (tempo_scale_factor, soxed_fh)
+            new_duration = sox.file_info.duration(scaled_file_name)
+            initial_duration = sox.file_info.duration(
+                _pathname(rec.AVpath))
+            logger.debug('Verif: initial_duration %.12f new_duration %.12f ratio:%.12f'%(
+                initial_duration, new_duration, initial_duration/new_duration))
+            logger.debug('delta duration %f ms'%((new_duration-initial_duration)*1e3))
 
     def _get_concatenated_audiofile_for(self, device):
         """
         return a handle for the final audio file formed by all detected
-        overlapping recordings, produced by the same specified device.
+        overlapping recordings, produced by the same audio recorder.
         
         """
         logger.debug('concatenating device %s'%str(device))
-        recordings = self._get_all_recordings_for(device)
+        audio_recs = self._get_all_recordings_for(device)
         # [TODO here] Check if all unidentified device files are not
         # overlapping because they are considered produced by the same
         # device. If some overlap then necessarily they're from different
         # ones. List the files and warn the user there is a risk of error if
         # they're not from the same device.
 
-        logger.debug('%i audio files for videoclip %s:'%(len(recordings),
+        logger.debug('%i audio files for videoclip %s:'%(len(audio_recs),
             self.videoclip))
-        for r in recordings:
+        for r in audio_recs:
             logger.debug('  %s'%r)
+        # ratio between real samplerates of audio and videoclip
         speeds = numpy.array([rec.get_speed_ratio(self.videoclip)
-                                    for rec in recordings])
+                                    for rec in audio_recs])
         mean_speed = numpy.mean(speeds)
-        for r in recordings:
-            r.device_relative_speed = mean_speed
-            # r.device_relative_speed = 0.9
-            logger.debug('set device_relative_speed for %s'%r)
-            logger.debug(' value: %f'%r.device_relative_speed)
-            r.set_time_position_to(self.videoclip)
-            logger.debug('time_position for %s: %fs relative to %s'%(r,
-                r.time_position, self.videoclip))
+        for audio in audio_recs:
+            audio.device_relative_speed = mean_speed
+            logger.debug('set device_relative_speed for %s'%audio)
+            logger.debug(' value: %f'%audio.device_relative_speed)
+            audio.set_time_position_to(self.videoclip)
+            logger.debug('time_position for %s: %fs relative to %s'%(audio,
+                audio.time_position, self.videoclip))
         # st_dev_speeds just to check for anomalous situation
         st_dev_speeds = numpy.std(speeds)
         logger.debug('mean speed for %s: %.6f std dev: %.0e'%(device,
@@ -458,7 +485,7 @@ class AudioStitcherVideoMerger:
 
         # process first element 'by hand' outside the loop
         # first_audio is a Recording, not a path nor filehandle
-        first_audio = recordings[0]
+        first_audio = audio_recs[0]
         needs_dedrift, delta = first_audio.needs_dedrifting()
         logger.debug('first audio is %s'%first_audio)
         logger.debug('checking drift, first audio: delta of %0.2f ms'%(
@@ -470,8 +497,8 @@ class AudioStitcherVideoMerger:
         self._pad_or_trim_first_audio(first_audio)
         # loop for the other files
         # growing_file = first_audio.edited_version
-        growing_file = self.edited_audio[first_audio]
-        for i, rec in enumerate(recordings[1:]):
+        growing_file = self.soxed_audio[first_audio]
+        for i, rec in enumerate(audio_recs[1:]):
             logger.debug('Padding and joining for %s'%rec)
             needs_dedrift, delta = rec.needs_dedrifting()
             logger.debug('next audio is %s'%rec)
@@ -494,7 +521,7 @@ class AudioStitcherVideoMerger:
                     (rec,rec.time_position,end_time))
             self._pad_file(rec, pad_duration)
             # new_file = rec.edited_version
-            new_file = self.edited_audio[rec]
+            new_file = self.soxed_audio[rec]
             growing_file = self._concatenate_audio_files(growing_file, new_file)
         end_time = sox.file_info.duration(growing_file.name)
         logger.debug('total edited audio duration  %.2f s'%end_time)
@@ -507,7 +534,7 @@ class AudioStitcherVideoMerger:
         TODO: check if first_rec is a Recording or tempfile (maybe a tempfile if dedrifted)
         NO: will change tempo after trimming/padding
 
-        Store (into Recording.edited_audio dict) the handle  of the sox processed
+        Store (into Recording.soxed_audio dict) the handle  of the sox processed
         first recording, padded or chopped according to AudioStitcherVideoMerger.videoclip
         starting time. Length of the written file can differ from length of the
         submitted Recording object if drift is corrected with sox tempo
@@ -571,22 +598,25 @@ class AudioStitcherVideoMerger:
     def _edit_audio_file(self, audio_rec, sox_transform):
         """
         Apply the specified sox_transform onto the audio_rec and update
-        self.edited_audio dict with the result (with audio_rec as the key)
+        self.soxed_audio dict with the result (with audio_rec as the key)
+        Returns the filehandle of the result.
         """
         output_fh = tempfile.NamedTemporaryFile(suffix='.wav', delete=DEL_TEMP)
         logger.debug('transform: %s'%sox_transform.effects)
-        recording_fh = self.edited_audio[audio_rec]
+        recording_fh = self.soxed_audio[audio_rec]
         logger.debug('for recording %s, matching %s'%(audio_rec,
                                                 self.videoclip))
         input_file = _pathname(recording_fh)
-        logger.debug('AudioStitcherVideoMerger.edited_audio[audio_rec]: %s'%
+        logger.debug('AudioStitcherVideoMerger.soxed_audio[audio_rec]: %s'%
                                                     input_file)
         out_file = _pathname(output_fh)
         logger.debug('sox in and out files: %s %s'%(input_file, out_file))
+        logger.debug('calling sox_transform.build()')
         status = sox_transform.build(input_file, out_file, return_output=True )
         logger.debug('sox.build exit code %s'%str(status))
         # audio_rec.edited_version = output_fh
-        self.edited_audio[audio_rec] = output_fh
+        self.soxed_audio[audio_rec] = output_fh
+        return output_fh
 
     def _write_ISOs(self, edited_audio_all_devices):
         """
@@ -797,10 +827,12 @@ class AudioStitcherVideoMerger:
         logger.debug('stereo_mic_idx_flat %s'%stereo_mic_idx_flat)
         mono_tracks = [i for i in range(1, device.n_chan + 1)
                                 if i not in stereo_mic_idx_flat]
-        logger.debug('mono_tracks: %s'%mono_tracks)
+        logger.debug('mono_tracks (with ttc+zeroed included): %s'%mono_tracks)
         # remove TTC track number
-        mono_tracks.remove(device.ttc + 1)
-        logger.debug('mono_tracks %s'%mono_tracks)
+        to_remove = device.tracks.unused + [device.ttc+1]# unused is sox idx
+        [mono_tracks.remove(t) for t in to_remove]
+        # mono_tracks.remove(device.ttc + 1)
+        logger.debug('mono_tracks (ttc+zeroed removed)%s'%mono_tracks)
         mono_files = [_sox_keep(multichan_tmpfl, [chan]) for chan
                                                     in mono_tracks]
         new_stereo_files = [_sox_mono2stereo(f) for f in mono_files]
@@ -988,7 +1020,7 @@ class AudioStitcherVideoMerger:
         """
         synced_clip_file = self.videoclip.final_synced_file
         video_path = self.videoclip.AVpath
-        timecode = self.videoclip.get_timecode()
+        timecode = self.videoclip.get_start_timecode_string()
         # self.videoclip.synced_audio = audio_path
         audio_path = self.videoclip.synced_audio
         vid_only_handle = self._keep_VIDEO_only(video_path)
@@ -1136,20 +1168,28 @@ class Matcher:
         case4 = R1 < A2 < R2
         return case1 or case2 or case3 or case4
 
-    def shrink_gaps_between_takes(self, with_gap=CLUSTER_GAP):
+    def shrink_gaps_between_takes(self, CLI_offset, with_gap=CLUSTER_GAP):
         """
         for single cam shootings this simply sets the gap between takes,
         tweaking each vid timecode metadata to distribute them next to each
-        other along NLE timeline. For multicam takes, shifts are computed so
+        other along NLE timeline.
+
+Moves clusters at the timelineoffset
+
+        For multicam takes, shifts are computed so
         video clusters are near but dont overlap, ex: 
 
-        Cluster 1           Cluster 2
-        1111111111111        2222222222 (cam A)
-           11111111111[...]222222222 (cam B)
+        Cluster 1                    Cluster 2
+        1111111111111                 2222222222 (cam A)
+           11111111111[inserted gap]222222222 (cam B)
 
         or
-        1111111111111    222222 (cam A)
-          1111111     22222 (cam B)
+        1111111111111[inserted   222222 (cam A)
+          1111111     gap]222222222 (cam B)
+
+        argument:
+            CLI_offset (str), option from command-line
+            with_gap (float), the gap duration in seconds
 
         Returns nothing, changes are done in the video files metadata
         (each referenced by Recording.final_synced_file)
@@ -1210,17 +1250,25 @@ class Matcher:
         cummulative_offsets = [td.total_seconds() for td in cummulative_offsets]
         logger.debug('cummulative_offsets: %s'%cummulative_offsets)
         time_of_first = clusters[0]['start']
+        # compute CLI_offset_in_seconds from HH:MM:SS:FF in CLI_offset
+        h, m, s, f = [float(s) for s in CLI_offset[0].split(':')]
+        logger.debug('CLI_offset float values %s'%[h,m,s,f])
+        CLI_offset_in_seconds = 3600*h + 60*m + s + f/vids[0].get_framerate()
+        logger.debug('CLI_offset in seconds %f'%CLI_offset_in_seconds)
         offset_for_all_clips = - from_midnight(time_of_first).total_seconds()
+        offset_for_all_clips += CLI_offset_in_seconds
         logger.debug('time_of_first: %s'%time_of_first)
         logger.debug('offset_for_all_clips: %s'%offset_for_all_clips)
         for cluster, offset in zip(clusters, cummulative_offsets):
+            # first one starts at 00:00:00:00
             total_offset = offset + offset_for_all_clips
             logger.debug('for %s offset in sec: %f'%(cluster['vids'],
                     total_offset))
             for vid in cluster['vids']:
-                tc = vid.get_timecode(with_offset=total_offset)
+                # tc = vid.get_start_timecode_string(CLI_offset, with_offset=total_offset)
+                tc = vid.get_start_timecode_string(with_offset=total_offset)
                 logger.debug('for %s old tc: %s new tc %s'%(vid,
-                    vid.get_timecode(), tc))
+                    vid.get_start_timecode_string(), tc))
                 vid.write_file_timecode(tc)
         return
 

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

@@ -36,7 +36,7 @@ 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 = 10e-3 # in sec, normally 10e-3 (10 ms)
+MAXDRIFT = 15e-3 # in sec, for end of clip
 
 
 ################## pasted from FSKfreqCalculator.py output:
@@ -46,7 +46,7 @@ SYMBOL_LENGTH = 14.286 # ms, from FSKfreqCalculator.py
 N_SYMBOLS = 35 # including sync pulse
 ##################
 
-MINIMUM_LENGTH = 4 # sec
+MINIMUM_LENGTH = 8 # sec
 TRIAL_TIMES = [ # in seconds
             (3.5, -2),
             (3.5, -3.5),
@@ -233,7 +233,7 @@ class Decoder:
 
         Uses the conditions below:
 
-            Extract duration is 1.143 s.
+            Extract duration is 1.143 s. (ie one sec + 1 symbol duration)
             In self.word_props (list of morphology.regionprops):
                 if one region, duration should be in [0.499 0.512] sec
                 if two regions, total duration should be in [0.50 0.655]
@@ -244,13 +244,19 @@ class Decoder:
         props = self.words_props
         if len(props) not in [1,2]:
             failing_comment = 'len(props) not in [1,2]: %i'%len(props)
+        else:
+            logger.debug('len(props), %i, is in [1,2]'%len(props))
         if len(props) == 1:
+            logger.debug('one region')
             w = _width(props[0])/self.samplerate
             # self.effective_word_duration = w
             # logger.debug('effective_word_duration %f (one region)'%w)
             if not 0.499 < w < 0.512: # TODO: move as TOP OF FILE PARAMS
                 failing_comment = '_width %f not in [0.499 0.512]'%w
+            else:
+                logger.debug('0.499 < width < 0.512, %f'%w)
         else: # 2 regions
+            logger.debug('two regions')
             widths = [_width(p)/self.samplerate for p in props] # in sec
             total_w = sum(widths)
             # extra_window_duration = SOUND_EXTRACT_LENGTH - 1
@@ -260,6 +266,8 @@ class Decoder:
                 failing_comment = 'two regions duration %f not in [0.50 0.655]\n%s'%(total_w, widths)
                 # fig, ax = plt.subplots()
                 # p(ax, sound_extract_one_bit)
+            else:
+                logger.debug('0.5 < total_w < 0.656, %f'%total_w)
         logger.debug('failing_comment: %s'%(
             'none' if failing_comment=='' else failing_comment))
         return failing_comment == '' # no comment = extract seems TicTacCode
@@ -558,7 +566,7 @@ 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
@@ -593,13 +601,15 @@ class Recording:
 
     def __init__(self, media, do_plots=False):
         """
+        Set AVfilename string and check if file exists, does not read any
+        media data right away but uses ffprobe to parses the file and sets
+        probe attribute.
+
+        Logs a warning and sets Recording.decoder to None if ffprobe cant
+        interpret the file or if file has no audio. If file contains audio,
+        initialise Recording.decoder(but doesnt try to decode anything yet).
+
         If multifile recording, AVfilename is sox merged audio file;
-        Set AVfilename string and check if file exists, does not read
-        any media data right away but uses ffprobe to parses the file and
-        sets probe attribute. 
-        Logs a warning if ffprobe cant interpret the file or if file
-        has no audio; if file contains audio, instantiates a Decoder object
-        (but doesnt try to decode anything yet)
 
         Parameters
         ----------
@@ -673,6 +683,7 @@ class Recording:
             print('Recording init failed: %s'%recording_init_fail)
             self.probe = None
             self.decoder = None
+            return
         logger.debug('ffprobe found: %s'%self.probe)
         logger.debug('n audio chan: %i'%self.get_audio_channels_nbr())
         self._read_audio_data()
@@ -708,7 +719,8 @@ class Recording:
             self.audio_data.shape))
 
     def __repr__(self):
-        return 'Recording of %s'%_pathname(self.new_rec_name)
+        # return 'Recording of %s'%_pathname(self.new_rec_name)
+        return _pathname(self.new_rec_name)
 
     def _check_for_camera_error_correction(self):
         # look for a file number
@@ -787,13 +799,14 @@ class Recording:
 
     def needs_dedrifting(self):
         rel_sp = self.device_relative_speed
-        if rel_sp > 1:
-            delta = (rel_sp - 1)*self.get_original_duration()
-        else:
-            delta = (1 - rel_sp)*self.get_original_duration()
+        # if rel_sp > 1:
+        #     delta = (rel_sp - 1)*self.get_original_duration()
+        # else:
+        #     delta = (1 - rel_sp)*self.get_original_duration()
+        delta = abs((1 - rel_sp)*self.get_original_duration())
         logger.debug('%s delta drift %.2f ms'%(str(self), delta*1e3))
         if delta > MAXDRIFT:
-            print('[gold1]%s[/gold1] will get drift correction: delta of [gold1]%.3f[/gold1] ms is too big'%
+            print('\n[gold1]%s[/gold1] will get drift correction: delta of [gold1]%.3f[/gold1] ms is too big'%
                 (self.AVpath, delta*1e3))
         return delta > MAXDRIFT, delta
 
@@ -942,9 +955,12 @@ class Recording:
         if successful, returns a datetime.datetime instance;
         if not returns None.
         """
-        logger.debug('for recording %s, recording.start_time %s'%(self,
+        logger.debug('for %s, recording.start_time %s'%(self,
                                                         self.start_time))
+        if self.decoder is None:
+            return None # ffprobe failes or file too short, see __init__
         if self.start_time is not None:
+            logger.debug('Recording.start_time already found %s'%self.start_time)
             return self.start_time #############################################
         cached_times = {}
         def find_time(t_sec):
@@ -969,8 +985,8 @@ class Recording:
                                         len(TRIAL_TIMES)))
             # time_around_beginning = self._find_time_around(near_beg)
             time_around_beginning = find_time(near_beg)
-            if self.TicTacCode_channel is None:
-                return None ####################################################
+            # if self.TicTacCode_channel is None:
+            #     return None ####################################################
             logger.debug('Trial #%i, end at %f'%(i+1, near_end))
             # time_around_end = self._find_time_around(near_end)
             time_around_end = find_time(near_end)
@@ -1048,6 +1064,7 @@ class Recording:
         return int(ppm)
 
     def get_speed_ratio(self, videoclip):
+        # ratio between real samplerates of audio and videoclip
         nominal = self.get_samplerate()
         true = self.true_samplerate
         ratio = true/nominal
@@ -1067,9 +1084,10 @@ class Recording:
         string = self._ffprobe_video_stream()['avg_frame_rate']
         return eval(string) # eg eval(24000/1001)
 
-    def get_timecode(self, with_offset=0):
-        # returns a HHMMSS:FR string
+    def get_start_timecode_string(self, with_offset=0):
+        # returns a HH:MM:SS:FR string
         start_datetime = self.get_start_time()
+        # logger.debug('CLI_offset %s'%CLI_offset)
         logger.debug('start_datetime %s'%start_datetime)
         start_datetime += timedelta(seconds=with_offset)
         logger.debug('shifted start_datetime %s (offset %f)'%(start_datetime,

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

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