Come costruire un lettore multimediale video usando Python

La creazione di un lettore video può aiutarti a goderti i tuoi video preferiti con un tema e uno stile personalizzati. Puoi rendere la riproduzione video più fluida, progettare i pulsanti e i menu della tua app e aggiungere qualsiasi funzionalità desideri.

Questo progetto ti offrirà anche un'esperienza pratica nella creazione di app desktop multipiattaforma, nell'elaborazione di contenuti multimediali e nella gestione di eventi. Scopri come creare un lettore multimediale video utilizzando Tkinter, VLC e il modulo datetime.

Il modulo Tkinter, VLC e Datetime

Tkinter ti consente di creare applicazioni desktop. Offre una varietà di widget come pulsanti, etichette e caselle di testo che semplificano lo sviluppo di applicazioni come un semplice calendario GUI, una calcolatrice o a gestore di elenchi di cose da fare. Per installare Tkinter, apri un terminale ed esegui:

pip install tkinter

IL python-vlc

module è un collegamento Python per la libreria del lettore multimediale VLC (VideoLAN Client). È possibile utilizzare questo modulo per implementare il caratteristiche di VLC e crea il tuo lettore multimediale personalizzato. Per installare VLC, eseguire:

pip install python-vlc

IL appuntamento Il modulo è integrato in Python e fornisce classi e funzioni per rappresentare date, orari, intervalli e zone diversi.

Puoi trovare il codice sorgente di questo progetto nel suo Deposito GitHub.

Importa i moduli richiesti. Definisci una classe, MediaPlayerApp. Definire il metodo costruttore e chiamarlo per inizializzare la finestra principale dell'applicazione. Imposta il titolo, le dimensioni e il colore di sfondo del lettore multimediale video. Chiama il initialize_player metodo.

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

Definire un metodo, initialize_player. Crea un'istanza del lettore multimediale VLC per interagire con le sue funzionalità. Utilizzando questa istanza, crea un oggetto lettore multimediale che puoi utilizzare per gestire la riproduzione multimediale. Inizializza una variabile, file corrente per tenere traccia del video attualmente in riproduzione. Impostare gli stati di riproduzione e chiamare il file create_widget metodo.

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

Definisci il create_widget metodo. Crea un widget canvas e passa l'elemento genitore in cui posizionarlo, il colore di sfondo, la larghezza e l'altezza. Creare un Seleziona il file pulsante per selezionare il file video che si desidera riprodurre. Imposta l'elemento genitore, il testo che dovrebbe visualizzare, gli stili del carattere e il comando che dovrebbe eseguire quando fai clic su di esso.

Crea un'etichetta per visualizzare il tempo trascorso e la durata del video. Imposta l'elemento genitore, il testo, gli stili del carattere, il colore del carattere e il colore di sfondo. Crea una cornice per controllare la riproduzione del video e assegnagli un colore di sfondo.

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)

Definisci il Giocare pulsante, il Pausa pulsante, il Fermare pulsante, il Avanti veloce pulsante e il Riavvolgi pulsante. Crea un widget per la barra di avanzamento del video. Imposta l'elemento genitore in cui desideri inserirlo, il metodo per aggiornare la posizione di riproduzione del video, il colore di sfondo e lo spessore.

Organizza tutti questi elementi con un'imbottitura appropriata in entrambe le direzioni.

 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)

Definire un metodo, seleziona il file. Apre una finestra di dialogo file per selezionare un file video con .mp4 O .avi estensione. Se selezioni un file, carica il suo percorso e aggiorna l'etichetta temporale con la sua durata. Avvia la riproduzione del video selezionato.

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

Definire un metodo, get_duration_str che utilizzerai per calcolare la durata totale del video. Se l'applicazione sta riproducendo un video, ottieni la sua durata in millisecondi e convertila in formato HH: MM: SS formato. Se non viene riprodotto alcun video, tornare 00:00:00 come valore predefinito.

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"

