Sådan bygger du en videomedieafspiller ved hjælp af Python

At bygge en videoafspiller kan hjælpe dig med at nyde dine yndlingsvideoer i et tilpasset tema og stil. Du kan gøre videoafspilning jævnere, designe din apps knapper og menuer og tilføje den funktionalitet, du ønsker.

Dette projekt vil også give dig praktisk erfaring med at bygge desktop-apps på tværs af platforme, behandle multimedier og håndtere begivenheder. Opdag, hvordan du kan lave en videomedieafspiller ved hjælp af Tkinter, VLC og datetime-modulet.

Tkinter-, VLC- og Datetime-modulet

Tkinter giver dig mulighed for at oprette desktop-applikationer. Det tilbyder en række widgets som knapper, etiketter og tekstbokse, der gør det nemmere at udvikle applikationer som f.eks. en simpel GUI-kalender, en lommeregner eller en to-do liste manager. For at installere Tkinter skal du åbne en terminal og køre:

pip install tkinter

Det python-vlc modul er en Python-binding til VLC (VideoLAN Client) medieafspillerbiblioteket. Du kan bruge dette modul til at implementere

funktioner i VLC og byg din egen tilpassede medieafspiller. For at installere VLC skal du køre:

pip install python-vlc

Det dato tid modul er indbygget i Python og giver klasser og funktioner til at repræsentere forskellige datoer, tidspunkter, intervaller og zoner.

Du kan finde dette projekts kildekode i dens GitHub-depot.

Importer de nødvendige moduler. Definer en klasse, MediaPlayerApp. Definer konstruktørmetoden og kald den for at initialisere programmets hovedvindue. Indstil titlen, dimensionerne og baggrundsfarven for videomedieafspilleren. Ring til initialize_player metode.

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()

Definer en metode, initialize_player. Opret en instans af VLC-medieafspilleren for at interagere med dens funktionaliteter. Brug denne instans til at oprette et medieafspillerobjekt, som du kan bruge til at administrere medieafspilningen. Initialiser en variabel, nuværende_fil for at holde styr på den video, der afspilles i øjeblikket. Indstil afspilningstilstandene og ring til oprette_widgets metode.

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()

Definer oprette_widgets metode. Opret en lærredswidget, og send det overordnede element til at placere det i, dets baggrundsfarve, bredde og højde. Lave en Vælg Fil knappen for at vælge den videofil, du vil afspille. Indstil det overordnede element, den tekst, det skal vise, skrifttypestilene og den kommando, det skal køre, når du klikker på det.

Opret en etiket for at vise den forløbne tid og varigheden af ​​videoen. Indstil det overordnede element, teksten, skrifttypestilene, skriftfarven og baggrundsfarven. Opret en ramme for at styre videoafspilningen og giv den en baggrundsfarve.

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)

Definer Spil knappen, den Pause knappen, den Hold op knappen, den Spol frem knappen og Spole tilbage knap. Opret en videostatuslinje-widget. Indstil det overordnede element, du vil placere det i, metoden til at opdatere videoafspilningspositionen, baggrundsfarven og tykkelsen.

Organiser alle disse elementer med passende polstring i begge retninger.

 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)

Definer en metode, vælg_fil. Åbn en fildialogboks for at vælge en videofil med .mp4 eller .avi udvidelse. Hvis du vælger en fil, skal du indlæse dens sti og opdatere tidsetiketten med dens varighed. Start afspilning af den valgte video.

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()

Definer en metode, get_duration_str som du vil bruge til at beregne videoens samlede varighed. Hvis applikationen afspiller en video, skal du få dens varighed i millisekunder og konvertere den til TT: MM: SS format. Hvis der ikke afspilles video, vend tilbage 00:00:00 som standardværdi.

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"

Definer en metode, play_video. Hvis en video ikke afspilles, skal du oprette et nyt medieobjekt ved hjælp af den valgte filsti. Knyt mediet til det tidligere oprettede lærred, og start videoafspilningen. Opdater afspilning_video stat til Rigtigt.

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

Definer en metode, spol frem. Hvis en video afspilles, skal du få den aktuelle forløbne tid og tilføje 10.000 millisekunder til den. Indstil den nye afspilningstid. På samme måde definerer du en metode, spole tilbage der trækker 10.000 millisekunder.

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)

Definer en metode, pause_video. Hvis du havde startet en videoafspilning og sat den på pause, så ring til Spil metode til at genoptage det. Ellers ring til pause metode og opdatere brugergrænsefladen i overensstemmelse hermed i begge tilfælde.

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")

Definer en metode, hold op. Hvis en video afspilles, skal du stoppe den og nulstille tidsetiketten. Definer en metode, sæt_video_position. Hvis en video afspilles, skal du hente den samlede varighed og beregne den ønskede position i millisekunder. Indstil videoafspilningstiden til den beregnede position.

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)

Definer en metode, update_video_progress. Hvis en video afspilles, skal du hente den samlede varighed og den aktuelle afspilningstid og beregne fremdriftsprocenten. Opdater statuslinjen ved hjælp af denne beregnede værdi. Formater det aktuelle tidspunkt og den samlede varighed i TT: MM: SS format.

Planlæg denne metode til at køre igen efter 1.000 millisekunder. Dette skaber en loop, der løbende opdaterer videoens fremskridt og tidsetiketter, mens videoen afspilles.

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)

Definer en klasse, VideoProgressBar der arver fra tk. vægt widget. Definer en konstruktør, der angiver statuslinjens begyndelsestilstand og adfærd. Indstil udstillingsværdi mulighed for at Falsk for at undgå at vise den aktuelle værdi.

Initialiser fremskridtet med et interval på 0 til 100. Indstil orienteringen, længden, kommandoen, den skal køre, og tilpasningen til statuslinjen. Bind en begivenhed til statuslinjen, så når du klikker på den, udfører den på_klik metode.

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)

Definer en metode, på_klik. Kontroller, om statuslinjen ikke er deaktiveret, og beregner den nye værdi baseret på klikkets position. Opdater statuslinjens værdi i overensstemmelse hermed.

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

Opret en instans af MediaPlayerApp klasse, og ring til update_video_progress metode. Det mainloop() funktion fortæller Python at køre Tkinter-hændelsesløkken og lytte efter hændelser, indtil du lukker vinduet.

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

Når programmet kører, dukker videomedieafspilleren op. Den indeholder Vælg Fil knappen, tidsetiketterne, knapper til at styre videoafspilning og en videostatuslinje.

Når du vælger en video, afspilles den automatisk fra begyndelsen og opdaterer starttidspunktet og varigheden af ​​tidsetiketterne.

Ved at ramme Pause knappen, pauser videoen og skifter til Genoptag knap. Ved at klikke på Spol frem knappen, springer videoen 10 sekunder frem.

Tilsvarende ved at ramme Spole tilbage knappen, går den 10 sekunder tilbage. Ved at trykke på Hold op knappen, stopper videoafspilningen. Du kan trække eller klikke på et hvilket som helst område på statuslinjen for at flytte til en hvilken som helst del af videoen, og tidsetiketten viser den forløbne tid.

Du kan forbedre denne videomedieafspiller ved at tilføje en mulighed for at indlæse og vise undertekster. Du kan også overveje funktioner som ændring af billedformatet, styring af lydstyrken og looping af en del af videoen.

For at implementere disse funktioner kan du udforske Pygame-modulet. Pygame er alsidigt, nemt at bruge og integrerer godt med Tkinter. Biblioteket tillader tilpasning, har interaktive funktioner og kan køre på enhver platform.