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

tictacsync/timeline.py

@@ -55,6 +55,10 @@ def _pathname(tempfile_or_path) -> str:
     else:
         raise Exception('%s should be Path or tempfile...'%tempfile_or_path)
 
+def ffprobe_duration(f):
+    pr = ffmpeg.probe(f)
+    return pr['format']['duration']
+
 # utility for printing groupby results
 def print_grby(grby):
     for key, keylist in grby:
@@ -711,6 +715,7 @@ class AudioStitcherVideoMerger:
                 sox.file_info.duration(_pathname(out_tf)))
             logger.debug('video duration  %.2f s'%
                 self.videoclip.get_duration())
+            logger.debug(f'video {self.videoclip}')
             return out_tf
         def _meta_wav_dest(p1, p2, p3):
             """
@@ -745,7 +750,8 @@ class AudioStitcherVideoMerger:
         logger.debug('ISOdir %s'%ISOdir)
         for name, mono_tmpfl, device in edited_audio_all_devices:
             logger.debug(f'name:{name} mono_tmpfl:{mono_tmpfl} device:{pformat(device)}')
-            destination = ISOdir/(f'{video_stem_WO_suffix}_{name}.wav')
+            # destination = ISOdir/(f'{video_stem_WO_suffix}_{name}.wav')
+            destination = ISOdir/(f'{name}_{video_stem_WO_suffix}.wav')
             mono_tmpfl_trimpad = _fit_length(mono_tmpfl)
             # if audio_only, self.ref_audio does not have itself as matching audio
             if audio_only and device == self.ref_audio.device:
@@ -828,8 +834,8 @@ class AudioStitcherVideoMerger:
         if device.ttc + 1 != device.tracks.ttc: # warn and quit
             print('Error: TicTacCode channel detected is [gold1]%i[/gold1]'%
                 (device.ttc), end=' ')
-            print('and [gold1]%s[/gold1] for the device [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
-                (device_scanner.TRACKSFILE,
+            print('and file [gold1]%s[/gold1]\nfor the device [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
+                (device.folder/Path(yaltc.TRACKSFILE),
                 device.name, device.tracks.ttc-1))
             print('Please correct the discrepancy and rerun. Quitting.')
             sys.exit(1)
@@ -900,20 +906,6 @@ class AudioStitcherVideoMerger:
         stereo_files = mic_stereo_files + new_stereo_files
         return _sox_mix_files(stereo_files)
 
-    # def build_audio_and_write_merged_media(self, top_dir, 
-    #                         dont_write_cam_folder, asked_ISOs, audio_REC_only):
-    #     # simply bifurcates depending if ref media is video (prob 99%)
-    #     # (then audio_REC_only == False)
-    #     # or if ref media is audio (no camera detected, 1% of cases)
-    #     # (with audio_REC_only == True)
-    #     if not audio_REC_only:
-    #         # almost always syncing audio to video clips
-    #         self._build_audio_and_write_video(top_dir,
-    #                                 dont_write_cam_folder, asked_ISOs)
-    #     else:
-    #         # rare
-    #         self._build_and_write_audio(top_dir, anchor_dir)
-
     def _build_and_write_audio(self, top_dir, anchor_dir=None):
         """
         This is called when only audio recorders were found (no cam).
@@ -1048,7 +1040,10 @@ class AudioStitcherVideoMerger:
             # MAM mode
             logger.debug('MAM mode')
             synced_clip_dir = Path(synced_root)/str(self.videoclip.AVpath.parent)[1:] # strip leading /
-            rel = self.videoclip.AVpath.parent.relative_to(raw_root).parent
+            logger.debug(f'self.videoclip.AVpath.parent: {self.videoclip.AVpath.parent}')
+            logger.debug(f'raw_root {raw_root}')
+            # rel = self.videoclip.AVpath.parent.relative_to(raw_root).parent # removes ROLL01?
+            rel = self.videoclip.AVpath.parent.relative_to(raw_root)
             logger.debug(f'relative path {rel}')
             synced_clip_dir = Path(synced_root)/Path(raw_root).name/rel
             logger.debug(f'will save in {synced_clip_dir}')
@@ -1140,6 +1135,7 @@ class AudioStitcherVideoMerger:
                 # generates track name for later if asked_ISOs
                 # idx is from 0 to nchan-1 for this device
                 if dev.tracks == None:
+                    logger.debug('dev.tracks == None')
                     # no tracks.txt was found so use ascending numbers for name
                     chan_name = 'chan%s'%str(idx+1).zfill(2)
                 else:
