tictacsync 0.3a3__py3-none-any.whl → 0.4a0__py3-none-any.whl

tictacsync/yaltc.py

@@ -71,11 +71,11 @@ BPF_LOW_FRQ, BPF_HIGH_FRQ = (0.5*F1, 2*F2)
 # utility for accessing pathnames
 def _pathname(tempfile_or_path):
     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,
@@ -90,7 +90,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("-")
@@ -243,7 +243,7 @@ class Decoder:
         #     return self.detected_pulse_position
         if self.estimated_pulse_position:
             logger.debug('returning cached estimated value')
-            return self.estimated_pulse_position
+            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*(
@@ -394,8 +394,9 @@ class Decoder:
             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)
+            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')
@@ -419,7 +420,7 @@ class Decoder:
             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 ###################################################
             return model - signal_data
         fit_trig = lmfit.minimize(
                             trig_wave, trig_params,
@@ -430,7 +431,8 @@ class Decoder:
         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['sound_extract_position'] = \
+                                                self.sound_extract_position
         self.cached_convolution_fit['chi_square'] = chi_square
         self.cached_convolution_fit['minimum position'] = min_position
 
@@ -465,8 +467,9 @@ class Decoder:
 
         """
         if self.silent_zone_indices:
-            return self.silent_zone_indices
-        _, silence_center_position = self._fit_triangular_signal_to_convoluted_env()
+            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
@@ -711,7 +714,7 @@ class Decoder:
         boundaries_OK, left_boundary, right_boundary = \
                 self._get_BFSK_word_boundaries()
         if left_boundary is None:
-            return None, None, None
+            return None, None, None ############################################
         symbol_width_samples = \
                 float(right_boundary - left_boundary)/N_SYMBOLS_SAMD21
         symbol_positions = symbol_width_samples * \
@@ -911,7 +914,7 @@ class Decoder:
 
     def get_time_in_sound_extract(self, plots):
         if self.sound_extract is None:
-            return None
+            return None ########################################################
         if plots:
             self.make_silence_analysis_plot()
         pulse_position = self._detect_sync_pulse_position()
@@ -928,7 +931,7 @@ class Decoder:
             self._plot_slices(pulse_position, symbols_indices, word_lft,
                                 word_rght, title)
         if symbols_indices is None:
-            return None
+            return None ########################################################
         sliced_data = self._slice_sound_extract(symbols_indices)
         frequencies = [self._get_main_frequency(data_slice)
                             for data_slice
@@ -950,7 +953,7 @@ class Decoder:
                                 symbols_indices[i],
                                 symbols_indices[i+1]))
         if None in bits:
-            return None
+            return None ########################################################
         bits_string = ''.join(bits)
         logger.debug('bits = %s'%bits_string)
         time_values = self._values_from_bits(bits_string)
@@ -1011,25 +1014,26 @@ class Recording:
             implicitly True for each video recordings (but not set)
 
         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
+            AudioStitcherVideoMerger 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()
 
         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 AudioStitcherVideoMerger
+            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
+            video recording, relative to the working directory
             
         synced_audio : pathlib.Path
             contains the path of audio only of self.final_synced_file. Absolute
@@ -1168,10 +1172,10 @@ class Recording:
         if self.valid_sound:
             val = sox.file_info.duration(_pathname(self.valid_sound))
             logger.debug('duration of valid_sound %f'%val)
-            return val
+            return val #########################################################
         else:
             if self.probe is None:
-                return 0
+                return 0 #######################################################
             try:
                 probed_duration = float(self.probe['format']['duration'])
             except:
@@ -1292,7 +1296,7 @@ class Recording:
 
         """
         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)
@@ -1334,19 +1338,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 AudioStitcherVideoMerger
+        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):
         """
@@ -1366,14 +1370,14 @@ class Recording:
         If successful AND self is audio, sets self.valid_sound
         """
         if self.start_time is not None:
-            return self.start_time
+            return self.start_time #############################################
         cached_times = {}
         def find_time(t_sec, plots=False):
             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)
