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 save_out(tracks, outfile=None, filetype='mp4'): out = [] vids = [t for t in tracks if t['type'] == 'vid'] texts = [t for t in tracks if t['type'] == 'text'] for v in vids: c = VideoFileClip(v['content']).subclip(v['in'], v['in'] + v['duration']) c = c.set_start(v['start']) out.append(c) size = out[0].size for t in texts: c = create_sub(t['content'], size, rect_offset=195, min_height=55) c = c.set_start(t['start']) c = c.set_duration(t['duration']) out.append(c) final_clip = CompositeVideoClip(out) if outfile is None: outfile = 'msg_' + str(int(time.time())) + '.mp4' if filetype == 'gif': outfile = outfile.replace('.mp4', '.gif') final_clip.speedx(1.7).write_gif(outfile, fps=7, loop=1) else: final_clip.write_videofile(outfile, fps=24, codec='libx264') return outfile
def generate_video(saved_model_path, video_category=None): """Uses the trained model to predict the frames and produce a video out of them""" # load model model = load_model(saved_model_path) which_one = video_category train_files, test_files = get_train_test_files(which=which_one) test_gen = get_data_gen(files=test_files, timesteps=timesteps, batch_size=batch_size, im_size=(im_width, im_height)) y_true = [] y_pred = [] for _ in range(200): x, y = next(test_gen) y_true.extend(y) predictions = model.predict_on_batch(x) y_pred.extend(predictions) clip1 = ImageSequenceClip([denormalize(i) for i in y_true], fps=5) clip2 = ImageSequenceClip([denormalize(i) for i in y_pred], fps=5) clip2 = clip2.set_position((clip1.w, 0)) video = CompositeVideoClip((clip1, clip2), size=(clip1.w * 2, clip1.h)) video.write_videofile( "{}.mp4".format(which_one if which_one else "render"), fps=5)
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 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 centerMerge(): clip1 = VideoFileClip("text.mp4", audio=False).resize([540, 1024]) print(clip1.duration) clip3 = VideoFileClip("cut_video.mp4", has_mask=True, audio=True) video = CompositeVideoClip([clip1, clip3.set_position('center')]) video.write_videofile("centermergr.mp4") # 先不加音频 video.close()
def write_video_file(file_path, pred_label_score, gt_info, save_dir): video_clip = VideoFileClip(file_path) text_clip = TextClip(txt=pred_label_score, font='utils/SimHei.ttf', color='white', fontsize=32, bg_color='black', align='West').set_pos( ("left", "top")).set_duration(video_clip.duration) compose_list = [video_clip, text_clip] if gt_info != "": gt_text_clip = TextClip(txt=gt_info, font='utils/SimHei.ttf', color='white', fontsize=32, bg_color='black', align='East').set_pos( ("right", "bottom")).set_duration( video_clip.duration) compose_list.append(gt_text_clip) result = CompositeVideoClip(compose_list) video_name = os.path.basename(file_path) result.write_videofile(save_dir + "/" + video_name, fps=25, codec='libx264', audio_codec='aac', temp_audiofile='temp-audio.m4a', remove_temp=True)
def main(url, output): driver = webdriver.Chrome() remote_url = url driver.get(remote_url) png = chrome_takeFullScreenshot(driver) with open("website_image.png", 'wb') as f: f.write(png) driver.close() clip = ImageClip('website_image.png') video_width = int(clip.size[0] + 800) video_height = int(video_width/1.5) bg_clip = ColorClip(size=(video_width, video_height), color=[228, 220, 220]) scroll_speed = 180 total_duration = (clip.h - 800)/scroll_speed fl = lambda gf,t : gf(t)[int(scroll_speed*t):int(scroll_speed*t)+800,:] clip = clip.fl(fl, apply_to=['mask']) video = CompositeVideoClip([bg_clip, clip.set_pos("center")]) video.duration = total_duration if not output.endswith('.mp4'): output += '.mp4' video.write_videofile(output, fps=26) os.remove('website_image.png')
def merge_videos(filepath_1, filepath_2, filepath_out): """ Overlay second video in the bottom right corner of the first video. """ # If the video generation failed, merge fails if not os.path.isfile(filepath_1) or not os.path.isfile(filepath_2): print("Error: The filepath(s) are invalid.") return False # Merge original lesson video with Wav2Lip result video clip1 = VideoFileClip(fr'{filepath_1}') # Use ./ instead of / clip2 = VideoFileClip(fr'{filepath_2}') clip2 = resize_clip_wrt(clip1, clip2) composite_clip = CompositeVideoClip([ clip1, clip2.set_position(("right", "bottom")).set_start(0).crossfadein(1) ]) # Use a temp audio file if audio is not working # It seems overriding an existing file will result in second video not running correctly try: # final_clip.write_videofile(r'./results/result_voice.mp4') composite_clip.write_videofile(fr'{filepath_out}', codec='libx264', audio_codec='aac', temp_audiofile='temp-audio.m4a', remove_temp=True) return True except Exception as e: print(e) return False
def make_test_vid(note_vid, segments, fname): t = 0 clips = [] padding = 2 i = 0 for note, (start, end) in segments: clip = note_vid.subclip(start, end) clip = clip.set_start(t) clips.append(clip) txt = (TextClip("%d %s" % (i, note), color='white', font='Ubuntu-Bold', fontsize=22).margin(1).margin( top=30, left=30, opacity=0.0).set_pos( ('left', 'top')).set_duration(end - start + padding).set_start(t)) clips.append(txt) t += (end - start) + padding i += 1 print(t, i) full_video = CompositeVideoClip(clips) print('full length %f' % full_video.duration) full_video.write_videofile(fname, threads=20)
def create_mtg_gif(name, id, border): if border == 'm': # Modern (post-8th Ed) card_upper_corner = (19, 38) gif_width = 202 - card_upper_corner[0] gif_height = 172 - card_upper_corner[1] elif border == 'c': # Current (post-Magic 2015) card_upper_corner = (17, 34) gif_width = 204 - card_upper_corner[0] gif_height = 173 - card_upper_corner[1] else: # Old (pre-8th Ed) card_upper_corner = (25, 30) gif_width = 196 - card_upper_corner[0] gif_height = 168 - card_upper_corner[1] mtg_card = Image.open(BytesIO(requests.get(get_mtg_image(id)).content)) mtg_card = ImageClip(np.asarray(mtg_card)).resize((222, 310)) get_giphy_gif(name) giphy_gif = (VideoFileClip( 'giphy_gif.mp4', target_resolution=(gif_height, gif_width)).set_pos(card_upper_corner)) if giphy_gif.duration < 2: giphy_gif = giphy_gif.fx(loop, n=1 + int(2 // giphy_gif.duration)) mtg_gif = CompositeVideoClip([mtg_card, giphy_gif]) mtg_gif = mtg_gif.set_start(0).set_duration(giphy_gif.duration) # mtg_gif.write_gif("mtg_gif.gif") mtg_gif.write_videofile("mtg_gif.mp4", codec='libx264', bitrate=str(np.power(10, 7)), verbose=False, progress_bar=False, audio=False, ffmpeg_params=['-pix_fmt', 'yuv420p'])
def mov_change_bg(avi, mov, name): logging.info('start processing {}'.format(name)) clip1 = VideoFileClip(avi) clip3 = VideoFileClip(mov, has_mask=True) video = CompositeVideoClip([clip1, clip3]) video.write_videofile(name, audio=True) video.close() logging.info('end processing {}'.format(name))
def concat_video(file, count, td, output): d = clip_duration(file) video = CompositeVideoClip([ VideoFileClip(file).set_start((d * i) - (td * i)).fx( transfx.crossfadein, td * (0 if i == 0 else 1)) for i in range(0, count) ]) video.write_videofile(output)
def mergeClips(): videoFileNames = readClip() clips = [] for i in range(0, len(videoFileNames)): clips.append(VideoFileClip(videoFileNames[i])) print(clips) result = CompositeVideoClip([clips[0], clips[1], clips[2]]) result.write_videofile("mergedNew.mp4", fps=60)
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 add_text(content, font_size): ''' add text on the top of video stream ''' txt_clip = (TextClip(content, fontsize=font_size, color='white').set_position('top').set_duration( video.duration)) result = CompositeVideoClip([video, txt_clip]) result.write_videofile(new_file)
def handleVideo(file_content): for i in range(0, len(file_content)): arr = file_content[i][0].split("-->") #列出音频文件文件夹下的所有文件 随机抽取音频插入剪切视频 musicFiles = os.listdir(arr[1]) musicFilesTempLength = len(musicFiles) - 1 #视频信息 clip = VideoFileClip(arr[0]).subclip(arr[2], arr[3]) #如果music文件夹下只有一个音频文件 则取第0个文件 其余时候取随机位置的音频 if musicFilesTempLength > 0: musicFilesIndex = random.randint(0, musicFilesTempLength) else: musicFilesIndex = 0 audioClip = AudioFileClip(arr[1] + musicFiles[musicFilesIndex]) video = clip.set_audio(audioClip) videoDuration = int(video.duration) # 获取mp3文件的长度 最多从音频文件的长度-video.duration的长度开始截取长度为video.duration的音频 # 随机选择Music文件夹下的音频文件 musicInfo = eyed3.load(arr[1] + musicFiles[musicFilesIndex]) # 得到mp3文件的长度 单位为秒 musicSecs = int(format(musicInfo.info.time_secs)) # 随机开始位置 确保加上video.duration之后不超过mp3文件的总长 最后几秒基本没有声音了 所以最多截到倒数第10秒 #如果所截视频长度大于音频长度 则从音频的0秒开始截取 if musicSecs - videoDuration <= 0: musicStart = 0 musicEnd = musicSecs else: musicStart = random.randint(0, musicSecs - videoDuration) musicEnd = musicStart + videoDuration # 从随机位置开始截取音频 并设置淡入淡出效果 video.audio = video.audio.subclip(musicStart, musicEnd) try: video.audio = audio_fadein(video.audio, 2.0) video.audio = audio_fadeout(video.audio, 2.0) except Exception as e: with open('error.txt', mode="w+") as f: f.write(str(e)) # 设置视频尺寸 设置视频居中显示 result = CompositeVideoClip([video.set_pos(('center'))], size=(1366, 728)) #创建存储目录 outputVideoPath = arr[1] + "../outputVideo/" isExists = os.path.exists(outputVideoPath) if not isExists: os.makedirs(outputVideoPath) result.write_videofile(outputVideoPath + "outputVideo" + str(i) + ".mp4", codec="libx264", fps=15, bitrate="512K", audio_fps=44100, audio_bitrate="128k") i += 1
def scaleVideo(self, fileLocation): (name, extension) = self.__removeExtension(fileLocation) clip = VideoFileClip(fileLocation) currentFPS = clip.fps # clip = clip.resize(0.75) final = CompositeVideoClip([clip]) newPath = name + "-scaled" + extension final.write_videofile(newPath, fps=currentFPS/2, codec='libx264')
def compose(text, duration=4.0, outname="sunset_words.mp4"): start = 108 end = start + duration clip1 = VideoFileClip("sunset.mp4").subclip(start, end).resize( (1920 / 2, 1080 / 2)) clip2 = TextClip(text, size=clip1.size).set_duration(4) composition = CompositeVideoClip([clip1, clip2]) composition.write_videofile(outname)
def merge_videos(path_source_1, path_source_2, mixed_path): clip01 = VideoFileClip(path_source_1) clip02 = VideoFileClip(path_source_2) clip01 = clip01.resize(0.60) clip02 = clip02.resize(0.60) final_clip = CompositeVideoClip([clip01.set_position(("left","center")), clip02.set_position(("right","center"))], size=(720, 460)) final_clip.write_videofile(mixed_path)
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 mergeVideos(): clip1 = VideoFileClip("text.mp4").subclip(0, 15) print(clip1.duration) clip2 = VideoFileClip("mhls.mp4").subclip(0, 15).resize(0.5) video = CompositeVideoClip([clip1, clip2 ]) CompositeVideoClip([clip1.set_pos("left", "center"), clip2.set_pos("right", "center")], size=(clip1.w + clip1.w, clip2.h)) video.write_videofile("merge_video.mp4")
def write_text(text_chunks, original_video, output, font_size=15): txt_clips = [] for i in range(len(text_chunks)): txt_clips.append(TextClip(text_chunks[i], fontsize=font_size, color="yellow") .set_position('bottom') .set_duration(3) .set_start(i * 3)) clips = [original_video] clips.extend(txt_clips) result = CompositeVideoClip(clips) result.write_videofile(output)
def make_sentence(sayer, text): word_list = text.lower().split(" ") list_dir = os.listdir(s_dir) sentences = sorted(list_dir) wrote = 0 cuts_dirs = [] cuts = [] not_found = [] for single in word_list: print "Word = " + single count = 0 flag = 0 for sen in sentences: print "Searhing sentence #" + str(count) words = os.listdir(s_dir + "/" + sen + "/words") words_dir = s_dir + "/" + sen + "/words" for word in words: if single == word and (single in sen.lower()): cut_single = words_dir + "/" + single + "/0.mp4" cuts_dirs.append(cut_single) flag = 1 break count += 1 if flag == 1: break if flag == 0: not_found.append(single) if not len(not_found) == 0: print "Keywords that are not found are: " + str(not_found) return video_cuts = [] for file in cuts_dirs: print file video = VideoFileClip(file) video = video.resize((1280, 720)) video_cuts.append(video) final = concatenate_videoclips(video_cuts) word_text = TextClip(text, fontsize=40, color="white", bg_color="black").set_pos("bottom").set_duration( final.duration) final = CompositeVideoClip([final, word_text]) if not os.path.exists(sayer + "* " + text): os.makedirs(sayer + "* " + text, 0777) final.write_videofile(sayer + "* " + text + "/" + text + ".mp4", codec='libx264', audio_codec='aac', temp_audiofile=sayer + "* " + text + "/" + text + ".m4a", remove_temp=True)
def add_zm(fg_in_bg_avi, zm_video_path, pictrue_name, video_name, output): clip1 = VideoFileClip(fg_in_bg_avi) clip3 = VideoFileClip(zm_video_path, has_mask=True) video = CompositeVideoClip([clip1, clip3]) try: os.mkdir(output) except OSError: pass video_name = video_name.split('/', 2)[-1] name = output + '/' + pictrue_name + video_name + ".mp4" video.write_videofile(name, audio=True) # 先不加音频 video.close() return name
def textclip(): text_1 = (TextClip("剪辑不易 \n 关注啊", fontsize=70, color='white', font="FZZJ.TTF") .set_position(lambda t: ('center', 100 - t)) .set_duration(15)) text_2 = (TextClip("赶快右侧 \n 点赞啦", fontsize=70, color='red', font="FZZJ.TTF") .set_position(lambda t: ('center', 900 - t)) .set_duration(15)) clip1 = VideoFileClip("cut_video.mp4").fx(vfx.mirror_x) print(clip1.duration) result = CompositeVideoClip([clip1.set_position('center'), text_1, text_2], size=[540, 1024]) # Overlay text on video result.write_videofile("final.mp4")
def write_video(out_path, audio_clip, lyric_clips): [print(c.duration) for c in lyric_clips] print(audio_clip.duration) full_text_clip = concatenate_videoclips(lyric_clips) video = CompositeVideoClip(clips=[ ColorClip(size=VIDEO_SIZE, color=BACKGROUND_COLOR, duration=audio_clip.duration), full_text_clip, ], ) video.fps = 24 video.audio = audio_clip video.write_videofile(out_path)
def make_video(animations, video, path, video_file_name): path = path background = VideoFileClip(path + video['name']) clips = [background] for index, animation in enumerate(animations): to_clip = path + animation['name'] start_time = animation['start_time'] clip = VideoFileClip(to_clip) masked_clip = clip.fx(vfx.mask_color, color=[0, 0, 0], thr=35, s=40) clips.append(masked_clip.set_start(start_time)) video = CompositeVideoClip(clips) video.write_videofile(f"{path}{video_file_name}.mp4") video.close()
def vid_watermark(vid, out, kind, caption, channel) -> str: try: logo_dir = "logo/{}.png".format(channel.name) pattern = re.compile(r':\d:') div = 5 find = int(re.findall(pattern, caption)[0][1:-1]) if re.search( pattern, caption) else channel.pos audio = False if kind == 'animation' else True clip = VideoFileClip(vid, audio) w, h = clip.size pos = { 1: ('left', 'top'), 2: ('center', 'top'), 3: ('right', 'top'), 4: ('left', 'center'), 5: ('center', 'center'), 6: ('right', 'center'), 7: ('left', 'bottom'), 8: ('center', 'bottom'), 9: ('right', 'bottom') } size = h // div if w > h else w // div if os.path.exists(logo_dir): logo = ImageClip(logo_dir) \ .set_duration(clip.duration) \ .resize(width=size, height=size) \ .set_pos(pos.get(find)) else: logo = logo_by_name(channel)\ .set_duration(clip.duration)\ .resize(width=size, height=size)\ .set_pos(pos.get(find)) final = CompositeVideoClip([clip, logo]) final.write_videofile(filename=out, logger=None, verbose=False, threads=multiprocessing.cpu_count()) if re.search(pattern, caption): caption = id_remove(re.sub(pattern, '', caption), channel) else: caption = id_remove(caption, channel) return caption except Exception as E: logging.error('vid_watermark {}'.format(E))
def render(self, talk, act, exp, move, render_video, dft_exp_dt=0.2): if self.cache_dir is not None: cache_video = '{}.mp4'.format( get_macro_act_key(talk, act, exp, move)) cache_video = os.path.join(self.cache_dir, cache_video) if os.path.exists(cache_video): clip = VideoFileClip(cache_video) clip.write_videofile(render_video) return act_clip = self.act_assets[act] default_exp_clip = self.exp_assets['null'] exp_clip = self.exp_assets[exp] if talk == '': clips = [ act_clip, default_exp_clip.set_position( lambda t: (291, 160)).set_duration(dft_exp_dt) ] else: talk_clip = TextClip(talk, font='data/SimHei.ttf', color='green', method='caption', fontsize=30) clips = [ act_clip, talk_clip.set_position(('center', 50)), default_exp_clip.set_position( lambda t: (291, 160)).set_duration(dft_exp_dt) ] clips.append( exp_clip.set_position(lambda t: (291, 160)).set_start(dft_exp_dt)) ts = dft_exp_dt + exp_clip.duration if ts < act_clip.duration: clips.append( default_exp_clip.set_position( lambda t: (291, 160)).set_duration(act_clip.duration - ts).set_start(ts)) if move != 'null': move_clip = self.move_assets[move] clips.append(move_clip.set_position(('center', 650))) final_clip = CompositeVideoClip(clips).set_duration(act_clip.duration) final_clip.write_videofile(render_video)
def generateVideo(text, line2, vId): sum = 0 fnlTxt = "" lines = [[], []] for ind, c in enumerate(text.split(" ")): if sum + len(c) <= charLimit: lines[0] += c if ind != 0: fnlTxt += " " fnlTxt += c sum += len(c) elif sum + len(c) <= charLimit * 2: if len(lines[1]) == 0: fnlTxt += "\n" if len(lines[1]) != 0: fnlTxt += " " lines[1] += c fnlTxt += c sum += len(c) print(fnlTxt) # Create the text txt_clip = (TextClip( fnlTxt, fontsize=ftSz, color="white", font=fontPth, align="West").set_position("left").set_start(0.6).set_duration(1.4)) line2C = (TextClip( line2, fontsize=ftSz, color="white", font=fontPth, align="center").set_position("left").set_start(2).set_duration(2.4)) line2C = line2C.set_position(lambda t: (w * 0.1, 1.8 * h / 6)) line2E = (TextClip(line2, fontsize=ftSz, color="white", font=fontPth, align="center").set_position("left").set_start( 4.4).set_duration(0.6).fadeout(0.6)) line2E = line2E.set_position(lambda t: (w * 0.1, 1.8 * h / 6)) txt_mov = txt_clip.set_pos(lambda t: ( # animate the text min((w * 0.1), int(-txt_clip.w - 500 + 2.7 * w * t)), # X max(1.8 * h / 6, int(100 * t)), # Y # Y )) rName = text + "." + ext nName = f"{vId}.{ext}" result = CompositeVideoClip([video, txt_mov, line2C, line2E]) # Overlay text on video result.write_videofile(rName, fps=video.reader.fps) # Many options... # Moves the video file to the render directory shutil.move(rName, "render/" + nName) return filename
def build__videos(self, option, skipbuild, interval): # video output file name vid_out_file = self.vid_build_name(option, interval) # build the vine compilation if not skipbuild: clips = [] # add the intro intro = self.add_intro() clips.append(intro) currloc = intro.duration # generate list of all available vids (tmpclips, currloc, totalcliptime) = self.generate_vid_list(\ option, currloc) # set the background image clip= self.add_background(intro, totalcliptime) clips.append(clip) # add list of individual vids clips.extend(tmpclips) # add the outro outro = self.add_outro(currloc) clips.append(outro) # add previous days best video to outro best_vid_clip = self.get_previous_bests_vid(option, currloc) clips.append(best_vid_clip) # finalize the video file final_clip = CompositeVideoClip(clips, size=(1920,1080)) final_clip.fps=30 final_clip.write_videofile(vid_out_file) return vid_out_file
def poop(source, destination, midi_file, stretch, fadeout, rebuild, max_stack): """ Create multiple pitchshifted versions of source video and arrange them to the pattern of the midi_file, also arrange the video if multiple notes play at the same time. """ print "Reading input files" video = VideoFileClip(source, audio=False) """ Non-main tracks are 30% the size of the main and have a white border and a margin around them. """ smaller = video.resize(0.3)\ .margin(mar=2, color=3*[255])\ .margin(mar=8, opacity=0) audio = AudioFileClip(source, fps=44100) mid = MidiFile(midi_file) ignoredtracks = ["Percussion", "Bass"] print "Analysing MIDI file" notes = [] # the number of messages in each track lowest = 127 # will contain the lowest note highest = 0 # will contain the highest note for i, track in enumerate(mid.tracks): notes.append(0) #if track.name in ignoredtracks: continue for message in track: if message.type == "note_on": lowest = min(lowest, message.note) highest = max(highest, message.note) notes[-1] += 1 """ The main track is the one featured in the center. It is probably the one with the most notes. Also record the lowest, highest, and average note to generate the appropriate pitches. """ maintrack = max(enumerate(notes), key=lambda x: x[1])[0] midpitch = int((lowest+highest)/2) print "Main track is probably", str(maintrack)+":", mid.tracks[maintrack].name mid.tracks.insert(0, mid.tracks.pop(maintrack)) # move main track to front notes.insert(0, notes.pop(maintrack)) # move main note count to front print sum(notes), "notes ranging from", lowest, "to", highest, "centering around", midpitch print "Transposing audio" sound = audio.to_soundarray(fps=44100) # source, original audio tones = range(lowest-midpitch, highest-midpitch) # the range of pitches we need pitches = [] # this will contain the final AudioFileClips if not os.path.exists("pitches/"): print "Creating folder for audio files" os.makedirs("pitches/") for n in tones: """ Pitches only need to be generated if they do not already exist or if we force the creation of new ones. Save them in order in pitches. """ name = "pitches/"+source+"_"+str(n)+".mp3" if not os.path.isfile(name) or rebuild: print "Transposing pitch", n splitshift(sound, n).write_audiofile(name) pitches.append(AudioFileClip(name, fps=44100)) print "Adding video clips" clips = [video.set_duration(1)] # to set the video size positions = [("left", "bottom"), ("right", "bottom"), ("left", "top"), ("right", "top"), ("center", "bottom"), ("center", "top"), ("left", "center"), ("right", "center")] # non-main tracks """ curpos is the current corner position on the screen and changes with each track. cache is used to make a unique file name whenever a new temporary file is created. endtime will be used at the end to set the end TextClip. It is the latest time any clip ends. """ curpos = -2 cache = endtime = 0 for i, track in enumerate(mid.tracks): #if track.name in ignoredtracks: continue print("Processing {} notes: {}".format(notes[i], track.name)) t = 1.0 # not 0 because we added one second of original video for size opennotes = [] # will contain all notes that are still playing curpos += 1 for message in track: if not isinstance(message, MetaMessage): message.time *= stretch t += message.time if message.type == "note_on": """ Add a video clip with the appropriate starting time and pitch. Also add an entry to opennotes (we don't know when the note ends yet). """ part = video mainvid = i is 0# and len(opennotes) is 0 if not mainvid: part = smaller part = part\ .set_audio(pitches[min(len(pitches)-1, max(0, message.note-lowest))])\ .set_start(t/1000) opennotes.append((message.note, len(clips), t)) """ If this isn't the main track, the video will be smaller and placed at the edge. We'll get a position for each track. If there is more than one video playing in this track, it will be placed slighly closer to the center. """ if not mainvid: stackheight = 6 part = part.set_position(positions[curpos % len(positions)]) clips.append(part) elif message.type == "note_off": reference = message.note index = 0 """ Find the note that ended in opennotes using the note. Get the index and start time, remove it from opennotes. """ for note in reversed(opennotes): n, j, d = note if n == reference: index = j opennotes.remove(note) break """ Get the clip for the open note, set its time to the difference between time now and start time. Have it fade out and update the endtime if needed. """ clips[index] = clips[index].set_duration((t-d)/1000+fadeout) clips[index] = clips[index].crossfadeout(fadeout) endtime = max(endtime, t/1000+fadeout) if len(clips) == max_stack: """ To save some memory, the clips in memory are emptied whenever they reach a certain size. All clips that are closed are merged into one file on disk. """ upuntil = len(clips) # the first open note if len(opennotes) > 0: _, upuntil, _ = opennotes[0] stillopen = clips[upuntil:] print "Stack reached", len(clips), "clips, merging", upuntil """ Save a temporary file to disk with all clips we can safely discard from clips. """ newcache = destination+".temporary"+str(cache)+".mp4" CompositeVideoClip(clips[:upuntil]).write_videofile(newcache) cache += 1 """ Shift all opennotes' indices down by the number of clips merged and saved to disk. Set clips to be the new, merged clip and any leftover clips. """ for i, note in enumerate(opennotes): n, j, d = note opennotes[i] = (n, j-upuntil+1, d) clips = [VideoFileClip(newcache)]+stillopen end = TextClip("pitch.py", font="Arial", color="white", fontsize=70)\ .set_pos("center")\ .set_duration(1)\ .set_start(endtime) clips.append(end) # add an ending frame """ Combine all leftover clips, write them to the final file and remove temporary files created before. """ print "Combining", len(clips), "clips" final = CompositeVideoClip(clips).set_start(1) final.write_videofile(destination) clips = [] if cache == 1: print "Removing one temporary file" elif cache > 1: print "Removing", cache, "temporary files" for i in range(0, cache): os.remove(destination+".temporary"+str(i)+".mp4")