Hogyan készítsünk videó médialejátszót Python használatával

A videolejátszó felépítése segíthet kedvenc videóinak testreszabott témában és stílusban való élvezésében. Simábbá teheti a videólejátszást, megtervezheti az alkalmazás gombjait és menüit, és bármilyen funkciót hozzáadhat.

Ez a projekt gyakorlati tapasztalatot is nyújt a platformok közötti asztali alkalmazások létrehozásában, a multimédiás feldolgozásban és az események kezelésében. Fedezze fel, hogyan készíthet videó médialejátszót a Tkinter, a VLC és a datetime modul használatával.

A Tkinter, VLC és Datetime modul

A Tkinter lehetővé teszi az asztali alkalmazások létrehozását. Számos widgetet kínál, például gombokat, címkéket és szövegdobozokat, amelyek megkönnyítik az olyan alkalmazások fejlesztését, mint egy egyszerű grafikus felületű naptár, számológépet vagy a teendőlista kezelője. A Tkinter telepítéséhez nyisson meg egy terminált, és futtassa:

pip install tkinter

A python-vlc modul egy Python-összerendelés a VLC (VideoLAN Client) médialejátszó könyvtárhoz. Ezzel a modullal megvalósíthatja a

A VLC jellemzői és készítse el saját, testreszabott médialejátszóját. A VLC telepítéséhez futtassa:

pip install python-vlc

A dátum idő modul a Pythonba van beépítve, és osztályokat és függvényeket biztosít a különböző dátumok, időpontok, intervallumok és zónák megjelenítéséhez.

A projekt forráskódja megtalálható benne GitHub adattár.

Importálja a szükséges modulokat. Határozzon meg egy osztályt, MediaPlayerApp. Határozza meg a konstruktor metódust, és hívja meg az alkalmazás főablakának inicializálásához. Állítsa be a videomédialejátszó címét, méreteit és háttérszínét. Hívja a inicializálás_lejátszó módszer.

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

Határozzon meg egy módszert, inicializálás_lejátszó. Hozzon létre egy példányt a VLC médialejátszóból, hogy kölcsönhatásba lépjen a funkcióival. Ezzel a példánysal hozzon létre egy médialejátszó objektumot, amellyel kezelheti a médialejátszást. Változó inicializálása, aktuális fájl az éppen lejátszott videó nyomon követéséhez. Állítsa be a lejátszási állapotokat, és hívja a create_widgets módszer.

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

Határozza meg a create_widgets módszer. Hozzon létre egy vászon widgetet, és adja át a szülőelemet, amelybe elhelyezheti, a háttérszínével, szélességével és magasságával együtt. Hozzon létre egy Válaszd ki a fájlt gombot a lejátszani kívánt videofájl kiválasztásához. Állítsa be a szülőelemet, a megjelenítendő szöveget, a betűstílusokat és a kattintáskor futtatandó parancsot.

Hozzon létre egy címkét az eltelt idő és a videó időtartamának megjelenítéséhez. Állítsa be a szülőelemet, a szöveget, a betűstílusokat, a betűszínt és a háttérszínt. Hozzon létre egy keretet a videó lejátszásának vezérléséhez, és adja meg a háttérszínt.

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)

Határozza meg a Játék gombot, a Szünet gombot, a Állj meg gombot, a Előrepörgetés gombot, és a Visszatekerés gomb. Hozzon létre egy videó folyamatjelző widgetet. Állítsa be a szülőelemet, amelybe el szeretné helyezni, a videó lejátszási pozíciójának frissítési módját, a háttérszínt és a vastagságot.

Mindezeket az elemeket mindkét irányban megfelelő párnázással rendezze.

 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)

Határozzon meg egy módszert, válaszd ki a fájlt. Nyisson meg egy fájl párbeszédpanelt a videofájl kiválasztásához .mp4 vagy .avi kiterjesztés. Ha kiválaszt egy fájlt, töltse be annak elérési útját, és frissítse az időcímkét az időtartamával. Indítsa el a kiválasztott videó lejátszását.

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

Határozzon meg egy módszert, get_duration_str amelyet a videó teljes időtartamának kiszámításához fog használni. Ha az alkalmazás lejátszik egy videót, adja meg az időtartamát ezredmásodpercben, és alakítsa át a HH: MM: SS formátum. Ha nem játszik le videót, térjen vissza 00:00:00 alapértelmezett értékként.

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"

