def vid_from_media(vid_path, media, song_path, titles, img_duration=8): clips = [] print "sequencing media..." for m in media: print m.path if good_file(m.path): try: if is_img(m.path): new_clip = ImageClip(m.path) new_clip.fps = 1.0 / img_duration new_clip.duration = img_duration else: new_clip = VideoFileClip(m.path) text = m.title if titles else None new_clip = format_clip(new_clip, text) clips.append(new_clip) except Exception as err: "COULDN'T CREAT CLIP BECAUSE: " + str(err) else: print 'CORRUPT FILE FOUND: ' + m.path + ', skipping.' vid = concatenate_videoclips(clips) print song_path audio = AudioFileClip(song_path) audio_loops = int(vid.duration / audio.duration) + 1 #times to loop audio audio = concatenate_audioclips([audio] * audio_loops) print audio.duration print vid.duration audio = audio.set_duration(vid.duration) vid = vid.set_audio(audio) print "writing video..." vid.write_videofile(vid_path, progress_bar=False, preset='ultrafast') return abspath(vid_path)
def video_render(txt_file,image_file,sound_file,save_file): from moviepy.editor import ImageClip from moviepy.editor import CompositeVideoClip from moviepy.editor import CompositeAudioClip from moviepy.editor import TextClip from moviepy.editor import AudioFileClip from moviepy.editor import concatenate from moviepy.config import change_settings change_settings({"IMAGEMAGICK_BINARY": "/usr/local/bin/convert"}) text=[] with open(txt_file,'r') as file: for lines in file: if lines!="\n": text.append(lines.rstrip('\n')) durs=[] for i in text: res = len(re.findall(r'\w+', i)) if res/2>3: durs.append(res/2) else: durs.append(3) total_duration=sum(durs) a_clip = AudioFileClip(sound_file) if a_clip.duration<total_duration: new_audioclip = CompositeAudioClip([a_clip, a_clip.set_start(a_clip.duration-1)]).set_duration(total_duration+3) else: new_audioclip=a_clip.set_duration(total_duration+3) screen=(1920,1080) clip_list = [] i=0 for string in text: duration=durs[i] i+=1 try: txt_clip = TextClip(string, fontsize = 70, color = 'white', method='caption',size=screen ).set_duration(duration).set_pos('center') clip_list.append(txt_clip) except UnicodeEncodeError: txt_clip = TextClip("Issue with text", fontsize = 70, color = 'white').set_duration(2) clip_list.append(txt_clip) final_text_clip = concatenate(clip_list, method = "compose").set_start(3) v_clip = ImageClip(image_file).set_duration(total_duration+3) video=CompositeVideoClip([v_clip, final_text_clip]) # video = video.set_audio(AudioFileClip('sound/Serenity (1).mp3')) video = video.set_audio(new_audioclip) video.write_videofile(save_file, codec='libx264', fps=10, threads=4, audio_codec='aac', temp_audiofile='temp-audio.m4a', remove_temp=True )
def visualize(model_cls, input_data): os.environ["FFMPEG_BINARY"] = "ffmpeg" model = model_cls() output = model.encode(input_data) output = output.reshape(output.shape[0] * 512, 128) min_val = np.amin(output) max_val_normalized = np.amax(output) - min_val last_percentage = -1 figures = [] # (graph total duration / graph datapoint count) * (graph datapoint count / graph width) figure_snapshot_rate = 40 tick_to_sample_ratio = 32.87890625 # This is still off sync with the audio, 2:53 becomes 2:58 for some reason frame_duration = (figure_snapshot_rate * tick_to_sample_ratio) / 44100 for i in range(128): column = i % 16 row = int(i / 16) figures.append(Figure(60, 60, row, column, frame_duration)) print(f"Rendering output: {output.shape}") for index, entry in enumerate(output): should_snapshot = index % figure_snapshot_rate == 0 for plot_index, plot in enumerate(figures): plot.push((entry[plot_index] - min_val) / max_val_normalized) if should_snapshot: plot.snapshot() percentage = int(index / len(output) * 100) if percentage % 1 == 0 and last_percentage != percentage: last_percentage = percentage print(f"Capturing figures: {percentage}%...") print(f"{len(figures[0].figures)} figure frames rendered") clips = [FigureClip(figure) for figure in figures] audio_filename = f"vis/output.wav" output = model.predict_output(input_data).flatten() write_wav(audio_filename, output) del model backend.clear_session() audio = AudioFileClip(audio_filename) audio = audio.set_start(0) audio = audio.set_duration( min(audio.duration, frame_duration * len(figures[0].figures))) result = CompositeVideoClip(clips, size=(16 * 66 + 12, 8 * 66 + 12)) result = result.set_audio(audio) result.write_videofile("vis/output.mp4", fps=1 / frame_duration)
def take(self, options: dict): if options["with_video"]: self._take_video(options["video_url"]) if options["with_audio"]: self._take_audio(options["audio_url"]) if options["with_video"]: video = VideoFileClip(self.__path_to_save_video) audio = AudioFileClip(self.__path_to_save_audio) video.audio = audio.set_duration(video.duration) os.remove(self.__path_to_save_video) os.remove(self.__path_to_save_audio) video.write_videofile(self.__path_to_save_video)
def save_as_mp3(file_name, clip_info): clip = AudioFileClip(file_name) t_start, t_end, duration = parse_clip_info(clip_info) print(t_start, t_end, duration) clip = clip.subclip(t_start=t_start, t_end=t_end) if duration: clip = clip.set_duration(duration) name, suffix = os.path.splitext(file_name) try: clip.write_audiofile('{}.mp3'.format(name)) except IndexError: print("Please try a bit longer duration") raise
def main(): # backend.set_floatx("float16") # backend.set_epsilon(1e-4) data = get_dataset( block_interval=10000, block_size=INPUT_COUNT, file_count=30, output_size=0, shuffle=True, ) train_data = data.train_data.reshape(len(data.train_data), INPUT_COUNT, 1) test_data = data.test_data.reshape(len(data.test_data), INPUT_COUNT, 1) model = ExperimentalModel() model.load() if "--train" in sys.argv: model.train(train_data, train_data, test_data, test_data) if "--plot" in sys.argv: plt.subplot(2, 2, 1) plt.plot(data.files[0][200]) plt.subplot(2, 2, 2) plt.plot( model.predict_output(data.files[0][200].reshape(1, INPUT_COUNT, 1)).flatten()) plt.subplot(2, 2, 3) plt.plot(data.files[0][210]) plt.subplot(2, 2, 4) plt.plot( model.predict_output(data.files[0][210].reshape(1, INPUT_COUNT, 1)).flatten()) plt.show() if "--out" in sys.argv: for i in range(min(len(data.files), 10)): inp = data.files[i].reshape(len(data.files[i]), INPUT_COUNT, 1) output = model.predict_output(inp).flatten() data.write_wav(f"output-{NAME}-{MODEL_ID}-{i}.wav", output) print(f"output-{NAME}-{MODEL_ID}-{i}.wav created") if "--convert" in sys.argv: file_data = get_dataset( block_interval=INPUT_COUNT, block_size=INPUT_COUNT, file_count=107, output_size=0, shuffle=False, just_files=True, ) inp = data.files.reshape() if "--vis" in sys.argv: os.environ["FFMPEG_BINARY"] = "ffmpeg" from moviepy.editor import (CompositeVideoClip, AudioFileClip, VideoClip) file = data.files[0] inp = file.reshape(len(file), INPUT_COUNT, 1) output = model.encode(inp) output = output.reshape(output.shape[0] * 512, 128) min_val = np.amin(output) max_val_normalized = np.amax(output) - min_val class Figure(object): def __init__(self, width, height, row, column, frame_duration): self.width = width self.height = height self.row = row self.column = column self.frame_duration = frame_duration self.current_highest = 0 self.buffer = [0 for i in range(self.width)] self.figures = [] def push(self, val): if val > self.buffer[-1]: self.buffer[-1] = val def render(self, peaks): figure = np.zeros((self.width, self.height), int) for column, peak in enumerate(peaks): for fill in range(int(round(peak * (self.height - 1)))): figure[self.height - 1 - fill, column] = 255 return np.stack((figure, ) * 3, axis=-1) def snapshot(self): self.figures.append(self.buffer) self.buffer = self.buffer[1:self.width] + [0] class FigureClip(VideoClip): def __init__(self, figure): super().__init__() self.figure = figure self.make_frame = lambda time: self.make_into_frame(time) self.start = 0 self.end = figure.frame_duration * len(figure.figures) self.size = (figure.width, figure.height) # 16 columns # 8 rows # padding of 6px self.pos = lambda _: (66 * figure.column + 6, 66 * figure.row + 6) def make_into_frame(self, time): index = int(time / self.figure.frame_duration) if index > len(self.figure.figures): return np.zeros(self.figure.width, self.figure.height) return self.figure.render(self.figure.figures[index]) last_percentage = -1 figures = [] # (graph total duration / graph datapoint count) * (graph datapoint count / graph width) figure_snapshot_rate = 40 tick_to_sample_ratio = 32.87890625 # This is still off sync with the audio, 2:53 becomes 2:58 for some reason frame_duration = (figure_snapshot_rate * tick_to_sample_ratio) / 44100 for i in range(128): column = i % 16 row = int(i / 16) figures.append(Figure(60, 60, row, column, frame_duration)) print(f"Rendering output: {output.shape}") for index, entry in enumerate(output): should_snapshot = index % figure_snapshot_rate == 0 for plot_index, plot in enumerate(figures): plot.push((entry[plot_index] - min_val) / max_val_normalized) if should_snapshot: plot.snapshot() percentage = int(index / len(output) * 100) if percentage % 1 == 0 and last_percentage != percentage: last_percentage = percentage print(f"Capturing figures: {percentage}%...") print(f"{len(figures[0].figures)} figure frames rendered") clips = [FigureClip(figure) for figure in figures] audio_filename = f"vis/output.wav" output = model.predict_output(inp).flatten() data.write_wav(audio_filename, output) del model backend.clear_session() audio = AudioFileClip(audio_filename) audio = audio.set_start(0) audio = audio.set_duration( min(audio.duration, frame_duration * len(figures[0].figures))) result = CompositeVideoClip(clips, size=(16 * 66 + 12, 8 * 66 + 12)) result = result.set_audio(audio) result.write_videofile("vis/output.mp4", fps=1 / frame_duration)
idx = [i for i in range(len(time_sum)-1) if t<=time_sum[i]][0] # print "======", jpegs[idx/2], "======", idx delta_fade = time_sum[idx]-time_sum[idx-1] fade_to = (t-time_sum[idx-1])/delta_fade # fraction fade_from = 1-fade_to # fraction frame_for_time_t_BGR_frame0 = fade_from * cv2.imread(jpegs[idx/2],cv2.CV_LOAD_IMAGE_COLOR) frame_for_time_t_BGR_frame1 = fade_to * cv2.imread(jpegs[idx/2+1],cv2.CV_LOAD_IMAGE_COLOR) # BLENDED FRAME frame_for_time_t_BGR_frame01 = frame_for_time_t_BGR_frame0 + frame_for_time_t_BGR_frame1 frame_for_time_t_BGR_frame01 = frame_for_time_t_BGR_frame01.astype('uint8') # convert from float to uint8 frame_for_time_t = cv2.cvtColor(frame_for_time_t_BGR_frame01, cv2.COLOR_BGR2RGB) # BGR-RGB COLOR return frame_for_time_t clip = VideoClip(make_frame, duration=time_sum[-1])#.set_audio(audio) # x-second clip if audio_on: audio = AudioFileClip("audioclip.mp3") audio = audio.set_duration(time_sum[-1]) clip = clip.set_audio(audio) clip.write_videofile("my_animation_%sfps_dummy.mp4" %fps, fps=fps) # export as video #clip.write_gif("my_animation.gif", fps=24) # export as GIF
#animation = VideoClip(make_frame, duration=5).resize(width=800,height=600) animation = VideoClip(make_frame, duration=10) #animation.write_gif('otto.gif', fps=2, opt='OptimizePlus') animation.write_videofile("surfVideo.webm",preset="medium",fps=20,audio=False) ######### close canvas only here ... app.process_events() canvas.close() app.process_events() app.quit() #try to create sound version ... audioclip = AudioFileClip("../data/zkmaudio.wav") videoclip = VideoFileClip("surfVideo.webm") l = videoclip.duration print("video length:",l) audio = audioclip.set_duration(l) # same length as video videoclip.set_audio(audio) #textclip = TextClip("ZKM Open Codes", fontsize=20, color='white').set_pos("center","center") # get font list with: #TextClip.list("font") # we could also add the text directly, see above textclip = TextClip("ZKM Open Codes", font="FreeSans",fontsize=40, color='white',method='label') t = textclip.set_duration(l) # compose everything. make sure to set audio here! finalclip = CompositeVideoClip([videoclip.set_audio(audio),t.set_pos("center","center")]) finalclip.write_videofile("surfVideo_sound.webm",preset="medium",fps=20)