tictacsync 0.82a0__tar.gz → 0.91a0__tar.gz

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

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

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

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

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

@@ -72,6 +72,9 @@ def process_files(medias):
 def process_single(file, args):
     # argument is a single file
     m = device_scanner.media_at_path(None, Path(file))
+    if args.plotting:
+        print('\nPlots can be zoomed and panned...')
+        print('Close window for next one.')
     a_rec = yaltc.Recording(m, do_plots=args.plotting)
     time = a_rec.get_start_time()
     # time = a_rec.get_start_time(plots=args.plotting)
@@ -97,10 +100,10 @@ def process_single(file, args):
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument(
-                "directory",
+                "path",
                 type=str,
                 nargs=1,
-                help="path of media directory"
+                help="directory_name or media_file"
                 )
     # parser.add_argument("directory", nargs="?", help="path of media directory")
     # parser.add_argument('-v', action='store_true')
@@ -108,29 +111,29 @@ def main():
                     dest='verbose_output',
                     help='Set verbose ouput')
     parser.add_argument('-o', nargs=1,
-                    help='where to write synced clips')
+                    help='Where to write the SyncedMedia folder [default to "path" ]')
     parser.add_argument('-p', action='store_true', default=False,
                     dest='plotting',
-                    help='Make plots')
+                    help='Produce plots')
     parser.add_argument('--isos', action='store_true', default=False,
                     dest='write_ISOs',
                     help='Write ISO sound files')
     parser.add_argument('--nosync', action='store_true',
                     dest='nosync',
-                    help='just scan and decode')
+                    help='Just scan and decode')
     parser.add_argument('--terse', action='store_true',
                     dest='terse',
-                    help='terse output')
+                    help='Terse output')
     args = parser.parse_args()
     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"] == "build_audio_and_write_video")
+    # 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")
-    top_dir = args.directory[0]
+    top_dir = args.path[0]
     if os.path.isfile(top_dir):
         file = top_dir
         process_single(file, args)
@@ -173,14 +176,12 @@ def main():
             for m in medias[:-1]:
                 print('[gold1]%s[/gold1]'%m.path.name, end=', ')
             print('[gold1]%s[/gold1]'%medias[-1].path.name)
-        # print('\nThese recordings will be analysed for timestamps:\n')
-        # for m in (scanner.found_media_files):
-        #     print('   ', '[gold1]%s[/gold1]'%m.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)
+    # 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_with_time =  [
         rec 
@@ -188,10 +189,9 @@ def main():
         if rec.get_start_time()
         ]
     if not args.terse:    
-        print('\n\n')
         table = Table(title="tictacsync results")
         table.add_column("Recording\n", justify="center", style='gold1')
-        table.add_column("TicTacCode\nChannel", justify="center", style='gold1')
+        table.add_column("TTC chan\n (1st=#0)", justify="center", style='gold1')
         # table.add_column("Device\n", justify="center", style='gold1')
         table.add_column("UTC times\nstart:end", justify="center", style='gold1')
         table.add_column("Clock drift\n(ppm)", justify="right", style='gold1')
@@ -244,18 +244,18 @@ def main():
         print('Warning, can\'t write ISOs without structured folders: [gold1]--isos[/gold1] option ignored.\n')
         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,
-            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 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,
+        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

{tictacsync-0.82a0 → tictacsync-0.91a0}/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.edited_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
@@ -343,23 +343,21 @@ class AudioStitcherVideoMerger:
 
     def add_matched_audio(self, audio_rec):
         """
-        Populates self.edited_audio, a dict as {Recording : path}
+        Populates AudioStitcherVideoMerger.edited_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
         matched audio.
 
         """
