def abridge_clip(
path: str,
out_dir: str = "processed",
diff_threshold: float = 20,
repetition_threshold: int = 5,
) -> None:
"""
Splice and render out the given clip with the given processing attributes
"""
clip = VideoFileClip(path)
clipname = ntpath.basename(path)
cuts: List[Tuple[float, float]] = _find_voids(
clip, diff_threshold, repetition_threshold
)
print(f"{clipname} - Removing empty sections")
before_time = clip.duration
clip = _apply_cuts(clip, cuts)
after_time = clip.duration
print(
f"{clipname} - Removed {before_time - after_time}s from footage. (before: {before_time}s, after: {after_time}s)"
)
with ui.ProgressBar(f"{clipname} - Rendering", 1) as progress:
clip.write_videofile(os.path.join(out_dir, clipname), logger=progress)
clip.close()
def configure_video(self, upload_id, video, thumbnail, caption=''):
clip = VideoFileClip(video)
self.upload_photo(photo=thumbnail,
caption=caption,
upload_id=upload_id)
data = json.dumps({
'upload_id': upload_id,
'source_type': 3,
'poster_frame_index': 0,
'length': 0.00,
'audio_muted': False,
'filter_type': 0,
'video_result': 'deprecated',
'clips': {
'length': clip.duration,
'source_type': '3',
'camera_position': 'back',
},
'extra': {
'source_width': clip.size[0],
'source_height': clip.size[1],
},
'device': DEVICE_SETTINTS,
'_csrftoken': self.token,
'_uuid': self.uuid,
'_uid': self.username_id,
'caption': caption,
})
clip.close()
return self.send_request('media/configure/?video=1',
self.generate_signature(data))
def main():
while True:
start_time = datetime.now()
folder_location = input("Enter Folder Location: ")
output_location = input("Enter Output Location: ")
trim_start = input("Enter Seconds to Trim From Start: ")
trim_end = input("Enter Seconds to Trim From End: ")
folder = os.listdir(folder_location)
print(f'{start_time}: Processing {len(folder)} files...')
for file in folder:
if file.endswith('.mp4'):
file_name = f"{folder_location}\\{file}"
video_file = VideoFileClip(file_name).cutout(
0, float(trim_start))
new_file_duration = float(
video_file.duration) - float(trim_end)
video_file.duration = new_file_duration
name_array = file.split('-')
new_file_name = f"{name_array[0].strip()} - {name_array[1].strip()}.mp4"
video_file.write_videofile(
f"{output_location}\\{new_file_name}")
video_file.close()
end_time = datetime.now()
print(f'Ended in {end_time - start_time} seconds')
continue_input = input("Should I update another folder? (y or n): ")
if continue_input.lower() == "n":
return False
def segment_video(video_file):
try:
clip = VideoFileClip(str(video_file))
video_length = int(clip.duration * 1000)
step_length = int(constants.SEGMENT_LENGTH * 1000)
clip.close()
scene_index = 0
segments = []
for scene in range(0, video_length, step_length):
start = time_handler.timestamp_to_str(scene)
end = time_handler.timestamp_to_str(scene + step_length)
segments.append({
'scene': scene_index,
'start': start,
'end': end
})
scene_index += 1
if SAVE_TO_FILE:
file_handler.save_to_video_file(video_file, SCENES_KEY, segments)
return segments
except Exception as e:
logging.exception(e)
def clip_movie(movie_file_path, periods, chara_crop_dir,
movie_encoded_file_name):
video = VideoFileClip(movie_file_path, fps_source="fps")
for period in periods:
[start_frame, end_frame] = list(map(int, period.split('-')))
start_time = calc_elapsed_time(start_frame, video.fps)
end_time = calc_elapsed_time(end_frame, video.fps)
clip = video.subclip(start_time, end_time)
[filename, ext] = os.path.splitext(os.path.basename(movie_file_path))
norm_filename = re.sub(r'[\\|/|:|?|.|"|<|>|\|]', '-',
f"{start_time}_{end_frame}")
output_dir = os.path.join(chara_crop_dir, filename)
dst = os.path.join(output_dir, f"{norm_filename}{ext}")
if os.path.exists(dst):
continue
if not os.path.exists(output_dir):
os.makedirs(output_dir, exist_ok=True)
final = concatenate_videoclips([clip])
final.write_videofile(
dst,
fps=video.fps,
codec=config["video_codec"],
audio_codec=config["audio_codec"],
)
video.close()
def export(self):
if self.clip is not None:
print("Saving frame_ini = {}, frame_end = {}".format(
self.selected_frame_ini, self.selected_frame_end))
_video = VideoFileClip(self.path_video)
_fpms = _video.fps / 1000
sub_video = _video.subclip(self.selected_frame_ini * _fpms,
self.selected_frame_end * _fpms)
export_base_path = os.path.splitext(self.path_video)[0]
sub_video_path = export_base_path + "_edited.mp4"
sub_video.write_videofile(filename=sub_video_path,
codec="mpeg4",
audio_codec='aac')
_video.close()
self.export_data = {
"video_path": self.path_video,
"video_fps": _video.fps,
"sub_video_path": sub_video_path,
"exported_date": datetime.now(),
"selected_frame_ini": self.selected_frame_ini,
"selected_frame_end": self.selected_frame_end
}
with open(export_base_path + "_edited_data.json",
'w') as json_file:
json.dump(self.export_data, json_file, default=str)
def mp3(URL):
video = YouTube(URL)
stream = video.streams.get_lowest_resolution()
stream.download(os.getcwd()+"/tmp",filename="video")
audio = VideoFileClip(os.getcwd()+"/tmp/"+"video.mp4")
audio.audio.write_audiofile(os.getcwd()+"/tmp/"+"audio.mp3")
audio.close()
os.rename(os.getcwd()+"/tmp/"+"audio.mp3",os.getcwd()+"/tmp/"+ stream.default_filename[:-4] +".mp3")
audio = eyed3.load("tmp/"+ stream.default_filename[:-4] +".mp3")
if (audio.tag == None):
audio.initTag()
thumb = video.thumbnail_url
thumb = requests.get(thumb)
with open("tmp/cover.jpg", "wb") as f:
f.write(thumb.content)
print("writting Data...")
audio.tag.images.set(3, open('./tmp/cover.jpg','rb').read(), 'image/jpeg')
audio.tag.artist=video.author
audio.tag.title=video.title
audio.tag.save()
os.rename(os.getcwd()+"/tmp/"+ stream.default_filename[:-4] +".mp3",os.getcwd()+"/mp3/"+ stream.default_filename[:-4] +".mp3")
def test_builds_correctly():
'''
This test ensures that a valid .mp4 video is created using images from the testing
directory.
'''
src_dir = os.path.join(TLD, 'testing', 'Killer Croc video')
dest_dir = "/tmp/"
filename = "test_KROC.mp4"
fps = random.randrange(MIN_FPS, MAX_FPS + 1)
ctx = StopMotionCTX(src=src_dir, dst=dest_dir, fps=fps, name=filename)
yellow_print(
f"Creating a {ctx.movie_len:.2f} second movie at {ctx.fps} fps: "
f"{os.path.join(dest_dir, filename)}...")
ctx.generate_clip()
green_print("Created.")
yellow_print(
f"Verifying created video has correct duration ({ctx.movie_len:.2f}s)..."
)
clip = VideoFileClip(ctx.full_name)
duration = clip.duration
clip.close()
assert abs(duration - ctx.movie_len) < LENGTH_MIN_ACCURACY
green_print("File is correct duration.")
yellow_print("Removing created video...")
assert os.remove(ctx.full_name) is None
green_print("Video file removed.")
def clip_duration(invideoF):
from moviepy.editor import VideoFileClip
clip = VideoFileClip(invideoF)
clip_duration = clip.duration
clip.close()
clip.close()
return clip_duration
def build_sample_slices(feed_dir, speaker_key):
filename = '{}/{}.mp4'.format(feed_dir, speaker_key)
video = VideoFileClip(filename)
duration = video.duration
video.close()
sample_video_slices = []
sample_audio_slices = []
end = 3.0
while end < duration:
start = end - 3.0
video = VideoFileClip(filename)
sub_video = video.subclip(start, end)
frames = [
frame for frame in sub_video.iter_frames(with_times=False, fps=25)
]
sample_video_slices.append(frames)
# For debugging only
# sub_video.write_videofile('test{}.mp4'.format(int(start)), codec="libx264", audio_codec="aac")
waveform = sub_video.audio.to_soundarray(
fps=16000)[:, 0] # We only care about the left channel
sample_audio_slices.append(waveform)
sub_video.close()
video.close()
end += 2.0
os.remove(filename)
return sample_video_slices, sample_audio_slices
def generate(self, avatars, text, usernames, kwargs):
name = uuid.uuid4().hex + '.mp4'
if len(text) >= 400:
text = text[:400] + '...'
@after_this_request
def remove(response): # pylint: disable=W0612
try:
os.remove(name)
except (FileNotFoundError, OSError, PermissionError):
pass
return response
clip = VideoFileClip("assets/letmein/letmein.mp4")
textclip = TextClip(txt=text, bg_color='White', fontsize=32, font='Verdana', method='caption', align='west', size=(clip.size[0], None)).set_duration(clip.duration)
color = ColorClip((clip.size[0], textclip.size[1]), color=(255, 255, 255), ismask=False).set_duration(clip.duration)
video = CompositeVideoClip([clip.set_position(("center", textclip.size[1])), color, textclip],
size=(clip.size[0], textclip.size[1] + clip.size[1]))
video.write_videofile(name, threads=4, preset='superfast', verbose=False)
clip.close()
video.close()
return send_file(name, mimetype='video/mp4')
def mp4_to_wav(file_path, input_directory, output_directory, name):
from moviepy.editor import VideoFileClip
import os
if (not os.path.exists(output_directory)):
os.mkdir(output_directory)
file = VideoFileClip(os.path.join(file_path))
times = int((file.duration) / 30)
is_multiple_of_thirty = isinstance((file.duration / 30), int)
for i in range(times):
path = input_directory + name + '-' + str(i) + '.mp4'
output_path = output_directory + name + '-' + str(i) + '.wav'
video = VideoFileClip(os.path.join(path))
video.audio.write_audiofile(os.path.join(output_path))
video.close()
if (not is_multiple_of_thirty):
path = input_directory + name + '-' + str(times) + '.mp4'
output_path = output_directory + name + '-' + str(times) + '.wav'
video = VideoFileClip(os.path.join(path))
video.audio.write_audiofile(os.path.join(output_path))
video.close()
def video_properties(filename):
my_clip = VideoFileClip(filename)
print("Duration of video : ", my_clip.duration)
print("FPS : ", my_clip.fps)
my_clip.close()
return my_clip.duration
def createPartition(index, videoData):
os.chdir("videos/" + str(index))
#Get the start and end second from the YAML Config and edit all of the videos into clips that can be concatinated.
start = videoData['startFrame']
end = videoData['endFrame']
print(start, end)
mp4 = findmp4()
print(mp4)
os.chdir(cwd)
fileLoc = 'videos' + '\\' + str(index) + '\\' + mp4
video = VideoFileClip(fileLoc).subclip(start - 4, end + 2).fx(
vfx.fadeout, duration=1).fx(vfx.fadein, duration=5)
# Make the text. Many more options are available.
txt_clip = (TextClip(videoData['date'],
fontsize=35,
color='white',
font='Hans Kendrick').set_position(
("center", 80)).set_duration(5).fx(
vfx.fadeout, duration=1.5).fx(vfx.fadein,
duration=3))
result = CompositeVideoClip([video, txt_clip]) # Overlay text on video
result.write_videofile(
"partitions\\" + str(index) +
".mp4") # Write the partition into a new partition folder
os.chdir(cwd)
video.close()
txt_clip.close()
result.close()
def merge_audio_and_video(video_input_path, audio_input_path,
video_output_path):
"""This function is used to mge voice with a video merged from images.
Args:
video_input_path: path of the origin video
audio_input_path: path of the voice file
video_output_path: path to the result video
Returns: int
on success this function returns 0
on failure this function returns 1
"""
if not os.path.isfile(video_input_path):
print("invalid video path")
return FAILED
if not os.path.isfile(audio_input_path):
print("invalid audio path")
return FAILED
my_video_clip = VideoFileClip(video_input_path)
my_audio_clip = AudioFileClip(audio_input_path)
video = my_video_clip.set_audio(my_audio_clip)
video.write_videofile(video_output_path, codec='libvpx')
if not os.path.isfile(video_output_path):
print("invalid output path")
my_audio_clip.close()
my_video_clip.close()
return FAILED
my_audio_clip.close()
my_video_clip.close()
return SUCCESS
class VideoBarrier(object):
"""docstring for VideoBarrier"""
CLIP_DIR = "clip"
def __init__(self, input, output, audio_path):
super(VideoBarrier, self).__init__()
self.input = input
self.filename, _ = os.path.splitext(os.path.basename(input))
self.output = os.path.join(output, VideoBarrier.CLIP_DIR)
self.audio_path = audio_path
def __enter__(self):
self.v_clip = VideoFileClip(self.input, audio=False)
self.a_clip = AudioFileClip(self.audio_path)
return self
def __exit__(self, exception_type, exception_value, traceback):
self.v_clip.close()
self.a_clip.close()
def set_audio(self, t_start=0, t_end=None):
self.v_clip = self.v_clip.set_audio(self.a_clip.subclip(
t_start, t_end))
def save(self, start_time=0, duration=60):
audio_fname, _ = os.path.splitext(os.path.basename(self.audio_path))
output_fname = "{}_{}.mp4".format(self.filename, audio_fname)
output_path = os.path.join(self.output, output_fname)
self.v_clip.set_duration(duration + 1).subclip(
t_start=start_time,
t_end=start_time + duration).write_videofile(output_path)
def gif_split(self, target):
if os.path.getsize(target) <= self.max_size:
return target
self.gif_optimize(target)
logger.info("Media[{}]: Splitting gif".format(target))
size = os.path.getsize(target)
path, filename = os.path.split(target)
filename = os.path.splitext(filename)[0]
new_filename = 'new_{}.gif'.format(filename)
new_path = os.path.join(path, new_filename)
if os.path.exists(new_path):
os.remove(new_path)
while size > self.max_size:
clip = VideoFileClip(target)
end = clip.duration * self.max_size / size - 1
clip = clip.subclip(0, end)
clip.write_gif(new_path, program='ffmpeg')
clip.close()
self._force_rename(new_path, target)
size = os.path.getsize(target)
return target
def process(self, data, inputs, utils):
logger = logging.getLogger(f'mainModule.{__name__}')
clips = []
for found in data:
logger.info(found.time)
logger.info(found.yt)
start, end = self.parse_caption_time(found.time)
try:
video = VideoFileClip(found.yt.get_video_filepath()).subclip(
start, end)
except OSError:
logger.warning('no video')
continue
# 因為影片太少會出錯找不到路徑 目前先 skip 掉這個步驟
clips.append(video)
if len(clips) >= inputs['limit']:
break
output_filepath = utils.get_output_filepath(inputs['channel_id'],
inputs['search_word'])
final_clip = concatenate_videoclips(clips)
final_clip.write_videofile(output_filepath)
# closing VideoFileClips
for video in clips:
video.close()
return output_filepath
def encoding_videos(self, start_end=None, use_GPU=False, codec='libx264'):
video_out_path, temp_audio_path, CPU_GPU = self.get_video_out_path(
start_end, use_GPU, codec)
duration = dict()
for i, in_path in enumerate(self.video_in_path):
out_path = video_out_path[i]
start_time = time.time()
clip = VideoFileClip(in_path)
if start_end is not None:
clip = clip.subclip(*start_end)
clip.write_videofile(out_path,
write_logfile=True,
codec=codec,
temp_audiofile=temp_audio_path[i])
clip.close()
duration[out_path] = dict()
duration[out_path]['time'] = str(
datetime.timedelta(seconds=(time.time() - start_time)))
duration[out_path]['device'] = CPU_GPU
duration[out_path]['codec'] = codec
duration[out_path]['start_end'] = start_end
print(duration[out_path]['time'])
print(duration)
curr_time = datetime.datetime.now()
curr_time_str = '{}-{}-{}_{}.{}.{}'.format(
curr_time.year, curr_time.month, curr_time.day, curr_time.hour,
curr_time.minute, curr_time.second)
json_path = os.path.join(self.root,
'{}_log.json'.format(curr_time_str))
json.dump(duration, open(json_path, 'w'), indent=2)
def preview_video(self, filename, playtime_before, playtime_after,
silence):
videoclip = VideoFileClip(filename)
start = max(0, silence.start_time - playtime_before)
stop = min(videoclip.duration, silence.stop_time + playtime_after)
start_cut = silence.start_cut()
stop_cut = silence.stop_cut()
if start_cut < stop_cut:
cliplist = []
if start < start_cut:
cliplist.append(videoclip.subclip(start, start_cut))
if stop_cut < stop:
cliplist.append(videoclip.subclip(stop_cut, stop))
assert len(cliplist) > 0
tmpclip = concatenate_videoclips(cliplist)
else:
tmpclip = videoclip.subclip(start, stop)
pygame.display.set_caption('Silence cut preview')
os.environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % (0, 30)
aud = tmpclip.audio.set_fps(44100)
tmpclip = tmpclip.without_audio().set_audio(aud)
tmpclip.preview()
pygame.display.quit()
videoclip.close()
def make_crab(self, t, u_id):
"""Non blocking crab rave video generation from DankMemer bot
https://github.com/DankMemer/meme-server/blob/master/endpoints/crab.py
"""
fp = str(cog_data_path(self) / f"Verdana.ttf")
clip = VideoFileClip(str(cog_data_path(self)) + "/template.mp4")
text = TextClip(t[0], fontsize=48, color="white", font=fp)
text2 = (
TextClip("____________________", fontsize=48, color="white", font=fp)
.set_position(("center", 210))
.set_duration(15.4)
)
text = text.set_position(("center", 200)).set_duration(15.4)
text3 = (
TextClip(t[1], fontsize=48, color="white", font=fp)
.set_position(("center", 270))
.set_duration(15.4)
)
video = CompositeVideoClip(
[clip, text.crossfadein(1), text2.crossfadein(1), text3.crossfadein(1)]
).set_duration(15.4)
video.write_videofile(
str(cog_data_path(self)) + f"/{u_id}crabrave.mp4",
threads=1,
preset="superfast",
verbose=False,
logger=None,
temp_audiofile=str(cog_data_path(self) / "crabraveaudio.mp3")
)
clip.close()
video.close()
return True
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 make_highlight(self, data_loader, y_pred):
segment_length = data_loader.get_metadata()['config']['segment_length']
segment_df = data_loader.test_segment_df.copy()
segment_df['pred'] = y_pred
segment_df['start_sec'] = (segment_df['index'] * segment_length)
segment_df['end_sec'] = ((segment_df['index'] + 1) * segment_length)
start = np.array(segment_df['start_sec'][segment_df['pred'] == 1])
end = np.array(segment_df['end_sec'][segment_df['pred'] == 1])
name = "raw"
i = 1
while (i < len(end)):
if end[i] - 3 == end[i - 1]:
end[i - 1] = end[i]
start = np.delete(start, i)
end = np.delete(end, i)
else:
i += 1
clip = VideoFileClip(os.path.join(self.video_dir, name + ".mp4"))
subclips = []
for i in range(len(start)):
start_lim = start[i]
end_lim = end[i]
subclips.append(clip.subclip(start_lim, end_lim))
final_clip = concatenate_videoclips(subclips)
final_clip.write_videofile(
"./Highlights" + name +
".mp4") #Enter the desired output highlights filename.
for i in subclips:
i.close()
clip.close()
def videoV():
#Initialize and access video functions
out = cv2.VideoWriter(clip.filename, clip.fourcc, clip.fps, (1366, 768), True)
#fps = 14.0 at 1920x1080
#Begin recording
while clip.begin == 1:
img = ImageGrab.grab(bbox=(clip.x0, clip.y0, clip.x1, clip.y1))
frame = cv2.cvtColor(np.array(img), cv2.COLOR_BGR2RGB)
reducedframe = cv2.resize(frame, (1366, 768), fx=0, fy=0, interpolation=cv2.INTER_CUBIC)
out.write(reducedframe)
#Stop recording and close VideoWriter
out.release()
# Get duration of the clip and check difference between audio and clip duration
check_clip = VideoFileClip(clip.filename)
sync = clip.timer / check_clip.duration
check_clip.close()
# Re-size clip to match audio duration size
path = os.path.join(clip.curpath, "ffmpeg", "bin", "ffmpeg.exe")
proc = subprocess.Popen(path + ' -i output.mp4 -vf "setpts='+str(sync)
+ '*PTS" output2.mp4', cwd=clip.curpath)
# Wait until process is done and close all windows
while proc.poll() is None:
continue
cv2.destroyAllWindows()
def extract_highlights(file_paths):
"""
:param file_paths: 동영상 경로 리스트
:return: 추출한 하이라이트 동영상 경로 리스트
"""
max_highlights = []
min_highlights = []
for file_path in file_paths:
video_clip = VideoFileClip(file_path)
audio_clip = video_clip.audio
src_audio_file_name = get_random_name('wav')
audio_clip.write_audiofile(src_audio_file_name)
source_wave = wave.read(src_audio_file_name)
stereo_channel_wave = source_wave[1].T[1]
normalize_wave = [(ele / 2 ** 8.) * 2 - 1 for ele in stereo_channel_wave] # this is 8-bit track, now normalized on [-1,1)
fourier_transform_wave = fft(normalize_wave) # calculate fourier transform (complex numbers list)
normalize_time = len(fourier_transform_wave) / video_clip.duration
argmax_frequency = np.argmax(fourier_transform_wave) / normalize_time + 0.5
argmin_frequency = np.argmin(abs(fourier_transform_wave)) / normalize_time + 0.5
max_highlight_path = max_highlights.append(get_random_name('mp4'))
min_highlight_path = min_highlights.append(get_random_name('mp4'))
video_clip.subclip(argmax_frequency - (HIGHLIGHT_LENGTH/2), argmax_frequency + (HIGHLIGHT_LENGTH/2)).write_videofile(max_highlight_path, codec='libx264', audio_codec='aac')
video_clip.subclip(argmin_frequency - (HIGHLIGHT_LENGTH/2), argmin_frequency + (HIGHLIGHT_LENGTH/2)).write_videofile(min_highlight_path, codec='libx264', audio_codec='aac')
video_clip.close()
return max_highlights, min_highlights
def video(self,
max_duration: int = 0,
font: str = 'Arial',
fontsize: int = 100,
color: str = 'white',
link: str = ''):
"""
Build CompositeVideoClip from source video
Parameters
----------
max_duration: int, optional
Duration of the clip if a video clip, default value is 0
font: str, optional
Name of font for text clip
fontsize: int, optional
Size of font
color: str, optional
Color of text
Returns
-------
StoryBuild
An object of StoryBuild
"""
clip = VideoFileClip(str(self.path), has_mask=True)
build = self.build_main(clip, max_duration, font, fontsize, color,
link)
clip.close()
return build
def generate(self, avatars, text, usernames, kwargs):
name = uuid.uuid4().hex + '.gif'
@after_this_request
def remove(response): # pylint: disable=W0612
try:
os.remove(name)
except (FileNotFoundError, OSError, PermissionError):
pass
return response
clip = VideoFileClip("assets/kowalski/kowalski.gif")
text = TextClip(text,
fontsize=36,
method='caption',
size=(245, None),
align='West',
color='black',
stroke_color='black',
stroke_width=1,
font='Verdana').set_duration(clip.duration)
text = text.set_position((340, 65)).set_duration(clip.duration)
text = rotate(text, angle=10, resample='bilinear')
video = CompositeVideoClip([clip, text]).set_duration(clip.duration)
video.write_gif(name)
clip.close()
video.close()
return send_file(name, mimetype='image/gif')
def make(csv_dir, mp4_dir):
# 모든 csv 불러와서 돌아가면서 시간값, 이름 읽기
all_csv_name_list = sorted(glob.glob(os.path.join(csv_dir, '*.csv')))
for csv_name in all_csv_name_list:
df = pd.read_csv(csv_name)
print(df)
start = np.array(df['start_sec'][df['pred'] == 1])
end = np.array(df['end_sec'][df['pred'] == 1])
name = os.path.split(os.path.splitext(csv_name)[0])[1]
i = 1
while (i < len(end)):
if end[i] - 3 == end[i - 1]:
end[i - 1] = end[i]
start = np.delete(start, i)
end = np.delete(end, i)
else:
i += 1
clip = VideoFileClip(os.path.join(mp4_dir, name + ".mp4"))
subclips = []
for i in range(len(start)):
start_lim = start[i]
end_lim = end[i]
subclips.append(clip.subclip(start_lim, end_lim))
final_clip = concatenate_videoclips(subclips)
final_clip.write_videofile(
"./Highlights" + name +
".mp4") #Enter the desired output highlights filename.
for i in subclips:
i.close()
clip.close()
def convert(name, outname):
# Buscamos el vídeo en la carpeta
p = Path("videos")
files = list(p.glob("*"))
for f in files:
fstr = str(f).lower()
if f.is_file() and f.suffix.lower() in video_formats and name in fstr:
video_path = str(f)
break
print(video_path)
# Buscamos la carátula
p = Path("Slides_start_end")
files = list(p.glob("*"))
for f in files:
fstr = str(f).lower()
if (f.is_file() and "1440" in str(f) and "end_1440" not in str(f)
and name in fstr):
cover_path = str(f)
break
print(cover_path)
# Buscamos la imagen de cierre
p = Path("Slides_start_end", "end_1440.png")
end_path = str(p)
print(end_path)
# Buscamos el ancho y alto del vídeo
clip = VideoFileClip(video_path)
clip_part = clip.subclip(0, 5)
clip_size = clip_part.size
# Ponemos el cover y final al mismo tamaño que el vídeo
im = Image.open(cover_path)
out = im.resize(clip_size)
arr_in = np.array(out)
im = Image.open(end_path)
out = im.resize(clip_size)
arr_out = np.array(out)
# Generamos la entradilla
clip = ImageClip(arr_in).set_duration(5)
clip.write_videofile('video_start.mp4', fps=24)
clip.close()
# Generamos el cierre
clip = ImageClip(arr_out).set_duration(5)
clip.write_videofile('video_end.mp4', fps=24)
clip.close()
# Generamos vídeo final
clip1 = VideoFileClip('video_start.mp4')
clip2 = VideoFileClip(video_path)
clip3 = VideoFileClip('video_end.mp4')
final = concatenate_videoclips([clip1, clip2, clip3], method="compose")
final.write_videofile(f'{outname}_final.mp4')
final.close()
def download_data(filename, output_dir, limit=0):
output_dir = output_dir.rstrip('/')
clip_dictionary = {}
with open(filename) as fp:
reader = csv.reader(fp, delimiter=',')
for row in reader:
if row[0] not in clip_dictionary:
clip_dictionary[row[0]] = []
clip_dictionary[row[0]].append((float(row[1]), float(row[2]), float(row[3]), float(row[4])))
meta_data, used_clips = build_meta(output_dir, clip_dictionary)
if limit:
limit = max(limit - len(used_clips), 0)
limited_keys = random.sample(list(set(list(clip_dictionary.keys())) - used_clips), limit)
clip_dictionary = {key: clip_dictionary[key] for key in limited_keys}
items_to_download = len(clip_dictionary)
downloading = 0
for clip_id, params in clip_dictionary.items():
downloading += 1
print(
'[IMP] Downloading {} of {}'.format(downloading, items_to_download))
download_opts = {
'format': 'mp4',
'outtmpl': 'data/{}.mp4'.format(clip_id),
'nocheckcertificate': True
}
try:
with youtube_dl.YoutubeDL(download_opts) as ydl:
ydl.download(['https://www.youtube.com/watch?v={}'.format(clip_id)])
for idx, param in enumerate(params):
main_clip = VideoFileClip('data/{}.mp4'.format(clip_id))
print(
'[IMP] {}_{} -> {} to {} from max {}'.format(clip_id, idx, param[0], param[1], main_clip.duration))
sub_clip = main_clip.subclip(param[0], param[1])
sub_clip_id = '{}_{}'.format(clip_id, idx)
sub_clip_file_name = '{}/{}.mp4'.format(output_dir, sub_clip_id)
sub_clip.write_videofile(sub_clip_file_name, codec="libx264", audio_codec="aac")
sub_clip.close()
main_clip.close()
meta_data[sub_clip_id] = (param[2], param[3])
os.remove('data/{}.mp4'.format(clip_id))
except youtube_dl.utils.DownloadError as error:
print(error)
with open('{}/meta.json'.format(output_dir), 'w') as fp:
fp.write(json.dumps(meta_data))
from py.utils.IO_util import get_all_file
from moviepy.editor import VideoFileClip
filePath = input('mp4 Path:')
files = get_all_file(filePath)
duration = 0
for f in files:
if f.endswith('.mp4'):
clip = VideoFileClip(f)
duration += clip.duration
print(f, clip.duration) # seconds
clip.close()
print(duration / 60)
