So erstellen Sie einen Video-Media-Player mit Python

Durch den Aufbau eines Videoplayers können Sie Ihre Lieblingsvideos in einem individuellen Thema und Stil genießen. Sie können die Videowiedergabe flüssiger gestalten, die Schaltflächen und Menüs Ihrer App gestalten und beliebige Funktionen hinzufügen.

Dieses Projekt vermittelt Ihnen auch praktische Erfahrungen beim Erstellen plattformübergreifender Desktop-Apps, der Verarbeitung von Multimedia und der Handhabung von Ereignissen. Entdecken Sie, wie Sie mit Tkinter, VLC und dem Datetime-Modul einen Video-Mediaplayer erstellen können.

Das Tkinter-, VLC- und Datetime-Modul

Mit Tkinter können Sie Desktop-Anwendungen erstellen. Es bietet eine Vielzahl von Widgets wie Schaltflächen, Beschriftungen und Textfelder, die die Entwicklung solcher Anwendungen erleichtern ein einfacher GUI-Kalender, ein Taschenrechner oder ein To-Do-Listen-Manager. Um Tkinter zu installieren, öffnen Sie ein Terminal und führen Sie Folgendes aus:

pip install tkinter

Der Python-VLC Das Modul ist eine Python-Bindung für die VLC-Mediaplayer-Bibliothek (VideoLAN Client). Mit diesem Modul können Sie das implementieren Funktionen von VLC und erstellen Sie Ihren eigenen maßgeschneiderten Mediaplayer. Um VLC zu installieren, führen Sie Folgendes aus:

pip install python-vlc

Der Terminzeit Das Modul ist in Python integriert und bietet Klassen und Funktionen zur Darstellung verschiedener Daten, Zeiten, Intervalle und Zonen.

Den Quellcode dieses Projekts finden Sie in seiner GitHub-Repository.

Importieren Sie die erforderlichen Module. Definieren Sie eine Klasse, MediaPlayerApp. Definieren Sie die Konstruktormethode und rufen Sie sie auf, um das Hauptanwendungsfenster zu initialisieren. Legen Sie den Titel, die Abmessungen und die Hintergrundfarbe des Video-Media-Players fest. Ruf den initialize_player 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()

Definieren Sie eine Methode, initialize_player. Erstellen Sie eine Instanz des VLC Media Players, um mit seinen Funktionen zu interagieren. Erstellen Sie mithilfe dieser Instanz ein Media Player-Objekt, mit dem Sie die Medienwiedergabe verwalten können. Initialisieren Sie eine Variable, aktuelle Datei um den Überblick über das aktuell abgespielte Video zu behalten. Legen Sie die Wiedergabezustände fest und rufen Sie die auf 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()

Definiere das create_widgets Methode. Erstellen Sie ein Canvas-Widget und übergeben Sie das übergeordnete Element, in dem es platziert werden soll, seine Hintergrundfarbe, Breite und Höhe. Ein... kreieren Datei aussuchen Klicken Sie auf die Schaltfläche, um die Videodatei auszuwählen, die Sie abspielen möchten. Legen Sie das übergeordnete Element, den anzuzeigenden Text, die Schriftarten und den Befehl fest, den es ausführen soll, wenn Sie darauf klicken.

Erstellen Sie eine Beschriftung, um die verstrichene Zeit und die Dauer des Videos anzuzeigen. Legen Sie das übergeordnete Element, den Text, die Schriftstile, die Schriftfarbe und die Hintergrundfarbe fest. Erstellen Sie einen Rahmen, um die Videowiedergabe zu steuern und ihm eine Hintergrundfarbe zu geben.

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)

Definiere das Spielen Knopf, der Pause Knopf, der Stoppen Knopf, der Schneller Vorlauf Taste und die Zurückspulen Taste. Erstellen Sie ein Video-Fortschrittsbalken-Widget. Legen Sie das übergeordnete Element fest, in dem Sie es platzieren möchten, die Methode zum Aktualisieren der Videowiedergabeposition, die Hintergrundfarbe und die Dicke.

Ordnen Sie alle diese Elemente mit entsprechender Polsterung in beide Richtungen an.

 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)

Definieren Sie eine Methode, Datei aussuchen. Öffnen Sie ein Dateidialogfeld, um eine Videodatei auszuwählen .mp4 oder .avi Verlängerung. Wenn Sie eine Datei auswählen, laden Sie deren Pfad und aktualisieren Sie die Zeitbezeichnung mit ihrer Dauer. Starten Sie die Wiedergabe des ausgewählten Videos.

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

Definieren Sie eine Methode, get_duration_str mit dem Sie die Gesamtdauer des Videos berechnen. Wenn die Anwendung ein Video abspielt, ermitteln Sie dessen Dauer in Millisekunden und konvertieren Sie es in HH: MM: SS Format. Wenn kein Video abgespielt wird, kehren Sie zurück 00:00:00 als Standardwert.

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"

Definieren Sie eine Methode, Video abspielen. Wenn ein Video nicht abgespielt wird, erstellen Sie ein neues Medienobjekt unter Verwendung des ausgewählten Dateipfads. Verknüpfen Sie die Medien mit der zuvor erstellten Leinwand und starten Sie die Videowiedergabe. Aktualisieren Sie die playing_video Staat zu WAHR.

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

