Ako vytvoriť prehrávač médií pomocou jazyka Python

Vytvorenie prehrávača videa vám môže pomôcť vychutnať si obľúbené videá v prispôsobenej téme a štýle. Môžete urobiť prehrávanie videa plynulejším, navrhnúť tlačidlá a ponuky svojej aplikácie a pridať ľubovoľné funkcie.

Tento projekt vám tiež poskytne praktické skúsenosti s vytváraním multiplatformových desktopových aplikácií, spracovaním multimédií a manipuláciou s udalosťami. Zistite, ako môžete vytvoriť prehrávač médií pomocou Tkinter, VLC a modulu datetime.

Modul Tkinter, VLC a Datetime

Tkinter vám umožňuje vytvárať desktopové aplikácie. Ponúka množstvo miniaplikácií, ako sú tlačidlá, štítky a textové polia, ktoré uľahčujú vývoj aplikácií, napr jednoduchý GUI kalendár, kalkulačka alebo a správca zoznamu úloh. Ak chcete nainštalovať Tkinter, otvorte terminál a spustite:

pip install tkinter

The python-vlc modul je väzba Pythonu pre knižnicu prehrávača médií VLC (VideoLAN Client). Tento modul môžete použiť na implementáciu

vlastnosti VLC a vytvorte si vlastný prispôsobený prehrávač médií. Ak chcete nainštalovať VLC, spustite:

pip install python-vlc

The Dátum Čas modul je zabudovaný do Pythonu a poskytuje triedy a funkcie na reprezentáciu rôznych dátumov, časov, intervalov a zón.

Zdrojový kód tohto projektu nájdete v ňom úložisko GitHub.

Importujte požadované moduly. Definujte triedu, Aplikácia MediaPlayer. Definujte metódu konštruktora a zavolajte ju na inicializáciu hlavného okna aplikácie. Nastavte názov, rozmery a farbu pozadia prehrávača médií. Zavolajte na initialize_player metóda.

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 metódu, initialize_player. Vytvorte inštanciu prehrávača médií VLC na interakciu s jeho funkciami. Pomocou tejto inštancie vytvorte objekt prehrávača médií, ktorý môžete použiť na riadenie prehrávania médií. Inicializujte premennú, aktuálny_súbor na sledovanie aktuálne prehrávaného videa. Nastavte stavy prehrávania a zavolajte na create_widgets metóda.

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 create_widgets metóda. Vytvorte miniaplikáciu plátna a odovzdajte nadradený prvok, do ktorého ho umiestnite, farbu pozadia, šírku a výšku. Vytvor Vyberte položku Súbor tlačidlom vyberte video súbor, ktorý chcete prehrať. Nastavte nadradený prvok, text, ktorý sa má zobraziť, štýly písma a príkaz, ktorý sa má spustiť, keď naň kliknete.

Vytvorte štítok na zobrazenie uplynutého času a trvania videa. Nastavte nadradený prvok, text, štýly písma, farbu písma a farbu pozadia. Vytvorte rám na ovládanie prehrávania videa a dajte mu farbu pozadia.

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 hrať tlačidlo, Pauza tlačidlo, Stop tlačidlo, Rýchlo vpred tlačidlo a Pretočiť späť tlačidlo. Vytvorte miniaplikáciu ukazovateľa priebehu videa. Nastavte nadradený prvok, do ktorého ho chcete umiestniť, spôsob aktualizácie pozície prehrávania videa, farbu pozadia a hrúbku.

