Jak zbudować odtwarzacz multimediów wideo za pomocą Pythona

Zbudowanie odtwarzacza wideo może pomóc Ci cieszyć się ulubionymi filmami w dostosowanym motywie i stylu. Możesz sprawić, by odtwarzanie wideo było płynniejsze, zaprojektować przyciski i menu aplikacji oraz dodać dowolną funkcjonalność.

Ten projekt zapewni Ci również praktyczne doświadczenie w tworzeniu wieloplatformowych aplikacji komputerowych, przetwarzaniu multimediów i obsłudze wydarzeń. Dowiedz się, jak stworzyć odtwarzacz multimediów wideo za pomocą Tkintera, VLC i modułu datetime.

Moduł Tkinter, VLC i Datetime

Tkinter umożliwia tworzenie aplikacji desktopowych. Oferuje różnorodne widżety, takie jak przyciski, etykiety i pola tekstowe, które ułatwiają tworzenie aplikacji, takich jak prosty kalendarz GUI, kalkulator lub menedżer list rzeczy do zrobienia. Aby zainstalować Tkintera, otwórz terminal i uruchom:

pip install tkinter

The python-vlc module to powiązanie Pythona dla biblioteki odtwarzacza multimediów VLC (VideoLAN Client). Możesz użyć tego modułu do zaimplementowania

cechy VLC i zbuduj własny dostosowany odtwarzacz multimedialny. Aby zainstalować VLC, uruchom:

pip install python-vlc

The datagodzina Moduł jest wbudowany w Pythona i zapewnia klasy i funkcje reprezentujące różne daty, godziny, interwały i strefy.

Możesz znaleźć kod źródłowy tego projektu w jego Repozytorium GitHub.

Zaimportuj wymagane moduły. Zdefiniuj klasę, Aplikacja MediaPlayer. Zdefiniuj metodę konstruktora i wywołaj ją, aby zainicjować główne okno aplikacji. Ustaw tytuł, wymiary i kolor tła odtwarzacza multimediów wideo. Zadzwoń do inicjalizuj_gracza 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()

Zdefiniuj metodę, inicjalizuj_gracza. Utwórz instancję odtwarzacza multimedialnego VLC, aby wchodzić w interakcje z jego funkcjami. Korzystając z tej instancji, utwórz obiekt odtwarzacza multimediów, którego możesz użyć do zarządzania odtwarzaniem multimediów. Inicjalizuj zmienną, aktualny dokument aby śledzić aktualnie odtwarzane wideo. Ustaw stany odtwarzania i wywołaj utwórz_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()

Zdefiniuj utwórz_widgety metoda. Utwórz widżet płótna i przekaż element nadrzędny, aby go umieścić, jego kolor tła, szerokość i wysokość. Stwórz Wybierz plik aby wybrać plik wideo, który chcesz odtworzyć. Ustaw element nadrzędny, tekst, który ma wyświetlać, style czcionek i polecenie, które ma uruchamiać po kliknięciu.

Utwórz etykietę, aby wyświetlić czas, który upłynął i czas trwania filmu. Ustaw element nadrzędny, tekst, style czcionek, kolor czcionki i kolor tła. Utwórz ramkę do sterowania odtwarzaniem wideo i nadaj jej kolor tła.

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)

Zdefiniuj Grać przycisk, ew Pauza przycisk, ew Zatrzymywać się przycisk, ew Szybkie przewijanie do przodu przycisk i Przewijanie do tyłu przycisk. Utwórz widżet paska postępu wideo. Ustaw element nadrzędny, w którym chcesz go umieścić, metodę aktualizacji pozycji odtwarzania wideo, kolor tła i grubość.

Uporządkuj wszystkie te elementy odpowiednimi wyściółkami w obu kierunkach.

 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)

Zdefiniuj metodę, Wybierz plik. Otwórz okno dialogowe pliku, aby wybrać plik wideo .mp4 Lub .avi rozszerzenie. Jeśli wybierzesz dowolny plik, załaduj jego ścieżkę i zaktualizuj etykietę czasu o czas trwania. Rozpocznij odtwarzanie wybranego wideo.

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

Zdefiniuj metodę, get_duration_str którego użyjesz do obliczenia całkowitego czasu trwania filmu. Jeśli aplikacja odtwarza wideo, uzyskaj czas jego trwania w milisekundach i przekonwertuj go na GG: MM: SS format. Jeśli nie ma odtwarzania wideo, wróć 00:00:00 jako wartość domyślna.

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"

