def convert(path): for root, folders, files in os.walk(path): for file_ in files: if not fnmatch.fnmatch(file_, '*.mp4'): continue complete_path = os.path.join(root, file_) filename, file_extension = os.path.splitext(complete_path) mp4_file = filename + '.mp4' mp3_file = filename + '.mp3' if not os.path.isfile(mp4_file): continue audio = AudioFileClip(mp4_file) audio.write_audiofile(mp3_file) audio.close() os.remove(mp4_file) # save_as = input('Save as: /home/yuukiasuna/') # destination = f'/home/yuukiasuna/{save_as}/' new_filename = mp3_file.split('/') destination = '/home/yuukiasuna/Downloads/Music/' shutil.move(mp3_file, destination + new_filename[-1])
def Audio_Visual_Separation(self, Video_Path, Video_Name, Audio_Path=None, Audio_Name=None): """ 音频分离函数 首先检查地址是否存在,默认只需要视频地址和视频名称,音频默认存放之视频地址下 视频是MP4格式,音频默认是MP3格式 :param Video_Path:视频地址 :param Video_Name: 视频名 :param Audio_Path: 音频地址 :param Audio_Name: 音频名称 :return: 分离好的音频 """ self.Video_Path = Video_Path self.Video_Name = Video_Name if Audio_Path is not None: self.Audio_Path = Audio_Path else: self.Audio_Path = Video_Path if Audio_Name is not None: self.Audio_Name = Audio_Name else: self.Audio_Name = Video_Name.replace(".mp4", ".mp3") if self._path_check(self.Video_Path + self.Video_Name): if self._path_check(self.Audio_Path): __video_path = self.Video_Path + self.Video_Name __audio_path = self.Audio_Path + self.Audio_Name my_audio_clip = AudioFileClip(__video_path) my_audio_clip.write_audiofile(__audio_path) else: print('error! :audio file path cant find') else: print('error! :video file or file path cant find')
def extract_mp3(video_file): path_ = "tracce_mp4//" + video_file audio_name = video_file[0:-3] + "mp3" clip = AudioFileClip(path_) clip.write_audiofile(audio_name) shutil.move(str(audio_name), audio_path) clip.close()
def record_button_clicked(self, widget, mode): audio_jack = AudioJack.get_thread() if mode == "start": if self.record_filename is None: filename = FileOp.choose_file(self, purpose="save_as", file_types="audio") if filename: self.set_record_filename(filename) self.record_clock.reset() else: self.record_pause_button.show() self.record_stop_button.show() self.record_start_button.hide() audio_jack.record = True self.record_clock.start() elif mode == "pause": self.record_pause_button.hide() self.record_stop_button.show() self.record_start_button.show() audio_jack.record = False self.record_clock.pause() elif mode == "stop": self.record_pause_button.hide() self.record_start_button.show() self.record_stop_button.hide() audio_jack.record = False self.record_clock.pause() if self.record_filename: mid_filename = self.record_filename + ".{0}.wav".format(time.time()) if audio_jack.save_record_file_as(mid_filename): clip = AudioFileClip(mid_filename) clip.write_audiofile(self.record_filename) os.remove(mid_filename) self.load_audio_samples(self.record_filename) self.set_filename(self.record_filename) self.set_record_filename("")
def separate_audio(file_path, save_path): audio_file = save_path + '\\tmp.wav' audio = AudioFileClip(file_path) audio.write_audiofile(audio_file, ffmpeg_params=['-ar', '16000', '-ac', '1'], logger=None) return audio_file
async def downloadVideo(self): # Get Video var_video = YouTube(self.url) time.sleep(0.05) # Get Title from Video var_title = var_video.title time.sleep(0.05) # Select Stream var_stream = var_video.streams.order_by("bitrate").filter(only_audio=True, file_extension="mp4").last() # Store File in Variable var_File = var_stream.download(self.path) var_newFile, ext = os.path.splitext(var_File) # Convert File audio = AudioFileClip(os.path.abspath(var_File)) audio.write_audiofile(var_newFile + ".mp3") audio.close() os.remove(os.path.abspath(var_File)) # Get Metadata finalFile = eyed3.load(os.path.abspath(var_newFile + ".mp3")) finalFile.tag.artist = self.artist finalFile.tag.album = self.album finalFile.tag.title = var_title finalFile.tag.save() print("Finished Download and Converting of: " + var_title)
def download(self, directory): bitrate = str(int(self.stream.bitrate / 1000)) + "k" url = self.stream.url extension = ".mp3" if self.onlyAudio else ".mp4" finalPath = os.path.join(directory, sanitizeFilename(self.name) + extension) clip = AudioFileClip(url) if self.onlyAudio else VideoFileClip(url) if self.stream.mediaType == "V": audioClip = AudioFileClip(self.audioStream.url) clip = clip.set_audio(audioClip) if self.volumeMultiplier != 0: newVolume = ( 1 + self.volumeMultiplier / 100 )**2 if self.volumeMultiplier < 0 else self.volumeMultiplier / 5 clip = clip.volumex(newVolume) if self.cut: # Clip the video low = self.lowCut high = self.highCut if low < 0: low = 0 if high > clip.end: high = clip.end clip = clip.subclip(low, high) # Save as final path name if self.onlyAudio: clip.write_audiofile(finalPath, bitrate=bitrate) self.applyID3Tags(finalPath) else: clip.write_videofile(finalPath, threads=NUM_THREADS) clip.close() elif self.onlyAudio: clip.write_audiofile(finalPath, bitrate=bitrate) clip.close() self.applyID3Tags(finalPath) else: clip.write_videofile(finalPath, threads=NUM_THREADS) clip.close() try: clip.close() except: pass return finalPath
def extract_sound_from_video(video_path): #[s3_key]_[randomized_file_name] print('Extracting sound from video ['+video_path+']') # ./[input_name]_[random_string].[file_extension] -> ./[input_name]_[random_string].mp3 tmp_extracted_sound_path = './'+os.path.basename(video_path).split('.')[0]+'.mp3' audio = AudioFileClip(video_path) audio.write_audiofile(tmp_extracted_sound_path) print('Sound extracted and saved under ['+tmp_extracted_sound_path+']') return tmp_extracted_sound_path
def convert_to_wav(source_path): clip = AudioFileClip(source_path) wav_path = tempfile_path('.wav') # NOTE: -ac stands for 'audio channels' # Force mono since Google Cloud STT only accepts mono audio ffmpeg_params = ['-ac', '1'] clip.write_audiofile(wav_path, ffmpeg_params=ffmpeg_params) return wav_path
def main(): file_name = '/home/uscc/USAI_Outsourcing/SBIR_fight_videos/ced_info_SBIR.csv' output_file1 = 'ucfInfo/ced_training.csv' output_file2 = 'ucfInfo/ced_testing.csv' v_ext = '.mp4' a_ext = '.mp3' subclips_info = pd.read_csv(file_name) # if os.path.exists(output_file1): # csv_writer = csv.writer(open(output_file1, 'a')) # else: # csv_writer = csv.writer(open(output_file1, 'w')) # csv_writer.writerow(['name', 'label', 'score']) # if os.path.exists(output_file2): # csv_writer2 = csv.writer(open(output_file2, 'a')) # else: # csv_writer2 = csv.writer(open(output_file2, 'w')) # csv_writer2.writerow(['name', 'label', 'score']) for index, row in subclips_info.iterrows(): # if index < 316: # continue print('[{}/{}] {}'.format(index, len(subclips_info), row.Name)) # print('Name: {row.Name}\t' # 'Label: {row.label}\t' # 'start: {row.start}\t' # 'end: {row.end}\t' # 'score: {row.score}'.format(row=row)) video_name = row.Name + v_ext audio_name = row.Name + a_ext output_name = row.Name[:-11] + 'v{:04d}_{}_{:03d}_n'.format( index, row.label, row.score) # if random() < 0.9: # csv_writer.writerow([output_name, row.label, row.score]) # else: # csv_writer2.writerow([output_name, row.label, row.score]) ## cut vedio and audio vedio_clip = VideoFileClip(video_name).subclip(row.start, row.end) audio_clip = AudioFileClip(audio_name).subclip(row.start, row.end) vedio_clip.write_videofile(output_name + v_ext) audio_clip.write_audiofile(output_name + a_ext) ## replace origional file os.remove(row.Name + v_ext) os.remove(row.Name + a_ext) os.rename( row.Name[:-11] + 'v{:04d}_{}_{:03d}_n'.format(index, row.label, row.score) + v_ext, row.Name[:-11] + row.Name[50:-12] + v_ext) os.rename( row.Name[:-11] + 'v{:04d}_{}_{:03d}_n'.format(index, row.label, row.score) + a_ext, row.Name[:-11] + row.Name[50:-12] + a_ext)
def __handle_download_all(self): """ Downloads all videos in the GUI video list to file location. This method creates a folder in the download location with all the audio files in the video list. The folder is in the format Youtube_Audio_Batch_Downloader_MM_DD_YYYY_hh_mm_ss """ folder_name = generate_folder() if not os.path.isdir(self.__values[Input.DOWNLOAD_LOCATION]): sg.Popup('Invalid path. Unable to download.') return download_path = os.path.join(self.__values[Input.DOWNLOAD_LOCATION], folder_name) num_videos = len(self.__loaded_videos) current_progress_bar = 0 progress_bar_iterator = ProgBar.MAX_VALUE.value / num_videos self.__window[Input.CURRENT_DOWNLOAD].update('Downloading: ') for video in self.__loaded_videos: title = self.__remove_special_char(video['title']) self.__window[Input.CURRENT_DOWNLOAD].update(f'Downloading: {video["title"]} ') video['audio'].download(download_path) video_file = download_path + f'\{title}.mp4' audio_file = download_path + f'\{title}.mp3' # Convert MP4 to MP3 file clip = AudioFileClip(video_file) clip.write_audiofile(audio_file) clip.close() os.remove(video_file) # Add thumbnail image to MP3 file response = urllib2.urlopen(video['thumbnail']) imagedata = response.read() audio = MP3(audio_file, ID3=ID3) audio.tags.add( APIC( encoding=3, mime='image/jpeg', type=3, desc=u'Cover', data=imagedata ) ) audio.save() self.__video_img.update(data=video['image']) self.__video_title.update(video['title']) self.__window[ProgBar.PROGRESS_BAR].update_bar(current_progress_bar + progress_bar_iterator) current_progress_bar += progress_bar_iterator self.__window[Input.CURRENT_DOWNLOAD].update('Download completed!') sg.Popup('Download Completed!')
def main_path(source_path, download_yt_captions, convert_wav): if convert_wav: src = AudioFileClip(source_path) filename = os.path.basename(source_path) name, _ = os.path.splitext(filename) wav_path = os.path.join(tempdir_path(), name + '.wav') src.write_audiofile(wav_path) return wav_path else: return source_path
def covertMp4Towav(self, inputName, outputName): """convert mp4 file to wave Arguments: inputName {string} -- file name outputName {string} -- file name after converting """ audioclip = AudioFileClip(inputName) audioclip.write_audiofile(outputName)
def generate_fingerprint(fname: str) -> List[int]: """return an audio fingerprint for a video file. """ audioclip = AudioFileClip(fname) audioclip.write_audiofile("temp.wav") duration, fp_encoded = acoustid.fingerprint_file("temp.wav") fingerprint, version = decode_fingerprint(fp_encoded) os.remove("temp.wav") return fingerprint
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 convert_mp3(song_name: str): """Función que convierte el formato MP4 a MP3""" print("\nConviertiendo la canción a formato 'mp3...") try: clip = AudioFileClip(song_name) clip.write_audiofile(song_name.replace('mp4', 'mp3')) except Exception as e: print("Hubo un error al convertir la cancación:", e) exit(1) if song_name.endswith('mp4'): remove(song_name)
def MP4toMP3(self, deletemp4): for file in [ n for n in os.listdir(self.tgt_folder) if re.search('mp4', n) ]: full_path = os.path.join(self.tgt_folder, file) output_path = os.path.join(self.tgt_folder, os.path.splitext(file)[0] + '.mp3') # .subclip(10,) # disable if do not want any clipping clip = AudioFileClip(full_path) clip.write_audiofile(output_path) if deletemp4: print("Deleting {}".format(full_path)) os.remove(full_path) # deletes the mp4 file else: pass
def audio_extraction(video_name): """ Receive a video filepath and returns a base64 bytes string of the ogg/vorbis video's audio :param video_name: The video file path :return: (bytes) base64 bytes string of the video's ogg/vorbis audio. """ audioclip = AudioFileClip(video_name) audio_fn = f"{video_name}_audio.ogg" audioclip.write_audiofile(audio_fn, codec='vorbis') b64audio = base64.b64encode(open(audio_fn, 'rb').read()).decode('utf-8') os.remove(audio_fn) return b64audio
class AudioExtractor(): """ Class for extracting audio (.mp3) from video file. """ def __init__(self, filename): self.filename = filename def load_video(self): self.video = VideoFileClip(self.filename) def load_mp3(self): self.audio = AudioFileClip(self.filename) def extract_audio(self): self.audio = self.video.audio def save_audio(self, audio_path): self.audio.write_audiofile(audio_path)
def process_video_exctract_peeks(filepath, do_print): filename = path_leaf(filepath) print('extracting peeks from ' + filename + '...') npy_path = NPY_PATH + filename + NPY_POSTF audio_path = AUDIO_FOLDER + filename + AUDIO_POSTF audioclip = AudioFileClip(filepath) audioclip.write_audiofile(audio_path) audio, sr = librosa.load(audio_path) print(sr) # FILTER x_f = butter_highpass(audio, 30000, sr, order=5) o_env = librosa.onset.onset_strength(x_f, sr=sr) times = librosa.frames_to_time(np.arange(len(o_env)), sr=sr) onset_frames = librosa.util.peak_pick(o_env, 2, 3, 3, 5, 0.3, 4) peeks = np.array(librosa.frames_to_time(onset_frames, sr=sr)) if (do_print): print(peeks) plt.plot(times, o_env, label='Onset strength') plt.vlines(times[onset_frames], 0, o_env.max(), color='r', alpha=0.9, linestyle='--', label='Onsets') plt.show() print("total: " + str(peeks.shape[0]) + " peeks found.") print('done.') print('----------------------') return peeks
def split_audio_from_video(video_input_path, audio_output_path): """This function is used to extract voice from a video. Args: video_input_path: path of the origin video audio_output_path: path to the voice file 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 my_audio_clip = AudioFileClip(video_input_path) my_audio_clip.write_audiofile(audio_output_path, codec='libvorbis') if not os.path.isfile(audio_output_path): print("invalid output path") my_audio_clip.close() return FAILED my_audio_clip.close() return SUCCESS
def as_mp3( self, mp3_path: Path, skip_existing: Optional[bool] = False, progress_logger: Optional[logging.Logger] = None, ) -> Path: """Download the track in `.mp3` format. Args: mp3_path (Path): where should the resulting file be stored skip_existing (Optional[bool]): whether or not to overwrite an existing file. Defaults to False. progress_logger (Optional[logging.Logger]): a logger reporting on the download progress. Defaults to None. Returns: Path: the download location of the `.mp3` file """ # FIXME: genres # FIXME: progress bar and logging both for moviepy and pytube mp3_path = Path(mp3_path) mp4_path = self.as_mp4(mp3_path, skip_existing=skip_existing) audio_file_clip = AudioFileClip(str(mp4_path)) audio_file_clip.write_audiofile(str(mp3_path), logger=progress_logger) mp4_path.unlink() easy_id3 = EasyID3(mp3_path) easy_id3.update(self.id3_tags) easy_id3.save(v2_version=3) return mp3_path
def get_audio_time(titles): time=0 temp_text='' for x in titles: time+=0.5 for y in grouper(x,2,""): for m in y: temp_text+=m+" " time+=get_time_to_read(temp_text) time+=0.3 temp_text='' return time+0.2 AUDIO_TIME=get_audio_time(title_texts) audio=AFC("/gdrive/My Drive/lil daufe/audios/birth_of_a_hero.mp3") audio=audio.subclip(0,AUDIO_TIME) audio.write_audiofile("lol.mp3") class final_video(Scene): ''' complete video ''' CONFIG={ "include_sound": True, "camera_config":{ "background_color": WHITE, "background_opacity":0.4, } } def construct(self): self.intro_video() self.remove(*self.get_mobjects()) self.wait()
def conversionop(a): audioclip = AudioFileClip(a) audioclip.write_audiofile("file.wav")
# pip install SpeechRecognition import speech_recognition as sr r = sr.Recognizer() from moviepy.editor import AudioFileClip my_clip = AudioFileClip("cutwithsound.mp4") audio = "sound.wav" my_clip.write_audiofile(audio) with sr.AudioFile(audio) as source: audio = r.record(source) text= r.recognize_google(audio, language="ru-RU") filename = "textfile.txt" f = open(filename, "w+") remainder = text.split() while remainder: line, remainder = remainder[:5], remainder[5:] f.write(' '.join(line) + "\n") from docx import Document document = Document() with open('textfile.txt') as f: for line in f:
def download(self): links = self.input.text() links = links.split(";") if self.path_to_save == None: self.path_to_save = self.basedir playlist_error = 0 video_error = 0 for link in links: if self.type == 0: try: video = YouTube(link) if self.content == 1: stream = video.streams.get_highest_resolution() self.label_status.setText("Fazendo Download ...") stream.download(self.path_to_save) elif self.content == 0: audio = video.streams.filter(only_audio=True).first() self.label_status.setText("Fazendo Download ...") audio.download(self.path_to_save) self.label_status.setText("Convertendo ...") mp4_path = os.path.join(self.path_to_save, audio.default_filename) mp3_path = os.path.join( self.path_to_save, os.path.splitext(audio.default_filename)[0] + ".mp3", ) new_file = AudioFileClip(mp4_path) new_file.write_audiofile(mp3_path) os.remove(mp4_path) except: self.alert( "Erro ao baixar video", "Verifique o link e sua conexão com a internet e tente novamente", ) video_error += 1 if self.type == 1: try: playlist = Playlist(link) for url in playlist: try: video = YouTube(url) if self.content == 1: stream = video.streams.get_highest_resolution() self.label_status.setText( "Fazendo Download ...") stream.download(self.path_to_save) elif self.content == 0: audio = video.streams.filter( only_audio=True).first() self.label_status.setText( "Fazendo Download ...") audio.download(self.path_to_save) self.label_status.setText("Convertendo ...") mp4_path = os.path.join( self.path_to_save, audio.default_filename) mp3_path = os.path.join( self.path_to_save, os.path.splitext(audio.default_filename)[0] + ".mp3", ) new_file = AudioFileClip(mp4_path) new_file.write_audiofile(mp3_path) os.remove(mp4_path) except: self.alert( "Erro ao baixar video", "Verifique o link e sua conexão com a internet e tente novamente", ) video_error += 1 except: self.alert( "Erro ao abrir playlist", "Verifique o link e sua conexão com a internet e tente novamente", ) playlist_error += 1 erro = "" if playlist_error > 0: erro += f" Erro ao abrir {playlist_error} playlists." if video_error > 0: erro += f" Erro ao baixar {video_error} video(s)." self.label_status.setText("Download(s) Concluidos") self.alert( "Download(s) Concluidos.", "Todos os downloads possiveis foram finalizados." + erro, )
from moviepy.editor import AudioFileClip """ href: https://blog.csdn.net/qq_34769162/article/details/107910036 """ my_audio_clip = AudioFileClip("../files/bbiamsheep.mp4") # my_audio_clip.write_audiofile("e:/chrome/my_audio.wav") my_audio_clip.write_audiofile("../files/bbiamsheep.mp3")
def dowload_videos(): # Warten, bis alle Videos hinzugefügt wurden for thread in threads: try: thread.join() except: pass # Videos werden nacheinander heruntergeladen for video in videos: try: # wenn nur die Audio gespeichert werden soll, if video.file_format == "mp3": # Audiostreams audio_streams = video.pytube_video.streams.filter( only_audio=True) # Audiospur download als mp4 filepath = audio_streams[0].download(os.getcwd(), skip_existing=False) # Konvertieren in mp3 und an gewünschtem Speicherort speichern audio = AudioFileClip(filepath).subclip( video.start_time, video.end_time) audio.write_audiofile( os.path.join(dest_path, video.filename + ".mp3")) try: # AurdioReader muss geschlossen werden, um die mp4 Datei zu löschen # manchmal wird ein Fehler erzeugt, mp4 Datei kann trotzdem gelöscht werden # fehler z.B.: https://www.youtube.com/watch?v=YbgDZfK8WR8 audio.reader.__del__() except Exception as e: pass # mp4 Datei wird gelöscht os.remove(filepath) print(video.pytube_video.title + " gespeichert als " + video.filename + ".mp3") # wenn das Video gespeichert werden soll elif video.file_format == "mp4": # Videostreams video_streams = video.pytube_video.streams.filter() # mp4 Download an gewünschten speicherort filepath = video_streams.get_highest_resolution().download( dest_path, skip_existing=False, filename=video.filename + "(old)") # Wenn nicht das ganze Video heruntergeladen werden soll, if video.start_time != 0 or video.end_time != video.pytube_video.length: # gewünschter Videoausschnitt wird erstellt videoclip = VideoFileClip(filepath).subclip( video.start_time, video.end_time) # Videoclip wird am gewünschten Speicherort gespeichert videoclip.write_videofile( os.path.join(dest_path, video.filename + ".mp4")) videoclip.reader.close() # ursprüngliches komplettes Video wird gelöscht os.remove(filepath) print(video.pytube_video.title + " gespeichert als " + video.filename + ".mp4") except Exception as e: print("Download von " + video.filename + " fehlgeschlagen\n" + str(e))
if args.audio: # Download Youtube file filters = yt_obj.streams.filter(only_audio=True) download_video(filters[0]) print("Video finish downloaded") # Convert to MP3 print("Converting to MP3 now....") audio_clip = AudioFileClip( f"{DOWNLOADED_VIDEO_FILE_PATH}/{args.filename or yt_obj.title}.mp4" ) audio_clip.write_audiofile( f"{DOWNLOADED_VIDEO_FILE_PATH}/{args.filename or yt_obj.title}.mp3" ) audio_clip.close() print("Finish converted.") else: # progressive=True mean that stream have both video & audio filters = yt_obj.streams.filter(progressive=True) download_video(filters.get_highest_resolution()) print("Video finish downloaded") except RegexMatchError as e: print("Unable to find the Youtube video.") print("Probably is a private video.")
from moviepy.editor import AudioFileClip import sys from you_get import common as you_get #导入you-get库 import time directory = r'E:\workspace\python\demo\src' #设置下载目录 name = str(time.time()) #获取当前时间戳命名 url = 'https://www.bilibili.com/bangumi/play/ss35874' #需要下载的视频地址 sys.argv = ['you-get', '-o', directory, '-O', name, url] #sys传递参数执行下载,就像在命令行一样 you_get.main() video = AudioFileClip('E:\\workspace\\python\demo\\src\\' + name + '.flv') #读取视频 audio = video.write_audiofile('E:\\workspace\\python\demo\\src\\' + name + '.wav') #将视频中的音频提取出来