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

tictacsync-1.4.4b0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.1
+Name: tictacsync
+Version: 1.4.4b0
+Summary: commands for syncing audio video recordings
+Home-page: https://tictacsync.org/
+Author: Raymond Lutz
+Author-email: lutzrayblog@mac.com
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Utilities
+Classifier: Topic :: Multimedia :: Sound/Audio :: Capture/Recording
+Classifier: Topic :: Multimedia :: Video :: Non-Linear Editor
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sox >=1.4.1
+Requires-Dist: ffmpeg-python >=0.2.0
+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
+
+## Warning: this is at beta stage
+
+Unfinished sloppy code ahead, but should run without errors. Some functionalities are still missing. Don't run the code without parental supervision. Suggestions and enquiries are welcome via the [lists hosted on sourcehut](https://sr.ht/~proflutz/TicTacSync/lists).
+
+## Description
+
+`tictacsync` is a python script to sync, cut and join audio files against camera files shot using a specific hardware timecode generator
+called [Tic Tac Sync](https://tictacsync.org). The timecode is named TicTacCode and should be recorded on a scratch
+track on each device for `tictacsync` to work.
+## Status
+
+Feature complete! `tictacsync`  scans for audio video files and then merges overlapping audio and video recordings, It
+
+* Decodes the TicTacCode audio track alongside your audio tracks
+* Establishes UTC start time (and end time) within 100 μs!
+* Syncs, cuts and joins any concurrent audio to camera files (using `FFmpeg`)
+* Processes _multiple_ audio recorders
+* Corrects device clock drift so _both_ ends coincide (thanks to `sox`)
+* Sets video metadata TC of multicam files for NLE timeline alignement
+* Writes _synced_ ISO files with dedicated file names declared in `tracks.txt`
+* Produces nice plots.
+
+
+## Installation
+
+This uses the [python interpreter](https://www.python.org/downloads/) and multiple packages (so you need python 3 + pip). Also, you need to install two non-python command line executables: [ffmpeg](https://windowsloop.com/install-ffmpeg-windows-10/) and [sox](https://sourceforge.net/projects/sox/files/). Make sure those are _accessible through your `PATH` system environment variable_.
+Then pip install the syncing program:
+
+
+   	> pip install tictacsync
+
+
+This should install python dependencies _and_ the `tictacsync` command.
+## Usage
+
+Download multiple sample files [here](https://nuage.lutz.quebec/s/4jw4xgqysLPS8EQ/download/dailies1_3.zip) (700+ MB, sorry) unzip and run:
+
+    > tictacsync dailies/loose
+The program `tictacsync` will recursively scan the directory given as argument, find all audio that coincide with any video and merge them into a subfolder named `SyncedMedia`. When the argument is an unique media file (not a directory), no syncing will occur but the decoded starting time will be printed to stdout:
+	
+	> tictacsync dailies/loose/MVI_0024.MP4
+
+	Recording started at 2024-03-12 23:07:01.4281 UTC
+	true sample rate: 48000.736 Hz
+	first sync at 27450 samples in channel 0
+	N.B.: all results are precise to the displayed digits!
+
+If shooting multicam, put clips in their respective directories (using the camera name as folder name) _and_ the audio under their own directory. `tictacsync` will detect that structured input and will generate multicam folders ready to be imported into your NLE (for now only DaVinci Resolve has been validated).
+
+## Options
+#### `-v`
+
+For a very verbose output add the `-v` flag:
+
+    > tictacsync -v dailies/loose/MVI_0024.MP4
+#### `--terse`
+For a one line output (or to suppress the progress bars) use the `--terse` flag:
+
+	> tictacsync --terse dailies/loose/MVI_0024.MP4 
+	dailies/loose/MVI_0024.MP4 UTC:2024-03-12 23:07:01.4281 pulse: 27450 in chan 0
+#### `--isos`
+
+Specifying `--isos` produces _synced_ ISO audio files: for each synced \<video-clip\> a directory named `<video-clip>_ISO` will contain a set of ISO audio files each of exact same length, padded or trimmed to coincide with the video start. After re-editing and re-mixing in your DAW of choice a `remergemix` command will resync the new audio with the video and _the new sound track will be updated on your NLE timeline_, _automagically_ on some NLEs or on command for [Davinci Resolve](https://www.niwa.nu/dr-scripts/).
+
+	> tictacsync --isos dailies/structured
+#### `-p`
+
+When called with the `-p` flag, zoomable plots will be produced for diagnostic purpose (close the plotting window for the 2nd one) and the decoded starting time will be output to stdin:
+
+    > tictacsync -p dailies/loose/MVI_0024.MP4
+
+Typical first plot produced :
+
+![word](https://mamot.fr/system/media_attachments/files/110/279/794/002/305/269/original/0198908c6eb5c592.png)
+
+Typical second plot produced (note the 34 [FSK](https://en.wikipedia.org/wiki/Frequency-shift_keying) encoded bits `0010111101001111100110000110010000`):
+![slicing](https://mamot.fr/system/media_attachments/files/110/279/794/021/372/766/original/6ec62bb417115f52.png)
+
+
+<!-- To run some tests, from top level `git cloned` dir:
+
+    cd tictacsync ; python -m pytest
+ Yes, the coverage is low. -->

tictacsync-1.4.4b0.dist-info/RECORD

@@ -0,0 +1,16 @@
+tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tictacsync/device_scanner.py,sha256=YxA3_0O1ZPE1ZuD-OgD-dWhtTWE-LamDhqXXyLo3IMw,26132
+tictacsync/entry.py,sha256=pcGuS4_o0o5dREpcccx1_X3w14PeHdQi5z1Ikzmhpwk,16198
+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=mpoHUAuJWiZ1JfVCECiiSLH_HNdXNV1Z_VlUlJBlPcM,14565
+tictacsync/multi2polywav.py,sha256=qJJhjwIgP1BCTpi2e0wfR95XlgZ2-EIqmefVh-jUBPc,7438
+tictacsync/timeline.py,sha256=ykmB8EfnprQZoEHXRYzriASNWZ7bHfkmQ2-TR6gxZ6Y,75985
+tictacsync/yaltc.py,sha256=xrgL7qokP1A7B_VF4W_BZcC7q9APSmYpmtWH8_t3VWc,68003
+tictacsync-1.4.4b0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
+tictacsync-1.4.4b0.dist-info/METADATA,sha256=R8XV5GMFARw0IBnpbaZ19AAAejTr2RYbcw73zpyj9LM,5689
+tictacsync-1.4.4b0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+tictacsync-1.4.4b0.dist-info/entry_points.txt,sha256=0R8K6T0iUJGj87LDZ0vNO8pToshbkxrXZqTRgcjBlMk,244
+tictacsync-1.4.4b0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
+tictacsync-1.4.4b0.dist-info/RECORD,,

tictacsync-1.4.4b0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+mamconf = tictacsync.mamconf: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_dict_from_path(Path(file_argument))
-        logger.debug('media_dict_from_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.YaLTC_channel))
-        print('audio samplerate (gps)', audio_samplerate_gps_corrected)
-        all_channels_data = read_whole_audio_data(file_argument)
-        TTC_data = all_channels_data[recording.YaLTC_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()

tictacsync-0.1a14.dist-info/METADATA

@@ -1,96 +0,0 @@
-Metadata-Version: 2.1
-Name: tictacsync
-Version: 0.1a14
-Summary: command for syncing audio video recordings
-Home-page: https://sr.ht/~proflutz/TicTacSync/
-Author: Raymond Lutz
-Author-email: lutzrayblog@mac.com
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Multimedia :: Sound/Audio
-Classifier: Topic :: Utilities
-Classifier: Topic :: Multimedia :: Sound/Audio :: Capture/Recording
-Classifier: Topic :: Multimedia :: Video :: Non-Linear Editor
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: sox >=1.4.1
-Requires-Dist: ffmpeg-python >=0.2.0
-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: scipy >=1.10.1
-Requires-Dist: scikit-learn ==1.2.2
-
-# tictacsync
-
-## Warning: this is at pre-alpha stage
-
-Unfinished sloppy code ahead, but should run without errors. Some functionalities are still missing. Don't run the code without parental supervision. Suggestions and enquiries are welcome via the [lists hosted on sourcehut](https://sr.ht/~proflutz/TicTacSync/lists).
-
-## Description
-
-`tictacsync` is a python script to sync audio and video files shot
-with [dual system sound](https://www.learnlightandsound.com/blog/2017/2/23/how-to-record-sound-for-video-dual-systemsync-sound)  using a specific hardware timecode generator
-called [Tic Tac Sync](https://tictacsync.org). The timecode is named YaLTC for *yet
-another longitudinal time code* and should be recorded on a scratch
-track on each device for the syncing to be performed, later in _postprod_ before editing.
-
-## Status
-
-`tictacsync`  scans for audio video files and displays their starting time and then merges overlapping audio and video recordings. Multicam syncing with one stereo audio recorder has been tested (spring 2023, [see demo](https://youtu.be/pklTSTi7cqs)). Multi audio recorders coming soon... 
-
-
-## Installation
-
-This uses the [python interpreter](https://www.python.org/downloads/) and multiple packages (so you need python 3 + pip). Also, you need to install two non-python command line executables: [ffmpeg](https://windowsloop.com/install-ffmpeg-windows-10/) and [sox](https://sourceforge.net/projects/sox/files/). Make sure those are _accessible through your `PATH` system environment variable_.
-Then pip install the syncing program:
-
-
-    pip install tictacsync
-
-
-This should install python dependencies _and_ the `tictacsync` command.
-## Usage
-
-Download some sample files [here](https://tictacsync.org/sampleFiles.zip), unzip and run 
-
-    tictacsync sampleFiles
-The resulting synced videos will be in a subfolder named `tictacsynced`. For a very verbose output add the `-v` flag:
-
-    tictacsync -v sampleFiles
-
-When the argument is an unique media file (not a directory), no syncing will occur but the decoded starting time will be printed to stdout:
-	
-	tictacsync sampleFiles/canon24fps01.MOV
-
-	Recording started at 2023-04-23 01:09:08.1605 UTC
-	true sample rate: 48000.545 Hz
-	first sync at 37414 samples
-	N.B.: all results are precise to the displayed digits!
-
-
-When called with the `-p` flag, zoomable plots will be produced for diagnostic purpose (close the plotting window for the 2nd one) and the decoded starting time will be output to stdin:
-
-    tictacsync -p sampleFiles/canon24fps01.MOV
-
-Typical first plot produced :
-
-![word](https://mamot.fr/system/media_attachments/files/110/279/794/002/305/269/original/0198908c6eb5c592.png)
-
-Typical second plot produced (note the 34 [FSK](https://en.wikipedia.org/wiki/Frequency-shift_keying) encoded bits `0010111101001111100110000110010000`):
-![slicing](https://mamot.fr/system/media_attachments/files/110/279/794/021/372/766/original/6ec62bb417115f52.png)
-
-
-<!-- To run some tests, from top level `git cloned` dir:
-
-    cd tictacsync ; python -m pytest
- Yes, the coverage is low. -->

tictacsync-0.1a14.dist-info/RECORD

@@ -1,13 +0,0 @@
-tictacsync/LTCcheck.py,sha256=SUq93zfky5njzvnsnIj-5nC01QYf3hVBegJftPOFeJQ,15708
-tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tictacsync/device_scanner.py,sha256=wDkhE_H33Zh5RIjASS33HOmX5-qI-dJ3h9yyvaTrAI0,15177
-tictacsync/entry.py,sha256=ICTDI6ZPaPsDnkZX-c7dahr6qpG09x618j9nPh3x2jM,10279
-tictacsync/multi2polywav.py,sha256=7Qnb986D3HJIAkNJ3IyvPWxIdqqh3KIfwnwFoUBw0pU,7013
-tictacsync/timeline.py,sha256=1NpfbvBv24oDtet8SafPcpvk5ppK8qTdEybs8qz8gkc,39258
-tictacsync/yaltc.py,sha256=Hu827V61yp1VcjZHJ9HMlCL_EEcxlhi_4hesOQy66bc,71391
-tictacsync-0.1a14.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
-tictacsync-0.1a14.dist-info/METADATA,sha256=K96y62aTWDK0EmlHyFR0ISO75ZrLf9OoKETTtoM0x8I,4218
-tictacsync-0.1a14.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tictacsync-0.1a14.dist-info/entry_points.txt,sha256=bre_DmdWFgHljcC0cyqh_dC9siGANO04MQ_wYsO2sxY,135
-tictacsync-0.1a14.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
-tictacsync-0.1a14.dist-info/RECORD,,

tictacsync-0.1a14.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-LTCcheck = tictacsync.LTCcheck:main
-multi2polywav = tictacsync.multi2polywav:main
-tictacsync = tictacsync.entry:main