tictacsync 0.82a0__py3-none-any.whl → 0.95a0__py3-none-any.whl

tictacsync/timeline.py

@@ -237,7 +237,6 @@ def _sox_mono2stereo(temp_file) -> tempfile.NamedTemporaryFile:
         sys.exit(1)
     return stereo_tempfile
 
-
 def _sox_mix_files(temp_files_to_mix:list) -> tempfile.NamedTemporaryFile:
     """
     Mix files referred by the list of Path into a new temporary files passed on
@@ -303,9 +302,10 @@ class AudioStitcherVideoMerger:
     """
     Typically each found video is associated with an AudioStitcherVideoMerger
     instance. AudioStitcherVideoMerger does the actual audio-video file
-    processing of merging self.videoclip (gen. a video) with all audio
-    files in  self.edited_audio as determined by the Matcher
-    object (it instanciates and manages AudioStitcherVideoMerger objects).
+    processing of merging AudioStitcherVideoMerger.videoclip (gen. a video)
+    with all audio files in  AudioStitcherVideoMerger.soxed_audio as
+    determined by the Matcher object (Matcher instanciates and manages
+    AudioStitcherVideoMerger objects).
 
     All audio file edits are done using pysox and video+audio merging with
     ffmpeg. When necessary, clock drift is corrected for all overlapping audio
@@ -317,58 +317,64 @@ 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 self.edited_audio, a dict as {Recording : path}
+        Populates AudioStitcherVideoMerger.soxed_audio,
+        a dict as {Recording : path}
 
-        AudioStitcherVideoMerger.add_matched_audio() is called
+        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.valid_sound
+        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
-        a new file and the precedent is unchanged (that's why from
-        AudioStitcherVideoMerger instance to another
-        audio_rec.valid_sound doesn't need to be reinitialized since
-        it stays unchanged)
+        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
 
     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()])
@@ -384,59 +390,77 @@ class AudioStitcherVideoMerger:
         return recs
 
     def _dedrift_rec(self, rec):
-        # first_audio_p = rec.AVpath
-        initial_duration = sox.file_info.duration(
-            _pathname(rec.valid_sound))
-        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('[gold1]%s[/gold1] clock too slow relative to [gold1]%s[/gold1] so file is too 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,
@@ -461,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'%(
@@ -473,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)
@@ -497,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)
@@ -510,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
@@ -574,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):
         """
@@ -740,9 +767,10 @@ class AudioStitcherVideoMerger:
                         (device.ttc, device.tracks.ttc))
         if device.ttc + 1 != device.tracks.ttc: # warn and quit
             print('Error: TicTacCode channel detected is [gold1]%i[/gold1]'%
-                device.ttc + 1, end=' ')
-            print('and the file [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
-                (device_scanner.TRACKSFN, device.tracks.ttc))
+                (device.ttc), end=' ')
+            print('and [gold1]%s[/gold1] for the device [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
+                (device_scanner.TRACKSFN,
+                device.name, device.tracks.ttc-1))
             print('Please correct the discrepancy and rerun. Quitting.')
             sys.exit(1)
         if device.tracks.mix == [] and device.tracks.stereomics == []:
@@ -799,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]
@@ -990,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)
@@ -1138,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)
@@ -1212,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