tictacsync 1.4.0b0__py3-none-any.whl → 1.4.5b0__py3-none-any.whl

tictacsync/device_scanner.py

@@ -159,7 +159,7 @@ def get_device_ffprobe_UID(file):
     except ffmpeg.Error as e:
         print('ffmpeg.probe error')
         print(e.stderr, file)
-        return None, None #-----------------------------------------------------
+        return None, None, None #-----------------------------------------------------
         # fall back to folder name
     logger.debug('ffprobe %s'%probe)
     streams = probe['streams']
@@ -271,7 +271,7 @@ class Scanner:
             with open(p, 'r') as fh:
                 done = set(fh.read().split()) # sets of strings of abs path
             logger.debug(f'done clips: {pformat(done)}')
-        files = Path(self.top_directory).rglob('*')
+        files = [p for p in Path(self.top_directory).rglob('*') if not p.name[0] == '.']
         clip_paths = []
         some_done = False
         for raw_path in files:

tictacsync/entry.py

@@ -117,21 +117,10 @@ def main():
                 nargs=1,
                 help="directory_name or media_file"
                 )
-    # parser.add_argument("directory", nargs="?", help="path of media directory")
-    # parser.add_argument('-v', action='store_true')
     parser.add_argument('-v',
                         action='store_true',  #ie default False
                         dest='verbose_output',
                         help='Set verbose ouput')
-    # parser.add_argument('--stop_mirroring',
-    #                     action='store_true',  #ie default False
-    #                     dest='stop_mirroring',
-    #                     help='Stop mirroring mode, will write synced files alongside originals.')
-    # parser.add_argument('--start-project', '-s' ,
-    #                 nargs=2,
-    #                 dest='proj_folders',
-    #                 default = [],
-    #                 help='start mirrored tree output mode and specifies 2 folders: source (RAW) and destination (synced).')
     parser.add_argument('-t','--timelineoffset',
                     nargs=1,
                     default=['00:00:00:00'],
@@ -145,10 +134,6 @@ def main():
                     action='store_true',
                     dest='dont_write_cam_folder',
                     help="Even if originals are inside CAM folders, don't put synced clips inside a CAM identified folder")
