| import subprocess |
| import os,cv2 |
| import argparse, os, random |
| import multiprocessing as mp |
| from multiprocessing import Manager |
| import logging,sys |
| from itertools import islice |
| logging.basicConfig(level=logging.INFO) |
| parser = argparse.ArgumentParser( |
| formatter_class=argparse.ArgumentDefaultsHelpFormatter) |
| parser.add_argument('--num_workers', |
| default=1, |
| type=int, |
| help="Multi-thread to facilate cropping process") |
| parser.add_argument('--save_dir', |
| required=True, |
| type=str, |
| help="where to save files") |
| parser.add_argument('--timestamp_path', |
| required=True, |
| type=str, |
| help="save path of timestamps") |
| parser.add_argument('--audio_root', |
| required=True, |
| type=str, |
| help="save path of audios") |
| args = parser.parse_args() |
|
|
|
|
| def split_dict(data, num_splits): |
| keys = list(data.keys()) |
| random.shuffle(keys) |
| split_keys = [keys[i::num_splits] for i in range(num_splits)] |
| return [{k: data[k] for k in subset} for subset in split_keys] |
| def frame2second(frame,fps=25): |
| return frame / fps |
| def prepare_timestamp(filename): |
| with open(filename, 'r') as file: |
| lines = file.readlines() |
| start_line = lines[7] if len(lines) >= 8 else None |
| end_line = lines[-1] if len(lines) > 0 else None |
| start_frame = start_line.strip().split("\t")[0] |
| end_frame = end_line.strip().split("\t")[0] |
| |
| return frame2second(int(start_frame)),frame2second(int(end_frame)) |
|
|
| def float_to_timecode(seconds): |
| hours = int(seconds // 3600) |
| minutes = int((seconds % 3600) // 60) |
| secs = seconds % 60 |
| return f"{hours:02}:{minutes:02}:{secs:06.3f}" |
|
|
| def cut_audio(input_path, output_path, start_time, end_time): |
| try: |
| start_timecode = float_to_timecode(start_time) |
| end_timecode = float_to_timecode(end_time) |
| |
| command = [ |
| 'ffmpeg', |
| '-y', |
| '-i', input_path, |
| '-ss', start_timecode, |
| '-to', end_timecode, |
| '-c', 'copy', |
| output_path |
| ] |
| |
| subprocess.run(command, check=True) |
| except subprocess.CalledProcessError as e: |
| print(f"failed extraction: {e}") |
|
|
| def crop_by_spks(spk2audios): |
| for spk, audios in spk2audios.items(): |
| tsf_spk = os.path.join(args.timestamp_path,spk) |
| if not os.path.exists(tsf_spk): |
| logging.info(f"Spk dir {tsf_spk} of timestamp does not exist. Skipping...") |
| continue |
| for audio in audios: |
| tsf_audio = os.path.join(tsf_spk, audio) |
| audio_path = os.path.join(args.audio_root,spk,audio+'.wav') |
| if not os.path.exists(tsf_audio): |
| logging.info(f"audio dir {tsf_audio} of timestamp does not exist. Skipping...") |
| continue |
| if not os.path.exists(audio_path): |
| logging.info(f"audio {audio_path} does not exist. Skipping...") |
| continue |
| os.makedirs(os.path.join(args.save_dir,spk,audio),exist_ok=True) |
| for tsf in os.listdir(tsf_audio): |
| num = tsf.replace(".txt","") |
| ts = os.path.join(tsf_audio,tsf) |
| start_time, end_time= prepare_timestamp(ts) |
| save_audio_path = os.path.join(args.save_dir,spk,audio,num+".wav") |
| cut_audio(audio_path,save_audio_path,start_time,end_time) |
|
|
| if __name__ == '__main__': |
| print("*"*15) |
| print("* Cropping Starts *") |
| print("*"*15) |
| os.makedirs(args.save_dir,exist_ok=True) |
| os.makedirs(os.path.join(args.save_dir,"audio"),exist_ok=True) |
| spk2audios_loc = "data/spk2videos" |
| assert os.path.exists(spk2audios_loc) |
| spk2audios = {line.split()[0]:line.strip().split()[1:] for line in open(spk2audios_loc)} |
| workers = min(args.num_workers,len(spk2audios)) |
| spk2audios_slices = split_dict(spk2audios,workers) |
| pool = mp.Pool(processes=workers) |
| pool.map(crop_by_spks, spk2audios_slices) |
| pool.close() |
| pool.join() |
|
|
| |
