Hoe een videomediaspeler te bouwen met behulp van Python

Door een videospeler te bouwen, kunt u genieten van uw favoriete video's in een aangepast thema en stijl. U kunt het afspelen van video's soepeler laten verlopen, de knoppen en menu's van uw app ontwerpen en elke gewenste functionaliteit toevoegen.

Dit project geeft je ook praktische ervaring in het bouwen van platformonafhankelijke desktop-apps, het verwerken van multimedia en het afhandelen van evenementen. Ontdek hoe u een videomediaspeler kunt maken met Tkinter, VLC en de datetime-module.

De Tkinter-, VLC- en Datetime-module

Met Tkinter kunt u desktop-applicaties maken. Het biedt een verscheidenheid aan widgets zoals knoppen, labels en tekstvakken die het gemakkelijker maken om applicaties te ontwikkelen zoals een eenvoudige GUI-kalender, een rekenmachine of een takenlijstbeheerder. Om Tkinter te installeren, opent u een terminal en voert u het volgende uit:

pip install tkinter

De python-vlc module is een Python-binding voor de VLC (VideoLAN Client) mediaspelerbibliotheek. U kunt deze module gebruiken om de

kenmerken van VLC en bouw je eigen aangepaste mediaspeler. Voer het volgende uit om VLC te installeren:

pip install python-vlc

De datum Tijd module is ingebouwd in Python en biedt klassen en functies om verschillende datums, tijden, intervallen en zones weer te geven.

U kunt de broncode van dit project vinden in zijn GitHub-opslagplaats.

Importeer de benodigde modules. Definieer een klasse, MediaPlayer-app. Definieer de constructormethode en roep deze aan om het hoofdtoepassingsvenster te initialiseren. Stel de titel, de afmetingen en de achtergrondkleur van de videomediaspeler in. Bel de initialiseer_speler methode.

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

Definieer een methode, initialiseer_speler. Maak een exemplaar van de VLC-mediaspeler om te communiceren met zijn functionaliteiten. Maak met deze instantie een mediaspelerobject dat u kunt gebruiken om het afspelen van media te beheren. Initialiseer een variabele, huidig ​​bestand om de momenteel afgespeelde video bij te houden. Stel de afspeelstatussen in en bel de create_widgets methode.

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

Definieer de create_widgets methode. Maak een canvas-widget en geef het bovenliggende element door om het in te plaatsen, de achtergrondkleur, breedte en hoogte. Maak een Selecteer bestand om het videobestand te selecteren dat u wilt afspelen. Stel het bovenliggende element in, de tekst die moet worden weergegeven, de lettertypestijlen en de opdracht die moet worden uitgevoerd wanneer u erop klikt.

Maak een label om de verstreken tijd en de duur van de video weer te geven. Stel het bovenliggende element, de tekst, de lettertypestijlen, de lettertypekleur en de achtergrondkleur in. Maak een frame om het afspelen van de video te regelen en geef het een achtergrondkleur.

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)

Definieer de Toneelstuk knoop, de Pauze knoop, de Stop knoop, de Snel vooruit knop, en de Terugspoelen knop. Maak een videovoortgangsbalk-widget. Stel het bovenliggende element in waarin u het wilt plaatsen, de methode om de afspeelpositie van de video bij te werken, de achtergrondkleur en de dikte.

Organiseer al deze elementen met de juiste opvulling in beide richtingen.

 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)

Definieer een methode, selecteer bestand. Open een bestandsdialoogvenster om een ​​videobestand mee te selecteren .mp4 of .avi verlenging. Als u een bestand selecteert, laadt u het pad en werkt u het tijdlabel bij met de duur ervan. Begin met het afspelen van de geselecteerde 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()

Definieer een methode, get_duration_str die u gaat gebruiken om de totale duur van de video te berekenen. Als de toepassing een video afspeelt, krijgt u de duur in milliseconden en converteert u deze naar de UU: MM: SS formaat. Als er geen video wordt afgespeeld, gaat u terug 00:00:00 als standaardwaarde.

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"

