Comment créer un lecteur multimédia vidéo à l'aide de Python

Construire un lecteur vidéo peut vous aider à profiter de vos vidéos préférées dans un thème et un style personnalisés. Vous pouvez rendre la lecture vidéo plus fluide, concevoir les boutons et les menus de votre application et ajouter toutes les fonctionnalités que vous souhaitez.

Ce projet vous donnera également une expérience pratique dans la création d'applications de bureau multiplateformes, le traitement multimédia et la gestion d'événements. Découvrez comment créer un lecteur multimédia vidéo à l'aide de Tkinter, VLC et du module datetime.

Le module Tkinter, VLC et Datetime

Tkinter vous permet de créer des applications de bureau. Il offre une variété de widgets tels que des boutons, des étiquettes et des zones de texte qui facilitent le développement d'applications telles que un simple calendrier graphique, une calculatrice ou un gestionnaire de liste de tâches. Pour installer Tkinter, ouvrez un terminal et exécutez :

pip install tkinter

Le python-vlc module est une liaison Python pour la bibliothèque de lecteur multimédia VLC (VideoLAN Client). Vous pouvez utiliser ce module pour implémenter Fonctionnalités de VLC et créez votre propre lecteur multimédia personnalisé. Pour installer VLC, exécutez :

pip install python-vlc

Le date-heure Le module est intégré à Python et fournit des classes et des fonctions pour représenter différentes dates, heures, intervalles et zones.

Vous pouvez trouver le code source de ce projet dans son Référentiel GitHub.

Importez les modules requis. Définir une classe, MediaPlayerApp. Définissez la méthode constructeur et appelez-la pour initialiser la fenêtre principale de l'application. Définissez le titre, les dimensions et la couleur d'arrière-plan du lecteur multimédia vidéo. Appeler le initialize_player méthode.

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

Définir une méthode, initialize_player. Créez une instance du lecteur multimédia VLC pour interagir avec ses fonctionnalités. À l'aide de cette instance, créez un objet lecteur multimédia que vous pouvez utiliser pour gérer la lecture multimédia. Initialiser une variable, Fichier actuel pour garder une trace de la vidéo en cours de lecture. Définissez les états de lecture et appelez le créer_widgets méthode.

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

Définir la créer_widgets méthode. Créez un widget canvas et transmettez l'élément parent dans lequel le placer, sa couleur d'arrière-plan, sa largeur et sa hauteur. Créer un Choisir le dossier pour sélectionner le fichier vidéo que vous souhaitez lire. Définissez l'élément parent, le texte qu'il doit afficher, les styles de police et la commande qu'il doit exécuter lorsque vous cliquez dessus.

Créez une étiquette pour afficher le temps écoulé et la durée de la vidéo. Définissez l'élément parent, le texte, les styles de police, la couleur de police et la couleur d'arrière-plan. Créez un cadre pour contrôler la lecture de la vidéo et donnez-lui une couleur d'arrière-plan.

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)

Définir la Jouer bouton, le Pause bouton, le Arrêt bouton, le Avance rapide bouton, et le Rembobiner bouton. Créez un widget de barre de progression vidéo. Définissez l'élément parent dans lequel vous souhaitez le placer, la méthode de mise à jour de la position de lecture vidéo, la couleur d'arrière-plan et l'épaisseur.

Organisez tous ces éléments avec un rembourrage approprié dans les deux sens.

 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)

Définir une méthode, choisir le dossier. Ouvrir une boîte de dialogue de fichier pour sélectionner un fichier vidéo avec .mp4 ou .avi extension. Si vous sélectionnez un fichier, chargez son chemin et mettez à jour l'étiquette de temps avec sa durée. Lancez la lecture de la vidéo sélectionnée.

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

Définir une méthode, get_duration_str que vous utiliserez pour calculer la durée totale de la vidéo. Si l'application lit une vidéo, obtenez sa durée en millisecondes et convertissez-la en HH: MM: SS format. S'il n'y a pas de lecture vidéo, revenez 00:00:00 comme valeur par défaut.

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"