Zdefiniuj metodę, odtwórz_wideo. Jeśli wideo nie jest odtwarzane, utwórz nowy obiekt multimedialny, korzystając z wybranej ścieżki pliku. Powiąż multimedia z wcześniej utworzonym płótnem i rozpocznij odtwarzanie wideo. Zaktualizuj odtwarzanie_wideo stan do PRAWDA.

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

Zdefiniuj metodę, fast_forward. Jeśli odtwarzany jest film, uzyskaj bieżący czas, który upłynął, i dodaj do niego 10 000 milisekund. Ustaw nowy czas odtwarzania. Podobnie zdefiniuj metodę, przewijanie do tyłu to odejmuje 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)

Zdefiniuj metodę, pauza_wideo. Jeśli zacząłeś odtwarzanie wideo i wstrzymałeś je, zadzwoń pod numer grać sposób, aby go wznowić. W przeciwnym razie zadzwoń do tel pauza metoda i odpowiednio zaktualizuj interfejs użytkownika w obu przypadkach.

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

Zdefiniuj metodę, zatrzymywać się. Jeśli odtwarzany jest film, zatrzymaj go i zresetuj etykietę czasową. Zdefiniuj metodę, set_video_position. Jeśli wideo jest odtwarzane, pobierz całkowity czas trwania i oblicz żądaną pozycję w milisekundach. Ustaw czas odtwarzania wideo na obliczoną pozycję.

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)

Zdefiniuj metodę, aktualizacja_postępu wideo. Jeśli wideo jest odtwarzane, pobierz całkowity czas trwania i bieżący czas odtwarzania oraz oblicz procentowy postęp. Zaktualizuj pasek postępu, korzystając z tej obliczonej wartości. Sformatuj bieżący czas i całkowity czas trwania w formacie GG: MM: SS format.

Zaplanuj ponowne uruchomienie tej metody po 1000 milisekundach. Tworzy to pętlę, która stale aktualizuje postęp wideo i etykiety czasowe podczas odtwarzania wideo.

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)

Zdefiniuj klasę, Pasek postępu wideo po którym dziedziczy tk. Skala widżet. Zdefiniuj konstruktora, który ustawia stan początkowy i zachowanie paska postępu. Ustaw pokaż wartość opcja do FAŁSZ aby uniknąć wyświetlania aktualnej wartości.

Zainicjuj postęp w zakresie od 0 do 100. Ustaw orientację, długość, polecenie, które ma uruchomić, oraz dostosowanie paska postępu. Powiąż zdarzenie z paskiem postępu w taki sposób, że kliknięcie go spowoduje wykonanie na kliknięcie 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)

Zdefiniuj metodę, na kliknięcie. Sprawdź, czy pasek postępu nie jest wyłączony i oblicza nową wartość na podstawie pozycji kliknięcia. Zaktualizuj odpowiednio wartość paska postępu.

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

Utwórz instancję Aplikacja MediaPlayer klasą i zadzwoń do aktualizacja_postępu wideo metoda. The główna pętla() mówi Pythonowi, aby uruchomił pętlę zdarzeń Tkinter i nasłuchiwał zdarzeń, dopóki nie zamkniesz okna.

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

Po uruchomieniu programu pojawia się odtwarzacz multimediów wideo. Zawiera Wybierz plik przycisk, etykiety czasu, przyciski do sterowania odtwarzaniem wideo oraz pasek postępu wideo.

Gdy wybierzesz film, zostanie on automatycznie odtworzony od początku, aktualizując czas rozpoczęcia i czas trwania etykiet czasowych.

Na trafieniu Pauza przycisk, wideo zostaje wstrzymane i zmienia się na Wznawiać przycisk. Po kliknięciu Szybkie przewijanie do przodu przycisk, wideo przeskakuje do przodu o 10 sekund.

Podobnie po uderzeniu w Przewijanie do tyłu przycisk, cofa się o 10 sekund. Po naciśnięciu Zatrzymywać się przycisk, odtwarzanie wideo zostaje zatrzymane. Możesz przeciągnąć lub kliknąć dowolny obszar na pasku postępu, aby przejść do dowolnej części wideo, a etykieta czasu odczytuje czas, który upłynął.

Możesz ulepszyć ten odtwarzacz multimediów wideo, dodając opcję ładowania i wyświetlania napisów. Możesz także rozważyć takie funkcje, jak zmiana współczynnika proporcji, regulacja głośności i zapętlenie części wideo.

Aby zaimplementować te funkcje, możesz zapoznać się z modułem Pygame. Pygame jest wszechstronny, łatwy w użyciu i dobrze integruje się z Tkinter. Biblioteka umożliwia dostosowywanie, ma interaktywne funkcje i może działać na dowolnej platformie.