tictacsync 0.4a0__py3-none-any.whl → 0.6a0__py3-none-any.whl

tictacsync/device_scanner.py

@@ -90,10 +90,12 @@ class Media:
     """
     path: Path
     device: Device
+
 def media_at_path(input_structure, p):
     # return Media object for mediafile using ffprobe
     dev_UID, dt = get_device_ffprobe_UID(p)
-    dev_name = None 
+    dev_name = None
+    logger.debug('ffprobe dev_UID:%s dt:%s'%(dev_UID, dt))
     if input_structure == 'folder_is_device':
         dev_name = p.parent.name
         if dev_UID is None:
@@ -114,9 +116,10 @@ def media_at_path(input_structure, p):
     else:
         n = sox.file_info.channels(_pathname(p)) # eg 2
     logger.debug('for file %s dev_UID established %s'%(p.name, dev_UID))
-    return Media(p,
-        Device(UID=dev_UID, folder=p.parent, name=dev_name, dev_type=dt,
-                n_chan=n, ttc=None, tracks=None))
+    device = Device(UID=dev_UID, folder=p.parent, name=dev_name, dev_type=dt,
+                n_chan=n, ttc=None, tracks=None)
+    logger.debug('for path: %s, device:%s'%(p,device))
+    return Media(p, device)
 
 def get_device_ffprobe_UID(file):
     """
@@ -141,7 +144,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 #-----------------------------------------------------
         # fall back to folder name
     streams = probe['streams']
     codecs = [stream['codec_type'] for stream in streams]
@@ -155,9 +158,12 @@ def get_device_ffprobe_UID(file):
                 and 'date' not in l ]
         # this removes any metadata related to the file
         # but keeps metadata related to the device
+        logger.debug('probe_lines %s'%probe_lines)
         UID = hash(''.join(probe_lines))
     else:
         UID = None
+    if UID == 0: # empty probe_lines from Audacity ?!?
+        UID = None
     logger.debug('ffprobe_UID is: %s'%UID)
     return UID, device_type
 
@@ -257,9 +263,6 @@ class Scanner:
         for p in paths:
             new_media = media_at_path(self.input_structure, p) # dev UID set here
             self.found_media_files.append(new_media)
-        # files from devices without UID or name
-        # def _list_all_the_same(l):
-        #     return all(e == l[0] for e in l)
         def _try_name(medias):
             # return common first strings in filename
             names = [m.path.name for m in medias]
@@ -274,7 +277,6 @@ class Scanner:
                     if not m.device.UID]
         if no_device_UID_media:
             logger.debug('no_device_UID_media %s'%no_device_UID_media)
-            # print(no_device_UID_media)
             start_string = _try_name(no_device_UID_media)
             if len(start_string) < 2:
                 print('\nError, cant identify the device for those files:')
@@ -286,7 +288,8 @@ class Scanner:
             if not one_device.UID:
                 one_device.UID = hash(start_string)
             print('\nWarning, guessing a device ID for those files:')
-            [print('[gold1]%s[/gold1], '%m.path.name, end='') for m in no_device_UID_media]
+            [print('[gold1]%s[/gold1], '%m.path.name, end='') for m
+                                            in no_device_UID_media]
             print('UID: [gold1]%s[/gold1]'%start_string)
             for m in no_device_UID_media:
                 m.device = one_device

tictacsync/entry.py

@@ -72,8 +72,9 @@ def process_files(medias):
 def process_single(file, args):
     # argument is a single file
     m = device_scanner.media_at_path(None, Path(file))
-    a_rec = yaltc.Recording(m)
-    time = a_rec.get_start_time(plots=args.plotting)
+    a_rec = yaltc.Recording(m, do_plots=args.plotting)
+    time = a_rec.get_start_time()
+    # time = a_rec.get_start_time(plots=args.plotting)
     if time != None:
         frac_time = int(time.microsecond / 1e2)
         d = '%s.%s'%(time.strftime("%Y-%m-%d %H:%M:%S"),frac_time)
@@ -124,11 +125,10 @@ def main():
     if args.verbose_output:
         logger.add(sys.stderr, level="DEBUG")
     # logger.add(sys.stdout, filter="__main__")
