Acest proiect GUI simplu vă va învăța despre fișierele media și programarea pe mai multe platforme.
Construirea unui player video vă poate ajuta să vă bucurați de videoclipurile preferate într-o temă și stil personalizat. Puteți face redarea video mai ușoară, puteți proiecta butoanele și meniurile aplicației și puteți adăuga orice funcționalitate doriți.
Acest proiect vă va oferi, de asemenea, experiență practică în construirea de aplicații desktop multiplatforme, procesarea multimedia și gestionarea evenimentelor. Descoperiți cum puteți crea un player media video folosind Tkinter, VLC și modulul datetime.
Modulul Tkinter, VLC și Datetime
Tkinter vă permite să creați aplicații desktop. Oferă o varietate de widget-uri, cum ar fi butoane, etichete și casete de text, care facilitează dezvoltarea unor aplicații precum un calendar simplu GUI, un calculator sau un manager de liste de sarcini. Pentru a instala Tkinter, deschideți un terminal și rulați:
pip install tkinter
The python-vlc modulul este o legare Python pentru biblioteca playerului media VLC (VideoLAN Client). Puteți folosi acest modul pentru a implementa
caracteristicile VLC și construiește-ți propriul player media personalizat. Pentru a instala VLC, rulați:pip install python-vlc
The datetime modulul este construit în Python și oferă clase și funcții pentru a reprezenta diferite date, ore, intervale și zone.
Puteți găsi codul sursă al acestui proiect în documentul său Depozitul GitHub.
Importați modulele necesare. Definiți o clasă, Aplicația MediaPlayer. Definiți metoda constructorului și apelați-o pentru a inițializa fereastra principală a aplicației. Setați titlul, dimensiunile și culoarea de fundal a playerului media video. Suna initialize_player metodă.
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()
Definiți o metodă, initialize_player. Creați o instanță a playerului media VLC pentru a interacționa cu funcționalitățile acestuia. Folosind această instanță, creați un obiect media player pe care îl puteți utiliza pentru a gestiona redarea media. Inițializați o variabilă, fila curenta pentru a urmări videoclipul redat în prezent. Setați stările de redare și apelați create_widgets metodă.
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()
Definiți create_widgets metodă. Creați un widget canvas și transmiteți elementul părinte în care să îl plasați, culoarea de fundal, lățimea și înălțimea acestuia. Creeaza o Selectați Fișier butonul pentru a selecta fișierul video pe care doriți să-l redați. Setați elementul părinte, textul pe care ar trebui să-l afișeze, stilurile de font și comanda pe care ar trebui să o ruleze când faceți clic pe el.
Creați o etichetă pentru a afișa timpul scurs și durata videoclipului. Setați elementul părinte, textul, stilurile de font, culoarea fontului și culoarea de fundal. Creați un cadru pentru a controla redarea videoclipului și a da-i o culoare de fundal.
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)
Definiți Joaca butonul, Pauză butonul, Stop butonul, Repede inainte butonul, iar butonul Derulează înapoi buton. Creați un widget pentru bara de progres video. Setați elementul părinte în care doriți să-l plasați, metoda de actualizare a poziției de redare a videoclipului, culoarea de fundal și grosimea.
Organizați toate aceste elemente cu căptușeală adecvată în ambele direcții.
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)
Definiți o metodă, select_file. Deschideți o casetă de dialog de fișier pentru a selecta un fișier video cu .mp4 sau .avi extensie. Dacă selectați orice fișier, încărcați calea acestuia și actualizați eticheta de timp cu durata acestuia. Începeți redarea videoclipului selectat.
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()
Definiți o metodă, get_duration_str pe care îl vei folosi pentru a calcula durata totală a videoclipului. Dacă aplicația redă un videoclip, obțineți durata acestuia în milisecunde și convertiți-l în HH: MM: SS format. Dacă nu se redă niciun videoclip, reveniți 00:00:00 ca valoare implicită.
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"
Definiți o metodă, rulează video. Dacă un videoclip nu este redat, creați un nou obiect media folosind calea fișierului selectată. Asociați media cu pânza creată mai devreme și inițiați redarea video. Actualizați redare_video stare să Adevărat.
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
Definiți o metodă, repede inainte. Dacă se redă un videoclip, obțineți timpul curent scurs și adăugați-i 10.000 de milisecunde. Setați noua oră de redare. În mod similar, definiți o metodă, derulează înapoi care scade 10.000 de milisecunde.
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)
Definiți o metodă, pauză_video. Dacă ați început orice redare video și ați întrerupt-o, sunați la Joaca metoda de a o relua. În caz contrar, sunați la pauză metoda și actualizați interfața de utilizare în consecință în ambele cazuri.
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")
Definiți o metodă, Stop. Dacă se redă un videoclip, opriți-l și resetați eticheta de timp. Definiți o metodă, set_video_position. Dacă este redat un videoclip, recuperați durata totală și calculați poziția dorită în milisecunde. Setați timpul de redare video la poziția calculată.
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)
Definiți o metodă, update_video_progress. Dacă este redat un videoclip, recuperați durata totală și timpul curent de redare și calculați procentul de progres. Actualizați bara de progres folosind această valoare calculată. Formatați ora curentă și durata totală în HH: MM: SS format.
Programați această metodă să ruleze din nou după 1.000 de milisecunde. Acest lucru creează o buclă care actualizează continuu progresul video și etichetele de timp în timp ce videoclipul este redat.
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)
Definiți o clasă, VideoProgressBar care moşteneşte de la tk. Scară widget. Definiți un constructor care stabilește starea inițială și comportamentul barei de progres. Seteaza valoare de prezentare opțiunea pentru Fals pentru a evita afișarea valorii curente.
Inițializați progresul cu un interval de la 0 la 100. Setați orientarea, lungimea, comanda pe care trebuie să o ruleze și personalizarea în bara de progres. Legați un eveniment la bara de progres astfel încât, atunci când faceți clic pe el, să execute pe_clic metodă.
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)
Definiți o metodă, pe_clic. Verificați dacă bara de progres nu este dezactivată și calculează noua valoare în funcție de poziția clicului. Actualizați valoarea barei de progres în consecință.
defon_click(self, event):
if self.cget("state") == tk.NORMAL:
value = (event.x / self.winfo_width()) * 100
self.set(value)
Creați o instanță a Aplicația MediaPlayer clasa și sună la update_video_progress metodă. The mainloop() funcția îi spune lui Python să ruleze bucla de evenimente Tkinter și să asculte evenimente până când închideți fereastra.
if __name__ == "__main__":
app = MediaPlayerApp()
app.update_video_progress()
app.mainloop()
La rularea programului, apare playerul media video. Acesta conține Selectați Fișier butonul, etichetele de timp, butoanele pentru a controla redarea video și o bară de progres video.
Când alegeți un videoclip, acesta va fi redat automat de la început, actualizând ora de începere și durata etichetelor de timp.
La lovirea Pauză butonul, videoclipul se întrerupe și se schimbă în Relua buton. Făcând clic pe Repede inainte butonul, videoclipul trece înainte cu 10 secunde.
În mod similar, la lovirea Derulează înapoi butonul, se întoarce cu 10 secunde. La apăsarea butonului Stop butonul, redarea videoclipului se oprește. Puteți trage sau face clic pe orice zonă din bara de progres pentru a vă deplasa la orice parte a videoclipului, iar eticheta de timp citește timpul scurs.
Puteți îmbunătăți acest player media video adăugând o opțiune pentru a încărca și afișa subtitrări. De asemenea, puteți lua în considerare funcții precum schimbarea raportului de aspect, controlul volumului și trecerea în buclă a unei părți a videoclipului.
Pentru a implementa aceste funcții, puteți explora modulul Pygame. Pygame este versatil, ușor de utilizat și se integrează bine cu Tkinter. Biblioteca permite personalizarea, are funcții interactive și poate rula pe orice platformă.