Határozzon meg egy módszert, videó lejátszása. Ha egy videót nem játszik le, hozzon létre egy új médiaobjektumot a kiválasztott fájl elérési útjával. Társítsa a médiát a korábban létrehozott vászonhoz, és indítsa el a videó lejátszását. Frissítse a videó lejátszása állam, hogy Igaz.

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

Határozzon meg egy módszert, előrepörgetés. Ha videót játszik le, kérje le az aktuális eltelt időt, és adjon hozzá 10 000 ezredmásodpercet. Állítsa be az új lejátszási időt. Hasonlóképpen határozzon meg egy módszert, visszatekerés ami levon 10 000 ezredmásodpercet.

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)

Határozzon meg egy módszert, pause_video. Ha elindította a videolejátszást, és szüneteltette azt, hívja a játék módszer a folytatáshoz. Ellenkező esetben hívja a szünet módszert, és ennek megfelelően frissítse a felhasználói felületet mindkét esetben.

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

Határozzon meg egy módszert, állj meg. Ha videót játszik le, állítsa le, és állítsa vissza az időcímkét. Határozzon meg egy módszert, set_video_position. Ha videót játszik le, kérje le a teljes időtartamot, és számítsa ki a kívánt pozíciót ezredmásodpercben. Állítsa be a videó lejátszási idejét a számított pozícióra.

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)

Határozzon meg egy módszert, update_video_progress. Ha videót játszik le, kérje le a teljes időtartamot és az aktuális lejátszási időt, és számítsa ki az előrehaladás százalékos arányát. Frissítse a folyamatjelző sávot ezzel a számított értékkel. Formázza meg az aktuális időt és a teljes időtartamot a HH: MM: SS formátum.

Ütemezze ezt a metódust úgy, hogy 1000 ezredmásodperc után újra lefusson. Ez egy hurkot hoz létre, amely a videó lejátszása közben folyamatosan frissíti a videó előrehaladását és időcímkéit.

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)

Határozzon meg egy osztályt, VideoProgressBar hogy örököl tk. Skála widget. Határozzon meg egy konstruktort, amely beállítja a folyamatjelző sáv kezdeti állapotát és viselkedését. Állítsa be a showvalue opciót Hamis hogy elkerülje az aktuális érték megjelenítését.

Inicializálja a folyamatot 0 és 100 közötti tartományban. Állítsa be a tájolást, a hosszt, a futtatandó parancsot és a testreszabást a folyamatjelző sávon. Kössön egy eseményt a folyamatjelző sávhoz úgy, hogy amikor rákattint, az végrehajtsa a kattintásra módszer.

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)

Határozzon meg egy módszert, kattintásra. Ellenőrizze, hogy a folyamatjelző sáv nincs-e letiltva, és a kattintás pozíciója alapján számítja ki az új értéket. Ennek megfelelően frissítse a folyamatjelző sáv értékét.

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

Hozzon létre egy példányt a MediaPlayerApp osztályt, és hívja a update_video_progress módszer. A mainloop() függvény azt mondja a Pythonnak, hogy futtassa a Tkinter eseményhurkot, és figyelje az eseményeket, amíg be nem zárja az ablakot.

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

A program futtatásakor megjelenik a videó médialejátszó. Ez tartalmazza a Válaszd ki a fájlt gombot, az időcímkéket, a videólejátszást vezérlő gombokat és a videó folyamatjelző sávját.

Amikor kiválasztasz egy videót, az automatikusan elindul az elejétől kezdve, frissítve a kezdési időpontot és az időcímkék időtartamát.

Az ütéskor a Szünet gombot, a videó szünetel, és a Önéletrajz gomb. A gombra kattintva Előrepörgetés gombot, a videó 10 másodperccel előre ugrik.

Hasonlóképpen a Visszatekerés gombot, visszalép 10 másodpercet. A gomb megnyomására Állj meg gombot, a videó lejátszása leáll. A folyamatjelző sáv bármely területére húzással vagy kattintással a videó bármely részére ugorhat, és az időcímke az eltelt időt mutatja.

A video-médialejátszót a feliratok betöltésének és megjelenítésének beállításával javíthatja. Olyan funkciókat is figyelembe vehet, mint a képarány módosítása, a hangerő szabályozása és a videó egy részének hurkolása.

E funkciók megvalósításához fedezze fel a Pygame modult. A Pygame sokoldalú, könnyen használható, és jól integrálható a Tkinterrel. A könyvtár lehetővé teszi a testreszabást, interaktív funkciókkal rendelkezik, és bármilyen platformon futhat.