-    # logger.add(sys.stdout, filter="device_scanner")
-    # logger.add(sys.stdout, filter="yaltc") _extract_sound_to_merge
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_tracks_from_file")
+    # logger.add(sys.stdout, filter="yaltc")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_read_sound_find_TicTacCode")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_detect_sync_pulse_position")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_device_mix")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_sox_mono2stereo")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "_sox_mix_files")
     top_dir = args.directory[0]
     if os.path.isfile(top_dir):
@@ -195,7 +195,7 @@ def main():
         # table.add_column("Device\n", justify="center", style='gold1')
         table.add_column("UTC times\nstart:end", justify="center", style='gold1')
         table.add_column("Clock drift\n(ppm)", justify="right", style='gold1')
-        table.add_column("SN ratio\n(dB)", justify="center", style='gold1')
+        # table.add_column("SN ratio\n(dB)", justify="center", style='gold1')
         table.add_column("Date\n", justify="center", style='gold1')
         rec_WO_time = [
             rec.AVpath.name
@@ -218,7 +218,7 @@ def main():
                 times_range,
                 # '%.6f'%(r.true_samplerate/1e3),
                 '%2i'%(r.get_samplerate_drift()),
-                '%.0f'%r.decoder.SN_ratio,
+                # '%.0f'%r.decoder.SN_ratio,
                 date
                 )
         console = Console()
@@ -277,6 +277,3 @@ if __name__ == '__main__':
 
 
 
-
-
-

tictacsync/multi2polywav.py

@@ -61,7 +61,7 @@ def build_poly_name(multifiles):
     """
     Returns string of polywav filename, constructed from similitudes between
     multifile names. Ex:
-    /full/path/4CH002I.wav and /full/path/4CH002M.wav returns 4CH002X.wav
+    4CH002I.wav and 4CH002M.wav returns 4CH002X.wav
     """
     s1 = str(multifiles[0].stem)
     s2 = str(multifiles[1].stem)
@@ -96,6 +96,7 @@ def build_poly(multifiles):
     # multifiles is list of Path
     # change extensions to mfw (multifile wav)
     dir_multi = multifiles[0].parent
+    multifiles.reverse()
     poly_name_b = build_poly_name(multifiles) # base only
     poly_name = str(dir_multi/Path(poly_name_b))
     filenames = [str(p) for p in multifiles]

tictacsync/remergemix.py

@@ -3,13 +3,35 @@ from loguru import logger
 from pathlib import Path
 import sox, tempfile, os, ffmpeg
 from rich import print
-import shutil
+import shutil, sys, re
+from pprint import pformat 
+from itertools import groupby
 
+try:
+    from . import timeline
+except:
+    import timeline
 
+DEL_TEMP = False
+
+logger.level("DEBUG", color="<yellow>")
 logger.remove()
-# OUT_DIR = 'SyncedMedia'
+
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_ISO_dirs")
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "_join_audio2video")
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "main")
+# logger.add(sys.stdout, filter="__main__")
+
+OUT_DIR = 'SyncedMedia'
+SEC_DELAY_CHANGED_ISO = 10 #sec, ISO_DIR changed if diff time is bigger
+
+video_extensions = \
+"""webm mkv flv flv vob ogv  ogg drc gif gifv mng avi mov 
+qt wmv yuv rm rmvb viv asf  mp4  m4p m4v mpg  mp2  mpeg  mpe 
+mpv mpg  mpeg  m2v m4v svi 3gp 3g2 mxf roq nsv""".split() # from wikipedia
 
 def _pathname(tempfile_or_path) -> str:
+    # utility for obtaining a str from different filesystem objects
     if isinstance(tempfile_or_path, str):
         return tempfile_or_path
     if isinstance(tempfile_or_path, Path):
@@ -19,125 +41,216 @@ def _pathname(tempfile_or_path) -> str:
     else:
         raise Exception('%s should be Path or tempfile...'%tempfile_or_path)
 
-def _join(left_right: list, video: Path, out: Path):
+def _keep_VIDEO_only(video_path):
+    # return file handle to a temp video file formed from the video_path
+    # stripped of its sound
+    in1 = ffmpeg.input(_pathname(video_path))
+    video_extension = video_path.suffix
+    silenced_opts = ["-loglevel", "quiet", "-nostats", "-hide_banner"]
+    file_handle = tempfile.NamedTemporaryFile(suffix=video_extension,
+        delete=DEL_TEMP)
+    out1 = in1.output(file_handle.name, map='0:v', vcodec='copy')
+    ffmpeg.run([out1.global_args(*silenced_opts)], overwrite_output=True)
+    return file_handle
+
+def _join_audio2video(audio_path: Path, video: Path):
+    """
+    Replace audio in video (argument)  by the audio contained in
+    audio_path (argument) returns nothing
+    """
     video_ext = video.name.split('.')[1]
