Cómo construir un reproductor multimedia de video usando Python

Crear un reproductor de video puede ayudarlo a disfrutar de sus videos favoritos con un tema y estilo personalizados. Puede hacer que la reproducción de video sea más fluida, diseñar los botones y menús de su aplicación y agregar cualquier funcionalidad que desee.

Este proyecto también le brindará experiencia práctica en la creación de aplicaciones de escritorio multiplataforma, el procesamiento de multimedia y el manejo de eventos. Descubra cómo puede crear un reproductor multimedia de video usando Tkinter, VLC y el módulo de fecha y hora.

Módulo Tkinter, VLC y Datetime

Tkinter te permite crear aplicaciones de escritorio. Ofrece una variedad de widgets como botones, etiquetas y cuadros de texto que facilitan el desarrollo de aplicaciones como un calendario GUI simple, una calculadora o un gestor de listas de tareas pendientes. Para instalar Tkinter, abre una terminal y ejecuta:

pip install tkinter

El python-vlc El módulo es un enlace de Python para la biblioteca del reproductor multimedia VLC (VideoLAN Client). Puede utilizar este módulo para implementar el caracteristicas de vlc y crea tu propio reproductor multimedia personalizado. Para instalar VLC, ejecute:

pip install python-vlc

El fecha y hora El módulo está integrado en Python y proporciona clases y funciones para representar diferentes fechas, horas, intervalos y zonas.

Puede encontrar el código fuente de este proyecto en su repositorio GitHub.

Importe los módulos requeridos. Definir una clase, MediaPlayerApp. Defina el método constructor y llámelo para inicializar la ventana principal de la aplicación. Establezca el título, las dimensiones y el color de fondo del reproductor multimedia de video. Llama a inicializar_jugador método.

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

Definir un método, inicializar_jugador. Cree una instancia del reproductor multimedia VLC para interactuar con sus funcionalidades. Usando esta instancia, cree un objeto de reproductor de medios que pueda usar para administrar la reproducción de medios. Inicializar una variable, archivo actual para realizar un seguimiento del vídeo que se está reproduciendo actualmente. Configure los estados de reproducción y llame al crear_widgets método.

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

Definir el crear_widgets método. Cree un widget de lienzo y pase el elemento principal para colocarlo, su color de fondo, ancho y alto. Crear un Seleccione Archivo para seleccionar el archivo de video que desea reproducir. Establezca el elemento principal, el texto que debe mostrar, los estilos de fuente y el comando que debe ejecutar al hacer clic en él.

Crea una etiqueta para mostrar el tiempo transcurrido y la duración del video. Establezca el elemento principal, el texto, los estilos de fuente, el color de fuente y el color de fondo. Cree un marco para controlar la reproducción del video y asígnele un color de fondo.

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)

Definir el Jugar botón, el Pausa botón, el Detener botón, el Avance rápido botón, y el Rebobinar botón. Cree un widget de barra de progreso de video. Establezca el elemento principal en el que desea colocarlo, el método para actualizar la posición de reproducción de video, el color de fondo y el grosor.

Organice todos estos elementos con acolchado adecuado en ambas direcciones.

 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)

Definir un método, seleccione Archivo. Abra un cuadro de diálogo de archivo para seleccionar un archivo de video con .mp4 o .avi extensión. Si selecciona cualquier archivo, cargue su ruta y actualice la etiqueta de tiempo con su duración. Comienza a reproducir el video seleccionado.

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

Definir un método, get_duration_str que usará para calcular la duración total del video. Si la aplicación está reproduciendo un video, obtenga su duración en milisegundos y conviértalo en el HH: MM: SS formato. Si no se reproduce ningún video, regrese 00:00:00 como valor predeterminado.

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"

Definir un método, reproduce el video. Si un video no se está reproduciendo, cree un nuevo objeto multimedia usando la ruta del archivo seleccionado. Asocie los medios con el lienzo creado anteriormente e inicie la reproducción de video. Actualizar el reproduciendo_video estado a Verdadero.

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

Definir un método, avance rápido. Si se está reproduciendo un video, obtenga el tiempo transcurrido actual y agréguele 10,000 milisegundos. Configure el nuevo tiempo de reproducción. Del mismo modo, defina un método, rebobinar eso resta 10,000 milisegundos.

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)

Definir un método, pausa_video. Si había iniciado la reproducción de un video y lo pausó, llame al jugar método para reanudarlo. De lo contrario, llame al pausa método y actualice la interfaz de usuario en consecuencia en ambos casos.

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

Definir un método, detener. Si se está reproduciendo un video, deténgalo y restablezca la etiqueta de tiempo. Definir un método, establecer_video_posición. Si se está reproduciendo un video, recupere la duración total y calcule la posición deseada en milisegundos. Establezca el tiempo de reproducción de video en la posición calculada.

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)

Definir un método, actualización_video_progreso. Si se está reproduciendo un video, recupere la duración total y el tiempo de reproducción actual, y calcule el porcentaje de progreso. Actualice la barra de progreso utilizando este valor calculado. Dar formato a la hora actual y la duración total en el HH: MM: SS formato.

Programe este método para que se ejecute nuevamente después de 1000 milisegundos. Esto crea un bucle que actualiza continuamente el progreso del video y las etiquetas de tiempo mientras se reproduce el 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)

Definir una clase, VideoProgressBar que hereda de tk. Escala artilugio. Defina un constructor que establezca el estado inicial y el comportamiento de la barra de progreso. Selecciona el Mostrar valor opción a FALSO para evitar mostrar el valor actual.

Inicialice el progreso con un rango de 0 a 100. Establezca la orientación, la longitud, el comando que debe ejecutar y la personalización de la barra de progreso. Vincule un evento a la barra de progreso de modo que cuando haga clic en él, ejecute el al hacer clic método.

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)

Definir un método, al hacer clic. Compruebe si la barra de progreso no está deshabilitada y calcula el nuevo valor en función de la posición del clic. Actualice el valor de la barra de progreso en consecuencia.

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

Crear una instancia de la MediaPlayerApp clase y llamar al actualización_video_progreso método. El bucle principal() La función le dice a Python que ejecute el ciclo de eventos de Tkinter y escuche los eventos hasta que cierre la ventana.

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

Al ejecutar el programa, aparece el reproductor multimedia de video. Contiene el Seleccione Archivo botón, las etiquetas de tiempo, botones para controlar la reproducción de video y una barra de progreso de video.

Cuando eliges un video, se reproducirá automáticamente desde el principio, actualizando la hora de inicio y la duración de las etiquetas de tiempo.

Al golpear el Pausa botón, el video se detiene y cambia a la Reanudar botón. Al hacer clic en el Avance rápido botón, el vídeo salta 10 segundos.

Del mismo modo, al golpear el Rebobinar botón, retrocede 10 segundos. Al presionar el Detener botón, la reproducción de vídeo se detiene. Puede arrastrar o hacer clic en cualquier área de la barra de progreso para moverse a cualquier parte del video y la etiqueta de tiempo lee el tiempo transcurrido.

Puede mejorar este reproductor multimedia de video agregando una opción para cargar y mostrar subtítulos. También podría considerar características como cambiar la relación de aspecto, controlar el volumen y reproducir en bucle parte del video.

Para implementar estas funciones, puede explorar el módulo Pygame. Pygame es versátil, fácil de usar y se integra bien con Tkinter. La biblioteca permite la personalización, tiene funciones interactivas y puede ejecutarse en cualquier plataforma.