Definieren Sie eine Methode, fast_forward. Wenn ein Video abgespielt wird, ermitteln Sie die aktuell verstrichene Zeit und addieren Sie 10.000 Millisekunden dazu. Stellen Sie die neue Wiedergabezeit ein. Definieren Sie auf ähnliche Weise eine Methode, zurückspulen das subtrahiert 10.000 Millisekunden.

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)

Definieren Sie eine Methode, pause_video. Wenn Sie die Wiedergabe eines Videos gestartet und dann angehalten haben, rufen Sie das an spielen Methode, um es fortzusetzen. Andernfalls rufen Sie an Pause -Methode und aktualisieren Sie die Benutzeroberfläche in beiden Fällen entsprechend.

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

Definieren Sie eine Methode, stoppen. Wenn ein Video abgespielt wird, stoppen Sie es und setzen Sie die Zeitangabe zurück. Definieren Sie eine Methode, set_video_position. Wenn ein Video abgespielt wird, rufen Sie die Gesamtdauer ab und berechnen Sie die gewünschte Position in Millisekunden. Stellen Sie die Videowiedergabezeit auf die berechnete Position ein.

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)

Definieren Sie eine Methode, update_video_progress. Wenn ein Video abgespielt wird, rufen Sie die Gesamtdauer und die aktuelle Wiedergabezeit ab und berechnen Sie den Fortschrittsprozentsatz. Aktualisieren Sie den Fortschrittsbalken mit diesem berechneten Wert. Formatieren Sie die aktuelle Uhrzeit und die Gesamtdauer im HH: MM: SS Format.

Planen Sie die erneute Ausführung dieser Methode nach 1.000 Millisekunden. Dadurch wird eine Schleife erstellt, die den Videofortschritt und die Zeitmarkierungen während der Wiedergabe des Videos kontinuierlich aktualisiert.

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)

Definieren Sie eine Klasse, VideoProgressBar das erbt von Tk. Skala Widget. Definieren Sie einen Konstruktor, der den Anfangszustand und das Verhalten des Fortschrittsbalkens festlegt. Stellen Sie die ein Showwert Option zu FALSCH um zu vermeiden, dass der aktuelle Wert angezeigt wird.

Initialisieren Sie den Fortschritt mit einem Bereich von 0 bis 100. Legen Sie die Ausrichtung, Länge, den auszuführenden Befehl und die Anpassung für den Fortschrittsbalken fest. Binden Sie ein Ereignis an den Fortschrittsbalken, sodass es ausgeführt wird, wenn Sie darauf klicken on_click 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)

Definieren Sie eine Methode, on_click. Überprüfen Sie, ob der Fortschrittsbalken nicht deaktiviert ist und berechnet den neuen Wert basierend auf der Position des Klicks. Aktualisieren Sie den Fortschrittsbalkenwert entsprechend.

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

Erstellen Sie eine Instanz von MediaPlayerApp Klasse und rufen Sie die an update_video_progress Methode. Der Hauptschleife() Die Funktion weist Python an, die Tkinter-Ereignisschleife auszuführen und auf Ereignisse zu warten, bis Sie das Fenster schließen.

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

Beim Ausführen des Programms wird der Video-Media-Player angezeigt. Es enthält die Datei aussuchen Schaltfläche, die Zeitbeschriftungen, Schaltflächen zur Steuerung der Videowiedergabe und eine Video-Fortschrittsleiste.

Wenn Sie ein Video auswählen, wird es automatisch von Anfang an abgespielt, wobei die Startzeit und die Dauer der Zeitmarkierungen aktualisiert werden.

Beim Schlagen des Pause Klicken Sie auf die Schaltfläche, das Video pausiert und wechselt zum Wieder aufnehmen Taste. Beim Klicken auf Schneller Vorlauf Wenn Sie die Taste drücken, springt das Video um 10 Sekunden weiter.

Ebenso beim Schlagen des Zurückspulen Taste, geht es 10 Sekunden zurück. Beim Drücken der Stoppen drücken, stoppt die Videowiedergabe. Sie können einen beliebigen Bereich auf dem Fortschrittsbalken ziehen oder darauf klicken, um zu einem beliebigen Teil des Videos zu gelangen. Die Zeitbeschriftung zeigt dann die verstrichene Zeit an.

Sie können diesen Video-Mediaplayer erweitern, indem Sie eine Option zum Laden und Anzeigen von Untertiteln hinzufügen. Sie könnten auch Funktionen wie das Ändern des Seitenverhältnisses, die Steuerung der Lautstärke und das Loopen eines Teils des Videos in Betracht ziehen.

Um diese Funktionen zu implementieren, können Sie das Pygame-Modul erkunden. Pygame ist vielseitig, einfach zu verwenden und lässt sich gut in Tkinter integrieren. Die Bibliothek ermöglicht eine individuelle Anpassung, verfügt über interaktive Funktionen und kann auf jeder Plattform ausgeführt werden.