-    audio_left = (
+    vid_only_handle = _keep_VIDEO_only(video)
+    a_n = _pathname(audio_path)
+    v_n = _pathname(vid_only_handle)
+    out_n = _pathname(video)
+    # building args for debug purpose only:
+    ffmpeg_args = (
         ffmpeg
-        .input(_pathname(left_right[0])))
-    audio_right = (
+        .input(v_n)
+        .output(out_n, shortest=None, vcodec='copy')
+        .global_args('-i', a_n, "-hide_banner")
+        .overwrite_output()
+        .get_args()
+    )
+    logger.debug('ffmpeg args: %s'%' '.join(ffmpeg_args))
+    try: # for real now
+        _, out = (
         ffmpeg
-        .input(_pathname(left_right[1])))
-    input_video = ffmpeg.input(_pathname(video))
-    out_file = tempfile.NamedTemporaryFile(suffix='.%s'%video_ext)
-    try:
-        (ffmpeg
-        .filter((audio_left, audio_right), 'join', inputs=2,
-                    channel_layout='stereo')
-        .output(input_video.video, _pathname(out_file),
-                    shortest=None, vcodec='copy', loglevel="quiet")
+        .input(v_n)
+        .output(out_n, shortest=None, vcodec='copy')
+        .global_args('-i', a_n, "-hide_banner")
         .overwrite_output()
-        .run())
+        .run(capture_stderr=True)
+        )
+        logger.debug('ffmpeg output')
+        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,
+            video_path,
+            synced_clip_file
+            ))
         print(e)
         print(e.stderr.decode('UTF-8'))
         sys.exit(1)
-    shutil.copyfile(_pathname(out_file), _pathname(video))
-
-
-def sync_cam(dir):
-    # dir is a CAM dir, contents are clips and ISO folders
-    ISOs = list(dir.glob('*.ISO'))
-    for iso in ISOs:
-        # iso is a folder
-        statResult = iso.stat()
-        mtime = statResult.st_mtime
-        # print('%s: %s'%(iso.name, biggest_mtime_in_dir(iso)))
-        iso_mod_time = biggest_mtime_in_dir(iso)
-        clip = clip_from_iso(iso)
-        clip_mod_time = clip.stat().st_mtime
-        iso_edited = iso_mod_time > clip_mod_time
-        # print('clip %s should be resync: %s'%(clip.name, iso_edited))
-        # print(clip)
-        if iso_edited:
-            print('Resyncing [gold1]%s[/gold1]'%clip.name)
-            LR_channels = list(valid_audio_files(iso))
-            _join(LR_channels, clip, 'test.MOV')
-
-
-def valid_audio_files(isofolder: Path) -> list:
+
+def _changed(dir) -> bool:
     """
-    Returns two valid audio files to be synced with video
-    case A - only two files differing by L and R
-    case B - more than two files, two are mixL mixR
-    case C - one file only -> sys.exit(1)
-    case D - more than two files, no mixL mixR -> sys.exit(1)
+    Returns True if any content of dir (arg) is more recent than dir itself by a
+    delay of SEC_DELAY_CHANGED_ISO. Uses modification times.
     """