Usporiadajte všetky tieto prvky s vhodnou výplňou v oboch smeroch.

 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 metódu, select_file. Otvorte dialógové okno súboru a vyberte video súbor .mp4 alebo .avi rozšírenie. Ak vyberiete ľubovoľný súbor, načítajte jeho cestu a aktualizujte časové označenie jeho trvaním. Spustite prehrávanie 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 metódu, get_duration_str ktoré použijete na výpočet celkovej dĺžky videa. Ak aplikácia prehráva video, získajte jeho trvanie v milisekundách a skonvertujte ho na HH: MM: SS formát. Ak sa neprehráva žiadne video, vráťte sa 00:00:00 ako predvolenú 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 metódu, prehrať_video. Ak sa video neprehráva, vytvorte nový mediálny objekt pomocou vybratej cesty k súboru. Priraďte médium k predtým vytvorenému plátnu a spustite prehrávanie videa. Aktualizujte prehrávanie_videa štát do Pravda.

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 metódu, rýchlo vpred. Ak sa video prehráva, zistite aktuálny čas, ktorý uplynul, a pridajte k nemu 10 000 milisekúnd. Nastavte nový čas prehrávania. Podobne definujte metódu, pretočiť späť ktorý odpočíta 10 000 milisekúnd.

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 metódu, pauza_video. Ak ste spustili prehrávanie akéhokoľvek videa a pozastavili ho, zavolajte na hrať spôsob, ako ho obnoviť. V opačnom prípade zavolajte na pauza a v oboch prípadoch zodpovedajúcim spôsobom aktualizujte používateľské rozhranie.

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 metódu, zastaviť. Ak sa video prehráva, zastavte ho a obnovte časový štítok. Definujte metódu, set_video_position. Ak sa video prehráva, získajte celkové trvanie a vypočítajte požadovanú pozíciu v milisekundách. Nastavte čas prehrávania videa na vypočítanú pozíciu.

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 metódu, update_video_progress. Ak sa video prehráva, získajte celkové trvanie a aktuálny čas prehrávania a vypočítajte percento priebehu. Aktualizujte indikátor priebehu pomocou tejto vypočítanej hodnoty. Naformátujte aktuálny čas a celkové trvanie v HH: MM: SS formát.

Naplánujte opätovné spustenie tejto metódy po 1 000 milisekúndách. Vytvorí sa tak slučka, ktorá priebežne aktualizuje priebeh videa a časové označenia počas prehrávania videa.

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 triedu, VideoProgressBar ktorý dedí z tk. Mierka widget. Definujte konštruktor, ktorý nastavuje počiatočný stav a správanie indikátora priebehu. Nastaviť výstavná hodnota možnosť Nepravdivé aby ste sa vyhli zobrazeniu aktuálnej hodnoty.

Inicializujte priebeh s rozsahom od 0 do 100. Nastavte orientáciu, dĺžku, príkaz, ktorý má spustiť, a prispôsobenie indikátoru priebehu. Naviažte udalosť na lištu priebehu tak, že keď na ňu kliknete, spustí sa po kliknutí metóda.

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 metódu, po kliknutí. Skontrolujte, či indikátor priebehu nie je vypnutý a vypočíta novú hodnotu na základe polohy kliknutia. Podľa toho aktualizujte hodnotu indikátora priebehu.

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

Vytvorte inštanciu súboru Aplikácia MediaPlayer triedy a zavolajte na update_video_progress metóda. The mainloop() funkcia hovorí Pythonu, aby spustil slučku udalostí Tkinter a počúval udalosti, kým nezatvoríte okno.

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

Po spustení programu sa zobrazí prehrávač médií. Obsahuje Vyberte položku Súbor tlačidlo, časové označenia, tlačidlá na ovládanie prehrávania videa a indikátor priebehu videa.

Keď vyberiete video, bude sa automaticky prehrávať od začiatku, pričom sa aktualizuje čas začiatku a trvanie časových označení.

Pri zasiahnutí Pauza, video sa pozastaví a zmení sa na Pokračovať tlačidlo. Po kliknutí na Rýchlo vpred tlačidlo, video preskočí dopredu o 10 sekúnd.

Podobne pri zasiahnutí Pretočiť späť tlačidlo, vráti sa o 10 sekúnd späť. Po stlačení tlačidla Stop tlačidlom, prehrávanie videa sa zastaví. Potiahnutím alebo kliknutím na ľubovoľnú oblasť na lište priebehu sa môžete presunúť na ktorúkoľvek časť videa a na označení času sa zobrazí uplynutý čas.

Tento prehrávač médií môžete vylepšiť pridaním možnosti načítania a zobrazenia titulkov. Môžete tiež zvážiť funkcie, ako je zmena pomeru strán, ovládanie hlasitosti a slučkovanie časti videa.

Ak chcete implementovať tieto funkcie, môžete preskúmať modul Pygame. Pygame je všestranný, ľahko sa používa a dobre sa integruje s Tkinter. Knižnica umožňuje prispôsobenie, má interaktívne funkcie a môže bežať na akejkoľvek platforme.