tictacsync 0.1a14__py3-none-any.whl → 1.4.4b0__py3-none-any.whl

tictacsync/yaltc.py

@@ -5,7 +5,7 @@ import lmfit, tempfile
 # from skimage.morphology import closing, square
 from numpy import arcsin, sin, pi
 from matplotlib.lines import Line2D
-import math, re, os
+import math, re, os, sys, itertools
 import sox
 from subprocess import Popen, PIPE
 from pathlib import Path
@@ -15,109 +15,82 @@ logging.config.dictConfig({
     'disable_existing_loggers': True,
 }) # for sox  "output file already exists and will be overwritten on build"
 from datetime import datetime, timezone, timedelta
+from pprint import pformat
 from collections import deque
 from loguru import logger
-from sklearn.mixture import GaussianMixture
+from skimage.morphology import closing, erosion, remove_small_objects
+from skimage.measure import regionprops, label
 import ffmpeg, shutil
-# import opentimelineio as otio
 from rich import print
+from rich.console import Console
+# from rich.text import Text
+from rich.table import Table
+try:
+    from . import device_scanner
+except:
+    import device_scanner
 
-# try:
-#     from cfuzzyset import cFuzzySet as FuzzySet
-# except ImportError:
-#     from fuzzyset import FuzzySet
-# pip install fuzzyset2
+TEENSY_MAX_LAG = 1.01*128/44100 # sec, duration of a default length audio block
+
+# see extract_seems_TicTacCode() for duration criterion values
+
+TRACKSFILE = 'tracks.txt'
+SILENT_TRACK_TOKENS = '-0n'
 
 
 CACHING = True
-DEL_TEMP = True
-DB_RMS_SILENCE_SOX = -50
-MAXDRIFT = 10e-3 # in sec, normally 10e-3 (10 ms)
-# MAXDRIFT = 0 # in sec, normally 10e-3 (10 ms)
+DEL_TEMP = False
+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
+F2 = 1190.00 # Hz , both from FSKfreqCalculator output
+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 = 1.56 # second
+SOUND_EXTRACT_LENGTH = (10*SYMBOL_LENGTH*1e-3 + 1) # second
 SYMBOL_LENGTH_TOLERANCE = 0.07 # relative
 FSK_TOLERANCE = 60 # Hz
 SAMD21_LATENCY = 63 # microseconds, for DAC conversion
 YEAR_ZERO = 2021
 
-################## pasted from FSKfreqCalculator.py output:
-F1 = 630.00 # Hertz
-F2 = 1190.00 # Hz , both from FSKfreqCalculator output
-SYMBOL_LENGTH = 14.286 # ms, from FSKfreqCalculator.py
-N_SYMBOLS_SAMD21 = 35 # including sync pulse
-##################
 
 BPF_LOW_FRQ, BPF_HIGH_FRQ = (0.5*F1, 2*F2)
 
-# try:
-#     layouts, _ = (
-#     ffmpeg.input('').output('')
-#     .global_args("-loglevel", "quiet","-nostats","-hide_banner","-layouts")
-#     .run(capture_stdout=True)
-#     )
-# except ffmpeg.Error as e:
-#     print('error',e.stderr)        
-
-
-
-# names_str, layouts = [l.split('\n') for l in 
-#     layouts.decode("utf-8").split('DECOMPOSITION')]
-# [names_str.pop(0) for i in range(2)]
-# [names_str.pop(-1) for i in range(3)]
-# layouts.pop(0)
-# layouts.pop(-1)
-# channel_name_regex = re.compile(r'(\w+)\s+(.+)')
-# layouts_regex = re.compile(r'(\S+)\s+(.+)')
-# FFMPEG_CHAN_NAMES = [
-#     channel_name_regex.match(name).group(1)
-#     for name in names_str
-# ]
-# FFMPEG_LAYO_NAMES = dict([
-#     layouts_regex.match(lay_out).groups()
-#     for lay_out in layouts
-# ])
-
-# """
-# FFMPEG_CHAN_NAMES are the names used by ffmpeg for channels, eg: FL, FR, FC for
-# front left, front right and front center.
-# FFMPEG_LAYO_NAMES are the order of channels for each layout, eg: stereo is FL+FR
-# and 5.1 is FL+FR+FC+LFE+BL+BR. Layout names are the dict keys.
-# Run ffmpeg -layouts for details.
-
-# """
 
 # utility for accessing pathnames
 def _pathname(tempfile_or_path):
+    # always returns a str
     if isinstance(tempfile_or_path, type('')):
-        return tempfile_or_path
+        return tempfile_or_path ################################################
     if isinstance(tempfile_or_path, Path):
-        return str(tempfile_or_path)
+        return str(tempfile_or_path) ###########################################
     if isinstance(tempfile_or_path, tempfile._TemporaryFileWrapper):
-        return tempfile_or_path.name
+        return tempfile_or_path.name ###########################################
     else:
         raise Exception('%s should be Path or tempfile... is %s'%(
             tempfile_or_path,
             type(tempfile_or_path)))
 
+# for skimage.measure.regionprops
+def _width(region):
+    _,x1,_,x2 = region.bbox
+    return x2-x1
+
+
 def to_precision(x,p):
     """
     returns a string representation of x formatted with a precision of p
@@ -127,7 +100,7 @@ def to_precision(x,p):
     """
     x = float(x)
     if x == 0.:
-        return "0." + "0"*(p-1)
+        return "0." + "0"*(p-1) ################################################
     out = []
     if x < 0:
         out.append("-")
@@ -168,19 +141,46 @@ def to_precision(x,p):
 
     return "".join(out)
 
+def read_audio_data_from_file(file, n_channels):
+    """
+    reads file and returns a numpy.array of shape (N1 channels, N2 samples)
+    where N1 >= 2 (minimaly solo track + TC)
+    """
+    dryrun = (ffmpeg
+        .input(_pathname(file))
+        .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))
+            .input(_pathname(file))
+            .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)
+    # transform 1D interleaved channels to [chan1, chan2, chanN]
+    return data.reshape(int(len(data)/n_channels),n_channels).T
+
+
 class Decoder:
     """
-    Object encapsulating DSP processes to demodulate YaLTC 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 YaLTC
-            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
@@ -191,8 +191,8 @@ class Decoder:
         rec : Recording
             recording on which the decoder is working
     
-        SN_ratio : float
-            signal over noise ratio in dB.
+        effective_word_duration : float
+            duration of a word, influenced by ucontroller clock
 
         pulse_detection_level : float
             level used to detect sync pulse
@@ -207,13 +207,9 @@ 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):
+    def __init__(self, aRec, do_plots):
         """
         Initialises Decoder
 
@@ -223,584 +219,333 @@ class Decoder:
 
         """
         self.rec = aRec
+        self.do_plots = do_plots
         self.clear_decoder()
 
     def clear_decoder(self):
         self.sound_data_extract = None
-        self.cached_convolution_fit = {'sound_extract_position': None}
         self.pulse_detection_level = None
-        self.silent_zone_indices = None
         self.detected_pulse_position = None
-        self.estimated_pulse_position = None
-
-    def set_sound_extract_and_sr(self, extract, s_r, where):
-        self.sound_extract = extract
-        self.samplerate = s_r
-        self.sound_extract_position = where
-        self.cached_convolution_fit = {'sound_extract_position': None}
-        logger.debug('sound_extract set, samplerate %i location %i'%(s_r, where))
-   
-
-        # there's always at least one complete 0.5 silence interval in a 1.5 second signal
-
-    def _get_envelope(self):
+        
+    def set_sound_extract_and_sr(self, sound_extract, samplerate, sound_extract_position):
         """
-        Compute self.sound_extract envelope, filtering its hilbert transform.
-        Uses scipy.signal.hilbert() and scipy.signal.savgol_filter();
-        window_length and polyorder savgol_filter() parameters values 
-        have been found by hit and miss on audio data.
-
-        maybe:
-        Values are roughly normalized: between 0 and approximately 1.0
-
-        Returns
-        -------
-        numpy.ndarray the same length of self.recording.sound_extract
+        Sets:
+            self.sound_extract -- mono data of short duration
+            self.samplerate -- in Hz
+            self.sound_extract_position -- position in the whole file
 
-        """
-        WINDOW_LENGTH, POLYORDER = (15, 3) # parameters found by experiment, hit and miss
-        absolute_of_hilbert = np.abs(scipy.signal.hilbert(self.sound_extract))
-        envelope = scipy.signal.savgol_filter(absolute_of_hilbert,
-                                              WINDOW_LENGTH, POLYORDER)
-        logger.debug('self.sound_extract envelope length %i samples'%len(envelope))
-        return envelope
-
-    def _get_signal_level(self):
-        abs_signal = abs(self.sound_extract)
-        return 2 * abs_signal.mean() # since 50% duty cycle
-
-    def _get_approx_pulse_position(self):
-        """
-        Returns the estimated pulse position using the detected silent
-        zone . The position is in samples number
-        relative to extract beginning
-        """
-        # if self.detected_pulse_position:
-        #     logger.debug('returning detected value')
-        #     return self.detected_pulse_position
-        if self.estimated_pulse_position:
-            logger.debug('returning cached estimated value')
-            return self.estimated_pulse_position
-        _, silence_center_x = self._fit_triangular_signal_to_convoluted_env()
-        # symbol_width_samples = 1e-3*SYMBOL_LENGTH
-        self.estimated_pulse_position = silence_center_x + int(0.5*(
-            0.5 - 1e-3*SYMBOL_LENGTH)*self.samplerate)
-        logger.debug('returning estimated value from silence mid position')
-        return self.estimated_pulse_position
-
-    def _get_pulse_position(self):
-        # relative to extract beginning
-        if self.detected_pulse_position:
-            logger.debug('returning detected value')
-            return self.detected_pulse_position
-        return None
-
-    def _get_pulse_detection_level(self):
-        # return level at which the sync pulse will be detected
-        if self.pulse_detection_level is None:
-            silence_floor = self._get_silence_floor()
-            # lower_BFSK_level = silence_floor
-            # pulse_position = self._get_pulse_position()
-            lower_BFSK_level = self._get_minimal_bfsk()
-            value = math.sqrt(silence_floor * lower_BFSK_level)
-            # value = OVER_NOISE_SYNC_DETECT_LEVEL * silence_floor
-            logger.debug('setting pulse_detection_level to %f'%value)
-            self.pulse_detection_level = value
-            return value
-        else:
-            return self.pulse_detection_level
+        Computes and sets:
+            self.pulse_detection_level
+            self.sound_extract_one_bit
+            self.words_props (contains the sync pulse too)
 
-    def _get_square_convolution(self):
+        Returns nothing
         """
