Jak vytvořit přehrávač video médií pomocí Pythonu

Sestavení přehrávače videa vám pomůže vychutnat si oblíbená videa v přizpůsobeném motivu a stylu. Můžete usnadnit přehrávání videa, navrhnout tlačítka a nabídky své aplikace a přidat libovolné funkce, které chcete.

Tento projekt vám také poskytne praktické zkušenosti s vytvářením desktopových aplikací pro různé platformy, zpracováním multimédií a zpracováním událostí. Zjistěte, jak můžete vytvořit přehrávač video médií pomocí Tkinter, VLC a modulu datetime.

Modul Tkinter, VLC a Datetime

Tkinter vám umožňuje vytvářet desktopové aplikace. Nabízí řadu widgetů, jako jsou tlačítka, štítky a textová pole, které usnadňují vývoj aplikací, jako jsou jednoduchý GUI kalendář, kalkulačka nebo a správce seznamu úkolů. Chcete-li nainstalovat Tkinter, otevřete terminál a spusťte:

pip install tkinter

The python-vlc module je vazba Pythonu pro knihovnu přehrávače médií VLC (VideoLAN Client). Tento modul můžete použít k implementaci

vlastnosti VLC a vytvořte si vlastní přizpůsobený přehrávač médií. Chcete-li nainstalovat VLC, spusťte:

pip install python-vlc

The čas schůzky modul je zabudován do Pythonu a poskytuje třídy a funkce pro reprezentaci různých dat, časů, intervalů a zón.

Zdrojový kód tohoto projektu najdete v něm úložiště GitHub.

Importujte požadované moduly. Definujte třídu, Aplikace MediaPlayer. Definujte metodu konstruktoru a zavolejte ji pro inicializaci hlavního okna aplikace. Nastavte název, rozměry a barvu pozadí přehrávače video médií. Zavolej initialize_player metoda.

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

Definujte metodu, initialize_player. Vytvořte instanci přehrávače médií VLC pro interakci s jeho funkcemi. Pomocí této instance vytvořte objekt přehrávače médií, který můžete použít ke správě přehrávání médií. Inicializovat proměnnou, aktuální_soubor pro sledování aktuálně přehrávaného videa. Nastavte stavy přehrávání a zavolejte vytvořit_widgety metoda.

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

Definujte vytvořit_widgety metoda. Vytvořte widget canvas a předejte nadřazený prvek, do kterého jej umístíte, jeho barvu pozadí, šířku a výšku. Vytvořit Zvolte soubor tlačítkem vyberte video soubor, který chcete přehrát. Nastavte nadřazený prvek, text, který se má zobrazit, styly písma a příkaz, který se má spustit, když na něj kliknete.

Vytvořte štítek pro zobrazení uplynulého času a trvání videa. Nastavte nadřazený prvek, text, styly písma, barvu písma a barvu pozadí. Vytvořte rámeček pro ovládání přehrávání videa a dejte mu barvu pozadí.

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)

Definujte Hrát si tlačítko, Pauza tlačítko, Stop tlačítko, Rychle vpřed tlačítko a Přetočit knoflík. Vytvořte widget ukazatele průběhu videa. Nastavte rodičovský prvek, do kterého jej chcete umístit, způsob aktualizace pozice přehrávání videa, barvu pozadí a tloušťku.

Uspořádejte všechny tyto prvky pomocí vhodného polstrování v obou směrech.

 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)

Definujte metodu, Zvolte soubor. Otevřete dialogové okno souboru a vyberte video soubor .mp4 nebo .avi rozšíření. Pokud vyberete libovolný soubor, načtěte jeho cestu a aktualizujte časový štítek jeho trváním. Spusťte přehrávání vybraného videa.

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

Definujte metodu, get_duration_str které použijete k výpočtu celkové doby trvání videa. Pokud aplikace přehrává video, získejte jeho trvání v milisekundách a převeďte jej na HH: MM: SS formát. Pokud se video nepřehrává, vraťte se 00:00:00 jako výchozí hodnotu.

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"