-        self.edited_audio[audio_rec] = audio_rec.valid_sound
+        self.edited_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)
+        a new file and audio_rec.AVpath is unchanged.
         """
         return
 
@@ -384,19 +382,18 @@ class AudioStitcherVideoMerger:
         return recs
 
     def _dedrift_rec(self, rec):
-        # first_audio_p = rec.AVpath
         initial_duration = sox.file_info.duration(
-            _pathname(rec.valid_sound))
+            _pathname(rec.AVpath))
         sox_transform = sox.Transformer()
         # tempo_scale_factor = rec.device_relative_speed
         tempo_scale_factor = rec.device_relative_speed
         audio_dev = rec.device.name
         video_dev = self.videoclip.device.name
         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('[gold1]%s[/gold1] clock too fast relative to [gold1]%s[/gold1] so file is too long by a %f factor;\n'%
                 (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('hence [gold1]%s[/gold1] clock too slow relative to [gold1]%s[/gold1] so file is short by a %f factor\n'%
                 (audio_dev, video_dev, tempo_scale_factor))
         sox_transform.tempo(tempo_scale_factor)
         # scaled_file = self._get_soxed_file(rec, sox_transform)
@@ -740,9 +737,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 == []:

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

@@ -29,7 +29,7 @@ try:
 except:
     import device_scanner
 
-TEENSY_MAX_LAG = 128/44100 # sec, duration of a default length audio block
+TEENSY_MAX_LAG = 1.01*128/44100 # sec, duration of a default length audio block
 
 # see extract_seems_TicTacCode() for duration criterion values
 
@@ -38,12 +38,6 @@ DEL_TEMP = False
 DB_RMS_SILENCE_SOX = -58
 MAXDRIFT = 10e-3 # in sec, normally 10e-3 (10 ms)
 
-SAFE_SILENCE_WINDOW_WIDTH = 400 # ms, not the full 500 ms, to accommodate decay
-# used in _get_silent_zone_indices()
-WORDWIDTHFACTOR = 2
-# see _get_word_width_parameters()
-
-OVER_NOISE_SYNC_DETECT_LEVEL = 2
 
 ################## pasted from FSKfreqCalculator.py output:
 F1 = 630.00 # Hertz
@@ -54,14 +48,14 @@ N_SYMBOLS = 35 # including sync pulse
 
 MINIMUM_LENGTH = 4 # sec
 TRIAL_TIMES = [ # in seconds
-            (0.5, -2),
-            (0.5, -3.5),
-            (0.5, -5),
+            (3.5, -2),
+            (3.5, -3.5),
+            (3.5, -5),
             (2, -2),
             (2, -3.5),
             (2, -5),
-            (3.5, -2),
-            (3.5, -3.5),
+            (0.5, -2),
+            (0.5, -3.5),
             ]
 SOUND_EXTRACT_LENGTH = (10*SYMBOL_LENGTH*1e-3 + 1) # second
 SYMBOL_LENGTH_TOLERANCE = 0.07 # relative
@@ -144,17 +138,16 @@ def to_precision(x,p):
 
 class Decoder:
     """
-    Object encapsulating DSP processes to demodulate TicTacCode track from audio file;
-    Decoders are instantiated by their respective Recording object. Produces
-    plots on demand for diagnostic purposes.
+    Object encapsulating DSP processes to demodulate TicTacCode track from audio
+    file; Decoders are instantiated by their respective Recording object.
+    Produces plots on demand for diagnostic purposes.
 
     Attributes:
 
-        sound_extract : numpy.ndarray of int16, shaped (N)
-            duration of about SOUND_EXTRACT_LENGTH sec. sound data extract,
-            could be anywhere in the audio file (start, end, etc...) Set by
-            Recording object. This audio signal might or might not be the TicTacCode
-            track.
+        sound_extract : 1d numpy.ndarray of int16
+            length determined by SOUND_EXTRACT_LENGTH (sec). Could be anywhere
+            in the audio file (start, end, etc...) Set by Recording object.
+            This audio signal might or might not be the TicTacCode track.
     
         sound_extract_position : int
             where the sound_extract is located in the file, samples
@@ -181,10 +174,6 @@ class Decoder:
         detected_pulse_position : int
             pulse position (samples) relative to the start of self.sound_extract
     