@@ -1214,9 +1210,12 @@ class AudioStitcherVideoMerger:
         """
         synced_clip_file = self.videoclip.final_synced_file
         video_path = self.videoclip.AVpath
+        logger.debug(f'original clip  {video_path}')
+        logger.debug(f'clip duration {ffprobe_duration(video_path)} s')
         timecode = self.videoclip.get_start_timecode_string()
         # self.videoclip.synced_audio = audio_path
         audio_path = self.videoclip.synced_audio
+        logger.debug(f'audio duration {sox.file_info.duration(_pathname(audio_path))}')
         vid_only_handle = self._keep_VIDEO_only(video_path)
         a_n = _pathname(audio_path)
         v_n = str(vid_only_handle.name)
@@ -1230,8 +1229,8 @@ class AudioStitcherVideoMerger:
         ffmpeg_args = (
             ffmpeg
             .input(v_n)
-            # .output(out_n, shortest=None, vcodec='copy',
-            .output(out_n, vcodec='copy',
+            .output(out_n, shortest=None, vcodec='copy',
+            # .output(out_n, vcodec='copy',
                 timecode=timecode)
             .global_args('-i', a_n, "-hide_banner")
             .overwrite_output()
@@ -1242,9 +1241,8 @@ class AudioStitcherVideoMerger:
             _, out = (
             ffmpeg
             .input(v_n)
-            .output(out_n, vcodec='copy',
-            # .output(out_n, shortest=None, vcodec='copy',
-                # metadata='reel_name=foo', not all container support gen MD
+            # .output(out_n, vcodec='copy',
+            .output(out_n, shortest=None, vcodec='copy',
                 timecode=timecode,
                 )
             .global_args('-i', a_n, "-hide_banner")
@@ -1252,8 +1250,8 @@ class AudioStitcherVideoMerger:
             .run(capture_stderr=True)
             )
             logger.debug('ffmpeg output')
-            for l in out.decode("utf-8").split('\n'):
-                logger.debug(l)
+            # for l in out.decode("utf-8").split('\n'):
+                # logger.debug(l)
         except ffmpeg.Error as e:
             print('ffmpeg.run error merging: \n\t %s + %s = %s\n'%(
                 audio_path,
@@ -1263,6 +1261,9 @@ class AudioStitcherVideoMerger:
             print(e)
             print(e.stderr.decode('UTF-8'))
             sys.exit(1)
+        logger.debug(f'merged clip  {out_n}')
+        logger.debug(f'clip duration {ffprobe_duration(out_n)} s')
+
 
 class Matcher:
     """
@@ -1510,7 +1511,7 @@ class Matcher:
         if synced_root == None:
             # alongside mode
             logger.debug('alongside mode')
-            multicam_dir = Path('').joinpath(*parts_up_a_level)/MCCDIR
+            multicam_dir = Path('/').joinpath(*parts_up_a_level)/MCCDIR
         else:
             # MAM mode
             logger.debug('MAM mode')
@@ -1549,6 +1550,7 @@ class Matcher:
             for r in cam_clips:
                 cam = r.device.name
                 clip_name = r.AVpath.name
+                logger.debug(f'r.final_synced_file: {r.final_synced_file}')
                 dest = r.final_synced_file.replace(multicam_dir/cam/clip_name)
                 # leave a symlink behind
                 os.symlink(multicam_dir/cam/clip_name, r.final_synced_file)

tictacsync/yaltc.py

@@ -15,6 +15,7 @@ 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 skimage.morphology import closing, erosion, remove_small_objects
@@ -33,6 +34,10 @@ 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 = False
 MAXDRIFT = 15e-3 # in sec, for end of clip
@@ -68,6 +73,7 @@ BPF_LOW_FRQ, BPF_HIGH_FRQ = (0.5*F1, 2*F2)
 
 # utility for accessing pathnames
 def _pathname(tempfile_or_path):
+    # always returns a str
     if isinstance(tempfile_or_path, type('')):
         return tempfile_or_path ################################################
     if isinstance(tempfile_or_path, Path):
@@ -135,6 +141,34 @@ 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 TicTacCode track from audio
@@ -188,7 +222,6 @@ class Decoder:
         self.do_plots = do_plots
         self.clear_decoder()
 
-
     def clear_decoder(self):
         self.sound_data_extract = None
         self.pulse_detection_level = None
@@ -524,6 +557,7 @@ class Decoder:
         return int(round(freq_in_hertz))
 
 
+
 class Recording:
     """
     Wrapper for file objects, ffmpeg read operations and fprobe functions
@@ -688,35 +722,16 @@ class Recording:
             return
         logger.debug('ffprobe found: %s'%self.probe)
         logger.debug('n audio chan: %i'%self.get_audio_channels_nbr())
-        self._read_audio_data()
-
-    def _read_audio_data(self):
-        # sets Recording.audio_data
-        dryrun = (ffmpeg
-            .input(str(self.AVpath))
-            .output('pipe:', format='s16le', acodec='pcm_s16le')
-            .get_args())
-        dryrun = ' '.join(dryrun)
-        logger.debug('using ffmpeg-python built args to pipe audio stream into numpy array:\nffmpeg %s'%dryrun)
-        try:
-            out, _ = (ffmpeg
-                # .input(str(path), ss=time_where, t=chunk_length)
-                .input(str(self.AVpath))
-                .output('pipe:', format='s16le', acodec='pcm_s16le')
-                .global_args("-loglevel", "quiet")
-                .global_args("-nostats")
-                .global_args("-hide_banner")
-                .run(capture_stdout=True))
-            data = np.frombuffer(out, np.int16)
-        except ffmpeg.Error as e:
-            print('error',e.stderr)
-        n_chan = self.get_audio_channels_nbr()
-        if n_chan == 1 and not self.is_video():
-            logger.error('file is sound mono')
+        # 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"%self.AVpath)
-        # from 1D  interleaved channels to [chan1, chan2, chanN]
-        self.audio_data = data.reshape(int(len(data)/n_chan),n_chan).T
+            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))
 
@@ -1029,6 +1044,319 @@ class Recording:
         #     self.valid_sound = self.AVpath
         return start_UTC
 
+    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 . 
+        """
+        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']
         audio_streams = [

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 1.2.0b0
+Version: 1.4.5b0
 Summary: commands for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz
@@ -33,7 +33,7 @@ Requires-Dist: platformdirs
 
 # tictacsync
 
-## Warning: this is at pre-alpha stage
+## 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).
 

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.2.0b0.dist-info → tictacsync-1.4.5b0.dist-info}/entry_points.txt

@@ -1,6 +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
-newmix = tictacsync.newmix:main
 tictacsync = tictacsync.entry:main