Definujte metodu, přehrát video. Pokud se video nepřehrává, vytvořte nový mediální objekt pomocí vybrané cesty k souboru. Přidružte média k dříve vytvořenému plátnu a spusťte přehrávání videa. Aktualizujte přehrávání_videa stát do Skutečný.

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

Definujte metodu, rychle vpřed. Pokud se video přehrává, zjistěte aktuální uplynulý čas a přidejte k němu 10 000 milisekund. Nastavte nový čas přehrávání. Podobně definujte metodu, přetočit která odečte 10 000 milisekund.

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)

Definujte metodu, pauza_video. Pokud jste spustili přehrávání videa a pozastavili jej, zavolejte na hrát si způsob, jak jej obnovit. V opačném případě zavolejte na pauza a v obou případech odpovídajícím způsobem aktualizujte uživatelské rozhraní.

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

Definujte metodu, stop. Pokud se video přehrává, zastavte jej a resetujte časový štítek. Definujte metodu, set_video_position. Pokud se přehrává video, načtěte celkovou dobu trvání a vypočítejte požadovanou pozici v milisekundách. Nastavte dobu přehrávání videa na vypočítanou pozici.

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)

Definujte metodu, update_video_progress. Pokud se video přehrává, načtěte celkovou dobu trvání a aktuální dobu přehrávání a vypočítejte procento průběhu. Aktualizujte ukazatel průběhu pomocí této vypočítané hodnoty. Naformátujte aktuální čas a celkovou dobu trvání v HH: MM: SS formát.

Naplánujte spuštění této metody znovu po 1 000 milisekundách. Tím se vytvoří smyčka, která během přehrávání videa průběžně aktualizuje průběh videa a časové popisy.

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)

Definujte třídu, VideoProgressBar která dědí od tk. Měřítko widget. Definujte konstruktor, který nastavuje počáteční stav a chování ukazatele průběhu. Nastav výstavní hodnota možnost Nepravdivé abyste se vyhnuli zobrazení aktuální hodnoty.

Inicializujte průběh s rozsahem 0 až 100. Nastavte orientaci, délku, příkaz, který má spustit, a přizpůsobení ukazatele průběhu. Svažte událost s indikátorem průběhu tak, že když na ni kliknete, spustí se při kliknutí metoda.

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)

Definujte metodu, při kliknutí. Zkontrolujte, zda není ukazatel průběhu deaktivován, a vypočítá novou hodnotu na základě pozice kliknutí. Podle toho aktualizujte hodnotu ukazatele průběhu.

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

Vytvořte instanci souboru Aplikace MediaPlayer třídy a zavolejte update_video_progress metoda. The mainloop() Funkce říká Pythonu, aby spustil smyčku událostí Tkinter a naslouchal událostem, dokud nezavřete okno.

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

Při spuštění programu se objeví přehrávač video médií. Obsahuje Zvolte soubor tlačítko, časové štítky, tlačítka pro ovládání přehrávání videa a ukazatel průběhu videa.

Když vyberete video, bude se automaticky přehrávat od začátku, přičemž se aktualizuje čas zahájení a délka časových štítků.

Při zasažení Pauza, video se pozastaví a změní se na Životopis knoflík. Po kliknutí na Rychle vpřed tlačítko, video přeskočí o 10 sekund dopředu.

Podobně při zasažení Přetočit tlačítko, vrátí se o 10 sekund zpět. Při stisknutí tlačítka Stop tlačítko, přehrávání videa se zastaví. Přetažením nebo kliknutím na libovolnou oblast na ukazateli průběhu se přesunete na kteroukoli část videa a na časovém štítku se zobrazí uplynulý čas.

Tento přehrávač médií můžete vylepšit přidáním možnosti načítání a zobrazování titulků. Můžete také zvážit funkce, jako je změna poměru stran, ovládání hlasitosti a smyčkování části videa.

Chcete-li implementovat tyto funkce, můžete prozkoumat modul Pygame. Pygame je univerzální, snadno se používá a dobře se integruje s Tkinter. Knihovna umožňuje přizpůsobení, má interaktivní funkce a může běžet na jakékoli platformě.