-    files = list(isofolder.iterdir())
-    if len(files) == 1: # case C
-        print('Error with folder %s: no mixL.wav, mixR.wav'%isofolder)
-        print('or micL.wav, micR.wav... Quitting.')
-        sys.exit(1)
-    def _is_case_A(files):
-        if len(files) != 2:
-            return False
-        stems = [p.stem.upper() for p in files]
-        lasts = [st[-1] for st in stems]
-        LR_pair = ''.join(lasts) in ['LR', 'RL']
-        prefix = [st[:-1] for st in stems]
-        same = prefix[0] == prefix[1]
-        return same and LR_pair
-    if _is_case_A(files):
-        return files
-    def _is_case_B(files):
-        if len(files) <= 2:
-            return False
-        stems = [p.stem.upper() for p in files]
-        return 'MIXL' in stems and 'MIXR' in stems
-    if _is_case_B(files):
-        return isofolder.glob('mix?.*')
-    print('Error with folder %s: no mixL.wav, mixR.wav'%isofolder)
-    print('or micL.wav, micR.wav... Quitting.')
-    sys.exit(1)
+    logger.debug(f'checking {dir.name} for change')
+    ISO_modification_time = biggest_mtime_in_dir(dir)
+    clip = clip_from_iso(dir)
+    clip_mod_time = clip.stat().st_mtime
+    # difference of modification time in secs
+    ISO_more_recent_by = ISO_modification_time - clip_mod_time
+    logger.debug('ISO_more_recent_by: %s'%(ISO_more_recent_by))
+    iso_edited = ISO_more_recent_by > SEC_DELAY_CHANGED_ISO
+    logger.debug(f'_changed: {iso_edited}')
+    return iso_edited
+
+def sox_mix(ISOdir):
+    """
+    Mixes all wav files present in ISOdir (so excludes ttc file and nullified
+    ones).
+    Returns a mono or stereo tempfile
+    """
+    logger.debug(f'mixing {ISOdir}')
+    def is_stereo_mic(p):
+        re_result = re.match(r'mic([lrLR])*', p.name)
+        # logger.debug(f're_result {re_result}')
+        return re_result is not None
+    stereo_mics = [p for p in ISOdir.iterdir() if is_stereo_mic(p)]
+    monofiles = [p for p in ISOdir.iterdir() if p not in stereo_mics]
+    # removing ttc files
+    def notTTC(p):
+        return p.name[:3] != 'ttc'
+    monofiles = [p for p in monofiles if notTTC(p)]
+    if stereo_mics == []: # mono
+        return timeline._sox_mix_files(monofiles) #-----------------------------
+    logger.debug(f'stereo_mics: {stereo_mics}')
+    def mic(p):
+        return re.search(r'(mic\d*)([lrLR])*', p.name).groups()
+    mics = [mic(p) for p in stereo_mics]
+    p_and_mic = list(zip(stereo_mics, mics))
+    logger.debug(f'p_and_mic: {p_and_mic}')
+    same_mic_key = lambda pair: pair[1][0]
+    p_and_mic = sorted(p_and_mic, key=same_mic_key)
+    grouped_by_mic = [ (k, list(iterator)) for k, iterator
+            in groupby(p_and_mic, same_mic_key)]
+    logger.debug(f'grouped_by_mic: {grouped_by_mic}')
+    def order_left_right(groupby_element):
+        # returns left and right path for a mic
+        name, paths = groupby_element
+        def chan(pair):
+            # (PosixPath('mic1r_ZOOM.wav'), ('mic1', 'r')) -> 'r'
+            return pair[1][1]
+        path_n_mic = sorted(paths, key=lambda pair: pair[1][1])
+        return [p[0] for p in path_n_mic] # just the path, not  ('mic1', 'r')
+    left_right_paths = [order_left_right(e) for e in grouped_by_mic]
+    # logger.debug(f'left_right_paths: {left_right_paths}')
+    stereo_files = [timeline._sox_combine(pair) for pair in left_right_paths]
+    monoNstereo = monofiles + stereo_files
+    return timeline._sox_mix_files(monoNstereo)
+
+def get_mix_file(iso_dir):
+    """
+    If iso_dir (arg) contains a mono mix sound file or a stereo mix, returns its
+    path. If not, this creates the mix and returns it. 
+    """
+    wav_files = list(iso_dir.iterdir())
+    logger.debug(f'wav_files {wav_files}')
+    def is_mix(p):
+        re_result = re.match(r'mix([lrLR])*', p.name)
+        # logger.debug(f're_result {re_result}')
+        return re_result is not None
+    location_mix = [p for p in wav_files if is_mix(p)]
+    if location_mix == []:
+        logger.debug('no mix track, do the mix')
+        return sox_mix(iso_dir)
+    else:
+        return location_mix
 
 def biggest_mtime_in_dir(folder: Path) -> float:
-    # return the most recent mod time in a folder
+    # return the most recent mod time of the files in a folder
     dir_content = list(folder.iterdir())
     stats = [p.stat() for p in dir_content]
     mtimes = [stat.st_mtime for stat in stats]
     return max(mtimes)
 