@@ -1391,7 +1395,7 @@ class Recording:
             # time_around_beginning = self._find_time_around(near_beg)
             time_around_beginning = find_time(near_beg, plots)
             if self.TicTacCode_channel is None:
-                return 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)
@@ -1407,11 +1411,11 @@ class Recording:
                 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)
@@ -1428,132 +1432,134 @@ class Recording:
         self.start_time = start_UTC
         self.sync_position = time_around_beginning['pulse at']
         if self.is_audio():
-            self.valid_sound = self._strip_TTC_and_Null()
+            # self.valid_sound = self._strip_TTC_and_Null() # why now? :-)
+            self.valid_sound = self.AVpath
         return start_UTC
 
-    def _strip_TTC_and_Null(self) -> tempfile.NamedTemporaryFile:
-        """        
-        TTC is stripped from original audio and a tempfile.NamedTemporaryFile is
-        returned. If the original audio is stereo, this is simply the audio
-        without the TicTacCode channel, so this fct returns a mono wav
-        tempfile. But if the original audio is multitrack, two possibilities:
-
-            A- there's a track.txt file declaring null channels (with '0' tags)
-            then those tracks are excluded too (a check is done those tracks
-            have low signal and warns the user otherwise) 
-
-            B- it's a multitrack recording but without track declaration
-            (no track.txt was found in the device folder): all the tracks are
-            returned into a multiwav tempfile (except TTC).
-
-        Notes:
-            'track.txt' is defined in device_scanner.TRACKSFN 
-
-            Beware of track indexing: sox starts indexing tracks at 1 but code
-            here uses zero based indexing.
-        """
-        tracks_file = self.device.folder/device_scanner.TRACKSFN
-        input_file = _pathname(self.AVpath)
-        # n_channels = sox.file_info.channels(input_file) # eg 2
-        n_channels = self.device.n_chan
-        sox_TicTacCode_channel = self.TicTacCode_channel + 1 # sox channels start at 1
-        if n_channels == 2:
-            logger.debug('stereo, so only excluding TTC (ZB idx) %i'%
-                    self.TicTacCode_channel)
-            return self._sox_strip(input_file, [self.TicTacCode_channel])
-        # First a check is done if the ttc tracks concur: the track detected
-        # by the Decoder class, stored in Recording.TicTacCode_channel VS the
-        # track declared by the user, Tracks.ttc (see device_scanner.py). If
-        # not, warn the user and exit.
-        trax = self.device.tracks # a Tracks dataclass instance, if any
-        logger.debug('trax %s'%trax)
-        if trax == None: #TO DO: mix or mixL, mixR or do mixdown
-            return self._sox_strip(input_file, [self.TicTacCode_channel])
-        else:
-            logger.debug('ttc channel declared for the device: %i, ttc detected: %i, non zero base indexing'%
-                        (trax.ttc, sox_TicTacCode_channel))
-        if trax.ttc != sox_TicTacCode_channel: # warn and quit
-            print('Error: TicTacCode channel detected is [gold1]%i[/gold1]'%
-                sox_TicTacCode_channel, end=' ')
-            print('and the file [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
-                (tracks_file, trax.ttc))
-            print('Please correct the discrepancy and rerun. Quitting.')
-            sys.exit(1)
-        track_is_declared_audio = [ tag not in ['ttc','0','tc']
-                                    for tag in trax.rawtrx]
-        logger.debug('from tracks_file %s'%tracks_file)
-        logger.debug('track_is_declared_audio (not ttc or 0): %s'%
-                                                track_is_declared_audio)
-        # Now find out which files are silent, ie those with sox stats "RMS lev
-        # db" value inferior to DB_RMS_SILENCE_SOX (typ -50 -60 dbFS) from the
-        # sox "stat" command. Ex output belwow:
-        #
-        # sox input.wav -n channels stats -w 0.01
-        #
-        #              Overall     Ch1       Ch2       Ch3       Ch4  
-        # DC offset  -0.000047 -0.000047 -0.000047 -0.000016 -0.000031
-        # Min level  -0.060913 -0.060913 -0.048523 -0.036438 -0.002777
-        # Max level   0.050201  0.050201  0.048767  0.039032  0.002838
-        # Pk lev dB     -24.31    -24.31    -26.24    -28.17    -50.94
-        # RMS lev dB    -40.33    -55.29    -53.70    -34.41    -59.75 <- this line
-        # RMS Pk dB     -28.39    -28.39    -30.90    -31.20    -55.79
-        # RMS Tr dB     -97.42    -79.66    -75.87    -97.42    -96.09
-        # Crest factor       -     35.41     23.61      2.05      2.76
-        # Flat factor     6.93      0.00      0.00      0.97     10.63
-        # Pk count        10.2         2         2        17        20
-        # Bit-depth      12/16     12/16     12/16     12/16      8/16
-        # Num samples    11.2M
-        # Length s     232.780
-        # Scale max   1.000000
-        # Window s       0.010
-        args = ['sox', input_file, '-n', 'channels', 'stats', '-w', '0.01']
-        _, _, stat_output = sox.core.sox(args)
-        logger.debug('sox stat output: \n%s'%stat_output)
-        sox_RMS_lev_dB = stat_output.split('\n')[5].split()[4:]
-        logger.debug('Rec %s'%self)
-        logger.debug('Sox RMS %s, n_channels: %i'%(sox_RMS_lev_dB, n_channels))
-        # valid audio is non silent and not ttc
-        track_is_active = [float(db) > DB_RMS_SILENCE_SOX
-            if idx + 1 != sox_TicTacCode_channel else False
-            for idx, db in enumerate(sox_RMS_lev_dB)]
-        logger.debug('track_is_active %s'%track_is_active)
-        # Stored in self.device.tracks and as declared by the user, a track is
-        # either:
-        #
-        # - an active track (because a name was given to it)
-        # - the ttc track (as identified by the user)
-        # - a muted track (declared by a "0" in tracks.txt)
-        #
-        # the following checks active tracks are effectively non silent and
-        # muted tracks are effectively silent (warn the user if not but
-        # proceed, giving priority to status declared in the tracks.txt file.
-        # eg a non silent track will be discarded if the user tagged it with
-        # a "0")
-        declared_and_detected_are_same = all([a==b for a,b
-            in zip(track_is_declared_audio, track_is_active)])
-        logger.debug('declared_and_detected_are_same: %s'%
-                                declared_and_detected_are_same)
-        if not declared_and_detected_are_same:
-            print('Warning, the file [gold1]%s[/gold1] specifies channel usage'%
-                (tracks_file))
-            print('and some muted tracks are not silent (or the inverse, see below),')
-            print('will proceed but if it\'s an error do necessary corrections and rerun.\n')
-            table = Table(title="Tracks status")
-            table.add_column("track #", justify="center", style='gold1')
-            table.add_column("RMS Level", justify="center", style='gold1')
-            table.add_column("Declared", justify="center", style='gold1')
-            for n in range(n_channels):
-                table.add_row(str(n+1), '%.0f dBFS'%float(sox_RMS_lev_dB[n]),
-                    trax.rawtrx[n])
-            console = Console()
-            console.print(table)
-        if trax:
-            excluded_channels = [i for i in range(n_channels)
-                if not track_is_declared_audio[i]]
-        else:
-            excluded_channels = [self.TicTacCode_channel]
-        logger.debug('excluded_channels %s (ZB idx)'%excluded_channels)
-        return self._sox_strip(input_file, excluded_channels)
+    # def _strip_TTC_and_Null(self) -> tempfile.NamedTemporaryFile:
+    #     """        
+    #     TTC is stripped from original audio and a tempfile.NamedTemporaryFile is
+    #     returned. If the original audio is stereo, this is simply the audio
+    #     without the TicTacCode channel, so this fct returns a mono wav
+    #     tempfile. But if the original audio is multitrack, two possibilities:
+
+    #         A- there's a track.txt file declaring null channels (with '0' tags)
+    #         then those tracks are excluded too (a check is done those tracks
+    #         have low signal and warns the user otherwise) 
+
+    #         B- it's a multitrack recording but without track declaration
+    #         (no track.txt was found in the device folder): all the tracks are
+    #         returned into a multiwav tempfile (except TTC).
+
+    #     Notes:
+    #         'track.txt' is defined in device_scanner.TRACKSFN 
+
+    #         Beware of track indexing: sox starts indexing tracks at 1 but code
+    #         here uses zero based indexing.
+    #     """
+    #     tracks_file = self.device.folder/device_scanner.TRACKSFN
+    #     input_file = _pathname(self.AVpath)
+    #     # n_channels = sox.file_info.channels(input_file) # eg 2
+    #     n_channels = self.device.n_chan
+    #     sox_TicTacCode_channel = self.TicTacCode_channel + 1 # sox start at 1
+    #     if n_channels == 2:
+    #         logger.debug('stereo, so only excluding TTC (ZB idx) %i'%
+    #                 self.TicTacCode_channel)
+    #         return self._sox_strip(input_file, [self.TicTacCode_channel]) ######
+    #     #
+    #     # First a check is done if the ttc tracks concur: the track detected
+    #     # by the Decoder class, stored in Recording.TicTacCode_channel VS the
+    #     # track declared by the user, Tracks.ttc (see device_scanner.py). If
+    #     # not, warn the user and exit.
+    #     trax = self.device.tracks # a Tracks dataclass instance, if any
+    #     logger.debug('trax %s'%trax)
+    #     if trax == None:
+    #         return self._sox_strip(input_file, [self.TicTacCode_channel]) ######
+    #     else:
+    #         logger.debug('ttc channel declared for the device: %i, ttc detected: %i, non zero base indexing'%
+    #                     (trax.ttc, sox_TicTacCode_channel))
+    #     if trax.ttc != sox_TicTacCode_channel: # warn and quit
+    #         print('Error: TicTacCode channel detected is [gold1]%i[/gold1]'%
+    #             sox_TicTacCode_channel, end=' ')
+    #         print('and the file [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
+    #             (tracks_file, trax.ttc))
+    #         print('Please correct the discrepancy and rerun. Quitting.')
+    #         sys.exit(1)
+    #     track_is_declared_audio = [ tag not in ['ttc','0','tc']
+    #                                 for tag in trax.rawtrx]
+    #     logger.debug('from tracks_file %s'%tracks_file)
+    #     logger.debug('track_is_declared_audio (not ttc or 0): %s'%
+    #                                             track_is_declared_audio)
+    #     # Now find out which files are silent, ie those with sox stats "RMS lev
+    #     # db" value inferior to DB_RMS_SILENCE_SOX (typ -50 -60 dbFS) from the
+    #     # sox "stat" command. Ex output belwow:
+    #     #
+    #     # sox input.wav -n channels stats -w 0.01
+    #     #
+    #     #              Overall     Ch1       Ch2       Ch3       Ch4  
+    #     # DC offset  -0.000047 -0.000047 -0.000047 -0.000016 -0.000031
+    #     # Min level  -0.060913 -0.060913 -0.048523 -0.036438 -0.002777
+    #     # Max level   0.050201  0.050201  0.048767  0.039032  0.002838
+    #     # Pk lev dB     -24.31    -24.31    -26.24    -28.17    -50.94
+    #     # RMS lev dB    -40.33    -55.29    -53.70    -34.41    -59.75 <- this line
+    #     # RMS Pk dB     -28.39    -28.39    -30.90    -31.20    -55.79
+    #     # RMS Tr dB     -97.42    -79.66    -75.87    -97.42    -96.09
+    #     # Crest factor       -     35.41     23.61      2.05      2.76
+    #     # Flat factor     6.93      0.00      0.00      0.97     10.63
+    #     # Pk count        10.2         2         2        17        20
+    #     # Bit-depth      12/16     12/16     12/16     12/16      8/16
+    #     # Num samples    11.2M
+    #     # Length s     232.780
+    #     # Scale max   1.000000
+    #     # Window s       0.010
+    #     args = ['sox', input_file, '-n', 'channels', 'stats', '-w', '0.01']
+    #     _, _, stat_output = sox.core.sox(args)
+    #     logger.debug('sox stat output: \n%s'%stat_output)
+    #     sox_RMS_lev_dB = stat_output.split('\n')[5].split()[4:]
+    #     logger.debug('Rec %s'%self)
+    #     logger.debug('Sox RMS %s, n_channels: %i'%(sox_RMS_lev_dB, n_channels))
+    #     # valid audio is non silent and not ttc
+    #     track_is_active = [float(db) > DB_RMS_SILENCE_SOX
+    #         if idx + 1 != sox_TicTacCode_channel else False
+    #         for idx, db in enumerate(sox_RMS_lev_dB)]
+    #     logger.debug('track_is_active %s'%track_is_active)
+    #     # Stored in self.device.tracks and as declared by the user, a track is
+    #     # either:
+    #     #
+    #     # - an active track (because a name was given to it)
+    #     # - the ttc track (as identified by the user)
+    #     # - a muted track (declared by a "0" in tracks.txt)
+    #     #
+    #     # the following checks active tracks are effectively non silent and
+    #     # muted tracks are effectively silent (warn the user if not but
+    #     # proceed, giving priority to status declared in the tracks.txt file.
+    #     # eg a non silent track will be discarded if the user tagged it with
+    #     # a "0")
+    #     declared_and_detected_are_same = all([a==b for a,b
+    #         in zip(track_is_declared_audio, track_is_active)])
+    #     logger.debug('declared_and_detected_are_same: %s'%
+    #                             declared_and_detected_are_same)
+    #     if not declared_and_detected_are_same:
+    #         print('Warning, the file [gold1]%s[/gold1] specifies channel usage'%
+    #             (tracks_file))
+    #         print('and some muted tracks are not silent (or the inverse, see below),')
+    #         print('will proceed but if it\'s an error do necessary corrections and rerun.\n')
+    #         table = Table(title="Tracks status")
+    #         table.add_column("track #", justify="center", style='gold1')
+    #         table.add_column("RMS Level", justify="center", style='gold1')
+    #         table.add_column("Declared", justify="center", style='gold1')
+    #         for n in range(n_channels):
+    #             table.add_row(str(n+1), '%.0f dBFS'%float(sox_RMS_lev_dB[n]),
+    #                 trax.rawtrx[n])
+    #         console = Console()
+    #         console.print(table)
+    #     if trax:
+    #         excluded_channels = [i for i in range(n_channels)
+    #             if not track_is_declared_audio[i]]
+    #     else:
+    #         excluded_channels = [self.TicTacCode_channel]
+    #     logger.debug('excluded_channels %s (ZB idx)'%excluded_channels)
+    #     return self._sox_strip(input_file, excluded_channels)
 
 
 