-        Compute self.sound_extract envelope convolution with a square signal of
-        0.5 second (+ SYMBOL_LENGTH) width, using numpy.convolve().
-        Values are roughly normalized: between 0 and approximately 1.0
+        logger.debug('sound_extract: %s, samplerate: %s Hz, sound_extract_position %s'%(
+                sound_extract, samplerate, sound_extract_position))
+        if len(sound_extract) == 0:
+            logger.error('sound extract is empty, is sound track duration OK?')
+            raise Exception('sound extract is empty, is sound track duration OK?')
+        self.sound_extract_position = sound_extract_position
+        self.samplerate = samplerate
+        self.sound_extract = sound_extract
+        self.pulse_detection_level = np.std(sound_extract)/4
+        logger.debug('pulse_detection_level %f'%self.pulse_detection_level)
+        bits = np.abs(sound_extract)>self.pulse_detection_level
+        N_ones = round(1.5*SYMBOL_LENGTH*1e-3*samplerate) # so it includes sync pulse
+        self.sound_extract_one_bit = closing(bits, np.ones(N_ones))
+        if self.do_plots:
+            self._plot_extract()
+        logger.debug('sound_extract_one_bit len %i'%len(self.sound_extract_one_bit))
+        self.words_props = regionprops(label(np.array(2*[self.sound_extract_one_bit]))) # new
+
+    def extract_seems_TicTacCode(self):
+        """        
+        Determines if signal in sound_extract seems to be TTC.
 
+        Uses the conditions below:
 
-        Returns:
-    
-         #1 the normalized convolution, a numpy.ndarray shorter than 
-             self.sound_extract, see numpy.convolve(..., mode='valid')
-
-         #2 a list of int, samples indexes where the convolution is computed
+            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]
 
+        Returns True if self.sound_data_extract seems TicTacCode
         """
-        sqr_window_width = int((0.5 + SYMBOL_LENGTH/1e3)*self.samplerate) # in samples
-        sqr_signal = np.ones(sqr_window_width,dtype=int)
-        envelope = self._get_envelope()
-        mean = envelope.mean()
-        if mean: # in case of zero padding (? dont remember why)
-            factor = 0.5/mean # since 50% duty cycle
+        failing_comment = '' # used as a flag
+        props = self.words_props
+        if len(props) not in [1,2]:
+            failing_comment = 'len(props) not in [1,2]: %i'%len(props)
         else:
-            factor = 1
-        normalized_envelope = factor*envelope
-        convol = np.convolve(normalized_envelope, sqr_signal,
-                             mode='valid')/sqr_window_width
-        start = int(sqr_window_width/2)
-
-        x = range(start, len(convol) + start)
-        return [*x], convol
-
-    def _get_word_envelope(self):
-        """
-        Chop the signal envelope keeping the word region and smooth it over the
-        longest BFSK period
-        """
-        SR = self.samplerate
-        envelope = self._get_envelope()
-        pulse_position = self._get_approx_pulse_position()
-        samples_to_end = len(self.sound_extract) - pulse_position
-        is_too_near_the_end = samples_to_end/SR < 0.5
-        logger.debug('pulse_position is_too_near_the_end %s'%
-            is_too_near_the_end)
-        if is_too_near_the_end:
-            pulse_position -= SR # one second sooner
-        symbol_width_samples = 1e-3*SYMBOL_LENGTH*SR
-        word_start = int(pulse_position + 3*symbol_width_samples)
-        word_end = int(pulse_position + 0.5*SR)
-        word_end -= int(2*symbol_width_samples) # slide to the left a little
-        logger.debug('word start, end: %i %i (in extract)'%(
-            word_start, word_end))
-        logger.debug('word start, end: %i %i (in file)'%(
-            word_start + self.sound_extract_position,
-            word_end + self.sound_extract_position))
-        w_envelope = envelope[word_start : word_end]
-        word_envelope_truncated = word_end-word_start != len(w_envelope)
-        logger.debug('w_envelope is sliced out of bounds: %s'%(
-            str(word_envelope_truncated)))
-        logger.debug('word envelope length %i samples %f secs'%(
-            len(w_envelope), len(w_envelope)/SR))
-        max_period = int(self.samplerate*max(1/F1,1/F2))
-        logger.debug('max BFSK period %i in samples'%max_period)
-        period_window = np.ones(max_period,dtype=int)/max_period
-        # smooth over longest BFSK period
-        return np.convolve(w_envelope, period_window, mode='same')
-
-    def _get_minimal_bfsk(self):
-        """
-        because of non-flat frequency response, bfsk bits dont have the same
-        amplitude. This returns the least of both by detecting a bimodal
-        gaussian distribution
-
-        """
-        # w_envelope = self._get_word_envelope()
-        # word_start = int(min_position + shift + 0.3*self.samplerate)
-        # word = w_envelope[word_start :  int(word_start + 0.4*self.samplerate)]
-        word = self._get_word_envelope()
-        # plt.plot(word)
-        # plt.show()
-        n = len(word)
-        word = word.reshape(n, 1)
-        gm = GaussianMixture(n_components=2, random_state=0).fit(word)
-        bfsk_minimal_amplitude = min(gm.means_)
-        logger.debug('bfsk_minimal_amplitude %f'%bfsk_minimal_amplitude)
-        return bfsk_minimal_amplitude
-
-    def _fit_triangular_signal_to_convoluted_env(self):
-        """
-        Try to fit a triangular signal to the envelope convoluted with a square
-        signal to evaluate if audio is composed of 0.5 sec signal and 0.5 s 
-        silence. If so, the convolution is a triangular fct and a
-        Levenberg–Marquardt fit is used to detect this occurence (lmfit).
-        Results are cached in self.cached_convolution_fit alongside
-        self.sound_extract_position for hit/miss checks.
-
-
-        Returns
-        -------
-        float
-            chi_sqr from lmfit.minimize(), indicative of fit quality
-        int
-            position of triangular minimum (base of the v shape), this
-            corresponds to the center of silent zone.
-
-        """
-        cached_value = self.cached_convolution_fit['sound_extract_position']
-        logger.debug('cache hit? asked:%s cached: %s'%(
-                        self.sound_extract_position,
-                        cached_value))
-        logger.debug('(sound_extract_position values)')
-        if (CACHING and
-                    # cache_is_clean and
-                    cached_value and 
-                    math.isclose(
-                        self.sound_extract_position,
-                        cached_value,
-                        abs_tol=0.1)):
-            logger.debug('yes, fit values cached:')
-            v1 = self.cached_convolution_fit['chi_square']
-            v2 = self.cached_convolution_fit['minimum position']
-            v2_file = v2 + self.sound_extract_position
-            logger.debug('cached chi_sq: %s minimum position in file: %s'%(v1, v2_file))
-            return (v1, v2)
-                # cached!
-        x_shifted, convolution = self._get_square_convolution()
-        # see numpy.convolve(..., mode='valid')
-        x = np.arange(len(convolution))
-        trig_params = lmfit.Parameters()
-        trig_params.add(
-            'A', value=1, min=0, max=2
-            )
-        period0 = 2*self.samplerate
-        trig_params.add(
-            'period', value=period0, min=0.9*period0,
-            max=1.1*period0
-            )
-        trig_params.add(
-            'min_position', value=len(convolution)/2
-            ) # at center
-        def trig_wave(pars, x, signal_data=None):
-            # looking for phase sx with a sin of 1 sec period and 0<y<1.0
-            A = pars['A']
-            p = pars['period']
-            mp = pars['min_position']
-            model = 2*A*arcsin(abs(sin((x - mp)*2*pi/p)))/pi
-            if signal_data is None:
-                return model
-            return model - signal_data
-        fit_trig = lmfit.minimize(
-                            trig_wave, trig_params,
-                            args=(x,), kws={'signal_data': convolution}
-                            )
-        chi_square = fit_trig.chisqr
-        shift = x_shifted[0] # convolution is shorter than sound envelope
-        min_position = int(fit_trig.params['min_position'].value) + shift
-        logger.debug('chi_square %.1f minimum convolution position %i in file'%
-                     (chi_square, min_position + self.sound_extract_position))
-        self.cached_convolution_fit['sound_extract_position'] = self.sound_extract_position
-        self.cached_convolution_fit['chi_square'] = chi_square
-        self.cached_convolution_fit['minimum position'] = min_position
-
-        return chi_square, min_position + shift
-
-    def extract_seems_YaLTC(self):
-        """margin
-        evaluate if sound data is half signal, half silence
-        no test is done on frequency components nor BFSK modulation.
-
-        Returns
-        -------
-        True if sound seems YaLTC
-
-        """
-        chi_square, _ = self._fit_triangular_signal_to_convoluted_env()
-        seems_YaLTC = chi_square < 200 # good fit so, yes
-        logger.debug('seems YaLTC: %s'%seems_YaLTC)
-        return seems_YaLTC
-
-    def _get_silent_zone_indices(self):
-        """
-        Returns silent zone boundary positions relative to the start
-        of self.sound_extract.
-
-        Returns
-        -------
-        left_window_boundary : int
-            left indice.
-        right_window_boundary : int
-            right indice.
+            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
+            # eff_w = total_w - extra_window_duration
+            # logger.debug('effective_word_duration %f (two regions)'%eff_w)
+            if not 0.5 < total_w < 0.656:
+                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
 
-        """
-        if self.silent_zone_indices:
-            return self.silent_zone_indices
-        _, silence_center_position = self._fit_triangular_signal_to_convoluted_env()
-        srate = self.samplerate
-        half_window = int(SAFE_SILENCE_WINDOW_WIDTH * 1e-3 * srate/2)
-        left_window_boundary = silence_center_position - half_window
-        right_window_boundary = silence_center_position + half_window
-        # margin = 0.75 * srate
-        values = np.array([left_window_boundary, right_window_boundary,
-                    silence_center_position])
-        values += self.sound_extract_position # samples pos in file
-        logger.debug('silent zone, left: %i, right %i, center %i'%tuple(values))
-        self.silent_zone_indices = (left_window_boundary, right_window_boundary)
-        return self.silent_zone_indices
- 
-    def _get_silence_floor(self):
-        # analyses the 0.5 silence zone
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        signal = self.sound_extract
-        silent_signal = signal[start_silent_zone:end_silent_zone]
-        max_value = 1.001*np.abs(silent_signal).max() # a little headroom
-        max_value = 0 # should toggle this with a CLI option
-        five_sigmas = 5 * silent_signal.std()
-        return max(max_value, five_sigmas) # if guassian, five sigmas will do it
-
-    def make_silence_analysis_plot(self, title=None, filename=None):
-        # save figure in filename if set, otherwise
-        # start an interactive plot, title is for matplotlib
-        pulse_pos_in_file = self._get_approx_pulse_position()
-        pulse_pos_in_file += self.sound_extract_position
-        pulse_position_sec = pulse_pos_in_file/self.samplerate
-        duration_in_sec = self.rec.get_duration()
-        if pulse_position_sec > duration_in_sec/2:
-            pulse_position_sec -= duration_in_sec
-        title = 'Silence analysis around %.2f s'%(pulse_position_sec)
-        logger.debug('make_silence_analysis_plot(title=%s, filename=%s)'%(
-                                title, filename))
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        signal = self.sound_extract
-        x_signal = range(len(signal))
-        x_convolution, convolution = self._get_square_convolution()
-        scaled_convo = self._get_signal_level()*convolution
-        # since 0 < convolution < 1
-        trig_level = self._get_pulse_detection_level()
-        sound_extract_position = self.sound_extract_position
-        def x2f(nx):
-            return nx + sound_extract_position
-        def f2x(nf):
-            return nf - sound_extract_position
+    def _plot_extract(self):
         fig, ax = plt.subplots()
