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

tictacsync/timeline.py

@@ -9,8 +9,9 @@ from rich import print
 from itertools import groupby
 # import opentimelineio as otio
 from datetime import timedelta
-import pprint, shutil, os, sys
+import shutil, os, sys, stat
 from subprocess import Popen, PIPE
+from pprint import pformat
 
 from inspect import currentframe, getframeinfo
 try:
@@ -20,10 +21,26 @@ except:
     import yaltc
     import device_scanner
 
-CLUSTER_GAP = 0.5 # secs between multicam clusters
+CLUSTER_GAP = 2 # secs between multicam clusters
 DEL_TEMP = False
 DB_OSX_NORM = -6 #dB
 OUT_DIR_DEFAULT = 'SyncedMedia'
+MCCDIR = 'SyncedMulticamClips'
+
+# utility to lock ISO audio files
+def remove_write_permissions(path):
+    """Remove write permissions from this path, while keeping all other permissions intact.
+
+    Params:
+        path:  The path whose permissions to alter.
+    """
+    NO_USER_WRITING = ~stat.S_IWUSR
+    NO_GROUP_WRITING = ~stat.S_IWGRP
+    NO_OTHER_WRITING = ~stat.S_IWOTH
+    NO_WRITING = NO_USER_WRITING & NO_GROUP_WRITING & NO_OTHER_WRITING
+
+    current_permissions = stat.S_IMODE(os.lstat(path).st_mode)
+    os.chmod(path, current_permissions & NO_WRITING)
 
 # utility for accessing pathnames
 def _pathname(tempfile_or_path) -> str:
@@ -64,6 +81,12 @@ def _extr_channel(source, dest, channel):
     status = sox_transform.build(str(source), str(dest))
     logger.debug('sox status %s'%status)
 
+def _same(aList):
+    return aList.count(aList[0]) == len(aList)
+
+def _flatten(xss):
+    return [x for xs in xss for x in xs]
+
 def _sox_keep(audio_file, kept_channels: list) -> tempfile.NamedTemporaryFile:
     """
     Returns a NamedTemporaryFile containing the selected kept_channels
@@ -102,7 +125,7 @@ def _sox_keep(audio_file, kept_channels: list) -> tempfile.NamedTemporaryFile:
         stderr).decode('utf-8'))
     return output_tempfile
 
-def _split_channels(multi_chan_audio:Path) -> list:
+def _sox_split_channels(multi_chan_audio:Path) -> list:
     nchan = sox.file_info.channels(_pathname(multi_chan_audio))
     source = _pathname(multi_chan_audio)
     paths = []
@@ -383,14 +406,14 @@ class AudioStitcherVideoMerger:
     def _get_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()))
+            pformat(self.get_matched_audio_recs()))
         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()))
+            pformat(self.get_matched_audio_recs()))
         logger.debug('devices %s'%devices)
         return devices
 
@@ -641,7 +664,7 @@ class AudioStitcherVideoMerger:
         Returns nothing, output is written to filesystem as below.
         ISOs subfolders structure when user invokes the --isos flag:
 
-        SyncedMedia/ (or output_dir)
+        SyncedMedia/ (or anchor_dir)
 
                 leftCAM/
 
@@ -689,24 +712,16 @@ class AudioStitcherVideoMerger:
         synced_clip_dir = synced_clip_file.parent
         # build ISOs subfolders structure, see comment string below
         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')
         os.makedirs(ISOdir, exist_ok=True)
         logger.debug('edited_audio_all_devices %s'%edited_audio_all_devices)
         logger.debug('ISOdir %s'%ISOdir)
-        # ISO_multi_chan = ISOdir / 'ISO_multi_chan.wav'
-        # logger.debug('temp file: %s'%(ISO_multi_chan))
-        # logger.debug('will split audio to %s'%(ISOdir))
         for name, mono_tmpfl in edited_audio_all_devices:
-             # pad(start_duration: float = 0.0, end_duration: float = 0.0)[source]
             destination = ISOdir/('%s.wav'%name)
             mono_tmpfl_trimpad = _fit_length(mono_tmpfl)
             shutil.copy(_pathname(mono_tmpfl_trimpad), destination)
+            remove_write_permissions(destination)
             logger.debug('destination:%s'%destination)
-        # # mixNnormed = _sox_mix_files(tempfiles)
-        # # print('516', _pathname(mixNnormed))
-        # os.remove(ISO_multi_chan)
 
     def _get_device_mix(self, device, multichan_tmpfl) -> tempfile.NamedTemporaryFile:
         """