@@ -1631,13 +1637,13 @@ class Recording:
             ppm = - (nominal/true - 1) * 1e6
         return int(ppm)
 
-    def get_speed_ratio(self, ref_recording):
+    def get_speed_ratio(self, 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):
@@ -1688,20 +1694,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
@@ -1742,7 +1748,7 @@ class Recording:
         # decoder.cached_convolution_fit['is clean'] = False
         if not self.has_audio():
             self.TicTacCode_channel = None
-            return
+            return #############################################################
         logger.debug('will read around %.2f sec'%time_where)
         dryrun = (ffmpeg
             .input(str(path), ss=time_where, t=chunk_length)
@@ -1775,9 +1781,10 @@ class Recording:
                     )
             if decoder.extract_seems_TicTacCode():
                 self.TicTacCode_channel = i_chan
+                self.device.ttc = i_chan
                 logger.debug('find TicTacCode channel, chan #%i'%
                                 self.TicTacCode_channel)
-                return self
+                return self ####################################################
         # end of loop: none found
         self.TicTacCode_channel = None
         logger.warning('found no TicTacCode channel')
@@ -1785,8 +1792,9 @@ class Recording:
     
     def seems_to_have_TicTacCode_at_beginning(self):
         if self.probe is None:
-            return False
-        self._read_sound_find_TicTacCode(TRIAL_TIMES[0][0], SOUND_EXTRACT_LENGTH)
+            return False #######################################################
+        self._read_sound_find_TicTacCode(TRIAL_TIMES[0][0],
+            SOUND_EXTRACT_LENGTH)
         return self.TicTacCode_channel is not None
 
     def does_overlap_with_time(self, time):

