Kaip sukurti vaizdo įrašų medijos leistuvą naudojant Python

Vaizdo įrašų grotuvo kūrimas gali padėti mėgautis mėgstamais vaizdo įrašais pagal tinkintą temą ir stilių. Galite padaryti vaizdo įrašų atkūrimą sklandesnį, kurti programos mygtukus ir meniu bei pridėti bet kokių norimų funkcijų.

Šis projektas taip pat suteiks praktinės patirties kuriant įvairių platformų darbalaukio programas, apdorojant daugialypės terpės ir tvarkant įvykius. Sužinokite, kaip galite sukurti vaizdo medijos leistuvą naudodami Tkinter, VLC ir datos ir laiko modulį.

„Tkinter“, VLC ir datos laiko modulis

„Tkinter“ leidžia kurti darbalaukio programas. Ji siūlo įvairius valdiklius, pvz., mygtukus, etiketes ir teksto laukelius, kurie palengvina tokių programų kūrimą kaip paprastas GUI kalendorius, skaičiuotuvą arba a darbų sąrašo valdytojas. Norėdami įdiegti „Tkinter“, atidarykite terminalą ir paleiskite:

pip install tkinter

The python-vlc modulis yra Python įrišimas, skirtas VLC (VideoLAN Client) medijos leistuvo bibliotekai. Šį modulį galite naudoti norėdami įgyvendinti

VLC savybės ir sukurkite savo pritaikytą medijos leistuvą. Norėdami įdiegti VLC, paleiskite:

pip install python-vlc

The data ir laikas modulis yra integruotas į Python ir teikia klases bei funkcijas, skirtas skirtingoms datoms, laikui, intervalams ir zonoms pavaizduoti.

Šio projekto šaltinio kodą galite rasti jame GitHub saugykla.

Importuokite reikiamus modulius. Apibrėžkite klasę, MediaPlayerApp. Apibrėžkite konstruktoriaus metodą ir iškvieskite jį, kad inicijuotų pagrindinį programos langą. Nustatykite vaizdo įrašų medijos leistuvo pavadinimą, matmenis ir fono spalvą. Paskambinkite į inicijuoti_grotuvą metodas.

import tkinter as tk
import vlc
from tkinter import filedialog
from datetime import timedelta
classMediaPlayerApp(tk.Tk):
def__init__(self):
 super().__init__()
 self.title("Media Player")
 self.geometry("800x600")
 self.configure(bg="#f0f0f0")
 self.initialize_player()

Apibrėžkite metodą, inicijuoti_grotuvą. Sukurkite VLC medijos leistuvo egzempliorių, kad galėtumėte sąveikauti su jo funkcijomis. Naudodami šį pavyzdį sukurkite medijos leistuvo objektą, kurį galite naudoti medijos atkūrimui valdyti. Inicijuoti kintamąjį, dabartinis_failas kad galėtumėte sekti šiuo metu leidžiamą vaizdo įrašą. Nustatykite atkūrimo būsenas ir skambinkite sukurti_valdiklius metodas.

definitialize_player(self):
 self.instance = vlc.Instance()
 self.media_player = self.instance.media_player_new()
 self.current_file = None
 self.playing_video = False
 self.video_paused = False
 self.create_widgets()

Apibrėžkite sukurti_valdiklius metodas. Sukurkite drobės valdiklį ir perduokite pagrindinį elementą, į kurį norite įdėti, jo fono spalvą, plotį ir aukštį. Sukurti Pasirinkite Failas mygtuką, norėdami pasirinkti vaizdo failą, kurį norite leisti. Nustatykite pirminį elementą, tekstą, kurį jis turi rodyti, šrifto stilius ir komandą, kurią jis turėtų paleisti spustelėjus.

Sukurkite etiketę, kad būtų rodomas praėjęs laikas ir vaizdo įrašo trukmė. Nustatykite pagrindinį elementą, tekstą, šrifto stilius, šrifto spalvą ir fono spalvą. Sukurkite rėmelį, kad galėtumėte valdyti vaizdo įrašo atkūrimą ir suteikti jam fono spalvą.

defcreate_widgets(self):
 self.media_canvas = tk.Canvas(self, bg="black", width=800, height=400)
 self.media_canvas.pack(pady=10, fill=tk.BOTH, expand=True)
 self.select_file_button = tk.Button(
 self,
 text="Select File",
 font=("Arial", 12, "bold"),
 command=self.select_file,
 )
 self.select_file_button.pack(pady=5)
 self.time_label = tk.Label(
 self,
 text="00:00:00 / 00:00:00",
 font=("Arial", 12, "bold"),
 fg="#555555",
 bg="#f0f0f0",
 )
 self.time_label.pack(pady=5)
 self.control_buttons_frame = tk.Frame(self, bg="#f0f0f0")
 self.control_buttons_frame.pack(pady=5)

Apibrėžkite žaisti mygtukas, Pauzė mygtukas, Sustabdyti mygtukas, Pirmyn mygtuką ir Atsukti mygtuką. Sukurkite vaizdo įrašo eigos juostos valdiklį. Nustatykite pagrindinį elementą, į kurį norite jį įdėti, vaizdo įrašo atkūrimo padėties atnaujinimo metodą, fono spalvą ir storį.