-def clip_from_iso(p: Path) -> Path:
-    folder = p.parent
-    pair = list(folder.glob('%s.*'%p.stem))
-    return [p for p in pair if p.name.split('.')[1] != 'ISO'][0]
-
-def synciso(top_dir):
-    p = Path(top_dir)/OUT_DIR
-    dir_content = list(p.iterdir())
-    logger.debug('dir_content %s'%dir_content)
-    all_are_dir = all([p.is_dir() for p in dir_content])
-    logger.debug('all_are_dir %s'%all_are_dir)
+def clip_from_iso(ISO_dir: Path) -> Path:
+    # find the sibling video file of ISO_dir. eg : MVI_01.ISO -> MVI_01.MP4
+    folder = ISO_dir.parent
+    siblings = list(folder.glob('%s.*'%ISO_dir.stem))
+    candidates =[p for p in siblings if p.name.split('.')[1] != 'ISO']
+    # should be unique
+    if len(candidates) != 1:
+        print(f'Error finding video corresponding to {ISO_dir}, quitting')
+        sys.exit(1)
+    return candidates[0]
+
+def _get_ISO_dirs(top_dir):
+    """
+    Check if top_dir contains (or somewhere beneath) videos with their
+    accompanying ISO folder (like the pair MVI_023.MP4 + MVI_023.ISO). If not
+    warns and exits.
+
+    Returns list of paths pointing to ISO dirs.
+    """
+    p = Path(top_dir)
+    ISO_dirs = list(Path(top_dir).rglob('*.ISO'))
+    logger.debug('all files: %s'%pformat(ISO_dirs))
+    # validation: .ISO should be dir
+    all_are_dir = all([p.is_dir() for p in ISO_dirs])
+    logger.debug('.ISO are all dir %s'%all_are_dir)
     if not all_are_dir:
-        print('Error: resync possible only on structured folders,')
-        print('Rerun tictacsync with one directory for each device.')
+        print('Error: some .ISO are not folders??? Quitting. %s'%ISO_dirs)
         sys.exit(1)
-    [sync_cam(f) for f in dir_content]
+    # for each folder check a video file exists with the same stem
+    # but with a video format extension (listed in video_extensions)
+    for ISO in ISO_dirs:
+        logger.debug(f'checking {ISO}')
+        voisins = list(ISO.parent.glob(f'{ISO.stem}.*'))
+        voisins_suffixes = [p.suffix for p in voisins]
+        # remove ISO
+        voisins_suffixes.remove('.ISO')
+        # validations: should remain one element and should be video
+        suffix = voisins_suffixes[0].lower()[1:] # remove dot
+        logger.debug(f'remaining ext: {suffix}')
+        if len(voisins_suffixes) != 1 or suffix not in video_extensions:
+            print(f'Error with {voisins}, no video unique sibling?')
+            sys.exit(1) #-------------------------------------------------------
+    logger.debug(f'All ok, returning {ISO_dirs}')
+    return ISO_dirs
 
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument(
                 "directory",
                 type=str,
-                nargs='+',
-                help="path of media directory containing Synced videos and their ISOs",
+                nargs=1,
+                help="path of media directory containing Synced videos and their .ISO folder",
                 default='.'
                 )
     args = parser.parse_args()
-    # logger.info('arguments: %s'%args)
     logger.debug('args %s'%args)
-    synciso(args.directory)
-        # for e in keylist:
-        #     print(' ', e)
+    ISO_dirs = _get_ISO_dirs(args.directory[0])
+    logger.debug(f'Will check any change in {pformat(ISO_dirs)}')
+    changed_ISOs = [isod for isod in ISO_dirs if _changed(isod)]
+    logger.debug(f'changed_ISOs: {changed_ISOs}')
+    if changed_ISOs != []:
+        print('Will remix audio for:')
+    for p in changed_ISOs:
+        print(p.name)
+    newaudio_and_videos = [(get_mix_file(iso), clip_from_iso(iso)) for iso
+                                                    in changed_ISOs]
+    for audio, video_clip in newaudio_and_videos:
+        print(f'Will remerge {video_clip.name}')
+        _join_audio2video(audio, video_clip)
+    if newaudio_and_videos == []:
+        print('Nothing has changed, bye.')
     sys.exit(0)
 
 if __name__ == '__main__':

tictacsync/timeline.py

@@ -9,14 +9,16 @@ from rich import print
 from itertools import groupby
 # import opentimelineio as otio
 from datetime import timedelta