-        plt.title(title)
-        secax = ax.secondary_xaxis('top', functions=(x2f, f2x))
-        # secax.set_xlabel('position in file')
-        # ax.set_xlabel('position in extract')
+        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(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()
-        _, silence_center_x = self._fit_triangular_signal_to_convoluted_env()
-        # symbol_width_samples = 1e-3*SYMBOL_LENGTH
-        # pulse_relative_pos = int(0.5*(0.5 - 1e-3*SYMBOL_LENGTH)*self.samplerate)
-        approx_pulse_x = self._get_approx_pulse_position()
-        ax.vlines(
-            silence_center_x, 0.4, 0.6, 
-            transform=xt, linewidth=1, colors='black'
-            )
-        ax.vlines(
-            approx_pulse_x, 0.1, 0.9, 
-            transform=xt, linewidth=1, colors='yellow'
-            )
-        bfsk_min = self._get_minimal_bfsk()
-        ax.hlines(
-            bfsk_min, 0, 1, 
-            transform=yt, linewidth=1, colors='red'
-            )
-        ax.hlines(
-            trig_level, 0, 1, 
-            transform=yt, linewidth=1, colors='blue'
-            )
-        ax.hlines(
-            -trig_level, 0, 1, 
-            transform=yt, linewidth=1, colors='blue'
-            )
-        ax.hlines(
-            0, 0, 1, 
-            transform=yt, linewidth=0.5, colors='black'
-            )
-        # plt.title(title)
+        ax.hlines(self.pulse_detection_level, 0, 1,
+            transform=yt, alpha=0.3,
+        linewidth=2, colors='green')
         custom_lines = [
-            Line2D([0], [0], color='black', lw=2),
             Line2D([0], [0], color='green', lw=2),
             Line2D([0], [0], color='blue', lw=2),
             Line2D([0], [0], color='red', lw=2),
-            Line2D([0], [0], color='yellow', lw=2),
             ]
         ax.legend(
             custom_lines,
-            'sqr convolution,silence zone,pulse level,lower FSK ampl., approx puls.'.split(','),
+            'detection level, signal, detected region'.split(','),
             loc='lower right')
-        ax.plot(
-            x_signal, signal,
-            marker='o', markersize='1',
-            linewidth=0.3, color='purple', alpha=0.3)
-        ax.axvspan(
-            start_silent_zone, end_silent_zone,
-            alpha=0.1, color='green')
-        ax.plot(
-            x_convolution, scaled_convo,
-            marker='.', markersize='0.2',
-            linestyle='None', color='black', alpha=1)
-            # linewidth=0.3, linestyle='None', color='black', alpha=0.3)
-        # ax.set_xlabel('Decoder.sound_extract samples')
-        if filename == None:
-            plt.show()
-        else:
-            logger.debug('saving silence_analysis_plot to %s'%filename)
-            plt.savefig(
-                filename,
-                format="png")
-            plt.close()
+        ax.set_title('Finding word + sync pulse')
+        plt.xlabel("Position in file %s (samples)"%self.rec)
+        plt.show()
 
-    def _detect_sync_pulse_position(self):
-        """
-        Determines noise level during silence period and use it to detect the
-        sync pulse position. Computes SN_ratio and stores it. Start searching
-        around end of silent zone. Adjustment are made so a complete 0.5
-        second signal is at the right of the starting search position so a
-        complete 0.5 s word is available for decoding.
-
-        Returns the pulse position relative to the extract beginning.
-
-        Sets self.detected_pulse_position to the returned value.
+    def get_time_in_sound_extract(self):
+        """        
+        Tries to decode time present in self.sound_extract, if successfull
+        return a time dict, eg:{'version': 0, 'seconds':
+        44, 'minutes': 57, 'hours': 19,
+        'day': 1, 'month': 3, 'year offset': 1, 
+        'pulse at': 670451.2217 } otherwise return None
         """
-        pulse_detection_level = self._get_pulse_detection_level()
-        abs_signal = abs(self.sound_extract)
-        mean_during_word = 2*abs_signal.mean()
-        self.SN_ratio = 20*math.log10(mean_during_word/pulse_detection_level)
-        logger.debug('SN ratio: %f dB'%(self.SN_ratio))
-        search_pulse_start_point = self._get_approx_pulse_position()
-        search_pulse_start_point -= 3*SYMBOL_LENGTH*1e-3*self.samplerate
-        search_pulse_start_point = int(search_pulse_start_point)
-        # search_pulse_start_point = end_silent_zone
-        logger.debug('_get_pulse_position %i as starting point'%search_pulse_start_point)
-        distance_to_end = len(self.sound_extract) - search_pulse_start_point
-        time_to_end = distance_to_end/self.samplerate
-        logger.debug('time_to_end after search_pulse_start_point %f sec'%
-                                        time_to_end)
-        if time_to_end < 0.5 + SYMBOL_LENGTH*1e-3: # sec
-            logger.debug('search_pulse_start_point too near the end')
-            # go back one second
-            search_pulse_start_point -= self.samplerate
-            logger.debug('new starting point %i'%search_pulse_start_point)
+        pulse_detected = self._detect_sync_pulse_position()
+        if not pulse_detected:
+            return None
+        symbols_data = self._get_symbols_data()
+        frequencies = [self._get_main_frequency(data_slice)
+                            for data_slice in symbols_data ]
+        logger.debug('found frequencies %s'%frequencies)
+        def _get_bit_from_freq(freq):
+            mid_FSK = 0.5*(F1 + F2)
+            return '1' if freq > mid_FSK else '0'
+        bits = [_get_bit_from_freq(f) for f in frequencies]
+        bits_string = ''.join(bits)
+        logger.debug('giving bits:  LSB %s MSB'%bits_string)
+
+        def _values_from_bits(bits):
+            word_payload_bits_positions = {
+                # start, finish (excluded)
+                'version':(0,3), # 3 bits
+                'seconds':(3,9), # 6 bits
+                'minutes':(9,15),
+                'hours':(15,20),
+                'day':(20,25),
+                'month':(25,29),
+                'year offset':(29,34),
+                }
+            binary_words = { key : bits[slice(*value)]
+                    for key, value 
+                    in word_payload_bits_positions.items()
+                    }
+            int_values = { key : int(''.join(reversed(val)),2)
+                    for key, val in binary_words.items()
+                    }
+            return int_values
+        time_values = _values_from_bits(bits_string)
+        logger.debug(' decoded time %s'%time_values)
+        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):
+        # sets self.detected_pulse_position, relative to sound_extract
+        #
+        regions = self.words_props # contains the sync pulse too
+        # len(self.words_props) should be 1 or 2 for vallid TTC
+        logger.debug('len() of words_props: %i'%len(self.words_props))
+        whole_region = [p for p in regions if 0.499 < _width(p)/self.samplerate < 0.512]
+        logger.debug('region widths %s'%[_width(p)/self.samplerate for p in regions])
+        logger.debug('number of whole_region %i'%len(whole_region))
+        if len(regions) == 1 and len(whole_region) != 1:
+            # oops
+            logger.debug('len(regions) == 1 and len(whole_region) != 1, failed')
+            return False #######################################################
+        if len(whole_region) > 1:
+            print('error in _detect_sync_pulse_position: len(whole_region) > 1 ')
+            return False #######################################################
+        if len(whole_region) == 1:
+            # sync pulse at the begining of this one
+            _, spike, _, _ = whole_region[0].bbox
         else:
-            logger.debug('ok, ample room for 0.5 s word')
-        search_pulse_start_point = max(search_pulse_start_point, 0)
-        logger.debug('search_pulse_start_point: %i in extract'%
-                search_pulse_start_point)
-        abs_signal_after_silence = abs_signal[search_pulse_start_point:]
-        # here the real searching with numpy.argmax()
-        first_point = \
-                    np.argmax(abs_signal_after_silence > pulse_detection_level)
-        first_point += search_pulse_start_point
-        logger.debug('found sync pulse at %i in extract'%first_point)
-        logger.debug('found sync pulse at %i in file'%(first_point
-                + self.sound_extract_position))
-        distance_to_end = len(self.sound_extract) - first_point
-        time_to_end = distance_to_end/self.samplerate
-        logger.debug('time_to_end after detected pulse %f sec'%
-                                        time_to_end)
-        if time_to_end < 0.5 + SYMBOL_LENGTH*1e-3: # sec
-            logger.debug('detected_pulse_position too near the end')
-            logger.debug('back one second')
-            first_point -= self.samplerate
-            logger.debug('new sync pulse at %i in extract'%first_point)
-            logger.debug('new sync pulse at %i in file'%first_point)
+            # whole_region is [] (all fractionnal) and
+            # sync pulse at the begining of the 2nd region
+            _, spike, _, _ = regions[1].bbox
+            # but check there is still enough place for ten bits: 
+            # 6 for secs + 3 for revision + blanck after sync
+            minimum_samples = int(self.samplerate*10*SYMBOL_LENGTH*1e-3)
+            whats_left = len(self.sound_extract) - spike
+            if whats_left < minimum_samples:
+                spike -= self.samplerate
+                # else: stay there, will decode seconds in whats_left
+        half_symbol_width = int(0.5*1e-3*SYMBOL_LENGTH*self.samplerate) # samples
+        left, right = (spike - half_symbol_width, spike+half_symbol_width)
+        spike_data = self.sound_extract[left:right]
+        biggest_positive = np.max(spike_data)
+        biggest_negative = np.min(spike_data)
+        if abs(biggest_negative) > biggest_positive:
+            # flip
+            spike_data = -1 * spike_data
+        def fit_line_until_negative():
+            import numpy as np
+            start = np.argmax(spike_data)
+            xs = [start]
+            ys = [spike_data[start]]
+            i = 1
+            while spike_data[start - i] > 0 and start - i >= 0:
+                xs.append(start - i)
+                ys.append(spike_data[start - i])
+                i += 1
+            # ax.scatter(xs, ys)
+            import numpy as np
+            coeff = np.polyfit(xs, ys, 1)
+            m, b = coeff
+            zero = int(-b/m)
+            # check if data is from USB audio and tweak
+            y_fit = np.poly1d(coeff)(xs)
+            err = abs(np.sum(np.abs(y_fit-ys))/np.mean(ys))
+            logger.debug('fit error for line in ramp: %f'%err)
+            if err < 0.01: #good fit so not analog
+                zero += 1
+            return zero
+        sync_sample = fit_line_until_negative() + left
+        logger.debug('sync pulse found at %i in extract, %i in file'%(
+                        sync_sample, sync_sample + self.sound_extract_position))
+        self.detected_pulse_position = sync_sample
+        return True
+    
+    def _get_symbols_data(self):
+        # part of extract AFTER sync pulse
+        whats_left = len(self.sound_extract) - self.detected_pulse_position # in samples
+        whats_left /= self.samplerate # in sec
+        whole_word_is_in_extr = whats_left > 0.512 
+        if whole_word_is_in_extr:
+            # one region
+            logger.debug('word is in one sole region')
+            length_needed = round(0.5*self.samplerate)
+            length_needed += round(self.samplerate*SYMBOL_LENGTH*1e-3)
+            whole_word = self.sound_extract[self.detected_pulse_position:
+                                           self.detected_pulse_position + length_needed]
         else:
-            logger.debug('ok, ample room for 0.5 s word after detected pulse')            
-        self.detected_pulse_position = first_point
-        return first_point
-
-    def _get_word_width_parameters(self):
-        """
-        Returns the parameters used to find and demodulate 2FSK word:
-        presumed_symbol_length
-        word_width_threshold
-        search_end_position
-        """
-        abs_signal = abs(self.sound_extract)
-        pulse_position = self._get_pulse_position()
-        bfsk_min = self._get_minimal_bfsk()
-        params = {'word_width_threshold': 0.8*bfsk_min}
-        sr = self.samplerate
-        presumed_symbol_length = SYMBOL_LENGTH*1e-3*sr
-        # in ms, now in samples
-        presumed_word_width = presumed_symbol_length * N_SYMBOLS_SAMD21
-        # word includes sync pulse
-        params['search_end_position'] = \
-                    int(presumed_symbol_length + pulse_position + \
-                    presumed_word_width) + 1700 # samples for headroom 
-        params['presumed_symbol_length'] = presumed_symbol_length
-        return params
-
-    def _get_BFSK_word_boundaries(self):
-        n_bits = N_SYMBOLS_SAMD21 - 1
-        sr = self.samplerate
-        wwp = self._get_word_width_parameters()
-        pulse_position = self._get_pulse_position()
-        # search_start_position = wwp['search_start_position']
-        search_end_position = wwp['search_end_position']
-        word_width_threshold = wwp['word_width_threshold']
-        word_extract = self.sound_extract[pulse_position :
-            search_end_position]
-        logger.debug('word left boundary search position: %i relative to extract'%
-            (search_end_position))
-        logger.debug('extract starting at %i in file (Decoder.sound_extract_position)'%
-                self.sound_extract_position)
-        flipped_extract = np.flip(np.abs(word_extract))
-        right_boundary = len(word_extract) - \
-            np.argmax(flipped_extract > word_width_threshold)  + \
-                pulse_position
-        # left_boundary = np.argmax(
-        #     np.abs(word_extract) > word_width_threshold)  + \
-        #     search_start_position
-        left_boundary = pulse_position
-        left_in_file = left_boundary + self.sound_extract_position
-        right_in_file = right_boundary + self.sound_extract_position
-        logger.debug('word boundaries: %i and %i in file'%
-                                (left_in_file, right_in_file))
-        eff_symbol_length = 1e3*(right_boundary-left_boundary)/(n_bits*sr)
-        logger.debug('effective symbol length %.4f ms '%
-                                eff_symbol_length)
-        logger.debug('presumed symbol length %.4f ms '%SYMBOL_LENGTH)
-        relative_error = (eff_symbol_length-SYMBOL_LENGTH)/SYMBOL_LENGTH
-        status = True
-        if relative_error > SYMBOL_LENGTH_TOLERANCE:
-            logger.error(
-                'actual symbol length differs too much: %.2f vs %.2f ms'%
-                (eff_symbol_length, SYMBOL_LENGTH))
-            # return None, None
-            status = False
-        logger.debug(' relative discrepancy %.4f%%'%(abs(100*relative_error)))
-        return status, left_boundary, right_boundary
-
-    def _get_BFSK_symbols_boundaries(self):
-        # returns indices of start of each slice and boundaries
-        pulse_position = self._get_pulse_position()
-        boundaries_OK, left_boundary, right_boundary = \
-                self._get_BFSK_word_boundaries()
-        if left_boundary is None:
-            return None, None, None
-        symbol_width_samples = \
-                float(right_boundary - left_boundary)/N_SYMBOLS_SAMD21
-        symbol_positions = symbol_width_samples * \
-                np.arange(float(0), float(N_SYMBOLS_SAMD21 + 1)) + \
-                pulse_position
-        int_symb_positions = symbol_positions.round().astype(int)
-        logger.debug('%i symbol positions %s samples in file'%
-                (
-                len(int_symb_positions),
-                int_symb_positions + self.sound_extract_position)
-                )
-        return int_symb_positions[:-1], left_boundary, right_boundary
-
-    def _values_from_bits(self, bits):
-        word_payload_bits_positions = {
-            'version':(0,2),
-            'clock source':(2,3),
-            'seconds':(3,9),
-            'minutes':(9,15),
-            'hours':(15,20),
-            'day':(20,25),
-            'month':(25,29),
-            'year offset':(29,34),
-            }
-        binary_words = { key : bits[slice(*value)]
-                for key, value 
-                in word_payload_bits_positions.items()
-                }
-        int_values = { key : self._get_int_from_binary_str(val)
-                for key, val                 in binary_words.items()
-                }
-        logger.debug(' Demodulated values %s'%int_values)
-        return int_values
-
-    def _slice_sound_extract(self, symbols_indices):
-        indices_left_shifted = deque(list(symbols_indices))
-        indices_left_shifted.rotate(-1)
-        all_intervals = list(zip(
-                                symbols_indices,
-                                indices_left_shifted
-                                ))
-        word_intervals = all_intervals[1:-1]
-        # [0, 11, 23, 31, 45] => [(11, 23), (23, 31), (31, 45)]
-        logger.debug('slicing intervals, word_intervals = %s'%
-                                                word_intervals)
-        # skip sample after pulse, start at BFSK word
-        filtered_sound_extract = self._band_pass_filter(self.sound_extract)
-        slices = [filtered_sound_extract[slice(*pair)]
-                            for pair in word_intervals]
-        np.set_printoptions(threshold=5)
-        # logger.debug('data slices: \n%s'%pprint.pformat(slices))
-        # raise Exception
+            # Two regions.
+            logger.debug('word is in two regions, will wrap past seconds')
+            # Consistency check: if not whole_word_is_in_extr
+            # check has been done so seconds are encoded in what s left
+            minimum_samples = round(self.samplerate*10*SYMBOL_LENGTH*1e-3)
+            if whats_left*self.samplerate < minimum_samples:
+                print('bug in _get_data_symbol():')
+                print(' whats_left*self.samplerate < minimum_samples')
+            # Should now build a whole 0.5 sec word by joining remaining data
+            # from previous second beep
+            left_piece = self.sound_extract[self.detected_pulse_position:]
+            one_second_before_idx = round(len(self.sound_extract) - self.samplerate)
+            length_needed = round(0.5*self.samplerate - len(left_piece))
+            length_needed += round(self.samplerate*SYMBOL_LENGTH*1e-3)
+            right_piece = self.sound_extract[one_second_before_idx:
+                                            one_second_before_idx + length_needed]
+            whole_word = np.concatenate((left_piece, right_piece))
+            logger.debug('two chunks lengths: %i %i samples'%(len(left_piece),
+                                                        len(right_piece)))
+        # search for word start (some jitter because of Teensy Audio Lib)
+        symbol_length = round(self.samplerate*SYMBOL_LENGTH*1e-3)
+        start = round(0.5*symbol_length) # half symbol
+        end = start + symbol_length
+        word_begining = whole_word[start:]
+        gt_detection_level = np.argwhere(np.abs(word_begining)>self.pulse_detection_level)
+        word_start = gt_detection_level[0][0]
+        word_end = gt_detection_level[-1][0]
+        self.effective_word_duration = (word_end - word_start)/self.samplerate
+        logger.debug('effective_word_duration %f s'%self.effective_word_duration)
+        uCTRLR_error = self.effective_word_duration/((N_SYMBOLS -1)*SYMBOL_LENGTH*1e-3)
+        logger.debug('uCTRLR_error %f (time ratio)'%uCTRLR_error)
+        word_start += start # relative to Decoder extract
+        # check if gap is indeed less than TEENSY_MAX_LAG
+        silence_length = word_start
+        gap = silence_length - symbol_length
+        relative_gap = gap/(TEENSY_MAX_LAG*self.samplerate)
+        logger.debug('Audio update() gap between sync pulse and word start: ')
+        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: # 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)
+        logger.debug('symbol width %i theo; %i effective (samples)'%(
+                                    symbol_width_samples_theor,
+                                    symbol_width_samples_eff))
+        symbol_positions = symbol_width_samples_eff * \
+            np.arange(float(0), float(N_SYMBOLS - 1)) + word_start
+        # symbols_indices contains 34 start of symbols (samples)
+        symbols_indices = symbol_positions.round().astype(int)
+        if self.do_plots:
+            fig, ax = plt.subplots()
+            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 + start, 0, 1,
+                    transform=xt,
+                linewidth=0.6, colors='green')
+                ax.set_title('Slicing the 34 bits word:')
+            plt.xlabel("Position in file %s (samples)"%self.rec)
+            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]
         return slices
 
     def _get_main_frequency(self, symbol_data):
@@ -811,194 +556,7 @@ class Decoder:
         freq_in_hertz = abs(freq * self.samplerate)
         return int(round(freq_in_hertz))
 
-    # def _get_bit_from_freq(self, freq):
-    #     if math.isclose(freq, F1, abs_tol=FSK_TOLERANCE):
-    #         return '0'
-    #     if math.isclose(freq, F2, abs_tol=FSK_TOLERANCE):
-    #         return '1'
-    #     else:
-    #         return None
-
-    def _get_bit_from_freq(self, freq):
-        mid_FSK = 0.5*(F1 + F2)
-        return '1' if freq > mid_FSK else '0'
-
-    def _get_int_from_binary_str(self, string_of_01s):
-        return int(''.join(reversed(string_of_01s)),2)
-        # LSB is leftmost in YaLTC
-
-    def _demod_values_are_OK(self, values_dict):
-        ranges = {
-            'seconds': range(60),
-            'minutes': range(60),
-            'hours': range(24),
-            'day': range(1,32),
-            'month': range(1,13),
-            }
-        for key in ranges:
-            val = values_dict[key]
-            ok =  val in ranges[key]
-            logger.debug(
-                'checking range for %s: %i, Ok? %s'%(key, val, ok))
-            if not ok:
-                logger.error('demodulated value is out of range')
-                return False
-        return True
 
-    def _plot_slices(self, sync_pulse, symbols_indices, word_lft, word_rght,
-                        title=None, filename=None):
-        # save figure in filename if set, otherwise
-        # start an interactive plot, title is for matplotlib
-        signal = self.sound_extract
-        # signal = self._band_pass_filter(signal)
-        start = self.sound_extract_position
-        x_signal_in_file = range(
-                                start,
-                                start + len(signal)
-                                )
-        wwp = self._get_word_width_parameters()
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        search_end_position = wwp['search_end_position'] + start
-        logger.debug('doing slice plot')
-        fig, ax = plt.subplots()
-        plt.title(title)
-        ax.plot(
-            x_signal_in_file, signal,
-            marker='.', markersize='1',
-            linewidth=0.3, color='purple', alpha=0.3)
-        yt = ax.get_yaxis_transform()
-        ax.hlines(
-            wwp['word_width_threshold'], 0, 1, 
-            transform=yt, linewidth=0.6, colors='green')
-        ax.hlines(
-            0, 0, 1, 
-            transform=yt, linewidth=0.6, colors='black')
-        ax.hlines(
-            -wwp['word_width_threshold'], 0, 1, 
-            transform=yt, linewidth=0.6, colors='green')
-        pulse_level = self._get_pulse_detection_level()
-        ax.hlines(
-            pulse_level, 0, 1, 
-            transform=yt, linewidth=0.6, colors='blue')
-        ax.hlines(
-            -pulse_level, 0, 1, 
-            transform=yt, linewidth=0.6, colors='blue')
-        xt = ax.get_xaxis_transform()
-        # ax.vlines(
-        #     search_start_position,
-        #     0, 1, transform=xt, linewidth=0.6, colors='blue')
-        ax.vlines(
-            search_end_position,
-            0, 1, transform=xt, linewidth=0.6, colors='blue')
-        ax.plot(
-            [sync_pulse + start], [0],
-            marker='D', markersize='7',
-            linewidth=0.3, color='blue', alpha=0.3)
-        ax.plot(
-            [start_silent_zone + start], [0],
-            marker='>', markersize='10',
-            linewidth=0.3, color='green', alpha=0.3)
-        ax.plot(
-            [end_silent_zone + start], [0],
-            marker='<', markersize='10',
-            linewidth=0.3, color='green', alpha=0.3)
-        boundaries_OK, word_lft, word_rght = \
-            self._get_BFSK_word_boundaries()
-        ax.vlines(
-            word_lft + start, 0, 1,
-            transform=ax.get_xaxis_transform(),
-            linewidth=0.6, colors='red')
-        ax.vlines(
-            word_rght + start, 0, 1, 
-            transform=ax.get_xaxis_transform(),
-            linewidth=0.6, colors='red')
-        for x in symbols_indices + self.sound_extract_position:
-            ax.vlines(
-            x, 0, 1,
-            transform=ax.get_xaxis_transform(),
-            linewidth=0.3, colors='green')
-        ax.set_xlabel(
-            'samples in file')
-        plt.xlim(
-            [sync_pulse - 300 + start, wwp['search_end_position'] + 400 + start])
-        if filename == None:
-            plt.show()
-        else:
-            plt.ylim(
-                [-1.5*wwp['word_width_threshold'],
-                1.1*signal.max()])
-            height = 1000
-            plt.savefig(
-                filename,
-                format='png',
-                dpi=height/fig.get_size_inches()[1])
-            plt.close()
-        logger.debug('done slice plot')
-
-    def _band_pass_filter(self, data):
-        # return filtered data
-        def _bandpass(data: np.ndarray, edges: list[float], sample_rate: float, poles: int = 5):
-            sos = scipy.signal.butter(poles, edges, 'bandpass', fs=sample_rate, output='sos')
-            filtered_data = scipy.signal.sosfiltfilt(sos, data)
-            return filtered_data
-        sample_rate = self.samplerate
-        times = np.arange(len(data))/sample_rate
-        return _bandpass(data, [BPF_LOW_FRQ, BPF_HIGH_FRQ], sample_rate)
-
-    def get_time_in_sound_extract(self, plots):
-        if self.sound_extract is None:
-            return None
-        if plots:
-            self.make_silence_analysis_plot()
-        pulse_position = self._detect_sync_pulse_position()
-        pulse_pos_in_file = pulse_position + self.sound_extract_position
-        pulse_position_sec = pulse_pos_in_file/self.samplerate
-        logger.debug('found sync pulse at sample %i in file'%pulse_pos_in_file)
-        symbols_indices, word_lft, word_rght = \
-            self._get_BFSK_symbols_boundaries()
-        if plots:
-            title = 'Bit slicing at %s, %.2f s'%(pulse_pos_in_file,
-                    pulse_position_sec)
-            # self.make_silence_analysis_plot()
-            logger.debug('calling _plot_slices()')
-            self._plot_slices(pulse_position, symbols_indices, word_lft,
-                                word_rght, title)
-        if symbols_indices is None:
-            return None
-        sliced_data = self._slice_sound_extract(symbols_indices)
-        frequencies = [self._get_main_frequency(data_slice)
-                            for data_slice
-                            in sliced_data
-                            ]
-        logger.debug('frequencies = %s'%frequencies)
-        sr = self.samplerate
-        n_bits = N_SYMBOLS_SAMD21 - 1
-        eff_symbol_length = 1e3*(word_rght-word_lft)/(n_bits*sr)
-        length_ratio = eff_symbol_length / SYMBOL_LENGTH
-        logger.debug('symbol length_ratio (eff/supposed) %f'%length_ratio)
-        corrected_freq = np.array(frequencies)*length_ratio
-        logger.debug('corrected freq (using symbol length) = %s'%corrected_freq)
-        bits = [self._get_bit_from_freq(f) for f in corrected_freq]
-        for i, bit in enumerate(bits):
-            if bit == None:
-                logger.warning('cant decode frequency %i for bit at %i-%i'%(
-                                corrected_freq[i],
-                                symbols_indices[i],
-                                symbols_indices[i+1]))
-        if None in bits:
-            return None
-        bits_string = ''.join(bits)
-        logger.debug('bits = %s'%bits_string)
-        time_values = self._values_from_bits(bits_string)
-        time_values['pulse at'] = (pulse_position +
-                                    self.sound_extract_position -
-                                    SAMD21_LATENCY*1e-6*self.samplerate)
-        time_values['clock source'] = 'GPS' \
-            if time_values['clock source'] == 1 else 'RTC'
-        if self._demod_values_are_OK(time_values):
-            return time_values
-        else:
-            return None
 
 class Recording:
     """
@@ -1006,28 +564,22 @@ class Recording:
     
     Attributes:
         AVpath : pathlib.path
-            path of video+sound+YaLTC file, relative to working directory
+            path of video+sound+TicTacCode file, relative to working directory
 
-        sound_without_YaLTC : pathlib.path
-            path of sound file stripped of silent and YaLTC channels
+        audio_data : in16 numpy.array of shape [nchan] x [N samples]
 
-        device : str
-            identifies the device used for the recording, set in __init__()
+        # valid_sound : pathlib.path
+        #     path of sound file stripped of silent and TicTacCode channels
 
-        new_rec_name : str
-            built using the device name, ex: "CAM_A001"
-            set by Timeline._rename_all_recs()
+        device : Device
+            identifies the device used for the recording, set in __init__()
 
         probe : dict
             returned value of ffmpeg.probe(self.AVpath)
 
-        YaLTC_channel : int
+        TicTacCode_channel : int
             which channel is sync track. 0 is first channel,
-            set in _read_sound_find_YaLTC().
-
-        silent_channels : list of ints
-            list of channel which are silent. 1 is first channel,
-            set in _strip_yaltc()
+            set in _find_TicTacCode().
 
         decoder : yaltc.decoder
             associated decoder object, if file is audiovideo
@@ -1043,7 +595,7 @@ class Recording:
         sync_position : int
             position of first detected syn pulse
 
-        is_reference : bool (True for ref rec only)
+        is_audio_reference : bool (True for ref rec only)
             in multi recorders set-ups, user decides if a sound-only recording
             is the time reference for all other audio recordings. By
             default any video recording is the time reference for other audio,
@@ -1052,24 +604,24 @@ class Recording:
 
         device_relative_speed : float
             the ratio of the recording device clock speed relative to the
-            reference_rec clock device, in order to correct clock drift with
-            pysox tempo transform. If value < 1.0 then the recording is slower
-            than reference_rec. Updated by each AudioStitcherVideoMerger
-            instance so the value can change depending on the reference
-            recording (video or main sound). A mean is calculated for all
+            video recorder clock device, in order to correct clock drift with
+            pysox tempo transform. If value < 1.0 then the recording is
+            slower than video recorder. Updated by each
+            MediaMerger instance so the value can change
+            depending on the video recording . A mean is calculated for all
             recordings of the same device in
-            AudioStitcherVideoMerger._get_concatenated_audiofile_for()
+            MediaMerger._get_concatenated_audiofile_for()
 
         time_position : float
             The time (in seconds) at which the recording starts relative to the
-            reference recording. Updated by each AudioStitcherVideoMerger
-            instance so the value can change depending on the reference
+            video recording. Updated by each MediaMerger
+            instance so the value can change depending on the video
             recording (a video or main sound).
 
         final_synced_file : a pathlib.Path
             contains the path of the merged video file after the call to
-            AudioStitcher.build_audio_and_write_video if the Recording is a
-            reference recording, relative to the working directory
+            AudioStitcher.build_audio_and_write_merged_media if the Recording is a
+            video recording, relative to the working directory
             
         synced_audio : pathlib.Path
             contains the path of audio only of self.final_synced_file. Absolute
@@ -1083,51 +635,59 @@ class Recording:
 
     """
 
-    def __init__(self, media):
+    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
         ----------
-        media : dict as
-                {
-                'path' : as is ,
-                'device type' : REC or CAM,
-                'sample length' : as is
-                'dev UID' : see get_device_ffprobe_UID()
-                }
-
+        media : Media dataclass with attributes:
+            path: Path
+            device: Device
+
+            with Device having attibutes (from device_scanner module):
+                UID: int
+                folder: Path
+                name: str
+                dev_type: str
+                tracks: Tracks
+
+                with Tracks having attributes (from device_scanner module):
+                    ttc: int # track number of TicTacCode signal
+                    unused: list # of unused tracks
+                    stereomics: list # of stereo mics track tuples (Lchan#, Rchan#)
+                    mix: list # of mixed tracks, if a pair, order is L than R
+                    others: list #of all other tags: (tag, track#) tuples
+                    rawtrx: list # list of strings read from file
+                    error_msg: str # 'None' if none
         Raises
         ------
         an Exception if AVfilename doesnt exist
 
         """
-
-        self.AVpath = media['path']
-        # self.device = media['dev UID']
-        self.device = media['dev']
+        self.AVpath = media.path
+        self.device = media.device
         self.true_samplerate = None
         self.start_time = None
         self.in_cam_audio_sync_arror = 0
         self.decoder = None
         self.probe = None
-        self.YaLTC_channel = None
-        self.is_reference = False
+        self.TicTacCode_channel = None
+        self.is_audio_reference = False
         self.device_relative_speed = 1.0
-        self.sound_without_YaLTC = None
+        # self.valid_sound = None
         self.final_synced_file = None
         self.synced_audio = None
-        self.new_rec_name = media['path'].name
-        # self.matched_audio_records = []
-        # self.relative_position = 0
-        # self.editing_front = {'what':None,'how': 0}
-        # self.editing_rear =  {'what':None,'how': 0}
+        # 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)
         recording_init_fail = ''
@@ -1150,7 +710,7 @@ class Recording:
         elif self.get_duration() < MINIMUM_LENGTH:
             recording_init_fail = 'file too short, %f s\n'%self.get_duration()
         if recording_init_fail == '': # success
-            self.decoder = Decoder(self)
+            self.decoder = Decoder(self, do_plots)
             # self._set_multi_files_siblings()
             self._check_for_camera_error_correction()
         else:
@@ -1159,11 +719,25 @@ 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()
+        N = self.get_audio_channels_nbr()
+        data = read_audio_data_from_file(self.AVpath, n_channels=N)
+        if len(data) == 1 and not self.is_video():
+            print(f'file sound is mono ({self.AVpath}), bye.')
+            sys.exit(0)
+        if np.isclose(np.std(data), 0, rtol=1e-2):
+            logger.error("ffmpeg can't extract audio from %s"%file)
+            sys.exit(0)
+        self.audio_data = data
+        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.AVpath)
 
     def _check_for_camera_error_correction(self):
         # look for a file number