Definieer een methode, video afspelen. Als een video niet wordt afgespeeld, maakt u een nieuw media-object met behulp van het geselecteerde bestandspad. Koppel de media aan het eerder gemaakte canvas en start het afspelen van de video. Update de speel_video staat aan WAAR.

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

Definieer een methode, snel vooruit. Als er een video wordt afgespeeld, haal dan de huidige verstreken tijd op en tel er 10.000 milliseconden bij op. Stel de nieuwe afspeeltijd in. Definieer op dezelfde manier een methode, terugspoelen dat trekt 10.000 milliseconden af.

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)

Definieer een methode, pauze_video. Als u het afspelen van een video had gestart en gepauzeerd, bel dan de toneelstuk methode om het te hervatten. Bel anders de pauze methode en werk de gebruikersinterface dienovereenkomstig bij in beide gevallen.

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

Definieer een methode, stop. Als een video wordt afgespeeld, stopt u deze en stelt u het tijdlabel opnieuw in. Definieer een methode, set_video_position. Als er een video wordt afgespeeld, haalt u de totale duur op en berekent u de gewenste positie in milliseconden. Stel de afspeeltijd van de video in op de berekende positie.

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)

Definieer een methode, update_video_progress. Als er een video wordt afgespeeld, haalt u de totale duur en de huidige afspeeltijd op en berekent u het voortgangspercentage. Werk de voortgangsbalk bij met deze berekende waarde. Formatteer de huidige tijd en de totale duur in de UU: MM: SS formaat.

Plan deze methode om na 1000 milliseconden opnieuw uit te voeren. Dit creëert een lus die de videovoortgang en tijdlabels continu bijwerkt terwijl de video wordt afgespeeld.

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)

Definieer een klasse, VideoProgressBar dat erft van tk. Schaal widget. Definieer een constructor die de initiële status en het gedrag van de voortgangsbalk instelt. Stel de showwaarde optie om Vals om te voorkomen dat de huidige waarde wordt weergegeven.

Initialiseer de voortgang met een bereik van 0 tot 100. Stel de oriëntatie, lengte, opdracht die het moet uitvoeren en de aanpassing aan de voortgangsbalk in. Bind een gebeurtenis aan de voortgangsbalk, zodat wanneer u erop klikt, deze de bij klikken methode.

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)

Definieer een methode, bij klikken. Controleer of de voortgangsbalk niet is uitgeschakeld en berekent de nieuwe waarde op basis van de positie van de klik. Werk de waarde van de voortgangsbalk dienovereenkomstig bij.

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

Maak een instantie van de MediaPlayer-app klas, en bel de update_video_progress methode. De Hoofdlus() functie vertelt Python om de Tkinter-gebeurtenislus uit te voeren en te luisteren naar gebeurtenissen totdat u het venster sluit.

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

Bij het uitvoeren van het programma verschijnt de videomediaspeler. Het bevat de Selecteer bestand -knop, de tijdlabels, knoppen om het afspelen van video's te regelen en een videovoortgangsbalk.

Wanneer u een video kiest, wordt deze automatisch vanaf het begin afgespeeld, waarbij de starttijd en de duur van de tijdlabels worden bijgewerkt.

Bij het raken van de Pauze knop, pauzeert de video en verandert in de Cv knop. Bij het klikken op de Snel vooruit knop, springt de video 10 seconden vooruit.

Evenzo bij het raken van de Terugspoelen knop, gaat het 10 seconden terug. Bij het indrukken van de Stop knop, stopt het afspelen van de video. U kunt elk gebied op de voortgangsbalk slepen of klikken om naar een willekeurig deel van de video te gaan en het tijdlabel leest de verstreken tijd.

U kunt deze videomediaspeler verbeteren door een optie toe te voegen om ondertitels te laden en weer te geven. U kunt ook functies overwegen zoals het wijzigen van de beeldverhouding, het regelen van het volume en het herhalen van een deel van de video.

Om deze functies te implementeren, kunt u de Pygame-module verkennen. Pygame is veelzijdig, gebruiksvriendelijk en integreert goed met Tkinter. De bibliotheek maakt maatwerk mogelijk, heeft interactieve functies en kan op elk platform worden uitgevoerd.