tictacsync 0.3a4__py3-none-any.whl → 0.5a0__py3-none-any.whl

tictacsync/device_scanner.py

@@ -77,6 +77,7 @@ class Device:
     name: str
     dev_type: str # CAM or REC
     n_chan: int
+    ttc: int
     tracks: Tracks
     def __hash__(self):
         return self.UID
@@ -89,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:
@@ -113,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, 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):
     """
@@ -140,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]
@@ -154,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
 
@@ -256,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]
@@ -273,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:')
@@ -285,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
@@ -342,32 +346,22 @@ class Scanner:
             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)
+            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('Error, quitting: in file %s, %s'%(tracks_file, err_msg))
                 raise Exception
             else:
+                logger.debug('tracks object%s'%tracks)
                 return tracks
         else:
             logger.debug('no tracks.txt file found')
             return None
 
-    # def _use_folder_as_device_name(self):
-    #     """
-    #     For each media in self.found_media_files replace existing Device.name by
-    #     folder name.
-
-    #     Returns nothing
-    #     """
-    #     for m in self.found_media_files:
-    #         m.device.name = m.path.parent.name
-    #     logger.debug(self.found_media_files)
-
     def _check_folders_have_same_device(self):
         """
         Since input_structure == 'folder_is_device,

tictacsync/entry.py

@@ -126,10 +126,10 @@ def main():
     # 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"] == "media_at_path")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_media_and_build_devices_UID")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_sox_multi2mono")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_mix")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_sox_mix")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_device_mix")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_sox_mix_files")
     top_dir = args.directory[0]
     if os.path.isfile(top_dir):
         file = top_dir
@@ -234,7 +234,7 @@ def main():
             print('\nNothing to sync, exiting.\n')
         sys.exit(1)
     matcher = timeline.Matcher(recordings_with_time)
-    matcher.scan_audio_for_each_ref_rec()
+    matcher.scan_audio_for_each_videoclip()
     if not matcher.video_mergers:
         if not args.terse:
             print('\nNothing to sync, bye.\n')
@@ -263,11 +263,11 @@ def main():
     print('\nWrote output in folder [gold1]%s[/gold1]'%(
             a_stitcher.synced_clip_dir))
     for stitcher in matcher.video_mergers:
-        print('[gold1]%s[/gold1]'%stitcher.ref_recording.AVpath.name, end='')
+        print('[gold1]%s[/gold1]'%stitcher.videoclip.AVpath.name, end='')
         for audio in stitcher.get_matched_audio_recs():
             print(' + [gold1]%s[/gold1]'%audio.AVpath.name, end='')
-        new_file = stitcher.ref_recording.final_synced_file.parts
-        print(' became [gold1]%s[/gold1]'%stitcher.ref_recording.final_synced_file.name)
+        new_file = stitcher.videoclip.final_synced_file.parts
+        print(' became [gold1]%s[/gold1]'%stitcher.videoclip.final_synced_file.name)
         # matcher._build_otio_tracks_for_cam()
     matcher.shrink_gaps_between_takes()
     sys.exit(0)
@@ -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__':