-        cached_convolution_fit : dict
-            if _fit_triangular_signal_to_convoluted_env() has already been called,
-            will use cached values if sound_extract_position is the same. 
-
     """
 
     def __init__(self, aRec, do_plots):
@@ -277,13 +266,18 @@ class Decoder:
 
     def _plot_extract(self):
         fig, ax = plt.subplots()
-        ax.plot(self.sound_extract, marker='o', markersize='1',
+        start = self.sound_extract_position
+        i_samples = np.arange(start, start + len(self.sound_extract))
+        yt = ax.get_yaxis_transform()
+        ax.hlines(0, 0, 1,
+            transform=yt, alpha=0.3,
+        linewidth=2, colors='black')
+        ax.plot(i_samples, self.sound_extract, marker='o', markersize='1',
             linewidth=1.5,alpha=0.3, color='blue' )
-        ax.plot(self.sound_extract_one_bit*np.max(np.abs(self.sound_extract)), 
+        ax.plot(i_samples, self.sound_extract_one_bit*np.max(np.abs(self.sound_extract)), 
             marker='o', markersize='1',
             linewidth=1.5,alpha=0.3,color='red')
         xt = ax.get_xaxis_transform()
-        yt = ax.get_yaxis_transform()
         ax.hlines(self.pulse_detection_level, 0, 1,
             transform=yt, alpha=0.3,
         linewidth=2, colors='green')
@@ -296,7 +290,8 @@ class Decoder:
             custom_lines,
             'detection level, signal, detected region'.split(','),
             loc='lower right')
-        ax.set_title('Finding word and sync pulse')
+        ax.set_title('Finding word + sync pulse')
+        plt.xlabel("Position in file (samples)")
         plt.show()
 
     def get_time_in_sound_extract(self):
@@ -450,14 +445,7 @@ class Decoder:
         start = round(0.5*symbol_length) # half symbol
         end = start + symbol_length
         word_begining = whole_word[start:]
-        # word_one_bit = np.abs(word_begining)>self.pulse_detection_level
-        # N_ones = round(1.5*SYMBOL_LENGTH*1e-3*self.samplerate) # so it includes sync pulse
-        # word_one_bit = closing(word_one_bit, np.ones(N_ones))
         gt_detection_level = np.argwhere(np.abs(word_begining)>self.pulse_detection_level)
-        # print(gt_detection_level)
-        # plt.plot(word_one_bit)
-        # plt.plot(word_begining/abs(np.max(word_begining)))
-        # plt.show()
         word_start = gt_detection_level[0][0]
         word_end = gt_detection_level[-1][0]
         self.effective_word_duration = (word_end - word_start)/self.samplerate
@@ -474,7 +462,10 @@ class Decoder:
                                     1e3*TEENSY_MAX_LAG))
         logger.debug('relative audio_block gap %.2f'%(relative_gap))
         if relative_gap > 1:
-            print('bug with relative_gap')
+            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)
@@ -487,14 +478,23 @@ class Decoder:
         symbols_indices = symbol_positions.round().astype(int)
         if self.do_plots:
             fig, ax = plt.subplots()
-            ax.plot(whole_word, marker='o', markersize='1',
+            ax.hlines(0, 0, 1,
+                transform=ax.get_yaxis_transform(), alpha=0.3,
+                linewidth=2, colors='black')
+            start = self.sound_extract_position
+            i_samples = np.arange(start, start + len(whole_word))
+            ax.plot(i_samples, whole_word, marker='o', markersize='1',
                 linewidth=1.5,alpha=0.3, color='blue' )
             xt = ax.get_xaxis_transform()
             for x in symbols_indices:
-                ax.vlines(x, 0, 1,
+                ax.vlines(x + start, 0, 1,
                     transform=xt,
                 linewidth=0.6, colors='green')
                 ax.set_title('Slicing the 34 bits word:')
+            plt.xlabel("Position in file (samples)")
+            ax.vlines(start, 0, 1,
+                transform=xt,
+                linewidth=0.6, colors='red')
             plt.show()
         slice_width = round(SYMBOL_LENGTH*1e-3*self.samplerate)
         slices = [whole_word[i:i+slice_width] for i in symbols_indices]
@@ -517,8 +517,10 @@ class Recording:
         AVpath : pathlib.path
             path of video+sound+TicTacCode file, relative to working directory
 
-        valid_sound : pathlib.path
-            path of sound file stripped of silent and TicTacCode channels
+        audio_data : in16 numpy.array of shape [nchan] x [N samples]
+
+        # valid_sound : pathlib.path
+        #     path of sound file stripped of silent and TicTacCode channels
 
         device : Device
             identifies the device used for the recording, set in __init__()
@@ -532,7 +534,7 @@ class Recording:
 
         TicTacCode_channel : int
             which channel is sync track. 0 is first channel,
-            set in _read_sound_find_TicTacCode().
+            set in _find_TicTacCode().
 
         decoder : yaltc.decoder
             associated decoder object, if file is audiovideo
@@ -635,7 +637,7 @@ class Recording:
         self.TicTacCode_channel = None
         self.is_reference = False
         self.device_relative_speed = 1.0
-        self.valid_sound = None
+        # self.valid_sound = None
         self.final_synced_file = None
         self.synced_audio = None
         self.new_rec_name = media.path.name
@@ -673,6 +675,37 @@ class Recording:
             self.decoder = None
         logger.debug('ffprobe found: %s'%self.probe)
         logger.debug('n audio chan: %i'%self.get_audio_channels_nbr())
+        self._read_audio_data()
+
+    def _read_audio_data(self):
+        # sets Recording.audio_data
+        dryrun = (ffmpeg
+            .input(str(self.AVpath))
+            .output('pipe:', format='s16le', acodec='pcm_s16le')
+            .get_args())
+        dryrun = ' '.join(dryrun)
+        logger.debug('using ffmpeg-python built args to pipe audio stream into numpy array:\nffmpeg %s'%dryrun)
+        try:
+            out, _ = (ffmpeg
+                # .input(str(path), ss=time_where, t=chunk_length)
+                .input(str(self.AVpath))
+                .output('pipe:', format='s16le', acodec='pcm_s16le')
+                .global_args("-loglevel", "quiet")
+                .global_args("-nostats")
+                .global_args("-hide_banner")
+                .run(capture_stdout=True))
+            data = np.frombuffer(out, np.int16)
+        except ffmpeg.Error as e:
+            print('error',e.stderr)
+        n_chan = self.get_audio_channels_nbr()
+        if n_chan == 1 and not self.is_video():
+            logger.error('file is sound mono')
+        if np.isclose(np.std(data), 0, rtol=1e-2):
+            logger.error("ffmpeg can't extract audio from %s"%self.AVpath)
+        # from 1D  interleaved channels to [chan1, chan2, chanN]
+        self.audio_data = data.reshape(int(len(data)/n_chan),n_chan).T
+        logger.debug('Recording.audio_data: %s of shape %s'%(self.audio_data,
+            self.audio_data.shape))
 
     def __repr__(self):
         return 'Recording of %s'%_pathname(self.new_rec_name)
@@ -712,9 +745,9 @@ class Recording:
             recording duration in seconds.
 
         """
-        if self.valid_sound:
-            val = sox.file_info.duration(_pathname(self.valid_sound))
-            logger.debug('sox duration of valid_sound %f for %s'%(val,_pathname(self.valid_sound)))
+        if self.is_audio():
+            val = sox.file_info.duration(_pathname(self.AVpath))
+            logger.debug('sox duration of valid_sound %f for %s'%(val,_pathname(self.AVpath)))
             return val #########################################################
         else:
             if self.probe is None:
@@ -740,8 +773,8 @@ class Recording:
             recording duration in seconds.
 
         """
-        val = sox.file_info.duration(_pathname(self.valid_sound))
-        logger.debug('duration of valid_sound %f'%val)
+        val = sox.file_info.duration(_pathname(self.AVpath))
+        logger.debug('duration of AVpath %f'%val)
         return val
 
     def get_corrected_duration(self):
@@ -783,8 +816,8 @@ class Recording:
 
     def _find_time_around(self, time):
         """        
-        Actually reads sound data and tries to decode it
-        through decoder object, if successful  return a time dict, eg:
+        Tries to decode FSK around time (in sec)
+        through decoder object; if successful  return a time dict, eg:
         {'version': 0, 'seconds': 44, 'minutes': 57,
         'hours': 19, 'day': 1, 'month': 3, 'year offset': 1, 
         'pulse at': 670451.2217 }
@@ -794,7 +827,7 @@ class Recording:
             there = self.get_duration() + time
         else:
             there = time
-        self._read_sound_find_TicTacCode(there, SOUND_EXTRACT_LENGTH)
+        self._find_TicTacCode(there, SOUND_EXTRACT_LENGTH)
         if self.TicTacCode_channel is None:
             return None
         else:
@@ -908,8 +941,9 @@ class Recording:
         Try to decode a TicTacCode_channel at start AND finish;
         if successful, returns a datetime.datetime instance;
         if not returns None.
-        If successful AND self is audio, sets self.valid_sound
         """
+        logger.debug('for recording %s, recording.start_time %s'%(self,
+                                                        self.start_time))
         if self.start_time is not None:
             return self.start_time #############################################
         cached_times = {}
@@ -949,6 +983,7 @@ class Recording:
                     time_around_end)
             logger.debug('_two_times_are_coherent: %s'%coherence) 
             if coherence:
+                logger.debug('Trial #%i successful'%(i+1))
                 break
         if not coherence:
             logger.warning('found times are incoherent')
@@ -972,49 +1007,10 @@ class Recording:
         logger.debug('recording started at %s'%start_UTC)
         self.start_time = start_UTC
         self.sync_position = time_around_beginning['pulse at']
-        if self.is_audio():
-            # self.valid_sound = self._strip_TTC_and_Null() # why now? :-)
-            self.valid_sound = self.AVpath
+        # if self.is_audio():
+        #     self.valid_sound = self.AVpath
         return start_UTC
 
-    def _sox_strip(self, audio_file, excluded_channels) -> tempfile.NamedTemporaryFile:
-        # building dict according to pysox.remix format.
-        # https://pysox.readthedocs.io/en/latest/api.html#sox.transform.Transformer.remix
-        # eg: 4 channels with TicTacCode_channel at #2 
-        # returns {1: [1], 2: [3], 3: [4]}
-        # ie the number of channels drops by one and chan 2 is missing
-        # excluded_channels is a list of Zero Based indexing chan numbers
-        n_channels = self.device.n_chan
-        all_channels = range(1, n_channels + 1) # from 1 to n_channels included
-        sox_excluded_channels = [n+1 for n in excluded_channels]
-        logger.debug('for file %s'%self.AVpath.name)
-        logger.debug('excluded chans %s (not ZBIDX)'%sox_excluded_channels)
-        kept_chans = [[n] for n in all_channels if n not in sox_excluded_channels]
-        # eg [[1], [3], [4]]
-        sox_remix_dict = dict(zip(all_channels, kept_chans))
-        # {1: [1], 2: [3], 3: [4]} -> from 4 to 3 chan and chan 2 is dropped
-        output_fh = tempfile.NamedTemporaryFile(suffix='.wav', delete=DEL_TEMP)
-        out_file = _pathname(output_fh)
-        logger.debug('sox in and out files: %s %s'%(audio_file, out_file))
-        # sox_transform.set_output_format(channels=1)
-        sox_transform = sox.Transformer()
-        sox_transform.remix(sox_remix_dict)
-        logger.debug('sox remix transform: %s'%sox_transform)
-        logger.debug('sox remix dict: %s'%sox_remix_dict)
-        status = sox_transform.build(audio_file, out_file, return_output=True )
-        logger.debug('sox.build exit code %s'%str(status))
-        p = Popen('ffprobe %s -hide_banner'%audio_file,
-            shell=True, stdout=PIPE, stderr=PIPE)
-        stdout, stderr = p.communicate()
-        logger.debug('remixed input_file ffprobe:\n%s'%(stdout +
-            stderr).decode('utf-8'))
-        p = Popen('ffprobe %s -hide_banner'%out_file,
-            shell=True, stdout=PIPE, stderr=PIPE)
-        stdout, stderr = p.communicate()
-        logger.debug('remixed out_file ffprobe:\n%s'%(stdout +
-            stderr).decode('utf-8'))
-        return output_fh
-
     def _ffprobe_audio_stream(self):
         streams = self.probe['streams']
         audio_streams = [
@@ -1130,12 +1126,11 @@ class Recording:
     def is_audio(self):
         return not self.is_video()
 
-    def _read_sound_find_TicTacCode(self, time_where, chunk_length):
+    def _find_TicTacCode(self, time_where, chunk_length):
         """
-        If this is called for the first time for the recording, it loads audio
-        data reading from self.AVpath; Split data into channels if stereo; Send
-        this data to Decoder object with set_sound_extract_and_sr() to find
-        which channel contains a TicTacCode track and sets TicTacCode_channel
+        Extracts a chunk from Recording.audio_data and sends it to
+        Recording.decoder object with set_sound_extract_and_sr() to find which
+        channel contains a TicTacCode track and sets TicTacCode_channel
         accordingly (index of channel). On exit, self.decoder.sound_extract
         contains TicTacCode data ready to be demodulated. If not,
         self.TicTacCode_channel is set to None.
@@ -1164,44 +1159,18 @@ class Recording:
         decoder = self.decoder
         if decoder:
             decoder.clear_decoder()
-        # decoder.cached_convolution_fit['is clean'] = False
         if not self.has_audio():
             self.TicTacCode_channel = None
             return #############################################################
-        logger.debug('will read around %.2f sec'%time_where)
-        dryrun = (ffmpeg
-            .input(str(path))
-            .output('pipe:', format='s16le', acodec='pcm_s16le')
-            .get_args())
-        dryrun = ' '.join(dryrun)
-        logger.debug('using ffmpeg-python built args to pipe wav file into numpy array:\nffmpeg %s'%dryrun)
-        try:
-            out, _ = (ffmpeg
-                # .input(str(path), ss=time_where, t=chunk_length)
-                .input(str(path))
-                .output('pipe:', format='s16le', acodec='pcm_s16le')
-                .global_args("-loglevel", "quiet")
-                .global_args("-nostats")
-                .global_args("-hide_banner")
-                .run(capture_stdout=True))
-            data = np.frombuffer(out, np.int16)
-        except ffmpeg.Error as e:
-            print('error',e.stderr)
-        sound_data_var = np.std(data)
-        logger.debug('extracting sound, ffmpeg output:%s with variance %f'%(data,
-                                                                sound_data_var))
-        sound_extract_position = int(self.get_samplerate()*time_where) # from sec to samples
-        n_chan = self.get_audio_channels_nbr()
-        if n_chan == 1 and not self.is_video():
-            logger.warning('file is sound mono')
-        if np.isclose(sound_data_var, 0, rtol=1e-2):
-            logger.warning("ffmpeg can't extract audio from %s"%self.AVpath)
-        # from 1D  interleaved channels to [chan1, chan2, chanN]
-        all_channels_data = data.reshape(int(len(data)/n_chan),n_chan).T
+        sound_data_var = np.std(self.audio_data)
+        sound_extract_position = int(self.get_samplerate()*time_where)
+        logger.debug('extracting sound at %i with variance %f'%(
+                                                    sound_extract_position,
+                                                    sound_data_var))
         if self.TicTacCode_channel == None:
             logger.debug('first call, will loop through all %i channels'%len(
-                                        all_channels_data))
-            for i_chan, chan_dat in enumerate(all_channels_data):
+                                        self.audio_data))
+            for i_chan, chan_dat in enumerate(self.audio_data):
                 logger.debug('testing chan %i'%i_chan)
                 start_idx = round(time_where*self.get_samplerate())
                 extract_length = round(chunk_length*self.get_samplerate())
@@ -1227,7 +1196,7 @@ class Recording:
             start_idx = round(time_where*self.get_samplerate())
             extract_length = round(chunk_length*self.get_samplerate())
             end_idx = start_idx + extract_length
-            chan_dat = all_channels_data[self.TicTacCode_channel]
+            chan_dat = self.audio_data[self.TicTacCode_channel]
             extract_audio_data = chan_dat[start_idx:end_idx]
             decoder.set_sound_extract_and_sr(
                     extract_audio_data,
@@ -1239,7 +1208,7 @@ class Recording:
     def seems_to_have_TicTacCode_at_beginning(self):
         if self.probe is None:
             return False #######################################################
-        self._read_sound_find_TicTacCode(TRIAL_TIMES[0][0],
+        self._find_TicTacCode(TRIAL_TIMES[0][0],
             SOUND_EXTRACT_LENGTH)
         return self.TicTacCode_channel is not None
 

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

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