-import pprint, shutil, os
+import pprint, shutil, os, sys
 from subprocess import Popen, PIPE
 
 from inspect import currentframe, getframeinfo
 try:
     from . import yaltc
+    from . import device_scanner
 except:
     import yaltc
+    import device_scanner
 
 CLUSTER_GAP = 0.5 # secs between multicam clusters
 DEL_TEMP = False
@@ -218,7 +220,6 @@ def _sox_mix_channels(multichan_tmpfl, stereo_pairs=[]) -> tempfile.NamedTempora
         # stereo tracks present, so stereo output
         logger.debug('stereo tracks present %s, so stereo output'%stereo_pairs)
         stereo_files = [_sox_keep(pair) for pair in stereo_pairs]
-    #### ???
     return 
 
 def _sox_mono2stereo(temp_file) -> tempfile.NamedTemporaryFile:
@@ -717,6 +718,7 @@ class AudioStitcherVideoMerger:
             kept_channel = (device.ttc + 1)%2 # 1 -> 0 and 0 -> 1
             logger.debug('no tracks.txt, keeping one chan %i'%kept_channel)
             return _sox_keep(multichan_tmpfl, [kept_channel + 1]) #-------------
+        logger.debug('device.n_chan != 2, so multitrack')
         # it's multitrack (more than 2 channels)
         if device.tracks is None:
             # multitrack but no mix done on location, so do mono mix with all
@@ -728,7 +730,21 @@ class AudioStitcherVideoMerger:
             logger.debug('mixing channels: %s (sox #)'%sox_kept_channels)
             kept_audio = _sox_keep(multichan_tmpfl, sox_kept_channels)
             return _sox_mix_channels(kept_audio) #------------------------------
-        # user wrote a tracks.txt metadata file, check it
+        logger.debug('there IS a device.tracks')
+        # user wrote a tracks.txt metadata file, check it to get the mix(or do
+        # it). But first a check is done if the ttc tracks concur: the track
+        # detected by the Decoder class, stored in device.ttc VS the track
+        # declared by the user, device.tracks.ttc (see device_scanner.py). If
+        # not, warn the user and exit.
+        logger.debug('ttc channel declared for the device: %i, ttc detected: %i, non zero base indexing'%
+                        (device.ttc, device.tracks.ttc))
+        if device.ttc + 1 != device.tracks.ttc: # warn and quit
+            print('Error: TicTacCode channel detected is [gold1]%i[/gold1]'%
+                device.ttc + 1, end=' ')
+            print('and the file [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
+                (device_scanner.TRACKSFN, device.tracks.ttc))
+            print('Please correct the discrepancy and rerun. Quitting.')
+            sys.exit(1)
         if device.tracks.mix == [] and device.tracks.stereomics == []:
             # it's multitrac and no mix done on location, so do a mono mix with
             # all, but here remove '0' and TTC tracks from mix
@@ -741,6 +757,7 @@ class AudioStitcherVideoMerger:
             logger.debug('mixing channels: %s (sox #)'%sox_kept_channels)
             kept_audio = _sox_keep(multichan_tmpfl, sox_kept_channels)
             return _sox_mix_channels(kept_audio) #------------------------------
+        logger.debug('device.tracks.mix != [] or device.tracks.stereomics != []')
         if device.tracks.mix != []:
             # Mix were done on location, no and we only have to extracted it
             # from the recording. If mono mix, device.tracks.mix has one element;
@@ -764,8 +781,10 @@ class AudioStitcherVideoMerger:
             logger.debug('%s mix declared on channel %s (sox #)'%
                     (mix_kind, device.tracks.mix))
             return _sox_keep(multichan_tmpfl, device.tracks.mix) #--------------
-        # if here, all cases have been covered except tracks.txt AND no mix AND
-        # stereo mic(s) so first a coherency check, and then proceed
+        logger.debug('device.tracks.mix == []')
+        # if here, all cases have been covered, all is remaining is this case:
+        # tracks.txt exists  AND there is no mix AND stereo mic(s) so first a
+        # coherency check, and then proceed
         if device.tracks.stereomics == []:
             print('Error, no stereo mic?, check tracks.txt. Quitting')
             sys.exit(1)
@@ -780,6 +799,7 @@ class AudioStitcherVideoMerger:
         logger.debug('stereo_mic_idx_flat %s'%stereo_mic_idx_flat)
         mono_tracks = [i for i in range(1, device.n_chan + 1)
                                 if i not in stereo_mic_idx_flat]
