Como construir um reprodutor de mídia de vídeo usando Python

Construir um reprodutor de vídeo pode ajudá-lo a curtir seus vídeos favoritos em um tema e estilo personalizados. Você pode tornar a reprodução de vídeo mais suave, projetar os botões e menus do seu aplicativo e adicionar qualquer funcionalidade que desejar.

Este projeto também lhe dará experiência prática na criação de aplicativos de desktop multiplataforma, processamento de multimídia e manipulação de eventos. Descubra como você pode criar um reprodutor de mídia de vídeo usando Tkinter, VLC e o módulo datetime.

O módulo Tkinter, VLC e Datetime

Tkinter permite que você crie aplicativos de desktop. Ele oferece uma variedade de widgets como botões, rótulos e caixas de texto que facilitam o desenvolvimento de aplicativos como um calendário GUI simples, uma calculadora ou um gerenciador de lista de tarefas. Para instalar o Tkinter, abra um terminal e execute:

pip install tkinter

O python-vlc module é uma ligação Python para a biblioteca do reprodutor de mídia VLC (VideoLAN Client). Você pode usar este módulo para implementar o

recursos do VLC e crie seu próprio reprodutor de mídia personalizado. Para instalar o VLC, execute:

pip install python-vlc

O data hora O módulo é integrado ao Python e fornece classes e funções para representar diferentes datas, horários, intervalos e zonas.

Você pode encontrar o código-fonte deste projeto em seu Repositório GitHub.

Importe os módulos necessários. Definir uma classe, MediaPlayerApp. Defina o método construtor e chame-o para inicializar a janela principal do aplicativo. Defina o título, as dimensões e a cor de fundo do media player de vídeo. Ligar para inicializar_jogador 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()

Defina um método, inicializar_jogador. Crie uma instância do reprodutor de mídia VLC para interagir com suas funcionalidades. Usando esta instância, crie um objeto media player que você pode usar para gerenciar a reprodução de mídia. Inicializar uma variável, arquivo atual para acompanhar o vídeo que está sendo reproduzido. Defina os estados de reprodução e chame o criar_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()

Defina a criar_widgets método. Crie um widget de tela e passe o elemento pai para colocá-lo, sua cor de fundo, largura e altura. Criar uma Selecione o arquivo para selecionar o arquivo de vídeo que deseja reproduzir. Defina o elemento pai, o texto que deve ser exibido, os estilos de fonte e o comando que deve ser executado quando você clicar nele.

Crie um rótulo para exibir o tempo decorrido e a duração do vídeo. Defina o elemento pai, o texto, os estilos de fonte, a cor da fonte e a cor de fundo. Crie um quadro para controlar a reprodução do vídeo e dê a ele uma cor de fundo.

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)

Defina a Jogar botão, o Pausa botão, o Parar botão, o Avanço rápido botão e o retroceder botão. Crie um widget de barra de progresso de vídeo. Defina o elemento pai no qual deseja colocá-lo, o método para atualizar a posição de reprodução do vídeo, a cor de fundo e a espessura.

Organize todos esses elementos com preenchimento apropriado em ambas as direções.

 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)

Defina um método, selecione o arquivo. Abra uma caixa de diálogo de arquivo para selecionar um arquivo de vídeo com .mp4 ou .avi extensão. Se você selecionar qualquer arquivo, carregue seu caminho e atualize o rótulo de tempo com sua duração. Comece a reproduzir o vídeo selecionado.

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

Defina um método, get_duration_str que você usará para calcular a duração total do vídeo. Se o aplicativo estiver reproduzindo um vídeo, obtenha sua duração em milissegundos e converta-o no formato HH: MM: SS formatar. Se não houver reprodução de vídeo, retorne 00:00:00 como o valor padrão.

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"

Defina um método, play_video. Se um vídeo não estiver sendo reproduzido, crie um novo objeto de mídia usando o caminho de arquivo selecionado. Associe a mídia à tela criada anteriormente e inicie a reprodução do vídeo. Atualize o jogando_vídeo estado para Verdadeiro.

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

Defina um método, fast_forward. Se um vídeo estiver sendo reproduzido, obtenha o tempo atual decorrido e adicione 10.000 milissegundos a ele. Defina o novo tempo de reprodução. Da mesma forma, defina um método, rebobinar que subtrai 10.000 milissegundos.

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)

Defina um método, pausa_vídeo. Se você iniciou qualquer reprodução de vídeo e a pausou, chame o jogar método para retomá-lo. Caso contrário, ligue para o pausa e atualize a IU de acordo em ambos os 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")

Defina um método, parar. Se um vídeo estiver sendo reproduzido, pare-o e redefina o rótulo de tempo. Defina um método, set_video_position. Se um vídeo estiver sendo reproduzido, recupere a duração total e calcule a posição desejada em milissegundos. Defina o tempo de reprodução do vídeo para a posição 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)

Defina um método, update_video_progress. Se um vídeo estiver sendo reproduzido, recupere a duração total e o tempo de reprodução atual e calcule a porcentagem de progresso. Atualize a barra de progresso usando este valor calculado. Formate a hora atual e a duração total no HH: MM: SS formatar.

Agende esse método para ser executado novamente após 1.000 milissegundos. Isso cria um loop que atualiza continuamente o andamento do vídeo e os rótulos de tempo enquanto o vídeo está sendo reproduzido.

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 uma classe, VideoProgressBar que herda de tk. Escala ferramenta. Defina um construtor que define o estado inicial e o comportamento da barra de progresso. Colocou o mostrar valor opção para Falso para evitar a exibição do valor atual.

Inicialize o progresso com um intervalo de 0 a 100. Defina a orientação, o comprimento, o comando a ser executado e a personalização da barra de progresso. Vincule um evento à barra de progresso de forma que, ao clicar nele, ele execute o on_click 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)

Defina um método, on_click. Verifique se a barra de progresso não está desabilitada e calcule o novo valor com base na posição do clique. Atualize o valor da barra de progresso de acordo.

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

Crie uma instância do MediaPlayerApp aula e chame o update_video_progress método. O circuito principal() A função diz ao Python para executar o loop de eventos Tkinter e escutar os eventos até que você feche a janela.

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

Ao executar o programa, o reprodutor de mídia de vídeo é exibido. Ele contém o Selecione o arquivo botão, os rótulos de tempo, botões para controlar a reprodução do vídeo e uma barra de progresso do vídeo.

Ao escolher um vídeo, ele será reproduzido automaticamente desde o início, atualizando o horário de início e a duração dos rótulos de tempo.

Ao acertar o Pausa botão, o vídeo pausa e muda para o Retomar botão. Ao clicar no Avanço rápido botão, o vídeo avança 10 segundos.

Da mesma forma, ao bater no retroceder botão, retrocede 10 segundos. Ao pressionar o Parar botão, a reprodução do vídeo é interrompida. Você pode arrastar ou clicar em qualquer área na barra de progresso para mover para qualquer parte do vídeo e o rótulo de tempo mostra o tempo decorrido.

Você pode aprimorar este reprodutor de mídia de vídeo adicionando uma opção para carregar e exibir legendas. Você também pode considerar recursos como alterar a proporção, controlar o volume e repetir parte do vídeo.

Para implementar esses recursos, você pode explorar o módulo Pygame. O Pygame é versátil, fácil de usar e se integra bem com o Tkinter. A biblioteca permite personalização, possui recursos interativos e pode ser executada em qualquer plataforma.