Sutvarkykite visus šiuos elementus su atitinkamais kamšalais abiem kryptimis.

 self.play_button = tk.Button(
 self.control_buttons_frame,
 text="Play",
 font=("Arial", 12, "bold"),
 bg="#4CAF50",
 fg="white",
 command=self.play_video,
 )
 self.play_button.pack(side=tk.LEFT, padx=5, pady=5)
 self.pause_button = tk.Button(
 self.control_buttons_frame,
 text="Pause",
 font=("Arial", 12, "bold"),
 bg="#FF9800",
 fg="white",
 command=self.pause_video,
 )
 self.pause_button.pack(side=tk.LEFT, padx=10, pady=5)
 self.stop_button = tk.Button(
 self.control_buttons_frame,
 text="Stop",
 font=("Arial", 12, "bold"),
 bg="#F44336",
 fg="white",
 command=self.stop,
 )
 self.stop_button.pack(side=tk.LEFT, pady=5)
 self.fast_forward_button = tk.Button(
 self.control_buttons_frame,
 text="Fast Forward",
 font=("Arial", 12, "bold"),
 bg="#2196F3",
 fg="white",
 command=self.fast_forward,
 )
 self.fast_forward_button.pack(side=tk.LEFT, padx=10, pady=5)
 self.rewind_button = tk.Button(
 self.control_buttons_frame,
 text="Rewind",
 font=("Arial", 12, "bold"),
 bg="#2196F3",
 fg="white",
 command=self.rewind,
 )
 self.rewind_button.pack(side=tk.LEFT, pady=5)
 self.progress_bar = VideoProgressBar(
 self, self.set_video_position, bg="#e0e0e0", highlightthickness=0
 )
 self.progress_bar.pack(fill=tk.X, padx=10, pady=5)

Apibrėžkite metodą, pasirinkti_failą. Atidarykite failo dialogo langą, kad pasirinktumėte vaizdo failą .mp4 arba .avi pratęsimas. Jei pasirinksite bet kurį failą, įkelkite jo kelią ir atnaujinkite laiko etiketę su jo trukme. Pradėkite leisti pasirinktą vaizdo įrašą.

defselect_file(self):
 file_path = filedialog.askopenfilename(
 filetypes=[("Media Files", "*.mp4 *.avi")]
 )
if file_path:
 self.current_file = file_path
 self.time_label.config(text="00:00:00 / " + self.get_duration_str())
 self.play_video()

Apibrėžkite metodą, get_duration_str kurį naudosite apskaičiuodami bendrą vaizdo įrašo trukmę. Jei programa leidžia vaizdo įrašą, gaukite jo trukmę milisekundėmis ir konvertuokite į HH: MM: SS formatu. Jei vaizdo įrašas nerodomas, grįžkite 00:00:00 kaip numatytąją reikšmę.

defget_duration_str(self):
if self.playing_video:
 total_duration = self.media_player.get_length()
 total_duration_str = str(timedelta(milliseconds=total_duration))[:-3]
return total_duration_str
return"00:00:00"

Apibrėžkite metodą, play_video. Jei vaizdo įrašas nepaleidžiamas, sukurkite naują medijos objektą naudodami pasirinktą failo kelią. Susiekite mediją su anksčiau sukurta drobe ir pradėkite vaizdo įrašo atkūrimą. Atnaujinkite play_video būsite į Tiesa.

defplay_video(self):
ifnot self.playing_video:
 media = self.instance.media_new(self.current_file)
 self.media_player.set_media(media)
 self.media_player.set_hwnd(self.media_canvas.winfo_id())
 self.media_player.play()
 self.playing_video = True

Apibrėžkite metodą, Pirmyn. Jei leidžiamas vaizdo įrašas, sužinokite, kiek dabar praėjo laikas, ir pridėkite prie jo 10 000 milisekundžių. Nustatykite naują atkūrimo laiką. Panašiai apibrėžkite metodą, atsukti tai atima 10 000 milisekundžių.

deffast_forward(self):
if self.playing_video:
 current_time = self.media_player.get_time() + 10000
 self.media_player.set_time(current_time)
defrewind(self):
if self.playing_video:
 current_time = self.media_player.get_time() - 10000
 self.media_player.set_time(current_time)

Apibrėžkite metodą, pause_video. Jei pradėjote vaizdo įrašo atkūrimą ir jį pristabdėte, skambinkite žaisti būdas jį atnaujinti. Kitu atveju skambinkite Pauzė metodą ir atitinkamai atnaujinkite vartotojo sąsają abiem atvejais.

defpause_video(self):
if self.playing_video:
if self.video_paused:
 self.media_player.play()
 self.video_paused = False
 self.pause_button.config(text="Pause")
else:
 self.media_player.pause()
 self.video_paused = True
 self.pause_button.config(text="Resume")