+        logger.debug('mono_tracks: %s'%mono_tracks)
         # remove TTC track number
         mono_tracks.remove(device.ttc + 1)
         logger.debug('mono_tracks %s'%mono_tracks)
@@ -831,8 +851,11 @@ class AudioStitcherVideoMerger:
         synced_clip_file = synced_clip_dir/\
             Path(self.videoclip.new_rec_name).name
         logger.debug('editing files for %s'%synced_clip_file)
-        self.videoclip.final_synced_file = synced_clip_file # relative
-        # collecting edited audio by device, in (Device, tempfile) pairs:
+        self.videoclip.final_synced_file = synced_clip_file # relative path
+        # Collecting edited audio by device, in (Device, tempfile) pairs:
+        # for a given self.videoclip, each audio device will have a sequence
+        # of matched, synced and joined audio files present in a single
+        # edited audio file, returned by _get_concatenated_audiofile_for
         merged_audio_files_by_device = [
                             (d, self._get_concatenated_audiofile_for(d)) 
                             for d in self._get_audio_devices()]
@@ -879,18 +902,6 @@ class AudioStitcherVideoMerger:
         device_mixes = [self._get_device_mix(device, multi_chan_audio)
                 for device, multi_chan_audio
                 in merged_audio_files_by_device]
-
-
-
-        # If multiple audio recorders were used and one of
-        # them has mixL and mixR tracks, two possibilities:
-
-        #     A- others have mixL mixR too: mix of device_mixes are done (and none mix
-        #     tracks are ignored but copied in the ISOs folder if asked)
-        #     B- others don't have mixL-mixR: all tracks from them are panned
-        #     50-50 and stereo-mixed
-
-
         logger.debug('there are %i dev device_mixes'%len(device_mixes))
         logger.debug('device_mixes %s'%device_mixes)
         mix_of_device_mixes = _sox_mix_files(device_mixes)
@@ -910,7 +921,7 @@ class AudioStitcherVideoMerger:
                     in merged_audio_files_by_device]
             logger.debug('devices_and_monofiles: %s'%
                 pprint.pformat(devices_and_monofiles))
-            def _trnm(dev, idx): # used in the list comprehension just below
+            def _trnm(dev, idx): # used in the loop just below
                 # generates track name for later if asked_ISOs
                 # idx is from 0 to nchan-1 for this device
                 if dev.tracks == None:
@@ -928,7 +939,10 @@ class AudioStitcherVideoMerger:
             names_audio_tempfiles = []
             for dev, mono_tmpfiles_list in devices_and_monofiles:
                 for idx, monotf in enumerate(mono_tmpfiles_list):
-                    names_audio_tempfiles.append((_trnm(dev, idx), monotf))
+                    track_name = _trnm(dev, idx)
+                    if track_name[0] == '0': # muted, skip
+                        continue
+                    names_audio_tempfiles.append((track_name, monotf))
             logger.debug('names_audio_tempfiles %s'%names_audio_tempfiles)
             self._write_ISOs(names_audio_tempfiles)
         logger.debug('merged_audio_files_by_device %s'%
@@ -1097,6 +1111,7 @@ class Matcher:
                             videoclip))
             audio_stitch = AudioStitcherVideoMerger(videoclip)
             for audio in audio_recs:
+                logger.debug('checking %s'%audio)
                 if self._does_overlap(videoclip, audio):
                     audio_stitch.add_matched_audio(audio)
                     logger.debug('recording %s overlaps,'%(audio))
@@ -1111,9 +1126,14 @@ class Matcher:
 
     def _does_overlap(self, videoclip, audio_rec):
         A1, A2 = audio_rec.get_start_time(), audio_rec.get_end_time()
+        logger.debug('audio str stp: %s %s'%(A1,A2))
         R1, R2 = videoclip.get_start_time(), videoclip.get_end_time()
-        no_overlap = (A2 < R1) or (A1 > R2)
-        return not no_overlap
+        logger.debug('video str stp: %s %s'%(R1,R2))
+        case1 = A1 < R1 < A2
+        case2 = A1 < R2 < A2
+        case3 = R1 < A1 < R2
+        case4 = R1 < A2 < R2
+        return case1 or case2 or case3 or case4
 
     def shrink_gaps_between_takes(self, with_gap=CLUSTER_GAP):
         """