-    # parser.add_argument('-m',
-    #                 action='store_true',
-    #                 dest='multicam',
-    #                 help='Outputs multicam structure for NLE program (based on Davinci Resolve input processing)')
     parser.add_argument('--isos',
                     action='store_true',
                     dest='write_ISOs',
@@ -308,15 +293,7 @@ def main():
     if asked_ISOs and scanner.input_structure != 'ordered':
         print('Warning, can\'t write ISOs without structured folders: [gold1]--isos[/gold1] option ignored.\n')
         asked_ISOs = False
-    # output_dir = args.o
-    # if args.verbose_output or args.terse: # verbose, so no progress bars
-    print('Merging...')
-    # for merger in matcher.mergers:
-    #     merger.build_audio_and_write_merged_media(top_dir,
-    #     args.dont_write_cam_folder,
-    #     asked_ISOs,
-    #     audio_REC_only)
-    for merger in matcher.mergers:
+    for merger in track(matcher.mergers, description='Merging audio with video...'):
         if audio_REC_only:
             # rare
             merger._build_and_write_audio(top_dir)

tictacsync/mamsync.py

@@ -45,7 +45,7 @@ amr ape au awb dss dvf flac gsm iklax ivs m4a m4b m4p mmf mp3 mpc msv nmf
 ogg oga mogg opus ra rm raw rf64 sln tta voc vox wav wma wv webm 8svx cda""".split()
 
 logger.remove()
-logger.level("DEBUG", color="<yellow>")
+# logger.level("DEBUG", color="<yellow>")
 # logger.add(sys.stdout, level="DEBUG")
 # logger.add(sys.stdout, filter=lambda r: r["function"] == "__init__" and r["module"] == "yaltc")
 # logger.add(sys.stdout, filter=lambda r: r["function"] == "_fit_length")
@@ -85,24 +85,6 @@ def copy_to_syncedroot(raw_root, synced_root):
                 logger.debug('same content, next')
                 continue # next raw_path in loop
 
-# logger.add(sys.stdout, filter=lambda r: r["function"] == "clean_synced")
-# def clean_synced(raw_root, synced_root):
-#     # removes <>v<capitalLetter>.mov if any
-#     # returns a list of deleted pathlib.Path
-#     project = Path(raw_root).name
-#     logger.debug(f'project {project}')
-#     synced_proj = Path(synced_root)/project
-#     if not synced_proj.exists():
-#         synced_proj.mkdir()
-#     deleted = []
-#     for raw_path in Path(synced_proj).rglob('*'):
-#         m = re.match(r'.*(v[A-Z])\..+', raw_path.name)
-#         if m != None:
-#             logger.debug(f'cleaning {raw_path}')
-#             raw_path.unlink()
-#             deleted.append(raw_path)
-#     return deleted
-
 def copy_raw_root_tree_to_sndroot(raw_root, snd_root):
     # args are str
     # copy only tree structure, no files

tictacsync/multi2polywav.py

@@ -29,8 +29,10 @@ def print_grby(grby):
             print(' ', e)
 
 def wav_recursive_scan(top_directory):
-    files_lower_case = Path(top_directory).rglob('*.wav') 
+    files_lower_case = Path(top_directory).rglob('*.wav')
+    files_lower_case = [p for p in files_lower_case if p.name[0] != '.']
     files_upper_case = Path(top_directory).rglob('*.WAV')
+    files_upper_case = [p for p in files_upper_case if p.name[0] != '.']
     files = set(list(files_lower_case) + list(files_upper_case))
     paths = [
         p

{tictacsync-1.4.0b0.dist-info → tictacsync-1.4.5b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 1.4.0b0
+Version: 1.4.5b0
 Summary: commands for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz
@@ -26,6 +26,7 @@ Requires-Dist: loguru >=0.6.0
 Requires-Dist: matplotlib >=3.7.1
 Requires-Dist: numpy >=1.24.3
 Requires-Dist: rich >=10.12.0
+Requires-Dist: lmfit
 Requires-Dist: scikit-image
 Requires-Dist: scipy >=1.10.1
 Requires-Dist: platformdirs

tictacsync-1.4.5b0.dist-info/RECORD

@@ -0,0 +1,16 @@
+tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tictacsync/device_scanner.py,sha256=lYCMWSCeI0KNQclrRMOzeIERh2ME2gvBxV-q9Y2uou0,26175
+tictacsync/entry.py,sha256=JmOx7B6d4LnGLWGuuMFpKV9GxkWhmAG4fdKayI7qzUA,15024
+tictacsync/mamconf.py,sha256=nfXTwabx-tJmBcpnDR4CRkFe9W4fudzfnbq_nHUg0qE,6424
+tictacsync/mamdav.py,sha256=2we8tfIbJBtDMQdpZZVlCQ9hCQRMbKmV2aU3dDEUf2k,27457
+tictacsync/mamreap.py,sha256=ej7Ap8nbVBCkfah2j5hrE7QBWuqL6Zm-OEsQpNK8mYg,21085
+tictacsync/mamsync.py,sha256=orwP-TzKdRTiTCoiM7BsQgVK1KtAIs3SpKe9K8ZWM_Q,13872
+tictacsync/multi2polywav.py,sha256=OX72eDtanaax-lGc6JJXwOz9MaveNcYlgBfBijzR8oA,7583
+tictacsync/timeline.py,sha256=ykmB8EfnprQZoEHXRYzriASNWZ7bHfkmQ2-TR6gxZ6Y,75985
+tictacsync/yaltc.py,sha256=xrgL7qokP1A7B_VF4W_BZcC7q9APSmYpmtWH8_t3VWc,68003
+tictacsync-1.4.5b0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
+tictacsync-1.4.5b0.dist-info/METADATA,sha256=isx8DzvfowkLJgEPTX6y7Q3xyqEvH2Rt2yRHPgHvMVM,5689
+tictacsync-1.4.5b0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+tictacsync-1.4.5b0.dist-info/entry_points.txt,sha256=0R8K6T0iUJGj87LDZ0vNO8pToshbkxrXZqTRgcjBlMk,244
+tictacsync-1.4.5b0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
+tictacsync-1.4.5b0.dist-info/RECORD,,

{tictacsync-1.4.0b0.dist-info → tictacsync-1.4.5b0.dist-info}/entry_points.txt

@@ -1,7 +1,7 @@
 [console_scripts]
 mamconf = tictacsync.mamconf:main
-mamdav = mamdav:main
-mamreap = mamreap:main
+mamdav = tictacsync.mamdav:called_from_cli
+mamreap = tictacsync.mamreap:main
 mamsync = tictacsync.mamsync:main
 multi2polywav = tictacsync.multi2polywav:main
 tictacsync = tictacsync.entry:main

tictacsync/LTCcheck.py

@@ -1,394 +0,0 @@
-print('Loading modules')
-import subprocess, io
-import argparse, os, sys, ffmpeg
-from loguru import logger
-from pathlib import Path
-from scipy.io import wavfile
-import numpy as np
-import matplotlib.pyplot as plt
-from rich.progress import track, Progress
-from pprint import pprint
-from collections import deque
-import wave
-try:
-    from . import yaltc
-except:
-    import yaltc
-try:
-    from . import device_scanner
-except:
-    import device_scanner
-
-# LEVELMODE = 'over_noise_silence'
-LEVELMODE = 'mean_silence_AFSK'
-
-OFFSET_NXT_PULSE = 50 # samples
-LENGTH_EXTRACT = int(14e-3 * 96000) # samples max freq
-
-logger.level("DEBUG", color="<yellow>")
-logger.remove()
-# logger.add(sys.stdout, filter="tictacsync.LTCcheck")
-# logger.add(sys.stdout, filter="tictacsync.yaltc")
-
-def ppm(a,b):
-    return 1e6*(max(a,b)/min(a,b)-1)
-
-class TCframe:
-    def __init__(self, string, max_FF):
-        # string is 'HH:MM:SS:FF' or ;|,|.
-        # max_FF is int for max frame number (hence fps-1)
-        string = string.replace('.',':').replace(';',':').replace(',',':')
-        ints = [int(e) for e in string.split(':')]
-        self.HH = ints[0]
-        self.MM = ints[1]
-        self.SS = ints[2]
-        self.FF = ints[3]
-        self.MAXFF = max_FF
-
-    def __repr__(self):
-        # return '%s-%s-%s-%s/%i'%(*self.ints(), self.MAXFF)
-        return '%02i-%02i-%02i-%02i'%self.ints()
-
-    def ints(self):
-        return (self.HH,self.MM,self.SS,self.FF)
-
-    def __eq__(self, other):
-        a,b,c,d = self.ints()
-        h,m,s,f = other.ints()
-        return a==h and b==m and c==s and d==f
-
-    def __sub__(self, tcf2):
-        # H1, M1, S1, F1 = self.ints()
-        # H2, M2, S2, F2 = tcf2.ints()
-        f1 = np.array(self.ints())
-        f2 = np.array(tcf2.ints())
-        HR, MR, SR, FR = f1 - f2
-        if FR < 0:
-            FR += self.MAXFF + 1
-            SR -= 1 # borrow
-        if SR < 0:
-            SR += 60
-            MR -= 1 # borrow
-        if MR < 0:
-            MR += 60
-            HR -= 1 # borrow
-        if HR < 0:
-            HR += 24 # underflow?
-        # logger.debug('%s %s'%(self.ints(), tcf2.ints()))
-        return TCframe('%02i:%02i:%02i:%02i'%(HR,MR,SR,FR), self.MAXFF)
-
-def read_whole_audio_data(path):
-    dryrun = (ffmpeg
-        .input(str(path))
-        .output('pipe:', format='s16le', acodec='pcm_s16le')
-        .get_args())
-    dryrun = ' '.join(dryrun)
-    logger.debug('using ffmpeg-python built args to pipe wav file into numpy array:\nffmpeg %s'%dryrun)
-    try:
-        out, _ = (ffmpeg
-            .input(str(path))
-            .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)
-    with wave.open(path, 'rb') as f:
-        samplerate = f.getframerate()
-        n_chan = f.getnchannels()
-    all_channels_data = data.reshape(int(len(data)/n_chan),n_chan).T
-    return all_channels_data   
-
-def find_nearest_fps(value):
-    array = np.asarray([24, 25, 30])
-    idx = (np.abs(array - value)).argmin()
-    return array[idx]
-
-def fps_rel_to_audio(frame_pos, samplerate):
-    _, first_frame_pos = frame_pos[0]
-    _, scnd_last_frame_pos = frame_pos[-2]
-    frame_duration = (scnd_last_frame_pos - first_frame_pos)/len(frame_pos[:-2]) # in audio samples
-    fps = float(samplerate) / frame_duration
-    return fps
-
-# def HHMMSSFF_from_line(line):
-#   line = line.replace('.',':')
-#   line = line.replace(';',':')
-#   ll = line.split()[1].split(':')
-#   return [int(e) for e in ll]
-
-def check_continuity_and_DF(LTC_frames_and_pos):
-    errors = []
-    DF_flag = False
-    oneframe = TCframe('00:00:00:01',None)
-    threeframes = TCframe('00:00:00:03',None)
-    last_two_TC = deque([], maxlen=2)
-    last_two_TC.append(LTC_frames_and_pos[0][0])
-    last_two_TC.append(LTC_frames_and_pos[1][0])
-    for frame, pos in track(LTC_frames_and_pos[2:],
-            description="Checking each frame increment"):
-        last_two_TC.append(frame)
-        past, now = last_two_TC
-        diff = now - past
-        if diff not in [oneframe, threeframes]:
-            errors.append((frame, pos))
-            continue
-        if diff == oneframe:
-            continue
-        if diff == threeframes: 
-            # DF? check if it is 59:xx and minutes are not mult. of tens
-            if past.SS != 59 or now.MM%10 == 0: 
-                errors.append((frame, pos))
-            DF_flag = True
-    return errors, DF_flag
-
-def ltcdump_and_check(file, channel):
-    # returns list of anormal frames, a bool if TC is DF, fps and
-    # a list of tuples (frame => str, sample position in file => int) as
-    # determined by external util ltcdump https://github.com/x42/ltc-tools
-    process_list = ["ltcdump","-c %i"%channel, file]
-    logger.debug('process %s'%process_list)
-    proc = subprocess.Popen(process_list, stdout=subprocess.PIPE)
-    LTC_frames_and_pos = []
-    iter_io = io.TextIOWrapper(proc.stdout, encoding="utf-8")
-    next(iter_io) # ltcdump 1st line: User bits  Timecode   |    Pos. (samples)
-    print()
-    try:
-        next(iter_io) # ltcdump 2nd line: #DISCONTINUITY
-    except StopIteration:
-        print('ltcdump has no output, is channel #%i really LTC?'%channel)
-        quit()
-    old = 0
-    for line in track(iter_io,
-        description='       Parsing ltcdump output'):  # next ones
-        # print(line)
-        if line == '#DISCONTINUITY\n':
-            # print('#DISCONTINUITY!')
-            continue
-        user_bits, HHMMSSFF_str, _, start_sample, end_sample =\
-                line.split()
-        audio_position = int(end_sample)
-        # print(audio_position - old, end=' ')
-        # old = audio_position
-        # audio_position = int(start_sample)
-        tc = HHMMSSFF_str
-        LTC_frames_and_pos.append((tc, audio_position))
-    with wave.open(file, 'rb') as f:
-        samplerate = f.getframerate()
-    fps = fps_rel_to_audio(LTC_frames_and_pos, samplerate)
-    rounded_fps = round(fps)
-    LTC_frames_and_pos = [(TCframe(tc, rounded_fps-1), pos) for tc, pos in LTC_frames_and_pos]
-    errors, DF_flag = check_continuity_and_DF(LTC_frames_and_pos)
-    return errors, DF_flag, fps, LTC_frames_and_pos
-
-def find_pulses(TTC_data, recording):
-    samplerate = recording.true_samplerate
-    i_samplerate = round(samplerate)
-    pulse_position = recording.sync_position
-    logger.debug('first detected pulse %i'%pulse_position)
-    # first_pulse_nbr_of_seconds = int(pulse_position/samplerate)
-    # if first_pulse_nbr_of_seconds > 1:
-    #     pulse_position = pulse_position%i_samplerate # very first pulse in file
-    # print('0 %i'%pulse_position)
-    pulse_position = pulse_position%i_samplerate
-    logger.debug('starting at %i'%pulse_position)
-    second = 0
-    duration = int(recording.get_duration())
-    decoder = recording.decoder
-    pulse_detection_level = decoder._get_pulse_detection_level()
-    logger.debug(' detection level %f'%pulse_detection_level)
-    pulses = []
-    approx_next_pulse = pulse_position
-    skipped_printed = False
-    while second < duration - 1:
-        second += 1
-        approx_next_pulse -= OFFSET_NXT_PULSE
-        start_of_extract = approx_next_pulse
-        sound_extract = TTC_data[start_of_extract:start_of_extract + LENGTH_EXTRACT]
-        abs_signal = abs(sound_extract)
-        detected_point = \
-                np.argmax(abs_signal > pulse_detection_level)
-        old_pulse_position = pulse_position
-        pulse_position = detected_point + start_of_extract
-        diff = pulse_position - old_pulse_position
-        logger.debug('pulse_position %f old_pulse_position %f diff %f'%(pulse_position,
-                        old_pulse_position, diff))
-        if not np.isclose(diff, samplerate, rtol=1e-4):
-            if not skipped_printed:
-                print('\nSkipped: ', end='')
-                skipped_printed = True
-            print('%i, '%(pulse_position), end='')
-            # if diff < samplerate:
-            # else:
-                # print('skipped: samples %i and %i are too far'%(pulse_position, old_pulse_position))
-        else:          
-            pulses.append((second, pulse_position))
-        approx_next_pulse = pulse_position + i_samplerate
-    if skipped_printed:
-        print('\n')
-    return pulses
-
-def main():
-    print('in main()')
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-                "LTC_chan",
-                type=int,
-                # nargs=2,
-                help="LTC channel number"
-                )
-    parser.add_argument(
-                "file_argument",
-                type=str,
-                nargs=1,
-                help="media file"
-                )
-    args = parser.parse_args()
-    # print(args.channels)
-    LTC_chan = args.LTC_chan
-    file_argument = args.file_argument[0]
-    logger.info('args.file_argument: %s'%file_argument)
-    if os.path.isdir(file_argument):
-        print('argument shoud be a media file, not a directory. Bye...')
-        quit()
-    # print(file_argument)
-    if not os.path.exists(file_argument):
-        print('%s does not exist, bye'%file_argument)
-        quit()
-    errors, DF_flag, fps_rel_to_audio, LTC_frames_and_pos = ltcdump_and_check(file_argument, LTC_chan)
-    if errors:
-        print('errors! %s'%errors)
-        print('Some errors in those %i but detected FPS rel to audio is %0.3f%s'%(len(LTC_frames_and_pos),
-                                fps_rel_to_audio, 'DF' if DF_flag else 'NDF'))
-    else:
-        print('\nAll %i frames are sequential and detected FPS rel to audio is %0.3f%s\n'%(len(LTC_frames_and_pos),
-                                fps_rel_to_audio, 'DF' if DF_flag else 'NDF'))
-    # print('trying to decode TTC...')
-    with Progress(transient=True) as progress:
-        task = progress.add_task("trying to decode TTC...")
-        progress.start()
-        m = device_scanner.media_at_path(Path(file_argument))
-        logger.debug('media_at_path %s'%m)
-        recording = yaltc.Recording(m, )
-        logger.debug('Rec %s'%recording)
-        time = recording.get_start_time(progress=progress, task=task)
-    if time == None:
-        print('Start time couldnt be determined')
-    else:
-        audio_samplerate_gps_corrected = recording.true_samplerate
-        audio_error = audio_samplerate_gps_corrected/recording.get_samplerate()
-        gps_corrected_framerate = fps_rel_to_audio*audio_error  
-        print('gps_corrected_framerate',gps_corrected_framerate,audio_error)
-        frac_time = int(time.microsecond / 1e2)
-        d = '%s.%s'%(time.strftime("%Y-%m-%d %H:%M:%S"),frac_time)
-        base = os.path.basename(file_argument)
-        print('%s UTC:%s pulse: %i on chan %i'%(base, d,
-                    recording.sync_position,
-                    recording.TicTacCode_channel))
-        print('audio samplerate (gps)', audio_samplerate_gps_corrected)
-        all_channels_data = read_whole_audio_data(file_argument)
-        TTC_data = all_channels_data[recording.TicTacCode_channel]
-        sec_and_pulses = find_pulses(TTC_data, recording)
-        secs, pulses = list(zip(*sec_and_pulses))
-        pulses = list(pulses)
-        logger.debug('pulses %s'%pulses)
-        samples_between_UTC_pulses = []
-        for n1, n2 in zip(pulses[1:], pulses):
-            delta = n1 - n2
-            if np.isclose(delta, audio_samplerate_gps_corrected, rtol=1e-3):
-                samples_between_UTC_pulses.append(delta - audio_samplerate_gps_corrected)
-        samples_between_UTC_pulses = np.array(samples_between_UTC_pulses)
-        pulse_length_std = samples_between_UTC_pulses.std()
-        max_min_over_2 = abs(samples_between_UTC_pulses.max() - samples_between_UTC_pulses.min())/2
-        # print(samples_between_UTC_pulses)
-        # print('time is measured with a precision of %f audio samples'%(pulse_length_std))
-        precision = 1e6*max_min_over_2/audio_samplerate_gps_corrected
-        print('Time is measured with a precision of %0.1f audio samples (%0.1f μs)'%(max_min_over_2, precision))
-        frame_duration = 1/fps_rel_to_audio
-        rel_min_error = 100*1e-6*precision/frame_duration
-        print('so LTC syncword jitter less than %0.1f %% wont be detected'%(rel_min_error))
-        # fig, ax = plt.subplots()
-        # n, bins, patches = ax.hist(samples_between_UTC_pulses)
-        # plt.show()
-        # x = range(len(pulses))
-        a, b = np.polyfit(pulses, secs, 1)
-        logger.debug('slope, b = %f %f'%(a,b))
-        # sr_slope = 1/a
-        # print(sr_slope/recording.true_samplerate)
-        coherent_sr = np.isclose(a*audio_samplerate_gps_corrected, 1, rtol=1e-7)
-        logger.debug('samplerates (slope VS rec) are close: %s ratio %f'%(coherent_sr,
-                                    a*audio_samplerate_gps_corrected))
-        if not coherent_sr:
-            print('warning, wav samplerate are incoherent (Rec + Decode VS slope)')
-        def make_sample2time(a, b):
-            return lambda n : a*n + b 
-        sample2time = make_sample2time(a, b)
-        logger.debug('sample2time fct: %s'%sample2time)
-        LTC_samples = [N for _, N in LTC_frames_and_pos]
-        LTC_times = [sample2time(N) for N in LTC_samples]
-        slope_fps, _ = np.polyfit(LTC_times, range(len(LTC_times)), 1)
-        print('slope_fps l329', ppm(slope_fps,24))
-        print('diff slope, ppm',ppm(gps_corrected_framerate, slope_fps))
-        LTC_frame_durations_samples = [a - b for a, b in zip(LTC_samples[1:], LTC_samples)]
-        # print(LTC_frame_durations_samples)
-        frame_duration = 1/fps_rel_to_audio 
-        errors_useconds = [1e6*(frame_duration -(a - b)) for a, b in zip(LTC_times[1:], LTC_times)]
-        # print(errors_useconds)
-        errors_useconds = np.array(errors_useconds)
-        LTC_std = abs(errors_useconds).std()
-        LTC_max_min = abs(errors_useconds.max() - errors_useconds.min())/2
-        # print('Mean frame duration is %i audio samples'%)
-        print('\nhere LTC frame duration varies by %f μs ('%LTC_max_min, end='')
-        print('%0.3fFPS nominal frame duration is %0.0f μs)\n'%(fps_rel_to_audio, 1e6/fps_rel_to_audio))
-        # print(errors_useconds[:200])
-        # audio_sampling_period = 1/samplerate
-        # print(audio_sampling_period)
-        # errors_in_audiosamples = [int(e/audio_sampling_period) for e in errors_seconds]
-        # print(delta_milliseconds)
-        # plt.plot(LTC_times, marker='.', markersize='1',
-        #     linestyle='None', color='black')
-        # plt.show()
-        # print(LTC_times)
-        # fig, ax = plt.subplots()
-
-        # the histogram of the data
-        # print(errors_in_audiosamples)
-        fig, ax = plt.subplots()
-        n, bins, patches = ax.hist(errors_useconds, bins=40)
-        plt.show()
-    quit()
-
-if __name__ == '__main__':
-    main()
-
-#     import matplotlib.pyplot as plt
-# import numpy as np
-
-# rng = np.random.default_rng(19680801)
-
-# # example data
-# mu = 106  # mean of distribution
-# sigma = 17  # standard deviation of distribution
-# x = rng.normal(loc=mu, scale=sigma, size=420)
-
-# num_bins = 42
-
-# fig, ax = plt.subplots()
-
-# # the histogram of the data
-# n, bins, patches = ax.hist(x, num_bins, density=True)
-
-# # add a 'best fit' line
-# y = ((1 / (np.sqrt(2 * np.pi) * sigma)) *
-#      np.exp(-0.5 * (1 / sigma * (bins - mu))**2))
-# ax.plot(bins, y, '--')
-# ax.set_xlabel('Value')
-# ax.set_ylabel('Probability density')
-# ax.set_title('Histogram of normal distribution sample: '
-#              fr'$\mu={mu:.0f}$, $\sigma={sigma:.0f}$')
-
-# # Tweak spacing to prevent clipping of ylabel
-# fig.tight_layout()
-# plt.show()