@@ -1180,7 +754,7 @@ class Recording:
                     f = str(calib_file[0])
                     print('problem parsing name of [gold1]%s[/gold1],'%f)
                     print('move elsewhere and rerun, quitting.\n')
-                    quit()
+                    sys.exit(1)
                 self.in_cam_audio_sync_arror = value
                 logger.debug('found error correction %i ms.'%value)
 
@@ -1200,19 +774,19 @@ class Recording:
             recording duration in seconds.
 
         """
-        if self.sound_without_YaLTC:
-            val = sox.file_info.duration(_pathname(self.sound_without_YaLTC))
-            logger.debug('duration of sound_without_YaLTC %f'%val)
-            return val
+        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:
-                return 0
+                return 0 #######################################################
             try:
                 probed_duration = float(self.probe['format']['duration'])
             except:
                 logger.error('oups, cant find duration from ffprobe')
                 raise Exception('stopping here')
-            logger.debug('ffprobed duration is: %f sec'%probed_duration)
+            logger.debug('ffprobed duration is: %f sec for %s'%(probed_duration, self))
             return probed_duration # duration in s
 
     def get_original_duration(self):
@@ -1228,27 +802,29 @@ class Recording:
             recording duration in seconds.
 
         """
-        val = sox.file_info.duration(_pathname(self.sound_without_YaLTC))
-        logger.debug('duration of sound_without_YaLTC %f'%val)
+        val = sox.file_info.duration(_pathname(self.AVpath))
+        logger.debug('duration of AVpath %f'%val)
         return val
 
     def get_corrected_duration(self):
         """
         uses device_relative_speed to compute corrected duration. Updated by
-        each AudioStitcherVideoMerger object in
-        AudioStitcherVideoMerger._get_concatenated_audiofile_for()
+        each MediaMerger object in
+        MediaMerger._get_concatenated_audiofile_for()
         """
         return self.get_duration()/self.device_relative_speed
 
     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('%s needs dedrifting: delta of %i ms is too big'%(self.AVpath, delta*1e3))
+            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
 
     def get_end_time(self):
@@ -1268,32 +844,38 @@ class Recording:
         end = self.get_end_time()
         return start < datetime and datetime < end
 
-    def _find_time_around(self, time, plots):
-        # actually reading sound data and trying to decode it
-        # through decoder object, if successful  return a time dict, eg:
-        # {'version': 0, 'clock source': 'GPS', 'seconds': 44, 'minutes': 57,
-        # 'hours': 19, 'day': 1, 'month': 3, 'year offset': 1, 
-        # 'pulse at': 670451.2217 }
-        # otherwise return None
-        if time < 0:
+    def _find_time_around(self, time):
+        """        
+        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 }
+        otherwise return None
+        """        
+        if time < 0: # negative = referenced from the end
             there = self.get_duration() + time
         else:
             there = time
-        self._read_sound_find_YaLTC(there, SOUND_EXTRACT_LENGTH)
-        if self.YaLTC_channel is None:
+        self._find_TicTacCode(there, SOUND_EXTRACT_LENGTH)
+        if self.TicTacCode_channel is None:
             return None
         else:
-            return self.decoder.get_time_in_sound_extract(plots)
+            return self.decoder.get_time_in_sound_extract()
 
     def _get_timedate_from_dict(self, time_dict):
-        python_datetime = datetime(
-            time_dict['year offset'] + YEAR_ZERO,
-            time_dict['month'],
-            time_dict['day'],
-            time_dict['hours'],
-            time_dict['minutes'],
-            time_dict['seconds'],
-            tzinfo=timezone.utc)
+        try:
+            python_datetime = datetime(
+                time_dict['year offset'] + YEAR_ZERO,
+                time_dict['month'],
+                time_dict['day'],
+                time_dict['hours'],
+                time_dict['minutes'],
+                time_dict['seconds'],
+                tzinfo=timezone.utc)
+        except ValueError as e:
+            print('Error converting date in _get_timedate_from_dict',e)
+            sys.exit(1)
         python_datetime += timedelta(seconds=1) # PPS precedes NMEA sequ
         return python_datetime
 
@@ -1301,7 +883,7 @@ class Recording:
         """
         For error checking. This verifies if two sync pulse apart
         are correctly space with sample interval deduced from
-        time difference of demodulated YaLTC times. The same 
+        time difference of demodulated TicTacCode times. The same 
         process is used for determining the true sample rate
         in _compute_true_samplerate(). On entry check if either time
         is None, return False if so.
@@ -1315,12 +897,11 @@ class Recording:
 
         Returns
         -------
-        TYPE
-            DESCRIPTION.
 
         """
         if t1 == None or t2 == None:
-            return False
+            return False #######################################################
+        logger.debug('t1 : %s t2: %s'%(t1, t2))
         datetime_1 = self._get_timedate_from_dict(t1)
         datetime_2 = self._get_timedate_from_dict(t2)
         # if datetime_2 < datetime_1:
@@ -1361,19 +942,19 @@ class Recording:
                                 to_precision(true_samplerate, 8))
         return true_samplerate
 
-    def set_time_position_to(self, reference_recording):
+    def set_time_position_to(self, video_clip):
         """
         Sets self.time_position, the time (in seconds) at which the recording
-        starts relative to the reference recording. Updated by each AudioStitcherVideoMerger
-        instance so the value can change depending on the reference
+        starts relative to the video recording. Updated by each MediaMerger
+        instance so the value can change depending on the video
         recording (a video or main sound).
 
         called by timeline.AudioStitcher._get_concatenated_audiofile_for()
         
         """
-        ref_start_time = reference_recording.get_start_time()
+        video_start_time = video_clip.get_start_time()
         self.time_position = (self.get_start_time()
-                                            - ref_start_time).total_seconds()
+                                            - video_start_time).total_seconds()
 
     def get_Dt_with(self, later_recording):
         """
@@ -1385,25 +966,29 @@ class Recording:
         t2 = later_recording.get_start_time()
         return t2 - t1
 
-    def get_start_time(self, plots=False):
+    def get_start_time(self):
         """
-        Try to decode a YaLTC_channel at start AND finish;
-        if successful, returns a python datetime object;
+        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.sound_without_YaLTC
         """
+        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:
-            return self.start_time
+            logger.debug('Recording.start_time already found %s'%self.start_time)
+            return self.start_time #############################################
         cached_times = {}
-        def find_time(t_sec, plots=False):
+        def find_time(t_sec):
             time_k = int(t_sec)
             # if cached_times.has_key(time_k):
             if CACHING and time_k in cached_times:
                 logger.debug('cache hit _find_time_around() for t=%s s'%time_k)
-                return cached_times[time_k]
+                return cached_times[time_k] ####################################
             else:
                 logger.debug('_find_time_around() for t=%s s not cached'%time_k)
-                new_t = self._find_time_around(t_sec, plots)
+                new_t = self._find_time_around(t_sec)
                 cached_times[time_k] = new_t
                 return new_t
         for i, pair in enumerate(TRIAL_TIMES):
@@ -1416,12 +1001,12 @@ class Recording:
                 logger.warning('More than one trial: #%i/%i'%(i+1,
                                         len(TRIAL_TIMES)))
             # time_around_beginning = self._find_time_around(near_beg)
-            time_around_beginning = find_time(near_beg, plots)
-            if self.YaLTC_channel is None:
-                return None
+            time_around_beginning = find_time(near_beg)
+            # 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, plots)
+            time_around_end = find_time(near_end)
             logger.debug('trial result, time_around_beginning:\n   %s'%
                     (time_around_beginning))
             logger.debug('trial result, time_around_end:\n   %s'%
@@ -1431,14 +1016,15 @@ 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')
-            return None
+            return None ########################################################
         if None in [time_around_beginning, time_around_end]:
             logger.warning('didnt find any time in file')
             self.start_time = None
-            return None
+            return None ########################################################
         true_sr = self._compute_true_samplerate(
                         time_around_beginning,
                         time_around_end)
@@ -1454,60 +1040,322 @@ 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.sound_without_YaLTC = self._strip_yaltc()
+        # if self.is_audio():
+        #     self.valid_sound = self.AVpath
         return start_UTC
 
-    def _strip_yaltc(self):
-        """        
-        Returns a tempfile.NamedTemporaryFile of sound file stripped
-        of YaLTC channel and of any silent channel. Criteria for
-        silence is sox stats "RMS lev db" < DB_RMS_SILENCE_SOX
-
-        Sets self.silent_channels
+    def _find_timed_tracks_(self, tracks_file) -> device_scanner.Tracks:
+        """
+        Look for any ISO 8601 timestamp e.g.: 2007-04-05T14:30Z
+        and choose the right chunk according to Recording.start_time
+        """
+        file=open(tracks_file,"r")
+        whole_txt = file.read()
+        tracks_lines = []
+        for l in whole_txt.splitlines():
+            after_sharp = l.split('#')[0]
+            if len(after_sharp) > 0:
+                tracks_lines.append(after_sharp)
+        logger.debug('file %s filtered lines:\n%s'%(tracks_file,
+                                pformat(tracks_lines)))
+        def _seems_timestamp(line):
+            # will validate format later with datetime.fromisoformat()
+            m = re.match(r'ts=(.*)', line)
+            # m = re.match(r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z', line)
+            if m != None:
+                return m.groups()[0]
+            else:
+                return None
+        chunks = []
+        new_chunk = []
+        timestamps_str = []
+        for line in tracks_lines:
+            timestamp_candidate = _seems_timestamp(line)
+            if timestamp_candidate != None:
+                logger.debug(f'timestamp: {line}')
+                timestamps_str.append(timestamp_candidate)
+                chunks.append(new_chunk)
+                new_chunk = []
+            else:
+                new_chunk.append(line)
+        chunks.append(new_chunk)
+        logger.debug(f'chunks {chunks}, timestamps_str {timestamps_str}')
+        str_frmt = '%Y-%m-%dT%H:%MZ'
+        # from strings to datetime instances
+        timestamps = []
+        for dtstr in timestamps_str:
+            try:
+                ts = datetime.fromisoformat(dtstr)
+            except:
+                print(f'Error: in file {tracks_file},\ntimestamp {dtstr} is ill formatted, bye.')
+                sys.exit(0)
+            timestamps.append(ts)
+        # timestamps = [datetime.strptime(dtstr, str_frmt, tzinfo=timezone.utc)
+        #                         for dtstr in timestamps]
+        logger.debug(f'datetime timestamps {timestamps}')
+        # input validations, check order:
+        if sorted(timestamps) != timestamps:
+            print(f'Error in {tracks_file}\nSome timestamps are not in ascending order:\n')
+            multi_lines = "\n".join(tracks_lines)
+            print(f'{multi_lines}, Bye.')
+            sys.exit(0)
+        time_ranges = [t2-t1 for t1,t2 in zip(timestamps, timestamps[1:])]
+        logger.debug(f'time_ranges {time_ranges} ')
+        # check times between timestamps are realistic
+        if timedelta(0) in time_ranges:
+            print(f'Error in {tracks_file}\nSome timestamps are repeating:\n')
+            multi_lines = "\n".join(tracks_lines)
+            print(f'{multi_lines}, Bye.')
+            sys.exit(0)
+        if any([ dt < timedelta(minutes=2) for dt in time_ranges]):
+            print(f'Warning in {tracks_file}\nSome timestamps are spaced by less than 2 minutes:\n')
+            print("\n".join(tracks_lines))
+            print(f'If this is an error, correct and rerun. For now will continue...')
+        if any([ dt > timedelta(days=1) for dt in time_ranges]):
+            print(f'Warning in {tracks_file}\nSome timestamps are spaced by more than 24 hrs:\n')
+            print("\n".join(tracks_lines))
+            print(f'If this is an error, correct and rerun. For now will continue...')
+        # add 'infinite in future' to time stamps for time matching
+        future = datetime.max
+        future = future.replace(tzinfo=timezone.utc)
+        timestamps.append(future)
+        # zip it with chunks
+        timed_chunks = list(zip(chunks,timestamps))
+        logger.debug(f'timed_chunks\n{pformat(timed_chunks)} ')
+        logger.debug(f'will find match with {self.start_time}')
+        # for tch in timed_chunks:
+        #     print(tch[1], self.start_time)
+        #     print(tch[1] > self.start_time)
+        idx = 0
+        # while timed_chunks[idx][1] < self.start_time:
+        #     logger.debug(f'does {timed_chunks[idx][1]} < {self.start_time} ?')
+        #     idx += 1
+        max_idx = len(timed_chunks) - 1
+        while True:
+            if timed_chunks[idx][1] > self.start_time or idx == max_idx:
+                break
+            idx += 1
+        chunk_idx = idx
+        logger.debug(f'chunk_idx {chunk_idx}')
+        right_chunk = chunks[chunk_idx]
+        logger.debug(f'found right chunk {right_chunk}')
+        tracks_instance = self._parse_trx_lines(right_chunk, tracks_file)
+        return tracks_instance
+
+    def _parse_trx_lines(self, tracks_lines_with_spaces, tracks_file):
+        """
+        read track names for naming separated ISOs
+        from tracks_file.
+
+        tokens looked for: mix; mix L; mix R; 0 and TC
+
+        repeating "mic*" pattern signals a stereo track
+        and entries will correspondingly panned into
+        a stero mix named mixL.wav and mixL.wav
+
+        mic L # spaces are ignored |
+        mic R                      | stereo pair
+        micB L
+        micB R
+
+        Returns: a Tracks instance:
+                # track numbers start at 1 for first track (as needed by sox)
+                ttc: int # track number of TicTacCode signal
+                unused: list # of unused tracks
+                stereomics: list # of stereo mics track tuples (Lchan#, Rchan#)
+                mix: list # of mixed tracks, if a pair, order is L than R
+                others: list #of all other tags: (tag, track#) tuples
+                rawtrx: list # list of strings read from file
+                error_msg: str # 'None' if none
+        e.g.: Tracks(   ttc=2,
+                        unused=[],
+                        stereomics=[('mic', (4, 3)), ('mic2', (6, 5))],
+                        mix=[], others=[('clics', 1)],
+                        rawtrx=['clics', 'TC', 'micL', 'micR', 'mic2L;1000', 'mic2R;1000', 'mixL', 'mixR'],
+                        error_msg=None, lag_values=[None, None, None, None, '1000', '1000', None, None])
+        """
+        def _WOspace(chaine):
+            ch = [c for c in chaine if c != ' ']
+            return ''.join(ch)
+        tracks_lines = [_WOspace(l) for l in tracks_lines_with_spaces if len(l) > 0 ]
+        rawtrx = [l for l in tracks_lines_with_spaces if len(l) > 0 ]
+        # add index with tuples, starting at 1
+        logger.debug('tracks_lines whole: %s'%tracks_lines)
+        def _detach_lag_value(line):
+            # look for ";number" ending any line, returns a two-list
+            splt = line.split(';')
+            if len(splt) == 1:
+                splt += [None]
+                if len(splt) != 2:
+                    # error
+                    print('\nText error in %s, line %s has too many ";"'%(
+                            tracks_file, line))
+            return splt
+        tracks_lines, lag_values = zip(*[_detach_lag_value(l) for l 
+                                                    in tracks_lines])
+        lag_values = [e for e in lag_values] # from tuple to list
+        # logger.debug('tracks_lines WO lag: %s'%tracks_lines)
+        tracks_lines = [l.lower() for l in tracks_lines]
+        logger.debug('tracks_lines lower case: %s'%tracks_lines)
+        # print(lag_values)
+        logger.debug('lag_values: %s'%lag_values)
+        tagsWOl_r = [e[:-1] for e in tracks_lines] # skip last letter
+        logger.debug('tags WO LR letter %s'%tagsWOl_r)
+        # find idx of start of pairs
+        # ['clics', 'TC', 'micL', 'micR', 'mic2L', 'mic2R', 'mixL', 'mixR']
+        def _micOrmix(a,b):
+            # test if same and mic mic or mix mix
+            if len(a) == 0:
+                return False
+            return (a == b) and (a in 'micmix')
+        pair_idx_start =[i for i, same in enumerate([_micOrmix(a,b) for a,b
+                        in zip(tagsWOl_r,tagsWOl_r[1:])]) if same]
+        logger.debug('pair_idx_start %s'%pair_idx_start)
+        def LR_OK(idx):
+            # in tracks_lines, check if idx ends a LR pair
+            # delays, if any, have been removed
+            a = tracks_lines[idx][-1]
+            b = tracks_lines[idx+1][-1]
+            return a+b in ['lr', 'rl']
+        LR_OKs = [LR_OK(p) for p in pair_idx_start]
+        logger.debug('LR_OKs %s'%LR_OKs)
+        if not all(LR_OKs):
+            print('\nError in %s'%tracks_file)
+            print('Some tracks are paired but not L and R: %s'%rawtrx)
+            print('quitting...')
+            quit()
+        complete_pairs_idx = pair_idx_start + [i + 1 for i in pair_idx_start]
+        singles = set(range(len(tracks_lines))).difference(complete_pairs_idx)
+        logger.debug('complete_pairs_idx %s'%complete_pairs_idx)
+        logger.debug('singles %s'%singles)
+        singles_tag = [tracks_lines[i] for i in singles]
+        logger.debug('singles_tag %s'%singles_tag)
+        n_tc_token = sum([t == 'tc' for t in singles_tag])
+        logger.debug('n tc tags %s'%n_tc_token)
+        if n_tc_token == 0:
+            print('\nError in %s'%tracks_file)
+            print('with %s'%rawtrx)
+            print('no TC track found, quitting...')
+            quit()
+        if n_tc_token > 1:
+            print('\nError in %s'%tracks_file)
+            print('with %s'%rawtrx)
+            print('more than one TC track, quitting...')
+            quit()
+        output_tracks = device_scanner.Tracks(None,[],[],[],[],rawtrx,None,[])
+        output_tracks.ttc = tracks_lines.index('tc') + 1 # 1st = 1
+        logger.debug('ttc_chan %s'%output_tracks.ttc)
+        zeroed = [i+1 for i, t in enumerate(tracks_lines) if t == '0']
+        logger.debug('zeroed %s'%zeroed)
+        output_tracks.unused = zeroed
+        output_tracks.others = [(st, tracks_lines.index(st)+1) for st
+                                in singles_tag if st not
+                                in ['tc', 'monomix', '0']]
+        logger.debug('output_tracks.others %s'%output_tracks.others)
+        # check for monomix
+        if 'monomix' in tracks_lines:
+            output_tracks.mix = [tracks_lines.index('monomix')+1]
+        else:
+            output_tracks.mix = []
+        # check for stereo mix
+        def _findLR(i_first):
+            # returns L R indexes (+1 for sox non zero based indexing)
+            i_2nd = i_first + 1
+            a = tracks_lines[i_first][-1] # l|r at end
+            b = tracks_lines[i_2nd][-1] # l|r at end
+            if a == 'l':
+                if b == 'r':
+                    # sequence is mixL mixR
+                    return i_first+1, i_2nd+1
+                else:
+                    print('\nError in %s'%tracks_file)
+                    print('with %s'%rawtrx)
+                    print('can not find stereo mix')
+                    quit()
+            elif a == 'r':
+                if b == 'l':
+                    # sequence is mixR mixL
+                    return i_2nd+1, i_first+1
+                else:
+                    print('\nError in %s'%tracks_file)
+                    print('with %s'%rawtrx)
+                    print('can not find stereo mix')
+                    quit()
+        logger.debug('for now, output_tracks.mix %s'%output_tracks.mix)
+        mix_pair = [p for p in pair_idx_start if tracks_lines[p][1:] == 'mix']
+        if len(mix_pair) == 1:
+            # one stereo mix, remove it from other pairs
+            i = mix_pair[0]
+            LR_pair =  _findLR(i)
+            logger.debug('LR_pair %s'%str(LR_pair))
+            pair_idx_start.remove(i)
+            # consistency check
+            if output_tracks.mix != []:
+                # already found a mono mix above!
+                print('\nError in %s'%tracks_file)
+                print('with %s'%rawtrx)
+                print('found a mono mix AND a stereo mix')
+                quit()
+            output_tracks.mix = LR_pair
+        logger.debug('finally, output_tracks.mix %s'%str(output_tracks.mix))
+        logger.debug('remaining pairs %s'%pair_idx_start)
+        # those are stereo pairs
+        stereo_pairs = []
+        for first_in_pair in pair_idx_start:
+            suffix = tracks_lines[first_in_pair][:-1]
+            stereo_pairs.append((suffix, _findLR(first_in_pair)))
+        logger.debug('stereo_pairs %s'%stereo_pairs)
+        output_tracks.stereomics = stereo_pairs
+        logger.debug('finished: %s'%output_tracks)
+        return output_tracks
+
+    def load_track_info(self):
+        """
+        If audio rec, look for eventual track names in TRACKSFILE file, stored inside the
+        recorder folder alongside the audio files. If there, store a Tracks
+        object into Recording.device.tracks . 
         """
-        input_file = _pathname(self.AVpath)
-        # building dict according to pysox.remix format.
-        # eg: 4 channels with YaLTC_channel at #2  returns {1: [1], 2: [3], 3: [4]}
-        # ie the number of channels drops by one and chan 2 is missing
-        YaLTC_channel = self.YaLTC_channel + 1 # sox channels start at 1
-        n_channels = sox.file_info.channels(input_file) # eg 2
-        args = ['sox', input_file, '-n', 'channels', 'stats', '-w', '0.01']
-        _, _, stat_output = sox.core.sox(args)
-        sox_RMS_lev_dB = stat_output.split('\n')[5].split()[4:]
-        logger.debug('Sox RMS %s, n_channels %i'%(sox_RMS_lev_dB, n_channels))
-        self.silent_channels = [i + 1 for i,db in enumerate(sox_RMS_lev_dB)
-                                            if float(db) < DB_RMS_SILENCE_SOX]
-        logger.debug('silent chans (1st = #1) %s'%self.silent_channels)
-        chan_list_out = range(1, n_channels) # eg [1,2,3]
-        all_channels = range(1, n_channels + 1) # eg [1,2,3,4]
-        excluded_chans = self.silent_channels + [YaLTC_channel]
-        logger.debug('excluded chans %s'%excluded_chans)
-        kept_chans = [[n] for n in all_channels if n not in excluded_chans]
-        # eg [[1], [3], [4]]
-        sox_remix_dict = dict(zip(chan_list_out, kept_chans))
-        # {1: [1], 2: [3], 3: [4]}
-        output_fh = tempfile.NamedTemporaryFile(suffix='.wav', delete=DEL_TEMP)
-        out_file = _pathname(output_fh)
-        logger.debug('sox in and out files: %s %s'%(input_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(input_file, out_file, return_output=True )
-        logger.debug('sox.build exit code %s'%str(status))
-        p = Popen('ffprobe %s -hide_banner'%input_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
+        if self.is_video():
+            return
+        source_audio_folder = self.device.folder
+        tracks_file = source_audio_folder/TRACKSFILE
+        track_names = False
+        # a_recording = [m for m in self.found_media_files
+        #                                         if m.device == device][0]
+        # logger.debug('a_recording for device %s : %s'%(device, a_recording))
+        nchan = self.get_audio_channels_nbr()
+        # nchan = sox.file_info.channels(str(a_recording.path))
+        if os.path.isfile(tracks_file):
+            logger.debug('found file: %s'%(TRACKSFILE))
+            tracks = self._find_timed_tracks_(tracks_file)
+            if tracks.error_msg:
+                print('\nError parsing [gold1]%s[/gold1] file: %s, quitting.\n'%
+                    (tracks_file, tracks.error_msg))
+                sys.exit(1)
+            logger.debug('parsed tracks %s'%tracks)
+            ntracks = 2*len(tracks.stereomics)
+            ntracks += len(tracks.mix)
+            ntracks += len(tracks.unused)
+            ntracks += len(tracks.others)
+            ntracks += 1 # for ttc track
+            logger.debug(' n chan: %i n tracks file: %i'%(nchan, ntracks))
+            if ntracks != nchan:
+                print('\nError parsing %s content'%tracks_file)
+                print('incoherent number of tracks, %i vs %i quitting\n'%
+                                                    (nchan, ntracks))
+                sys.exit(1)
+            err_msg = tracks.error_msg
+            if  err_msg != None:
+                print('\nError, quitting: in file %s, %s'%(tracks_file, err_msg))
+                raise Exception
+            else:
+                self.device.tracks = tracks
+                logger.debug('for rec %s'%self)
+                logger.debug('tracks object: %s'%self.device.tracks)
+                return
+        else:
+            logger.debug('no tracks.txt file found')
+            return None
 
     def _ffprobe_audio_stream(self):
         streams = self.probe['streams']
@@ -1545,28 +1393,30 @@ class Recording:
             ppm = - (nominal/true - 1) * 1e6
         return int(ppm)
 
-    def get_speed_ratio(self, ref_recording):
+    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
-        nominal_ref = ref_recording.get_samplerate()
-        true_ref = ref_recording.true_samplerate
-        ratio_ref = true_ref/nominal_ref
+        nominal_vid = videoclip.get_samplerate()
+        true_ref = videoclip.true_samplerate
+        ratio_ref = true_ref/nominal_vid
         return ratio/ratio_ref
 
     def get_samplerate(self):
-        # return int samplerate (nominal)
+        # returns int samplerate (nominal)
         string = self._ffprobe_audio_stream()['sample_rate']
-        return eval(string) # eg eval(24000/1001)
+        logger.debug('ffprobe samplerate: %s'%string)
+        return eval(string)
 
     def get_framerate(self):
-        # return int samplerate (nominal)
         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,
@@ -1602,20 +1452,20 @@ class Recording:
 
     def has_audio(self):
         if not self.probe:
-            return False
+            return False #######################################################
         streams = self.probe['streams']
         codecs = [stream['codec_type'] for stream in streams]
         return 'audio' in codecs
 
     def get_audio_channels_nbr(self):
         if not self.has_audio():
-            return 0
+            return 0 ###########################################################
         audio_str = self._ffprobe_audio_stream()
         return audio_str['channels']
 
     def is_video(self):
         if not self.probe:
-            return False
+            return False #######################################################
         streams = self.probe['streams']
         codecs = [stream['codec_type'] for stream in streams]
         return 'video' in codecs
@@ -1623,15 +1473,17 @@ class Recording:
     def is_audio(self):
         return not self.is_video()
 
-    def _read_sound_find_YaLTC(self, time_where, chunk_length):
+    def _find_TicTacCode(self, time_where, chunk_length):
         """
-        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 YaLTC track and sets YaLTC_channel
-        accordingly: a tuple (#file, #chan). On exit, self.decoder.sound_extract
-        contains YaLTC data ready to be demodulated. If not, self.YaLTC_channel
-        is set to None.
+        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.
+
+        If this has been called before (checking self.TicTacCode_channel) then
+        is simply read the audio in and calls set_sound_extract_and_sr(). 
 
         Args:
             time_where : float
@@ -1643,7 +1495,8 @@ class Recording:
             self.decoder.set_sound_extract_and_sr()
 
         Sets:
-            self.YaLTC_channel
+            self.TicTacCode_channel = index of TTC chan
+            self.device.ttc  = index of TTC chan
 
         Returns:
             this Recording instance
@@ -1653,56 +1506,52 @@ class Recording:
         decoder = self.decoder
         if decoder:
             decoder.clear_decoder()
-        # decoder.cached_convolution_fit['is clean'] = False
         if not self.has_audio():
-            self.YaLTC_channel = None
-            return
-        logger.debug('will read around %.2f sec'%time_where)
-        dryrun = (ffmpeg
-            .input(str(path), ss=time_where, t=chunk_length)
-            .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)
-                .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_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')
-        all_channels_data = data.reshape(int(len(data)/n_chan),n_chan).T
-        for i_chan, chan_dat in enumerate(all_channels_data):
-            logger.debug('testing chan %i'%i_chan)
+            self.TicTacCode_channel = None
+            return #############################################################
+        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(
+                                        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())
+                end_idx = start_idx + extract_length
+                extract_audio_data = chan_dat[start_idx:end_idx]
+                decoder.set_sound_extract_and_sr(
+                        extract_audio_data,
+                        self.get_samplerate(),
+                        sound_extract_position
+                        )
+                if decoder.extract_seems_TicTacCode():
+                    self.TicTacCode_channel = i_chan
+                    self.device.ttc = i_chan
+                    logger.debug('found TicTacCode channel: chan #%i'%
+                                    self.TicTacCode_channel)
+                    return self ################################################
+            # end of loop: none found
+            # self.TicTacCode_channel = None # was None already 
+            logger.warning('found no TicTacCode channel')
+        else:
+            logger.debug('been here before, TTC chan is %i'%
+                                                self.TicTacCode_channel)
+            start_idx = round(time_where*self.get_samplerate())
+            extract_length = round(chunk_length*self.get_samplerate())
+            end_idx = start_idx + extract_length
+            chan_dat = self.audio_data[self.TicTacCode_channel]
+            extract_audio_data = chan_dat[start_idx:end_idx]
             decoder.set_sound_extract_and_sr(
-                    chan_dat,
+                    extract_audio_data,
                     self.get_samplerate(),
                     sound_extract_position
                     )
-            if decoder.extract_seems_YaLTC():
-                self.YaLTC_channel = i_chan
-                logger.debug('find YaLTC channel, chan #%i'%
-                                self.YaLTC_channel)
-                return self
-        # end of loop: none found
-        self.YaLTC_channel = None
-        logger.warning('found no YaLTC channel')
         return self
     
-    def seems_to_have_YaLTC_at_beginning(self):
-        if self.probe is None:
-            return False
-        self._read_sound_find_YaLTC(TRIAL_TIMES[0][0], SOUND_EXTRACT_LENGTH)
-        return self.YaLTC_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()
@@ -1747,24 +1596,3 @@ class Recording:
             )
         return clip
 
-import argparse
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument("mediafile", nargs="?", help="path of media file with YaLTC")
-    parser.add_argument('-v', action='store_true')
-    args = parser.parse_args()
-    if not args.v:
-        logger.remove()
-    fn = args.mediafile
-    a_recording = Recording(fn)
-    start_time = a_recording.get_start_time()
-    if start_time is not None:
-        print('%s started at %s'%(fn, start_time))
-    else:
-        print("can't find start time for %s"%fn)
-
-
-
-
-