Como construir um reprodutor de mídia de vídeo usando Python
Construir um leitor de vídeo pode ajudá-lo a desfrutar dos seus vídeos favoritos num tema e estilo personalizados. Podes tornar a reprodução de vídeo mais suave, desenhar os botões e menus da tua aplicação e adicionar qualquer funcionalidade que queiras.
O presente empreendimento proporcionará familiaridade prática com o desenvolvimento de aplicações de desktop multiplataforma, bem como proficiência no processamento de conteúdo multimédia e gestão de interacções do utilizador através do tratamento de eventos. Utilizando o Tkinter, o VLC e o módulo datetime, este projeto oferece a oportunidade de criar um leitor multimédia de vídeo funcional.
O módulo Tkinter, VLC e Datetime
O Tkinter é um ambiente de desenvolvimento integrado (IDE) para criar interfaces gráficas de utilizador (GUIs) em Python. Com a sua gama abrangente de widgets incorporados, como botões, etiquetas e caixas de texto, os programadores podem facilmente criar aplicações complexas, incluindo, mas não se limitando a, uma interface básica de calendário, uma calculadora ou mesmo um sistema de gestão de tarefas. Para configurar o Tkinter no seu computador, basta abrir uma linha de comandos e introduzir o comando de instalação.
pip install tkinter
O módulo python-vlc é uma interface que facilita a comunicação entre aplicações Python e a biblioteca do leitor multimédia VLC. Isto permite que os programadores aproveitem todo o potencial do extenso conjunto de funcionalidades do VLC nos seus projectos, integrando-o na sua base de código. Para obter o pacote python-vlc , execute o seguinte comando:
pip install python-vlc
O módulo datetime em Python oferece uma gama de classes e funções que permitem aos utilizadores trabalhar com vários formatos de data e hora, bem como efetuar operações envolvendo fusos horários. Esta funcionalidade permite a manipulação e o cálculo eficientes de dados temporais em programas Python.
Construindo a Estrutura do Video Media Player
O código fonte deste projeto está disponível no seu repositório GitHub, ao qual se pode aceder navegando para o respetivo URL.
De facto, para implementar a nossa visão de um leitor multimédia intuitivo e visualmente cativante, temos primeiro de importar os módulos necessários que nos permitirão criar essa experiência. Em particular, vamos definir uma nova classe chamada MediaPlayerApp , que servirá de base para a interface de utilizador da nossa aplicação. Uma vez definida, invocaremos o seu método construtor para configurar o estado inicial da janela principal da aplicação, incluindo a definição do título, a definição das dimensões e a especificação da cor de fundo do leitor multimédia de vídeo. Por fim, vamos chamar o método initialize_player para garantir que todos os componentes sejam inicializados corretamente antes de qualquer interação.
import tkinter as tk
import vlc
from tkinter import filedialog
from datetime import timedelta
class MediaPlayerApp(tk.Tk):
def __init__(self):
super().__init__()
self.title("Media Player")
self.geometry("800x600")
self.configure(bg="#f0f0f0")
self.initialize_player()
A função initializer\_player() é responsável pela configuração do leitor multimédia, criando uma instância da biblioteca do leitor multimédia VLC, que fornece várias funcionalidades para gerir a reprodução de áudio e vídeo. A função também cria um novo objeto QMediaPlayer, que serve como elemento da interface do utilizador para controlar a reprodução de multimédia. Para manter um registo do ficheiro de vídeo atualmente em reprodução, é introduzida uma variável denominada current\_file. Esta variável será utilizada nas etapas seguintes para garantir uma transição perfeita entre diferentes vídeos durante o jogo. Além disso, a função define inicialmente o estado de reprodução como “parado”, permitindo que os utilizadores comecem a jogar do zero quando desejarem. Por fim, o método create\_widgets() é invocado para configurar os elementos da interface gráfica do utilizador que correspondem a cada botão do dispositivo de controlo remoto.
def initialize_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()
gera um widget de ecrã pegando no elemento principal especificado e definindo as suas propriedades, como o posicionamento no ecrã utilizando place , determinando as suas dimensões, como largura e altura, juntamente com a aplicação de um identificador único para fins de referência. Além disso, construa um botão de seleção de ficheiro através da instanciação, defina os seus atributos, incluindo o elemento principal, a etiqueta de texto que irá apresentar, os parâmetros de estilo para o aspeto e a ação designada que é executada após a interação do utilizador, que é clicar no botão.
Assegurar que é criada uma etiqueta adequada para apresentar a hora atual e a duração total do vídeo, ao mesmo tempo que define o seu elemento principal, ajusta o estilo do texto, define as cores do tipo de letra e determina a tonalidade do fundo. Além disso, estabeleça uma área delimitada com uma tonalidade de fundo específica para regular a progressão da reprodução do vídeo.
def create_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)
Incorporar a funcionalidade de definir os botões de reprodução, pausa, paragem, avanço rápido e retrocesso, juntamente com a criação de um widget de barra de progresso de vídeo numa aplicação de leitor de vídeo em tela HTML5. Além disso, especificar o contentor principal pretendido para a colocação destes elementos, bem como o método designado para atualizar a posição de reprodução do vídeo, a cor de fundo preferida para a barra de progresso e a espessura correspondente.
Certifique-se de que todos estes componentes estão dispostos de forma harmoniosa, com um espaçamento adequado em ambos os lados.
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)
Construir a funcionalidade do leitor multimédia de vídeo
Incorpore o excerto de código fornecido abaixo para definir um método select_file que abre uma caixa de diálogo de ficheiro para permitir que os utilizadores escolham um ficheiro de vídeo MP4 ou AVI. O método utilizará então a duração do ficheiro selecionado para atualizar a visualização da linha de tempo e iniciar a reprodução do suporte de dados escolhido.
def select_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()
Para determinar a duração total de um vídeo, proponho a implementação de uma nova função chamada get_duration_str que calcula este valor com base no facto de uma aplicação estar ou não a reproduzir um vídeo. Se a aplicação estiver de facto a reproduzir um vídeo, podemos obter a sua duração em milissegundos e depois convertê-la no formato de tempo padrão constituído por horas, minutos e segundos (HH:MM:SS). Por outro lado, se não estiver a ser reproduzido nenhum vídeo, devemos definir o valor predefinido para get_duration_str como 00:00:00 .
def get_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 chamado “play\_video” que verifica se um vídeo está ou não a ser reproduzido no ecrã. Se nenhum vídeo estiver a ser reproduzido, crie um novo objeto multimédia especificando o caminho do ficheiro na variável “selected\_file\_path”. Em seguida, associe este objeto multimédia à instância da tela criada anteriormente e comece a reproduzir o vídeo. Finalmente, actualize o valor do estado “playing\_video” para indicar que o vídeo começou a ser reproduzido.
def play_video(self):
if not 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
Para implementar uma funcionalidade de avanço rápido para um leitor de vídeo em Python, podemos criar dois métodos - fast_forward e rewind . O primeiro irá aumentar o tempo de reprodução atual adicionando-lhe 10.000 milissegundos, enquanto o segundo irá diminuir o tempo de reprodução subtraindo-lhe uma quantidade equivalente.
def fast_forward(self):
if self.playing_video:
current_time = self.media_player.get_time() \\+ 10000
self.media_player.set_time(current_time)
def rewind(self):
if self.playing_video:
current_time = self.media_player.get_time() - 10000
self.media_player.set_time(current_time)
Incorpore a funcionalidade de pausa e reprodução de vídeos na interface da sua aplicação, implementando um método chamado “pause\_video”. Este método será responsável pelo tratamento das interacções do utilizador relacionadas com a reprodução de vídeo. O primeiro passo é determinar se o vídeo foi ou não pausado anteriormente. Se o vídeo já estava em andamento e foi temporariamente interrompido, chame o método “play” para continuar de onde parou. Por outro lado, se o vídeo nunca tiver sido iniciado ou parado anteriormente, o método “pause” deve ser invocado com as devidas actualizações na interface do utilizador que reflictam esta ação.
def pause_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")
Para comunicar eficazmente o texto dado de uma forma mais refinada, sugiro que o reformule da seguinte forma:> “Para gerir eficazmente a reprodução de vídeo, implemente dois métodos no seu código. O primeiro, ‘stop’, interrompe qualquer reprodução de vídeo em curso e repõe o registo de data e hora associado. O segundo, ‘set\_video\_position’, determinará se um vídeo está a ser reproduzido atualmente. Neste caso, calcula a posição desejada em milissegundos com base na duração total do vídeo e define o tempo de reprodução em conformidade.
def stop(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())
def set_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)
Para transmitir eficazmente a informação pretendida, mantendo um tom profissional, sugiro que reformule o texto dado da seguinte forma: javascriptfunction updateVideoProgress() {// Verificar se um vídeo está atualmente a ser reproduzidose (isPlaying) {// Recuperar a duração total do vídeo em segundosconst totalDuration = getTotalDuration();// Calcular a percentagem de progresso com base nos valores recuperadoslet progressPercentage = ((getCurrentTime() / totalDuration) * 100). toFixed(2);// Atualizar a barra de progresso com o valor calculadoupdateProgressBar(progressPercentage \+ “%”);// Formatar a hora atual e a duração total para efeitos de visualizaçãoconst formattedCurrentTime =
Para executar repetidamente este método a cada 1.000 milissegundos, criando assim um ciclo infinito que continua a atualizar as etiquetas de progresso e tempo do vídeo durante a reprodução, programe esta operação da seguinte forma
def update_video_progress(self):
if self.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)
Claro! Aqui está a minha tentativa de parafrasear as instruções numa linguagem mais formal:pythonclass VideoProgressBar(tk.Scale):def init (self, master=None, **kwargs):super(). init (master, **kwargs)# define o estado inicial e o comportamento das barras de progressoself[‘orient’] = ‘horizontal’self[’tickinterval’] = - 1self[‘command’] = Noneself[‘showgrid’] = Falseself[‘showlabel’] = Trueself[‘sliderrelief’] = ‘groove’self[‘start’] = 0self[’end’] = 100# defina a opção showvalue como False para evitar a exibição do
Inicie a inicialização da barra de progresso especificando um intervalo de 0 a 100, definir sua orientação, determinar seu comprimento e aplicar personalizações à barra de progresso. Além disso, associe um ouvinte de eventos à barra de progresso para que, após a interação do utilizador, seja acionado o método especificado on_click para processamento posterior.
class VideoProgressBar(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("<Button-1>", self.on_click)
Incorpore a funcionalidade do manipulador de eventos “on\_click”, implementando-o na base de código. O objetivo é determinar se a barra de progresso foi ou não activada para interação e, em seguida, calcular um valor atualizado para a barra de progresso com base na posição em que o utilizador clicou. Por fim, atualizar o valor apresentado da barra de progresso com este novo valor calculado.
def on_click(self, event):
if self.cget("state") == tk.NORMAL:
value = (event.x / self.winfo_width()) * 100
self.set(value)
Crie uma nova instância da classe MediaPlayerApp e invoque o seu método update_video_progress() no contexto de uma GUI Tkinter. Além disso, certifique-se de que a função mainloop() é chamada de modo a iniciar o ciclo de eventos e a permanecer ativa até o utilizador fechar a janela.
if __name__ == "__main__":
app = MediaPlayerApp()
app.update_video_progress()
app.mainloop()
Testar diferentes funcionalidades do leitor de multimédia de vídeo
Ao executar a aplicação, surge uma interface de multimédia de vídeo com uma opção “Selecionar ficheiro” incorporada, acompanhada por uma série de controlos fáceis de utilizar, como indicadores de tempo, ferramentas de gestão da reprodução e uma representação visual da progressão do vídeo, tudo isto encapsulado numa estrutura visualmente apelativa.
Ao selecionar um vídeo, deve iniciar a reprodução desde o início, ajustando simultaneamente o carimbo de data/hora inicial e a etiqueta de duração para refletir o tempo decorrido.
Ao premir a tecla “Pausa”, o suporte visual é suspenso, passando para a opção “Retomar”. Ao selecionar a função “Avanço rápido”, a apresentação audiovisual avança uma duração de dez segundos.
Do mesmo modo, ao premir a tecla “Retroceder”, o vídeo retrocede dez segundos. O botão “Stop” termina completamente a reprodução do vídeo. Os utilizadores têm a possibilidade de manipular a barra de progresso para navegar para pontos específicos do vídeo. À medida que a barra de progresso se move ao longo do seu comprimento, o tempo apresentado reflecte a duração que passou desde o início do vídeo.
Melhorar a aplicação Video Media Player
Para melhorar a funcionalidade deste media player de vídeo, talvez queira incluir um recurso que permita aos utilizadores aceder e exibir opções de legendas. Além disso, outras melhorias potenciais podem envolver o ajuste das dimensões do ecrã, a regulação dos níveis de áudio e a repetição de segmentos específicos do vídeo.
Para incorporar estas capacidades, pode mergulhar-se no domínio da biblioteca Pygame. Pygame é uma ferramenta altamente adaptável e fácil de usar que se funde perfeitamente com o Tkinter. Este pacote de recursos oferece a oportunidade de configuração personalizada, apresenta uma série de elementos interactivos e funciona sem falhas em todas as plataformas.