Apibrėžkite metodą, sustabdyti. Jei leidžiamas vaizdo įrašas, sustabdykite jį ir iš naujo nustatykite laiko etiketę. Apibrėžkite metodą, set_video_position. Jei leidžiamas vaizdo įrašas, gaukite visą trukmę ir apskaičiuokite norimą padėtį milisekundėmis. Nustatykite vaizdo įrašo atkūrimo laiką į apskaičiuotą padėtį.

defstop(self):
if self.playing_video:
 self.media_player.stop()
 self.playing_video = False
 self.time_label.config(text="00:00:00 / " + self.get_duration_str())
defset_video_position(self, value):
if self.playing_video:
 total_duration = self.media_player.get_length()
 position = int((float(value) / 100) * total_duration)
 self.media_player.set_time(position)

Apibrėžkite metodą, update_video_progress. Jei leidžiamas vaizdo įrašas, gaukite visą trukmę, dabartinį atkūrimo laiką ir apskaičiuokite progreso procentą. Atnaujinkite eigos juostą naudodami šią apskaičiuotą vertę. Formatuokite dabartinį laiką ir bendrą trukmę HH: MM: SS formatu.

Suplanuokite, kad šis metodas būtų paleistas dar kartą po 1 000 milisekundžių. Tai sukuria kilpą, kuri nuolat atnaujina vaizdo įrašo eigos ir laiko etiketes, kol vaizdo įrašas leidžiamas.

defupdate_video_progress(self):
ifself.playing_video:
 total_duration = self.media_player.get_length()
 current_time = self.media_player.get_time()
 progress_percentage = (current_time / total_duration) * 100
self.progress_bar.set(progress_percentage)
 current_time_str = str(timedelta(milliseconds=current_time))[:-3]
 total_duration_str = str(timedelta(milliseconds=total_duration))[:-3]
 self.time_label.config(text=f"{current_time_str}/{total_duration_str}")
self.after(1000, self.update_video_progress)

Apibrėžkite klasę, VideoProgressBar kad paveldi iš tk. Skalė valdiklis. Apibrėžkite konstruktorių, kuris nustato pradinę eigos juostos būseną ir elgesį. Nustatyti parodyti vertę galimybė į Netiesa kad nebūtų rodoma dabartinė vertė.

Pažangą inicijuokite intervalu nuo 0 iki 100. Eigos juostoje nustatykite orientaciją, ilgį, komandą, kurią ji turi vykdyti, ir tinkinimą. Susiekite įvykį su eigos juosta taip, kad jį spustelėjus jis vykdytų paspaudus metodas.

classVideoProgressBar(tk.Scale):
def__init__(self, master, command, **kwargs):
 kwargs["showvalue"] = False
 super().__init__(
 master,
 from_=0,
 to=100,
 orient=tk.HORIZONTAL,
 length=800,
 command=command,
 **kwargs,
 )
 self.bind("", self.on_click)

Apibrėžkite metodą, paspaudus. Patikrinkite, ar eigos juosta nėra išjungta, ir apskaičiuoja naują vertę pagal paspaudimo padėtį. Atitinkamai atnaujinkite eigos juostos reikšmę.

defon_click(self, event):
if self.cget("state") == tk.NORMAL:
 value = (event.x / self.winfo_width()) * 100
 self.set(value)

Sukurkite egzempliorių MediaPlayerApp klasėje ir paskambinkite update_video_progress metodas. The mainloop () funkcija liepia Python paleisti Tkinter įvykių kilpą ir klausytis įvykių, kol uždarysite langą.

if __name__ == "__main__":
 app = MediaPlayerApp()
 app.update_video_progress()
 app.mainloop()

Paleidus programą, pasirodo vaizdo medijos leistuvas. Jame yra Pasirinkite Failas mygtuką, laiko etiketes, vaizdo įrašo atkūrimo valdymo mygtukus ir vaizdo įrašo eigos juostą.

Kai pasirinksite vaizdo įrašą, jis bus paleistas automatiškai nuo pat pradžių, atnaujinant pradžios laiką ir laiko etikečių trukmę.

Pataikius į Pauzė mygtuką, vaizdo įrašas pristabdomas ir pasikeičia į Aprašymas mygtuką. Spustelėjus Pirmyn mygtuką, vaizdo įrašas prabėga 10 sekundžių į priekį.

Panašiai, paspaudus Atsukti mygtuką, jis grįžta 10 sekundžių atgal. Paspaudus Sustabdyti mygtuką, vaizdo įrašo atkūrimas sustabdomas. Galite vilkti arba spustelėti bet kurią eigos juostos sritį, kad pereitumėte į bet kurią vaizdo įrašo dalį, o laiko etiketėje bus nurodytas praėjęs laikas.

Galite patobulinti šį vaizdo įrašų medijos leistuvą pridėdami parinktį įkelti ir rodyti subtitrus. Taip pat galite apsvarstyti tokias funkcijas kaip kraštinių santykio keitimas, garsumo valdymas ir vaizdo įrašo dalies keitimas.

Norėdami įdiegti šias funkcijas, galite ištirti Pygame modulį. „Pygame“ yra universalus, paprastas naudoti ir puikiai integruojamas su „Tkinter“. Biblioteka leidžia tinkinti, turi interaktyvių funkcijų ir gali veikti bet kurioje platformoje.