Cara Membuat Pemutar Media Video Menggunakan Python

Membuat pemutar video dapat membantu Anda menikmati video favorit dengan tema dan gaya yang disesuaikan. Anda dapat membuat pemutaran video lebih lancar, mendesain tombol dan menu aplikasi Anda, dan menambahkan fungsionalitas apa pun yang Anda inginkan.

Proyek ini juga akan memberi Anda pengalaman langsung dalam membuat aplikasi desktop lintas platform, memproses multimedia, dan menangani acara. Temukan bagaimana Anda dapat membuat pemutar media video menggunakan Tkinter, VLC, dan modul datetime.

Modul Tkinter, VLC, dan Datetime

Tkinter memungkinkan Anda membuat aplikasi desktop. Ini menawarkan berbagai widget seperti tombol, label, dan kotak teks yang membuatnya lebih mudah untuk mengembangkan aplikasi seperti kalender GUI sederhana, kalkulator, atau a pengelola daftar tugas. Untuk menginstal Tkinter, buka terminal dan jalankan:

pip install tkinter

Itu python-vlc module adalah pengikatan Python untuk pustaka pemutar media VLC (VideoLAN Client). Anda dapat menggunakan modul ini untuk mengimplementasikan

fitur VLC dan bangun pemutar media kustom Anda sendiri. Untuk menginstal VLC, jalankan:

pip install python-vlc

Itu tanggal Waktu modul dibangun ke dalam Python dan menyediakan kelas dan fungsi untuk mewakili tanggal, waktu, interval, dan zona yang berbeda.

Anda dapat menemukan kode sumber proyek ini di dalamnya repositori GitHub.

Impor modul yang diperlukan. Tentukan kelas, Aplikasi MediaPlayer. Tentukan metode konstruktor dan panggil untuk menginisialisasi jendela aplikasi utama. Tetapkan judul, dimensi, dan warna latar belakang pemutar media video. Panggil initialize_player metode.

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

Tentukan metode, initialize_player. Buat instance pemutar media VLC untuk berinteraksi dengan fungsinya. Dengan menggunakan instance ini, buat objek pemutar media yang dapat Anda gunakan untuk mengelola pemutaran media. Inisialisasi variabel, file_saat ini untuk melacak video yang sedang diputar. Atur status pemutaran dan panggil buat_widget metode.

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

Tentukan buat_widget metode. Buat widget kanvas dan berikan elemen induk untuk menempatkannya, warna latar belakang, lebar, dan tingginya. Membuat Pilih file tombol untuk memilih file video yang ingin diputar. Tetapkan elemen induk, teks yang harus ditampilkan, gaya font, dan perintah yang harus dijalankan saat Anda mengkliknya.

Buat label untuk menampilkan waktu berlalu dan durasi video. Atur elemen induk, teks, gaya font, warna font, dan warna latar belakang. Buat bingkai untuk mengontrol pemutaran video dan berikan warna latar belakang.

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)

Tentukan Bermain tombol, itu Berhenti sebentar tombol, itu Berhenti tombol, itu Maju Cepat tombol, dan Memutar ulang tombol. Buat widget bilah progres video. Tetapkan elemen induk tempat Anda ingin menempatkannya, metode untuk memperbarui posisi pemutaran video, warna latar belakang, dan ketebalannya.

Atur semua elemen ini dengan padding yang sesuai di kedua arah.

 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)

Tentukan metode, Pilih file. Buka kotak dialog file untuk memilih file video .mp4 atau .avi perpanjangan. Jika Anda memilih file apa pun, muat jalurnya dan perbarui label waktu dengan durasinya. Mulai putar video yang dipilih.

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

Tentukan metode, get_duration_str yang akan Anda gunakan untuk menghitung total durasi video. Jika aplikasi memutar video, dapatkan durasinya dalam milidetik dan ubah menjadi HH: MM: SS format. Jika tidak ada video yang diputar, kembalikan 00:00:00 sebagai nilai default.

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"