Definire un metodo, riproduci_video. Se un video non viene riprodotto, crea un nuovo oggetto multimediale utilizzando il percorso del file selezionato. Associa il supporto alla tela creata in precedenza e avvia la riproduzione del video. Aggiorna il riproduzione_video stato a VERO.

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

Definire un metodo, avanti veloce. Se un video è in riproduzione, ottieni il tempo corrente trascorso e aggiungi 10.000 millisecondi. Imposta il nuovo tempo di riproduzione. Allo stesso modo, definire un metodo, riavvolgere che sottrae 10.000 millisecondi.

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)

Definire un metodo, pausa_video. Se hai avviato la riproduzione di un video e l'hai messa in pausa, chiama il giocare metodo per riprenderlo. Altrimenti chiama il pausa metodo e aggiornare l'interfaccia utente di conseguenza in entrambi i casi.

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

Definire un metodo, fermare. Se un video è in riproduzione, interrompilo e reimposta l'etichetta temporale. Definire un metodo, set_video_posizione. Se un video è in riproduzione, recupera la durata totale e calcola la posizione desiderata in millisecondi. Imposta il tempo di riproduzione del video sulla posizione calcolata.

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)

Definire un metodo, update_video_progress. Se un video è in riproduzione, recupera la durata totale e il tempo di riproduzione corrente e calcola la percentuale di avanzamento. Aggiorna la barra di avanzamento utilizzando questo valore calcolato. Formatta l'ora corrente e la durata totale nel file HH: MM: SS formato.

Pianifica questo metodo per essere eseguito di nuovo dopo 1.000 millisecondi. Questo crea un loop che aggiorna continuamente l'avanzamento del video e le etichette temporali durante la riproduzione del video.

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)

Definisci una classe, VideoProgressBar che eredita da tk. Scala aggeggio. Definire un costruttore che imposta lo stato iniziale e il comportamento della barra di avanzamento. Impostare il mostra valore opzione a Falso per evitare di visualizzare il valore corrente.

Inizializza l'avanzamento con un intervallo da 0 a 100. Imposta l'orientamento, la lunghezza, il comando che deve eseguire e la personalizzazione sulla barra di avanzamento. Associa un evento alla barra di avanzamento in modo tale che quando fai clic su di esso, esegue il file al clic metodo.

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)

Definire un metodo, al clic. Controlla se la barra di avanzamento non è disabilitata e calcola il nuovo valore in base alla posizione del clic. Aggiorna il valore della barra di avanzamento di conseguenza.

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

Crea un'istanza di MediaPlayerApp classe e chiama il update_video_progress metodo. IL ciclo principale() La funzione dice a Python di eseguire il ciclo di eventi Tkinter e di ascoltare gli eventi finché non chiudi la finestra.

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

Durante l'esecuzione del programma, viene visualizzato il lettore multimediale video. Contiene il Seleziona il file pulsante, le etichette temporali, i pulsanti per controllare la riproduzione video e una barra di avanzamento video.

Quando scegli un video, questo verrà riprodotto automaticamente dall'inizio, aggiornando l'ora di inizio e la durata delle etichette temporali.

Colpendo il Pausa pulsante, il video viene messo in pausa e passa al file Riprendere pulsante. Facendo clic sul Avanti veloce pulsante, il video salta avanti di 10 secondi.

Allo stesso modo, colpendo il Riavvolgi pulsante, torna indietro di 10 secondi. Premendo il Fermare pulsante, la riproduzione del video si interrompe. Puoi trascinare o fare clic su qualsiasi area della barra di avanzamento per spostarti in qualsiasi parte del video e l'etichetta del tempo legge il tempo trascorso.

Puoi migliorare questo lettore multimediale video aggiungendo un'opzione per caricare e visualizzare i sottotitoli. Potresti anche prendere in considerazione funzionalità come la modifica delle proporzioni, il controllo del volume e il looping di parte del video.

Per implementare queste funzionalità, puoi esplorare il modulo Pygame. Pygame è versatile, facile da usare e si integra bene con Tkinter. La libreria consente la personalizzazione, ha funzionalità interattive e può essere eseguita su qualsiasi piattaforma.