def get_video_parts(self, video_filename=None, start_time=0, end_time=0, steps_num=1): if not video_filename: video_filename = self.config['VideoSection']['sample_video'] output_video_location = self.config['VideoSection']['video_output'] if not video_filename: print("Error getting video") return False base_name_ext = os.path.basename(video_filename) base_name = base_name_ext.split('.')[0] if not output_video_location: print("Error finding output location") output_video_location = 'test_video_' output_video_name = f'{output_video_location}{base_name}' with VideoFileClip(video_filename) as video: audio = video.audio max_duration = video.duration if video.duration < audio.duration else audio.duration if start_time >= max_duration: print('Video Editor: start_time exceeds max video duration') return end_time = max_duration if max_duration <= end_time else end_time targetname = f'{output_video_name}{start_time}_to_{end_time}.mp4' ffmpeg_extract_subclip(video_filename, start_time, end_time, targetname=targetname)
def install_insta(self): '''Скачивание видео из инстаграма''' link_to_video = self.request.GET['link'] response = requests.get(link_to_video) text_for_parser = response.content text_for_parser = str(text_for_parser) regxp = '(http[^"]+mp4)' result = [] result = re.findall(regxp, text_for_parser) try: url = result[0] except: return 'link_error' timeof = self.request.GET['timeof'].split(':') timeto = self.request.GET['timeto'].split(':') timeof_seconds = int(timeof[0]) * 60 + int(timeof[1]) timeto_seconds = int(timeto[0]) * 60 + int(timeto[1]) if timeto_seconds - timeof_seconds > 30 and timeto_seconds - timeof_seconds < 1: return 'time_error' link = link_to_video.split('?')[0] + '?__a=1' response = requests.get(link_to_video).text soup = BeautifulSoup(response, 'lxml') for heading in soup.find_all(re.compile("^script")): if heading.text.strip()[0:18] == 'window._sharedData': arr_link = heading.text.strip('window._sharedData = ').split('video_url')[1].split('"')[2].strip().split('\\u0026') url = '' for i in arr_link: url += i + '&' ffmpeg_extract_subclip(url, timeof_seconds, timeto_seconds, targetname="audio/{}.mp4".format(self.name)) return 'ok'
def test_ffmpeg_extract_subclip(util): extract_subclip_tempdir = os.path.join( util.TMP_DIR, "moviepy_ffmpeg_extract_subclip" ) if os.path.isdir(extract_subclip_tempdir): shutil.rmtree(extract_subclip_tempdir) os.mkdir(extract_subclip_tempdir) inputfile = os.path.join(extract_subclip_tempdir, "fire2.mp4") shutil.copyfile("media/fire2.mp4", inputfile) # default name expected_outputfile = os.path.join(extract_subclip_tempdir, "fire2SUB300_500.mp4") ffmpeg_extract_subclip(inputfile, 0.3, "00:00:00,5", logger=None) assert os.path.isfile(expected_outputfile) # custom name expected_outputfile = os.path.join(extract_subclip_tempdir, "foo.mp4") ffmpeg_extract_subclip( inputfile, 0.3, "00:00:00,5", outputfile=expected_outputfile, logger=None ) assert os.path.isfile(expected_outputfile) # assert subclip duration clip = VideoFileClip(expected_outputfile) assert 0.18 <= clip.duration <= 0.22 # not accurate if os.path.isdir(extract_subclip_tempdir): try: shutil.rmtree(extract_subclip_tempdir) except PermissionError: pass
def separate(input_path: str, output_directory: str, name: str): if (not os.path.exists(output_directory)): os.mkdir(output_directory) video = VideoFileClip(input_path) times = int((video.duration) / 30) init_time = 0 final_time = 30 is_multiple_of_thirty = isinstance((video.duration / 30), int) for i in range(times): ffmpeg_extract_subclip(input_path, init_time, final_time, targetname=output_directory + name + "-" + str(i) + ".mp4") init_time += 30 final_time += 30 video.close() if (not is_multiple_of_thirty): video = VideoFileClip(input_path) rest = int(video.duration - (times * 30)) init_rest_time = times * 30 final_rest_time = init_rest_time + rest ffmpeg_extract_subclip(input_path, init_rest_time, final_rest_time, targetname=output_directory + name + "-" + str(times) + ".mp4") video.close()
def split_videos(labels_path, videos_path, target_path): """ This function splits the given videos into small chunks of videos corresponding to each delivery. It takes the csv files in the label path which has a separate file for each video and corresponding video file from videos_path and does the splitting according to the csv data""" no_videos = len(glob.glob(labels_path + "/*.csv")) for i in range(1, no_videos + 1): file1 = labels_path + "/" + str( i) + ".csv" #csv file must be named like "1.csv", 2.csv file2 = videos_path + "/" + str( i) + ".mp4" #video file must be named like "1.mp4", "2.mp4" obj = pd.read_csv(file1) for j in range(len(obj)): target = target_path + "/" + str(count) + ".mp4" ffmpeg_extract_subclip(file2, obj['s'][j], obj['e'][j], targetname=target) csv.append([ "video" + str(count) + ".mp4", obj['ba'][j], obj['bo'][j], obj['ty'][j], i, j + 1, obj['e'][j] - obj['s'][j] ]) count = count + 1 csv = pd.DataFrame(csv, columns=[ 'File', 'Batsman', 'Bowler', 'Delivery', 'Video', 'index', 'Time' ]) csv.to_csv(targets_path + "/processed_file.csv", index=False)
def video_to_frames(video_url, res, video_name, length): """ video_url: url of youtube video res: resolution; eg '144p' video_name: name of video length: trim length """ # grab YouTube object from url and download it to data/ yt = get_yt(video_url) if yt is None: return download_video(yt, res, video_name) # trim to first length seconds ffmpeg_extract_subclip('data' + res + '/' + video_name + '.mp4', 0, length, targetname='data' + res + '/' + video_name + '_trimmed.mp4') # loads video and extracts frame by frame vid_cap = cv2.VideoCapture('data' + res + '/' + video_name + '.mp4') success, image = vid_cap.read() count = 0 while success: if not os.path.exists("video_frames" + res): os.makedirs("video_frames" + res) cv2.imwrite("video_frames" + res + "/frame%d.jpg" % count, image) # save frame as JPEG file success, image = vid_cap.read() print('Read a new frame: ', success) count += 1
def upload_video(self, item, filename): full_path = str(Path("./videos/{f}.mp4".format(f=filename))) video = requests.get(item["url"]) open(full_path, "wb").write(video.content) if item["cut"] == True: new_path = str(Path("./videos/{f}_cut.mp4".format(f=filename))) ffmpeg_extract_subclip(full_path, 0, 59, targetname=new_path) os.remove(full_path) full_path = new_path xd = self.api.prepare_direct_video(item["userid"], full_path) try: self.api.send_direct_video(xd) except Exception as e: rnd = random.randint(1, 5) time.sleep(rnd) self.api.send_direct_video(xd) user = self.cfg.get_user(item["userid"]) cfg.user_add_download(item["userid"], item["username"], item["download_from"]) cfg.day_add_download() logging.info("{d} successfully downloaded a video from {u}".format( d=item["username"], u=item["download_from"])) logging.info("Timespan since sent video: {0}ms".format( str((time.time() * 1000 // 1) - item["sent"] // 1000))) self.cfg.capture_delay(int(time.time() - item["sent"] // 1000000), item["priority"]) if os.path.exists(full_path): os.remove(full_path)
def cut_clips(data): for line in data: videoName = line[0] if videoName + '.mp4' not in videoNames: continue actionId = int(line[-1].strip()) # I only want fall-down action if actionId != 5: continue if videoName != prename: count = 0 else: count += 1 middleTimeStamp = int(line[1]) startTime = middleTimeStamp - 2.0 endTime = middleTimeStamp + 1.5 targetVideo = os.path.join(videoFolder, videoName + '-' + str(count) + '-cut.mp4') ffmpeg_extract_subclip(os.path.join(videoFolder, videoName + '.mp4'), startTime, endTime, targetname=targetVideo)
def cutAndScaleVideo(file, start, end, width, height): fileName = file.replace('.mp4', '') ffmpeg_extract_subclip(file, start, end, targetname=fileName + "_cutted.mp4") escape = 27 #fourcc = cv2.VideoWriter_fourcc(*'MPEG') fourcc = cv2.VideoWriter_fourcc(*'FMP4') out = cv2.VideoWriter(fileName + '_cutted_scaled.mp4', fourcc, 20, (width, height)) capture = cv2.VideoCapture(fileName + '_cutted.mp4') while capture.isOpened(): ret, frame = capture.read() if ret: sky = frame[300:1300, 200:900] resized_frame = cv2.resize(sky, (width, height), fx=0, fy=0, interpolation=cv2.INTER_CUBIC) out.write(resized_frame) cv2.imshow('', resized_frame) else: break key = cv2.waitKey(1) if key == escape: break capture.release() out.release()
def check_save_video(item, url, settings): # First: Check if the video is new (is not in the video backup directory) # Second: If new trims the video, saves the video and finally returns the path of the video, if not new return False destination_dir = f"{settings['vid_backup_dir']}".format( arrow.utcnow().format("DD-MM-YYYY")) destination_path_beforetrimming = os.path.join(destination_dir, f"trim_me.mp4") destination_path_final = os.path.join(destination_dir, f"{item['id']}.mp4") if os.path.isfile(destination_path_final): print(f"Video {destination_path_final} already exists.") return False elif not os.path.isfile(destination_path_final): os.makedirs(destination_dir, exist_ok=True) ydl_opts = { "format": "mp4", "outtmpl": destination_path_beforetrimming, } with youtube_dl.YoutubeDL(ydl_opts) as ydl: ydl.download([url]) # trim video to 10 seconds print("Triming video...") ffmpeg_extract_subclip(destination_path_beforetrimming, 0, 9, targetname=destination_path_final) os.remove(destination_path_beforetrimming) return destination_path_final
def sync_videos(videofile, visualise=False, output='output.mov'): clip = mp.VideoFileClip(videofile) waveform = clip.audio.to_soundarray() fs = waveform.shape[0] // clip.duration audio = AudioProcessing(waveform, fs, clip.fps) bandpass = audio.filter((3700, 4000), btype='bandpass', order=7) # plot onsets from bandpass mono = peaks = bandpass.detect_onsets() n1 = parse_input('Select start peak: ') n2 = parse_input('Select end peak (-1 for EOF): ') if n1 >= len(peaks): print(f'error - peak {n1} does not exists') err = True if n2 >= len(peaks) or (n2 < -1): print(f'error - peak {n2} does not exists or invalid') err = True if n2 != -1 and n1 >= n2: print(f'error - peak2 must be greater than peak1') err = True if err: print('fatal error has occured') exit(0) if output: ffmpeg_extract_subclip(videofile, peaks[n], clip.duration, output)
def cut_lecture_mp4(video_path, save_path, lecture_trim_path): print("\n[lec mp4 CUT 시작] 원본 강의의 mp4 파일 CUT을 시작합니다") time_csv = pd.read_csv(save_path) # 디렉토리 유무 검사 및 디렉토리 생성 try: if not os.path.exists(lecture_trim_path): # 디렉토리 없을 시 생성 os.makedirs(lecture_trim_path) except OSError: print('Error: Creating directory. ' + lecture_trim_path) # 디렉토리 생성 오류 for i in range(len(time_csv["time"])): fileName = "lec_" + set_Filenum_of_Name(i + 1) + ".mp4" fileName = lecture_trim_path + fileName if i == (len(time_csv["time"]) - 1): # 마지막 클립 cut_point_start = int(time_csv["time"][i]) clip = VideoFileClip(video_path) ffmpeg_extract_subclip(video_path, cut_point_start, clip.duration, targetname=fileName) else: # 처음, 중간 클립 cut_point_start = int(time_csv["time"][i]) cut_point_end = int(time_csv["time"][i + 1]) ffmpeg_extract_subclip(video_path, cut_point_start, cut_point_end, targetname=fileName) print(">>> >>>", i + 1, "번째 클립 mp4 파일 생성 완료") print("\n[lec mp4 CUT 시작] 원본 강의의 mp4 파일 CUT을 종료합니다")
def process(video_path: str, credentials): from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip ffmpeg_extract_subclip(video_path, 0, 30, targetname=video_path.replace('.mp4', '_cuted.mp4')) video_path = video_path.replace('.mp4', '_cuted.mp4') video_path = decrease_fps(video_path) video = cv2.VideoCapture(video_path) video_seconds = int( video.get(cv2.CAP_PROP_FRAME_COUNT) / video.get(cv2.CAP_PROP_FPS)) extracted_labels = extract_labels(video_path, credentials) results = pd.DataFrame(data={'second': list(range(1, video_seconds))}) results[EXPECTED_LABELS] = 0 for _, row in extracted_labels.iterrows(): label = row['label'] assigned_labels = get_similar_label(label, 0.55) if label else None for assigned_label in assigned_labels: results.loc[(row['start_time'] < results['second']) & (results['second'] <= row['end_time']), assigned_label] = 1 return results
def splitter(day, streamtime, i): offset = datetime.datetime.utcnow() - datetime.datetime.now() matchtimestamp = i.actual_time + offset starttime = matchtimestamp - streamtime endtime = starttime + 180 ffmpeg_extract_subclip('{}.mp4'.format(day), starttime, endtime, '{}.mp4'.format(i.key))
def trim_video(video_path, start_time, end_time): file_name = video_path.split('/')[-1] ffmpeg_extract_subclip(video_path, start_time, end_time, targetname=os.path.join('python_files', 'instance', 'videos', file_name))
def download_file(filename, prefix, num_videos=None): try: os.mkdir('{}_videos'.format(prefix)) except Exception as e: print(e) try: os.mkdir('{}_audio'.format(prefix)) except Exception as e: print(e) num_downloaded = 0 with open(filename) as csv_file: csv_reader = csv.reader(csv_file, delimiter=',') for row in csv_reader: video_id = row[0] end_time = string_to_int(row[1]) start_time = end_time - 1 url = 'http://youtube.com/watch?v={}'.format(video_id) try: yt = YouTube(url) except: print('Error when trying to fetch video') continue if int(yt.length) > 500: continue filtered = yt.streams.filter(res='360p', mime_type='video/mp4', fps=30, progressive=True) if not filtered.all(): continue num_downloaded += 1 itag = filtered.first().itag filename = '{}.mp4'.format(video_id) filename_mp4 = '{}.mp4'.format(video_id) original_video_location = f'videos/{filename}' keyframe_video_location = f'videos/key-{filename}' download_video(url, itag, filename=original_video_location) start_min = start_time//60 start_sec = start_time%60 subprocess.call(f'ffmpeg -i {original_video_location} -force_key_frames 00:{start_min}:{start_sec} {keyframe_video_location}', shell=True) ffmpeg_extract_subclip(keyframe_video_location, start_time, end_time, targetname='{}_videos/{}'.format(prefix, filename_mp4)) extract_audio(prefix, video_id) os.remove(original_video_location) os.remove(keyframe_video_location) if num_videos and num_downloaded == num_videos: break
def extractVideoClip(self, file, startTime, endTime, filename='subclip'): ffmpeg_extract_subclip(f'{file}.mp4', startTime, endTime, targetname=f'{filename}.mp4') return True
def extract_videos_from_annotations_colab(video_name, eaf_file_name, gloss_list): """ Function to extract videos from eaf annotations. Additionally it creates folders with the extracted frames for each video. """ def check_folders(gl_name): directory1 = "openpose/" + gl_name + "/" if not os.path.exists(directory1): os.makedirs(directory1) file = pympi.Eaf(file_path=eaf_file_name) tier_names = file.get_tier_names() for tier_name in tier_names: annotations = file.get_annotation_data_for_tier(tier_name) count = 0 for annotation in annotations: for gloss in gloss_list: if annotation[2] == gloss: start = annotation[0] end = annotation[1] print(start / 1000, end / 1000) check_folders(gloss) ffmpeg_extract_subclip(video_name, start / 1000, end / 1000, targetname="openpose/" + str(gloss) + "/" + "%#05d.mp4" % (count + 1)) # Comment next line if you don't want to extract the frames for each video # video_to_frames("Data/"+str(gloss)+"/Videos/"+"%#05d.mp4" % (count+1), "Data/"+str(gloss)+"/"+"%#05d" % (count+1) ) count = count + 1 if count == 0: print("No annotation found with this name")
def status_maker(self): self.disable_button() file = self.op.text reading_directory = os.path.dirname(file) basename = os.path.basename(file) basename_root = os.path.splitext(basename)[0] ext = os.path.splitext(basename)[1] if ext == ".mp4": os.chdir(reading_directory) #changing file directory writing_directory = os.path.join(reading_directory, basename_root + "_WA_Status") if not os.path.exists(writing_directory): os.mkdir(writing_directory) os.chdir(writing_directory) size = VideoFileClip(file).duration i = 0 ii = 1 while i < size: try: ffmpeg_extract_subclip(file, i, i + 25, str(ii) + ext) except: self.status.text = "Error: File Could not be manipulated." i += 25 ii += 1 self.status.text = f"Your o/p saved in {writing_directory}" else: self.status.text = f"Extension Error. Choose .mp4 extension." self.enable_button()
def cut_video_by_scenes(self): try: scenes = find_scenes( video_path=f"{self.path_to_videos}/{self.last_video_id}.mp4", threshold=50.0) self.number_of_scenes = len(scenes[5:-5]) for index, scene in enumerate(scenes[5:-5]): start_scene_seconds = to_secondes(time=str(scene[0]), time_format="%H:%M:%S.%f") end_scene_seconds = to_secondes(time=str(scene[1]), time_format="%H:%M:%S.%f") if int(end_scene_seconds) - int(start_scene_seconds) < 15: continue # Enlever les deux premières secondes pour corriger les erreurs de cuts start_scene_seconds = start_scene_seconds + 2 ffmpeg_extract_subclip( filename=f"{self.path_to_videos}/{self.last_video_id}.mp4", t1=start_scene_seconds, t2=end_scene_seconds, targetname= f"{self.path_to_cutted_videos}/{self.last_video_id}_{index}.mp4" ) self.cutted_videos.append(f"{self.last_video_id}_{index}") print('cut_video_by_scenes: DONE') except Exception as e: logging.error(e)
def split_movie(inputfile, number): clip = VideoFileClip(inputfile) start = 0.0 total = math.floor(clip.duration) segment = total // number filename, extension = os.path.splitext(inputfile) print(filename) endpoints = [] for i in range(number): if i == number - 1: endpoints.append(clip.duration) else: endpoints.append(segment * (i + 1)) pieces = [] for point in endpoints: pieces.append((start, point)) start = point for i, piece in enumerate(pieces): name = filename + "_" + str(i + 1) + extension ffmpeg_extract_subclip(inputfile, piece[0], piece[1], name) print("Splitting %s into file %s..." % (inputfile, name))
def frames_to_videos(original_videos_path, frame_indices_dict, results_clips_path): """ :param original_videos_path: path to the videos :param frame_indices_dict: indices of the frames as a result of the search :param results_clips_path: path to the directory where the resulting videos are saved :return: """ print('Constricting video clips ...') t = time.time() for video in frame_indices_dict.keys(): if frame_indices_dict[video] == []: continue else: count = 0 if not os.path.exists(os.path.join(results_clips_path, video)): os.mkdir(os.path.join(results_clips_path, video)) for i, item in enumerate(frame_indices_dict[video]): target_path = os.path.join(results_clips_path, video, "subvideo_{}.mp4".format(count)) start_time = item[0] end_time = item[-1] ffmpeg_extract_subclip(os.path.join(original_videos_path, "{}".format(video)), start_time - 1, end_time + 1, targetname=target_path) count += 1 elif os.path.exists(os.path.join(results_clips_path, video)) and len( os.listdir(os.path.join(results_clips_path, video))) > 0: print("{} directory exists and is not empty".format(os.path.join(results_clips_path, video))) print('Done constructing video clips ... {} seconds'.format(time.time() - t))
def cut_movie(file_dir): for root, dirs, files in os.walk(file_dir): # print(root) # 当前目录路径 # print(dirs) # 当前路径下所有子目录 # print(files) # 当前路径下所有非目录子文件 if len(files) >= 1 and "out_to" not in dirs: # print(len(files)) print("发现需处理的文件") for file_info in files: # print(file_info[-3:]) if file_info[-3:] == "mp4": # 新建输出文件夹 if not os.path.exists(root + "\\out_to\\"): os.makedirs(root + "\\out_to\\") # print(file_info) # 获取视频时间 file_dirs = root + "\\" + file_info # print(file_dirs) clip = VideoFileClip(file_dirs) # print(clip.end) # 分割 print(root + "\\out_to\\" + file_info) ffmpeg_extract_subclip( file_dirs, 3.4, clip.end - 9.8, targetname=root + "\\out_to\\" + file_info.replace(" ", "").replace("000", "")) time.sleep(1.5) clean_ffmpeg()
def split_video(videofile): """ Given a path to a video file, load the video and split the videos into 30 second segments. The last segment would be the rest of the video, even if it's less than 30 seconds. The video segments are saved with the original name followed by their number, in the same folder as the original video. Example: input file = "example.mp4" -> "example1.mp4" "example2.mp4" "example3.mp4" """ clip = VideoFileClip(videofile) start = 0 end = clip.duration i = 1 filename = videofile.split('.') extension = filename[1] filename = filename[0] while start + 30 <= end: target_name = filename + str(i) + '.' + extension ffmpeg_extract_subclip(videofile, start, start + 30, targetname=target_name) start += 30 i += 1 target_name = filename + str(i) + '.' + extension ffmpeg_extract_subclip(videofile, start, end, targetname=target_name)
def install_vk(self): '''Скачивание видео из вк''' videos = self.request.GET['link'].strip('https://vk.com/video') videos = videos.split('?')[0] token = 'ae1f79f5b6f3ff797737b9462904dc1c0b531fb8a95e3cff8d8ea45d2dab94fb223ba4a814879dfc7c829' vk = vk_api.VkApi(token=token) vk._auth_token() video_url = vk.method("video.get", { 'videos' : videos, 'extended': True, }) if len(video_url['items']) > 0: url = video_url['items'][0]['files']['mp4_240'] else: return 'link_error' timeof = self.request.GET['timeof'].split(':') timeto = self.request.GET['timeto'].split(':') timeof_seconds = int(timeof[0]) * 60 + int(timeof[1]) timeto_seconds = int(timeto[0]) * 60 + int(timeto[1]) if timeto_seconds - timeof_seconds > 30 and timeto_seconds - timeof_seconds < 1: return 'time_error' ffmpeg_extract_subclip(url, timeof_seconds, timeto_seconds, targetname="audio/{}.mp4".format(self.name))# + '000' # ffmpeg_extract_audio("audio/{}.mp4".format(self.name + '000'), "audio/{}.mp4".format(self.name), bitrate=3000, fps=44100) # path = os.path.join(os.path.abspath(os.getcwd()), 'audio/{}.mp4'.format(self.name + '000')) # os.remove(path) return 'ok'
def extract_subclips(annots, counter, output_folder): csv = [] for i in range(len(annots)): video_name, start_time, end_time, label = annots[i] if "test" in video_name: ffmpeg_extract_subclip( "./videos/test/{}.mp4".format(video_name), float(start_time), float(end_time), targetname="./new_videos/{}/{:05d}.mp4".format( output_folder, counter)) elif "validation" in video_name: ffmpeg_extract_subclip( "./videos/val/{}.mp4".format(video_name), float(start_time), float(end_time), targetname="./new_videos/{}/{:05d}.mp4".format( output_folder, counter)) csv.append("{};{}".format(counter, label)) counter += 1 if i % 50 == 0: print("-- \t{} / {} ({}%)".format( i, len(annots), round(i / len(annots) * 100.0, 2))) return csv, counter
def cut_patches(clip_config, temp_dir): Utils.log(" [Tailor] Cutting patch from (%s)" % (clip_config["name"])) ffmpeg_extract_subclip(clip_config["name"], clip_config["start_at"], clip_config["end_at"], targetname=temp_dir + "/" + Tailor.CLIP_PREFIX + clip_config["name"])
def makevideofromvideos(video_filenames, video_length): print("Making the video...") path = DIRECTORY directory = sorted(os.listdir(path)) video_list = video_filenames print("VIDEO PRESENT: ", video_list) os.chdir("..") os.chdir(path) name_list = [] vidcount = 1 print("VIDEO LENGTH: ", video_length) for vid in video_list: print("VID:", vid) vidname = "video" + str(vidcount) + ".mp4" print("vidname:", vidname) my_clip = mp.VideoFileClip(vid) if my_clip.duration > video_length: start_time = 0 end_time = video_length ffmpeg_extract_subclip(vid, start_time, end_time, targetname=vidname) else: start_time = 0 end_time = my_clip.duration ffmpeg_extract_subclip(vid, start_time, end_time, targetname=vidname) name_list.append(vidname) vidcount += 1 return name_list os.chdir("..")
def Splitter(spl_file): video = VideoFileClip(spl_file) vtime = video.duration vsize = os.stat(spl_file).st_size / (1024 * 1024) #size in MB time_per_clip = int(50 * vtime / vsize) if vsize <= 50: return start = 0 end = time_per_clip i = 1 while end <= vtime: ffmpeg_extract_subclip(spl_file, start, end, targetname=str(i) + "_" + spl_file) start += time_per_clip end += time_per_clip i += 1 if end > vtime and start < vtime: ffmpeg_extract_subclip(spl_file, start, vtime, targetname=str(i) + "_" + spl_file)
def main(file_name: str): uploadable_size = 900000000 duration, size = get_duration(file_name), get_size(file_name) divide = size // uploadable_size time, time_table = 0, [0] chunks = duration // divide while time < duration: time += chunks time_table.append(round(time)) time_table.pop() if time_table[-1] < duration: time_table.pop() time_table.append(round(duration)) total_split = [] for t in range(1, len(time_table)): new_name = file_name[:-4] + f'{t:02}' + file_name[-4:] total_split.append(new_name) ffmpeg_extract_subclip(file_name, time_table[t - 1], time_table[t], targetname=new_name) print("Completed Split!")