Tentukan metode, play_video. Jika video tidak diputar, buat objek media baru menggunakan jalur file yang dipilih. Kaitkan media dengan kanvas yang dibuat sebelumnya dan mulai pemutaran video. Perbarui playing_video negara bagian ke BENAR.

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

Tentukan metode, fast_forward. Jika video diputar, dapatkan waktu saat ini berlalu dan tambahkan 10.000 milidetik ke dalamnya. Setel waktu pemutaran baru. Demikian pula, tentukan metode, memutar ulang yang mengurangi 10.000 milidetik.

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)

Tentukan metode, pause_video. Jika Anda telah memulai pemutaran video dan menjedanya, hubungi bermain metode untuk melanjutkannya. Jika tidak, hubungi berhenti sebentar metode dan perbarui UI yang sesuai dalam kedua kasus.

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

Tentukan metode, berhenti. Jika video diputar, hentikan, dan setel ulang label waktu. Tentukan metode, set_video_position. Jika video diputar, dapatkan durasi total dan hitung posisi yang diinginkan dalam milidetik. Setel waktu pemutaran video ke posisi yang dihitung.

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)

Tentukan metode, perbarui_video_progres. Jika video sedang diputar, dapatkan durasi total, dan waktu pemutaran saat ini, dan hitung persentase progresnya. Perbarui bilah kemajuan menggunakan nilai yang dihitung ini. Format waktu saat ini dan total durasi di HH: MM: SS format.

Jadwalkan metode ini untuk berjalan lagi setelah 1.000 milidetik. Ini menciptakan loop yang terus memperbarui progres video dan label waktu saat video diputar.

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)

Tentukan kelas, VideoProgressBar yang mewarisi dari tk. Skala widget. Tentukan konstruktor yang menetapkan status awal dan perilaku bilah kemajuan. Mengatur showvalue pilihan untuk PALSU untuk menghindari menampilkan nilai saat ini.

Inisialisasi progres dengan rentang 0 hingga 100. Tetapkan orientasi, panjang, perintah yang harus dijalankan, dan kustomisasi ke bilah kemajuan. Ikat acara ke bilah progres sehingga saat Anda mengekliknya, acara akan dijalankan on_click metode.

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)

Tentukan metode, on_click. Periksa apakah bilah progres tidak dinonaktifkan dan hitung nilai baru berdasarkan posisi klik. Perbarui nilai bilah kemajuan yang sesuai.

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

Buat contoh dari Aplikasi MediaPlayer kelas, dan memanggil perbarui_video_progres metode. Itu mainloop() fungsi memberi tahu Python untuk menjalankan loop acara Tkinter dan mendengarkan acara sampai Anda menutup jendela.

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

Saat menjalankan program, pemutar media video muncul. Ini berisi Pilih file tombol, label waktu, tombol untuk mengontrol pemutaran video, dan bilah progres video.

Saat Anda memilih video, itu akan diputar secara otomatis dari awal, memperbarui waktu mulai dan durasi label waktu.

Saat memukul Berhenti sebentar tombol, video berhenti, dan berubah menjadi Melanjutkan tombol. Saat mengklik Maju Cepat tombol, video melompat ke depan 10 detik.

Demikian pula, pada memukul Memutar ulang tombol, itu kembali 10 detik. Saat menekan Berhenti tombol, pemutaran video berhenti. Anda dapat menyeret atau mengeklik area mana pun di bilah kemajuan untuk berpindah ke bagian mana pun dari video dan label waktu membaca waktu yang telah berlalu.

Anda dapat meningkatkan pemutar media video ini dengan menambahkan opsi untuk memuat dan menampilkan subtitle. Anda juga dapat mempertimbangkan fitur seperti mengubah rasio aspek, mengontrol volume, dan mengulang bagian video.

Untuk mengimplementasikan fitur ini, Anda dapat menjelajahi modul Pygame. Pygame serbaguna, mudah digunakan, dan terintegrasi dengan baik dengan Tkinter. Perpustakaan memungkinkan penyesuaian, memiliki fitur interaktif, dan dapat berjalan di platform apa pun.