@@ -789,7 +804,7 @@ class AudioStitcherVideoMerger:
             # all, but here remove '0' and TTC tracks from mix
             all_channels = list(range(1, device.n_chan + 1)) # sox not ZBIDX
             to_remove = device.tracks.unused + [device.ttc+1]# unused is sox idx
-            logger.debug('multitrack but no tracks.txt, mixing %s except # %s (sox #)'%
+            logger.debug('multitrack but no mix, mixing mono %s except # %s (sox #)'%
                 (all_channels, to_remove))
             sox_kept_channels = [i for i in all_channels
                                             if i not in to_remove]
@@ -851,26 +866,25 @@ class AudioStitcherVideoMerger:
         stereo_files = mic_stereo_files + new_stereo_files
         return _sox_mix_files(stereo_files)
 
-    def build_audio_and_write_merged_media(self, top_dir, output_dir,
-                                    write_multicam_structure,
-                                    asked_ISOs, audio_REC_only):
+    def build_audio_and_write_merged_media(self, top_dir, 
+                            dont_write_cam_folder, 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)
+        # or if ref media is audio (no camera detected, 1% of cases)
         # (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)
+            self._build_audio_and_write_video(top_dir,
+                                    dont_write_cam_folder, asked_ISOs)
         else:
-            self._build_and_write_audio(top_dir, output_dir)
+            self._build_and_write_audio(top_dir, anchor_dir)
 
-    def _build_and_write_audio(self, top_dir, output_dir):
+    def _build_and_write_audio(self, top_dir, anchor_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
+        anchor_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
@@ -889,16 +903,16 @@ class AudioStitcherVideoMerger:
                                                 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:
+        if anchor_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
+            synced_clip_dir = Path(anchor_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)
+        logger.debug('editing files for synced_clip_file%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
@@ -919,15 +933,15 @@ class AudioStitcherVideoMerger:
             # 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))
+        devices_and_monofiles = [(device, _sox_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))
+                        _sox_split_channels(self.ref_audio.AVpath))
         devices_and_monofiles.append(new_tuple)
         logger.debug('devices_and_monofiles: %s'%
-            pprint.pformat(devices_and_monofiles))
+            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
@@ -963,17 +977,15 @@ class AudioStitcherVideoMerger:
         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):
+    def _build_audio_and_write_video(self, top_dir, dont_write_cam_folder,
+                                            asked_ISOs):
         """
         top_dir: Path, directory where media were looked for
 
-        output_dir: str for optional folder specified as CLI argument, if
+        anchor_dir: str for optional folder specified as CLI argument, if
         value is None, fall back to OUT_DIR_DEFAULT
 
-        write_multicam_structure: True if needs to write multicam folders
+        dont_write_cam_folder: True if needs to bypass writing multicam folders
 
         asked_ISOs: bool flag specified as CLI argument
 
@@ -987,25 +999,28 @@ 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'%
-            (top_dir, output_dir, write_multicam_structure, asked_ISOs))
+        logger.debug(' fct args: top_dir %s, dont_write_cam_folder %s, asked_ISOs %s'%
+            (top_dir, dont_write_cam_folder, asked_ISOs))
         logger.debug('device for rec %s: %s'%(self.videoclip,
             self.videoclip.device))
         # 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
-        if write_multicam_structure:
-            device_name = self.videoclip.device.name
-            synced_clip_dir = synced_clip_dir/device_name # = synced_clip_dir/ZOOM
+        # if anchor_dir == None:
+        # then "alongside mode" i.e., in a folder neighboring the video clip
+        # WAS: synced_clip_dir = Path(top_dir)/OUT_DIR_DEFAULT # = mondayPM/SyncedMedia
+        logger.debug('"alongside mode" for clip: %s'%self.videoclip.AVpath)
+        synced_clip_dir = self.videoclip.AVpath.parent/OUT_DIR_DEFAULT
+        # else: # [TODO: replace original clip in a mirrored file structure]
+        #     logger.debug('mirrored mode for clip: %s'%self.videoclip.AVpath)
+        #     synced_clip_dir = Path(anchor_dir)/Path(top_dir).name # = somefolder/mondayPM
+        # if write_multicam_structure:
+        #     device_name = self.videoclip.device.name
+        #     synced_clip_dir = synced_clip_dir/device_name # = synced_clip_dir/ZOOM
         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)
+        synced_clip_file = synced_clip_dir/self.videoclip.AVpath.name
+        logger.debug('editing files for synced_clip_file %s'%synced_clip_file)
         self.videoclip.final_synced_file = synced_clip_file # relative path
         # Collecting edited audio by device, in (Device, tempfiles) pairs:
         # for a given self.videoclip, each audio device will have a sequence
@@ -1069,7 +1084,7 @@ class AudioStitcherVideoMerger:
         mix_of_device_mixes = _sox_mix_files(device_mixes)
         logger.debug('will merge with %s'%(_pathname(mix_of_device_mixes)))
         self.videoclip.synced_audio = mix_of_device_mixes
-        logger.debug('mix_of_device_mixes n chan: %i'%
+        logger.debug('mix_of_device_mixes (final mix) has %i channels'%
             sox.file_info.channels(_pathname(mix_of_device_mixes)))
         self._merge_audio_and_video()
         # devices_and_monofiles is list of (device, [monofiles])
@@ -1079,18 +1094,20 @@ class AudioStitcherVideoMerger:
         # devices_and_monofiles:
         if asked_ISOs:
             logger.debug('will output ISO files...')
-            devices_and_monofiles = [(device, _split_channels(multi_chan_audio))
+            devices_and_monofiles = [(device, _sox_split_channels(multi_chan_audio))
                     for device, multi_chan_audio
                     in merged_audio_files_by_device]
             logger.debug('devices_and_monofiles: %s'%
-                pprint.pformat(devices_and_monofiles))
-            def _trnm(dev, idx): # used in the loop just below
+                pformat(devices_and_monofiles))
+            def _build_from_tracks_txt(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:
+                    # no tracks.txt was found so use ascending numbers for name
                     chan_name = 'chan%s'%str(idx+1).zfill(2)
                 else:
-                    # sanitize
+                    # sanitize names in tracks.txt
                     symbols = set(r"""`~!@#$%^&*()_-+={[}}|\:;"'<,>.?/""")
                     chan_name = dev.tracks.rawtrx[idx]
                     logger.debug('raw chan_name %s'%chan_name)
@@ -1110,12 +1127,12 @@ class AudioStitcherVideoMerger:
             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)
+                    track_name = _build_from_tracks_txt(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)
+            logger.debug('names_audio_tempfiles %s'%pformat(names_audio_tempfiles))
             self._write_ISOs(names_audio_tempfiles)
         logger.debug('merged_audio_files_by_device %s'%
             merged_audio_files_by_device)
@@ -1233,6 +1250,10 @@ class Matcher:
             AudioStitcherVideoMerger object. An audio_stitch doesn't extend
             beyond the corresponding video start and end times.
 
+        multicam_clips_clusters : list
+            of  {'end': t1, 'start': t2, 'vids': [r1,r3]} where r1 and r3
+            are overlapping.
+
     """
 
     def __init__(self, recordings_list):
@@ -1246,20 +1267,20 @@ class Matcher:
         self.recordings = recordings_list
         self.mergers = []
 
-    def _rename_all_recs(self):
-        """
-        Add _synced to filenames of synced video files. Change stored name only:
-        files have yet to be written to.
-        """
-        # match IO_structure:
-            # case 'foldercam':
-        for rec in self.recordings:
-            rec_extension = rec.AVpath.suffix
-            rel_path_new_name = '%s%s'%(rec.AVpath.stem, rec_extension)
-            rec.new_rec_name = Path(rel_path_new_name)
-            logger.debug('for %s new name: %s'%(
-                _pathname(rec.AVpath),
-                _pathname(rec.new_rec_name)))
+    # def _rename_all_recs(self):
+    #     """
+    #     Add _synced to filenames of synced video files. Change stored name only:
+    #     files have yet to be written to.
+    #     """
+    #     # match IO_structure:
+    #         # case 'foldercam':
+    #     for rec in self.recordings:
+    #         rec_extension = rec.AVpath.suffix
+    #         rel_path_new_name = '%s%s'%(rec.AVpath.stem, rec_extension)
+    #         rec.new_rec_name = Path(rel_path_new_name)
+    #         logger.debug('for %s new name: %s'%(
+    #             _pathname(rec.AVpath),
+    #             _pathname(rec.new_rec_name)))
 
     def scan_audio_for_each_videoclip(self):
         """
@@ -1295,7 +1316,7 @@ class Matcher:
                 self.mergers.append(audio_stitch)
             else:
                 logger.debug('\n  nothing\n')
-                print('No overlap found for %s'%videoclip.AVpath.name)
+                print('No overlap found for [gold1]%s[/gold1]'%videoclip.AVpath.name)
                 del audio_stitch
         logger.debug('%i mergers created'%len(self.mergers))
 
@@ -1310,49 +1331,29 @@ class Matcher:
         case4 = R1 < A2 < R2
         return case1 or case2 or case3 or case4
 
-    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.
-
-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[inserted gap]222222222 (cam B)
-
-        or
-        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)
-        """
+    def set_up_clusters(self):
+        # builds the list self.multicam_clips_clusters. A list 
+        # of  {'end': t1, 'start': t2, 'vids': [r1,r3]} where r1 and r3
+        # are overlapping.
+        # if no overlap occurs, length of vid = 1, ex 'vids': [r1]
+        # so not really a cluster in those cases
+        # returns nothing and sets Matcher.multicam_clips_clusters
         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')
-            return #############################################################
         # INs_and_OUTs contains (time, direction, video) for each video,
         # where direction is 'in|out' and video an instance of Recording
         INs_and_OUTs = [(vid.get_start_time(), 'in', vid) for vid in vids]
         for vid in vids:
             INs_and_OUTs.append((vid.get_end_time(), 'out', vid))
         INs_and_OUTs = sorted(INs_and_OUTs, key=lambda vtuple: vtuple[0])
-        logger.debug('INs_and_OUTs: %s'%INs_and_OUTs)
+        logger.debug('INs_and_OUTs: %s'%pformat(INs_and_OUTs))
         new_cluster = True
         current_cluster = {'vids':[]}
         N_in, N_out = (0, 0)
         # clusters is a list of  {'end': t1, 'start': t2, 'vids': [r1,r3]}
         clusters = []
+        # a cluster begins (and grows) when a time of type 'in' is encountered
+        # a cluster degrows when a time of type 'out' is encountered and
+        # closes when its size (N_currently_open) reach back to zero
         for t, direction, video in INs_and_OUTs:
             if new_cluster and direction == 'out':
                 logger.error('cant begin a cluster with a out time %s'%video)
@@ -1373,7 +1374,44 @@ Moves clusters at the timelineoffset
                 new_cluster = True
                 current_cluster = {'vids':[]}
                 N_in, N_out = (0, 0)
-        logger.debug('clusters: %s'%pprint.pformat(clusters))
+        logger.debug('clusters: %s'%pformat(clusters))
+        self.multicam_clips_clusters = clusters
+        return
+
+    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.
+
+        Moves clusters at the timelineoffset
+
+        For multicam takes, shifts are computed so
+        video clusters are near but dont overlap, ex: 
+
+        ***** are inserted gaps
+
+        Cluster 1                    Cluster 2
+        1111111111111                 2222222222 (cam A)
+           11111111111******222222222 (cam B)
+
+        or
+        11111111111111          222222 (cam A)
+          1111111     ******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)
+        """
+        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')
+            return #############################################################
+        clusters = self.multicam_clips_clusters
         # if there are N clusters, there are N-1 gaps to evaluate and shorten
         # (lengthen?) to a value of with_gap seconds
         gaps = [c2['start'] - c1['end'] for c1, c2
@@ -1414,7 +1452,61 @@ Moves clusters at the timelineoffset
                 vid.write_file_timecode(tc)
         return
 
+    def move_multicam_to_dir(self):
+        # creates a dedicated multicam directory and move clusters there
+        # e.g., for "top/day01/camA/roll02"
+        #                       ^  at that level
+        #            0   1     2    3
+        # Note: ROLLxx maybe present or not.
+        #
+        # check for consistency: are all clips at the same level from topdir?
+        # Only for video, not audio (which doesnt fill up cards)
+        video_medias = [m for m in self.recordings if m.device.dev_type == 'CAM']
+        video_paths = [m.AVpath.parts for m in video_medias]
+        AV_path_lengths = [len(p) for p in video_paths]
+        # print('AV_path_lengths', AV_path_lengths)
+        if not _same(AV_path_lengths):
+            print('\nError with some clips, check if their locations are consistent (all at the same level in folders).')
+            print('Video synced but could not regroup multicam clips.')
+            sys.exit(0)
+        # now find at which level CAMs reside (maybe there are ROLLxx)
+        CAM_levels = [vm.AVpath.parts.index(vm.device.name)
+                            for vm in video_medias]
+        # find for all, should be same
+        if not _same(CAM_levels):
+            print('\nError with some clips, check if their locations are consistent (all at the same level in folders).')
+            print('Video synced but could not regroup multicam clips.')
+            sys.exit(0)
+        # pick first
+        CAM_level, avp = CAM_levels[0], video_medias[0].AVpath
+        logger.debug('CAM_levels: %s for ex \n%s'%(CAM_level, avp))
+        # MCCDIR = 'SyncedMulticamClips'
+        parts_up_a_level = avp.parts[:CAM_level]
+        multicam_dir = Path('').joinpath(*parts_up_a_level)/MCCDIR
+        logger.debug('multicam_dir: %s'%multicam_dir)
+        Path.mkdir(multicam_dir, exist_ok=True)
+        cam_clips = []
+        [cam_clips.append(cl['vids']) for cl in self.multicam_clips_clusters]
+        cam_clips = _flatten(cam_clips)
+        logger.debug('cam_clips: %s'%cam_clips)
+        cam_names = set([r.device.name for r in cam_clips])
+        # create new dirs for each CAM
+        [Path.mkdir(multicam_dir/cam_name, exist_ok=True)
+                        for cam_name in cam_names]
+        # move clips there
+        for r in cam_clips:
+            cam = r.device.name
+            clip_name = r.AVpath.name
+            dest = r.final_synced_file.replace(multicam_dir/cam/clip_name)
+            logger.debug('dest: %s'%dest)
+            origin_folder = r.final_synced_file.parent
+            folder_now_empty = len(list(origin_folder.glob('*.*'))) == 0
+            if folder_now_empty:
+                logger.debug('after moving %s, folder is now empty, removing it'%dest)
+                origin_folder.rmdir()
+        print('\nMoved %i multicam clips in %s'%(len(cam_clips), multicam_dir))
 
+        
 
 
 

tictacsync/yaltc.py

@@ -298,7 +298,7 @@ class Decoder:
             'detection level, signal, detected region'.split(','),
             loc='lower right')
         ax.set_title('Finding word + sync pulse')
-        plt.xlabel("Position in file (samples)")
+        plt.xlabel("Position in file %s (samples)"%self.rec)
         plt.show()
 
     def get_time_in_sound_extract(self):
@@ -347,6 +347,14 @@ class Decoder:
         sync_pos_in_file = self.detected_pulse_position + \
                     self.sound_extract_position
         time_values['pulse at'] = sync_pos_in_file
+        if not 0 <= time_values['seconds'] <= 59:
+            return None
+        if not 0 <= time_values['minutes'] <= 59:
+            return None
+        if not 0 <= time_values['hours'] <= 23:
+            return None
+        if not 1 <= time_values['month'] <= 12:
+            return None
         return time_values
     
     def _detect_sync_pulse_position(self):
@@ -468,11 +476,11 @@ class Decoder:
         logger.debug('%.2f ms (max value %.2f)'%(1e3*gap/self.samplerate,
                                     1e3*TEENSY_MAX_LAG))
         logger.debug('relative audio_block gap %.2f'%(relative_gap))
-        if relative_gap > 1:
-            print('Warning: gap between spike and word is too big for %s'%self.rec)
-            print('Audio update() gap between sync pulse and word start: ')
-            print('%.2f ms (max value %.2f)'%(1e3*gap/self.samplerate,
-                                    1e3*TEENSY_MAX_LAG))
+        # if relative_gap > 1: # dont tell: simply fail and try elsewhere
+        #     print('Warning: gap between spike and word is too big for %s'%self.rec)
+        #     print('Audio update() gap between sync pulse and word start: ')
+        #     print('%.2f ms (max value %.2f)'%(1e3*gap/self.samplerate,
+        #                             1e3*TEENSY_MAX_LAG))
         symbol_width_samples_theor = self.samplerate*SYMBOL_LENGTH*1e-3
         symbol_width_samples_eff = self.effective_word_duration * \
                                             self.samplerate/(N_SYMBOLS - 1)
@@ -498,7 +506,7 @@ class Decoder:
                     transform=xt,
                 linewidth=0.6, colors='green')
                 ax.set_title('Slicing the 34 bits word:')
-            plt.xlabel("Position in file (samples)")
+            plt.xlabel("Position in file %s (samples)"%self.rec)
             ax.vlines(start, 0, 1,
                 transform=xt,
                 linewidth=0.6, colors='red')
@@ -532,10 +540,6 @@ class Recording:
         device : Device
             identifies the device used for the recording, set in __init__()
 
-        new_rec_name : str
-            built using the device name, ex: "CAM_A001"
-            set by Timeline._rename_all_recs()
-
         probe : dict
             returned value of ffmpeg.probe(self.AVpath)
 
@@ -648,7 +652,7 @@ class Recording:
         # self.valid_sound = None
         self.final_synced_file = None
         self.synced_audio = None
-        self.new_rec_name = media.path.name
+        # self.new_rec_name = media.path.name
         self.do_plots = do_plots
         logger.debug('__init__ Recording object %s'%self.__repr__())
         logger.debug(' in directory %s'%self.AVpath.parent)
@@ -718,7 +722,7 @@ class Recording:
 
     def __repr__(self):
         # return 'Recording of %s'%_pathname(self.new_rec_name)
-        return _pathname(self.new_rec_name)
+        return _pathname(self.AVpath)
 
     def _check_for_camera_error_correction(self):
         # look for a file number
@@ -1220,13 +1224,6 @@ class Recording:
                     )
         return self
     
-    def seems_to_have_TicTacCode_at_beginning(self):
-        if self.probe is None:
-            return False #######################################################
-        self._find_TicTacCode(TRIAL_TIMES[0][0],
-            SOUND_EXTRACT_LENGTH)
-        return self.TicTacCode_channel is not None
-
     def does_overlap_with_time(self, time):
         A1, A2 = self.get_start_time(), self.get_end_time()
         # R1, R2 = rec.get_start_time(), rec.get_end_time()

{tictacsync-0.96a0.dist-info → tictacsync-0.98a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 0.96a0
+Version: 0.98a0
 Summary: command for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz
@@ -29,6 +29,7 @@ Requires-Dist: rich >=10.12.0
 Requires-Dist: lmfit
 Requires-Dist: scikit-image
 Requires-Dist: scipy >=1.10.1
+Requires-Dist: platformdirs
 
 # tictacsync
 
@@ -67,7 +68,7 @@ Then pip install the syncing program:
 This should install python dependencies _and_ the `tictacsync` command.
 ## Usage
 
-Download multiple sample files [here](https://nuage.lutz.quebec/s/nY54nQyxmZbTLti/download/dailies.zip) (625 MB, sorry) unzip and run:
+Download multiple sample files [here](https://nuage.lutz.quebec/s/NpjzXH5R7DrQEWS/download/dailies.zip) (625 MB, sorry) unzip and run:
 
     > tictacsync dailies/loose
 The program `tictacsync` will recursively scan the directory given as argument, find all audio that coincide with any video and merge them into a subfolder named `SyncedMedia`. When the argument is an unique media file (not a directory), no syncing will occur but the decoded starting time will be printed to stdout:
@@ -82,19 +83,22 @@ The program `tictacsync` will recursively scan the directory given as argument,
 If shooting multicam, put clips in their respective directories (using the camera name as folder name) _and_ the audio under their own directory. `tictacsync` will detect that structured input and will generate multicam folders ready to be imported into your NLE (for now only DaVinci Resolve has been validated).
 
 ## Options
+#### `-v`
 
 For a very verbose output add the `-v` flag:
 
     > tictacsync -v dailies/loose/MVI_0024.MP4
-
+#### `--terse`
 For a one line output (or to suppress the progress bars) use the `--terse` flag:
 
 	> tictacsync --terse dailies/loose/MVI_0024.MP4 
 	dailies/loose/MVI_0024.MP4 UTC:2024-03-12 23:07:01.4281 pulse: 27450 in chan 0
+#### `--isos`
 
-To also produce _synced_ ISO audio files, specify `--isos` . A directory named `ISOs` will contain _for each synced video_ a set of ISO audio files of exact same length, padded or trimmed to coincide with the video track. After re-editing and re-mixing a `remergemix` command will resync the new audio with the video and _the new sound track will be updated on your NLE timeline_, at least in Kdenlive...
+Specifying `--isos` produces _synced_ ISO audio files: for each synced \<video-clip\> a directory named `<video-clip>_ISO` will contain a set of ISO audio files each of exact same length, padded or trimmed to coincide with the video start. After re-editing and re-mixing in your DAW of choice a `remergemix` command will resync the new audio with the video and _the new sound track will be updated on your NLE timeline_, _automagically_ on some NLEs or on command for [Davinci Resolve](https://www.niwa.nu/dr-scripts/).
 
 	> tictacsync --isos dailies/structured
+#### `-p`
 
 When called with the `-p` flag, zoomable plots will be produced for diagnostic purpose (close the plotting window for the 2nd one) and the decoded starting time will be output to stdin: