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

tictacsync/yaltc.py

@@ -29,21 +29,15 @@ 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
 
 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
 
-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
@@ -52,16 +46,16 @@ 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
-            (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):
@@ -244,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]
@@ -255,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
@@ -271,19 +266,26 @@ 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
 
     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 +298,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 +453,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 +470,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 +486,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 +525,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 +542,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
@@ -556,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
@@ -591,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
         ----------
@@ -635,7 +647,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
@@ -671,11 +683,44 @@ 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()
+
+    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)
+        # 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
@@ -712,9 +757,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 +785,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):
@@ -754,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
 
@@ -783,8 +829,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 +840,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,9 +954,13 @@ 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 %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):
@@ -935,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)
@@ -949,6 +999,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 +1023,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 = [
@@ -1052,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
@@ -1071,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,
@@ -1130,12 +1144,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 +1177,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 +1214,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 +1226,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.dist-info → tictacsync-0.95a0.dist-info}/METADATA

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

tictacsync-0.95a0.dist-info/RECORD

@@ -0,0 +1,15 @@
+tictacsync/LTCcheck.py,sha256=IEfpB_ZajWuRTWtqji0H-B2g7GQvWmGVjfT0Icumv7o,15704
+tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tictacsync/device_scanner.py,sha256=kkwiO6qFNyBwqyZGqsf2q8WUqu4BBMFqFaUFFTeFfiY,29034
+tictacsync/entry.py,sha256=fklCyTgqxJPWzKsn1ow3IxLPq8obv-N8Z72ieRzulCI,13352
+tictacsync/multi2polywav.py,sha256=BsZxUjZo2Px6opKpFlgcvdZuUKDANEVTdapuWrX1jKw,7287
+tictacsync/remergemix.py,sha256=FJTMipIS0O7mMl_tr8BhuYqWvanSydvjGkFCEd-jaDk,9829
+tictacsync/synciso.py,sha256=XmUcdUF9rl4VdCm7XW4PeYWYWM0vgAY9dC2hapoul9g,4821
+tictacsync/timeline.py,sha256=YhnNqYnbTTf2YVN5nLlQY62UA4z9fTij6x18tR_u3Nc,60424
+tictacsync/yaltc.py,sha256=EzAF5VnMMeBp_o2AOs7wj0p31mElcb6D57YJVKUbOxM,53400
+tictacsync-0.95a0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
+tictacsync-0.95a0.dist-info/METADATA,sha256=oHUqw0Q9bboCClpSRB8wNs5rQv_Ex5RnYefGLV2bpik,5502
+tictacsync-0.95a0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+tictacsync-0.95a0.dist-info/entry_points.txt,sha256=g3tdFFrVRcrKpuyKOCLUVBMgYfV65q9kpLZUOD_XCKg,139
+tictacsync-0.95a0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
+tictacsync-0.95a0.dist-info/RECORD,,

tictacsync-0.82a0.dist-info/RECORD

@@ -1,15 +0,0 @@
-tictacsync/LTCcheck.py,sha256=IEfpB_ZajWuRTWtqji0H-B2g7GQvWmGVjfT0Icumv7o,15704
-tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tictacsync/device_scanner.py,sha256=lvWps5XPvzubnTqisFWjdRUpxsM9YMRYMp-xQu7H6Os,27515
-tictacsync/entry.py,sha256=Uf-vSHVmGfWnyXq8Ee4bWLzzJMoo9G1iuRZKOeYk8aE,11386
-tictacsync/multi2polywav.py,sha256=k7VU-yjO1_0DbygWNytYvaExbiAs3_0-n0UmgGTa8wM,7282
-tictacsync/remergemix.py,sha256=FJTMipIS0O7mMl_tr8BhuYqWvanSydvjGkFCEd-jaDk,9829
-tictacsync/synciso.py,sha256=XmUcdUF9rl4VdCm7XW4PeYWYWM0vgAY9dC2hapoul9g,4821
-tictacsync/timeline.py,sha256=HvSy8_0auI2-jE1rZ9Bu9PcCIAHhNyUv9tpL75Po-uk,57877
-tictacsync/yaltc.py,sha256=zXbAvM00t1-VXRooH28AO3AcYgLSoo0p2Fq2LN4SALU,54457
-tictacsync-0.82a0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
-tictacsync-0.82a0.dist-info/METADATA,sha256=z4G9ejQfvAURTp340mIdCbhoAkV-6pTJdjd8TN8UgDI,5502
-tictacsync-0.82a0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tictacsync-0.82a0.dist-info/entry_points.txt,sha256=g3tdFFrVRcrKpuyKOCLUVBMgYfV65q9kpLZUOD_XCKg,139
-tictacsync-0.82a0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
-tictacsync-0.82a0.dist-info/RECORD,,