{tictacsync-0.3a3.dist-info → tictacsync-0.4a0.dist-info}/METADATA

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

tictacsync-0.4a0.dist-info/RECORD

@@ -0,0 +1,15 @@
+tictacsync/LTCcheck.py,sha256=IEfpB_ZajWuRTWtqji0H-B2g7GQvWmGVjfT0Icumv7o,15704
+tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tictacsync/device_scanner.py,sha256=JmjwMFr6Jy6Jnl5sAycUSEXezF3ETLyF3TEXjn_orKs,27339
+tictacsync/entry.py,sha256=oSDfa01wToQy6wyEw_IA1WeD7mFXTKbXmB4M3QD-ir4,11386
+tictacsync/multi2polywav.py,sha256=Zl5EP2Yf-PKiZ8ewRSwqWsDULvKKjeWANK_-Yd5RAg4,7279
+tictacsync/remergemix.py,sha256=BUtZ8YHw5Oz8VseTD-A4imNbtF7h391pw5yyl6v6OG4,4885
+tictacsync/synciso.py,sha256=XmUcdUF9rl4VdCm7XW4PeYWYWM0vgAY9dC2hapoul9g,4821
+tictacsync/timeline.py,sha256=HlCTnS48Z54t8DyplDLIKL2_uD952xulkTlDklzxGeM,56225
+tictacsync/yaltc.py,sha256=n7ubnlcFDzCpvhZNIwMZMfijZq-ROEA-hS0dbcZgPtE,78490
+tictacsync-0.4a0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
+tictacsync-0.4a0.dist-info/METADATA,sha256=3Ui70mGVLMKKO2hI32WUGXng-ZziDOiREYi8Qnt7jZU,5298
+tictacsync-0.4a0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+tictacsync-0.4a0.dist-info/entry_points.txt,sha256=g3tdFFrVRcrKpuyKOCLUVBMgYfV65q9kpLZUOD_XCKg,139
+tictacsync-0.4a0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
+tictacsync-0.4a0.dist-info/RECORD,,