Définir une méthode, lire la vidéo. Si une vidéo n'est pas en cours de lecture, créez un nouvel objet multimédia en utilisant le chemin de fichier sélectionné. Associez le média au canevas créé précédemment et lancez la lecture vidéo. Mettre à jour le lecture_vidéo état à Vrai.

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

Définir une méthode, avance rapide. Si une vidéo est en cours de lecture, obtenez le temps actuel écoulé et ajoutez-y 10 000 millisecondes. Réglez la nouvelle durée de lecture. De même, définissez une méthode, rembobiner qui soustrait 10 000 millisecondes.

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)

Définir une méthode, pause_video. Si vous avez démarré une lecture vidéo et l'avez interrompue, appelez le jouer méthode pour le reprendre. Sinon, appelez le pause méthode et mettre à jour l'interface utilisateur en conséquence dans les deux cas.

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

Définir une méthode, arrêt. Si une vidéo est en cours de lecture, arrêtez-la et réinitialisez l'étiquette de temps. Définir une méthode, set_video_position. Si une vidéo est en cours de lecture, récupérez la durée totale et calculez la position souhaitée en millisecondes. Réglez le temps de lecture vidéo sur la position calculée.

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)

Définir une méthode, update_video_progress. Si une vidéo est en cours de lecture, récupérez la durée totale et le temps de lecture actuel, puis calculez le pourcentage de progression. Mettez à jour la barre de progression à l'aide de cette valeur calculée. Formatez l'heure actuelle et la durée totale dans HH: MM: SS format.

Planifiez cette méthode pour qu'elle s'exécute à nouveau après 1 000 millisecondes. Cela crée une boucle qui met à jour en permanence la progression de la vidéo et les étiquettes de temps pendant la lecture de la vidéo.

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)

Définir une classe, Barre de progression vidéo qui hérite de tk. Échelle widget. Définissez un constructeur qui définit l'état initial et le comportement de la barre de progression. Met le afficher la valeur possibilité de FAUX pour éviter d'afficher la valeur actuelle.

Initialiser la progression avec une plage de 0 à 100. Définissez l'orientation, la longueur, la commande à exécuter et la personnalisation de la barre de progression. Liez un événement à la barre de progression de sorte que lorsque vous cliquez dessus, il exécute le sur clic méthode.

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)

Définir une méthode, sur clic. Vérifiez si la barre de progression n'est pas désactivée et calcule la nouvelle valeur en fonction de la position du clic. Mettez à jour la valeur de la barre de progression en conséquence.

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

Créer une instance de MediaPlayerApp classe et appeler le update_video_progress méthode. Le boucle principale() La fonction indique à Python d'exécuter la boucle d'événements Tkinter et d'écouter les événements jusqu'à ce que vous fermiez la fenêtre.

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

Lors de l'exécution du programme, le lecteur multimédia vidéo apparaît. Il contient le Choisir le dossier bouton, les étiquettes de temps, les boutons pour contrôler la lecture vidéo et une barre de progression vidéo.

Lorsque vous choisissez une vidéo, elle sera lue automatiquement depuis le début, mettant à jour l'heure de début et la durée des étiquettes de temps.

En frappant le Pause, la vidéo s'interrompt et passe au CV bouton. En cliquant sur le Avance rapide, la vidéo avance de 10 secondes.

De même, en frappant le Rembobiner bouton, il recule de 10 secondes. En appuyant sur le Arrêt bouton, la lecture vidéo s'arrête. Vous pouvez faire glisser ou cliquer sur n'importe quelle zone de la barre de progression pour passer à n'importe quelle partie de la vidéo et l'étiquette de temps lit le temps écoulé.

Vous pouvez améliorer ce lecteur multimédia vidéo en ajoutant une option pour charger et afficher les sous-titres. Vous pouvez également envisager des fonctionnalités telles que la modification du format d'image, le contrôle du volume et la mise en boucle d'une partie de la vidéo.

Pour implémenter ces fonctionnalités, vous pouvez explorer le module Pygame. Pygame est polyvalent, facile à utiliser et s'intègre bien à Tkinter. La bibliothèque permet la personnalisation, possède des fonctionnalités interactives et peut s'exécuter sur n'importe quelle plate-forme.