Hur man bygger en videomediaspelare med Python

Att bygga en videospelare kan hjälpa dig att njuta av dina favoritvideor i ett anpassat tema och stil. Du kan göra videouppspelningen smidigare, designa appens knappar och menyer och lägga till vilken funktion du vill.

Detta projekt kommer också att ge dig praktisk erfarenhet av att bygga plattformsoberoende skrivbordsappar, bearbeta multimedia och hantera händelser. Upptäck hur du kan skapa en videomediaspelare med Tkinter, VLC och datetime-modulen.

Tkinter-, VLC- och Datetime-modulen

Tkinter låter dig skapa skrivbordsapplikationer. Den erbjuder en mängd olika widgets som knappar, etiketter och textrutor som gör det lättare att utveckla applikationer som en enkel GUI-kalender, en miniräknare eller en att göra-lista manager. För att installera Tkinter, öppna en terminal och kör:

pip install tkinter

De python-vlc modulen är en Python-bindning för VLC (VideoLAN Client) mediaspelares bibliotek. Du kan använda den här modulen för att implementera

funktioner i VLC och bygg din egen skräddarsydda mediaspelare. För att installera VLC, kör:

pip install python-vlc

De datum Tid modulen är inbyggd i Python och tillhandahåller klasser och funktioner för att representera olika datum, tider, intervall och zoner.

Du kan hitta detta projekts källkod i dess GitHub-förråd.

Importera de nödvändiga modulerna. Definiera en klass, MediaPlayerApp. Definiera konstruktormetoden och anrop den för att initiera huvudprogrammets fönster. Ställ in titeln, måtten och bakgrundsfärgen för videomediaspelaren. Ring initialize_player metod.

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

Definiera en metod, initialize_player. Skapa en instans av VLC-mediaspelaren för att interagera med dess funktioner. Med den här instansen skapar du ett mediaspelareobjekt som du kan använda för att hantera mediauppspelningen. Initiera en variabel, nuvarande fil för att hålla reda på den video som spelas för närvarande. Ställ in uppspelningslägen och ring upp skapa_widgets metod.

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

Definiera skapa_widgets metod. Skapa en canvas-widget och skicka det överordnade elementet att placera det i, dess bakgrundsfärg, bredd och höjd. Skapa en Välj fil för att välja den videofil du vill spela upp. Ställ in det överordnade elementet, texten det ska visa, typsnittsstilarna och kommandot det ska köras när du klickar på det.

Skapa en etikett för att visa förfluten tid och videons varaktighet. Ställ in det överordnade elementet, texten, typsnittsstilarna, teckensnittsfärgen och bakgrundsfärgen. Skapa en ram för att styra videouppspelningen och ge den en bakgrundsfärg.

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)

Definiera Spela knappen, den Paus knappen, den Sluta knappen, den Snabbspola knappen och Spola tillbaka knapp. Skapa en videoförloppsindikator. Ställ in det överordnade elementet du vill placera det i, metoden för att uppdatera videouppspelningspositionen, bakgrundsfärgen och tjockleken.

Organisera alla dessa element med lämplig stoppning i båda riktningarna.

 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)

Definiera en metod, Välj fil. Öppna en fildialogruta för att välja en videofil med .mp4 eller .avi förlängning. Om du väljer någon fil, ladda dess sökväg och uppdatera tidsetiketten med dess varaktighet. Börja spela upp den valda videon.

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

Definiera en metod, get_duration_str som du kommer att använda för att beräkna videons totala längd. Om programmet spelar en video, få dess varaktighet i millisekunder och konvertera den till HH: MM: SS formatera. Om det inte spelas någon video, återvänd 00:00:00 som standardvärde.

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"

Definiera en metod, spela filmen. Om en video inte spelas upp, skapa ett nytt medieobjekt med den valda filsökvägen. Koppla media till arbetsytan som skapats tidigare och starta videouppspelningen. Uppdatera spelar_video ange till Sann.

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

Definiera en metod, snabbspola. Om en video spelas upp, få den aktuella tiden som förflutit och lägg till 10 000 millisekunder. Ställ in den nya uppspelningstiden. Definiera på samma sätt en metod, spola tillbaka som subtraherar 10 000 millisekunder.

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)

Definiera en metod, pause_video. Om du hade startat någon videouppspelning och pausat den, ring till spela metod för att återuppta det. Annars ringer du paus metod och uppdatera användargränssnittet i enlighet därmed i båda fallen.

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

Definiera en metod, sluta. Om en video spelas upp, stoppa den och återställ tidsetiketten. Definiera en metod, set_video_position. Om en video spelas upp, hämta den totala varaktigheten och beräkna önskad position i millisekunder. Ställ in videouppspelningstiden till den beräknade positionen.

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)

Definiera en metod, update_video_progress. Om en video spelas upp, hämta den totala varaktigheten och den aktuella uppspelningstiden och beräkna förloppsprocenten. Uppdatera förloppsindikatorn med detta beräknade värde. Formatera aktuell tid och total varaktighet i HH: MM: SS formatera.

Schemalägg den här metoden att köras igen efter 1 000 millisekunder. Detta skapar en loop som kontinuerligt uppdaterar videons framsteg och tidsetiketter medan videon spelas upp.

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)

Definiera en klass, VideoProgressBar som ärver från tk. Skala widget. Definiera en konstruktor som ställer in det initiala tillståndet och beteendet för förloppsindikatorn. Ställ in visa värde möjlighet att Falsk för att undvika att visa det aktuella värdet.

Initiera förloppet med ett intervall på 0 till 100. Ställ in orientering, längd, kommando som den måste köra och anpassningen till förloppsindikatorn. Bind en händelse till förloppsfältet så att när du klickar på den kör den on_click metod.

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)

Definiera en metod, on_click. Kontrollera om förloppsindikatorn inte är inaktiverad och beräknar det nya värdet baserat på klickets position. Uppdatera förloppsindikatorns värde i enlighet med detta.

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

Skapa en instans av MediaPlayerApp klass och ring update_video_progress metod. De mainloop() funktionen säger åt Python att köra Tkinter-händelsslingan och lyssna efter händelser tills du stänger fönstret.

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

När programmet körs, dyker videomediaspelaren upp. Den innehåller Välj fil knapp, tidsetiketter, knappar för att styra videouppspelning och en videoförloppsindikator.

När du väljer en video spelas den upp automatiskt från början och uppdaterar starttiden och tidsetiketternas varaktighet.

På att slå Paus knappen pausas videon och ändras till Återuppta knapp. När du klickar på Snabbspola knappen hoppar videon framåt med 10 sekunder.

På samma sätt, på att slå Spola tillbaka knappen går den tillbaka 10 sekunder. När du trycker på Sluta knappen stoppas videouppspelningen. Du kan dra eller klicka på valfritt område på förloppsindikatorn för att flytta till någon del av videon och tidsetiketten visar den förflutna tiden.

Du kan förbättra denna videomediaspelare genom att lägga till ett alternativ för att ladda och visa undertexter. Du kan också överväga funktioner som att ändra bildförhållandet, kontrollera volymen och en looping av en del av videon.

För att implementera dessa funktioner kan du utforska Pygame-modulen. Pygame är mångsidigt, lätt att använda och integreras väl med Tkinter. Biblioteket tillåter anpassning, har interaktiva funktioner och kan köras på vilken plattform som helst.