tictacsync-0.3a3.dist-info/RECORD

@@ -1,15 +0,0 @@
-tictacsync/LTCcheck.py,sha256=IEfpB_ZajWuRTWtqji0H-B2g7GQvWmGVjfT0Icumv7o,15704
-tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tictacsync/device_scanner.py,sha256=-m2gd0XWXyJLNWfpLc_XQbMwFfNLJ4y3AmI4abz85W4,27558
-tictacsync/entry.py,sha256=zyF8alGtJ57fmKm-_w1eCZber-T9VmeuKFL6yRyRofM,11385
-tictacsync/multi2polywav.py,sha256=Zl5EP2Yf-PKiZ8ewRSwqWsDULvKKjeWANK_-Yd5RAg4,7279
-tictacsync/remergemix.py,sha256=BUtZ8YHw5Oz8VseTD-A4imNbtF7h391pw5yyl6v6OG4,4885
-tictacsync/synciso.py,sha256=XmUcdUF9rl4VdCm7XW4PeYWYWM0vgAY9dC2hapoul9g,4821
-tictacsync/timeline.py,sha256=Qy37vFmFsGDSVpEio3ts_TmGeD96868qfioIevhp92U,45925
-tictacsync/yaltc.py,sha256=eGCDzp5aTF4zqFN4wNfiESXRnaHEXtQB-u13gYBf8g8,76810
-tictacsync-0.3a3.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
-tictacsync-0.3a3.dist-info/METADATA,sha256=RLwLKCbmVfO1A1dBZL-wdF9I4nHk2km0c5j05N9mTIY,5298
-tictacsync-0.3a3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tictacsync-0.3a3.dist-info/entry_points.txt,sha256=g3tdFFrVRcrKpuyKOCLUVBMgYfV65q9kpLZUOD_XCKg,139
-tictacsync-0.3a3.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
-tictacsync-0.3a3.dist-info/RECORD,,