Kā izveidot video multivides atskaņotāju, izmantojot Python

Video atskaņotāja izveide var palīdzēt baudīt iecienītos videoklipus pielāgotā motīvā un stilā. Varat padarīt video atskaņošanu vienmērīgāku, izveidot savas lietotnes pogas un izvēlnes, kā arī pievienot jebkuru vēlamo funkcionalitāti.

Šis projekts sniegs jums arī praktisku pieredzi vairāku platformu darbvirsmas lietotņu veidošanā, multivides apstrādē un notikumu apstrādē. Uzziniet, kā izveidot video multivides atskaņotāju, izmantojot Tkinter, VLC un datuma un laika moduli.

Tkinter, VLC un datuma un laika modulis

Tkinter ļauj izveidot darbvirsmas lietojumprogrammas. Tā piedāvā dažādus logrīkus, piemēram, pogas, etiķetes un tekstlodziņus, kas atvieglo tādu lietojumprogrammu izstrādi kā vienkāršs GUI kalendārs, kalkulators vai a uzdevumu saraksta pārvaldnieks. Lai instalētu Tkinter, atveriet termināli un palaidiet:

pip install tkinter

The python-vlc modulis ir Python saite VLC (VideoLAN Client) multivides atskaņotāja bibliotēkai. Varat izmantot šo moduli, lai ieviestu

VLC iezīmes un izveidojiet savu pielāgoto multivides atskaņotāju. Lai instalētu VLC, palaidiet:

pip install python-vlc

The datums Laiks modulis ir iebūvēts Python un nodrošina klases un funkcijas, lai attēlotu dažādus datumus, laikus, intervālus un zonas.

Jūs varat atrast šī projekta pirmkodu tajā GitHub repozitorijs.

Importējiet nepieciešamos moduļus. Definējiet klasi, MediaPlayerApp. Definējiet konstruktora metodi un izsauciet to, lai inicializētu galveno lietojumprogrammas logu. Iestatiet video multivides atskaņotāja nosaukumu, izmērus un fona krāsu. Zvaniet uz inicializēt_spēlētāju metodi.

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

Definējiet metodi, inicializēt_spēlētāju. Izveidojiet VLC multivides atskaņotāja gadījumu, lai mijiedarbotos ar tā funkcijām. Izmantojot šo gadījumu, izveidojiet multivides atskaņotāja objektu, ko varat izmantot, lai pārvaldītu multivides atskaņošanu. Inicializējiet mainīgo, pašreizējais_fails lai izsekotu pašlaik atskaņojamajam videoklipam. Iestatiet atskaņošanas stāvokļus un zvaniet uz Create_widgets metodi.

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

Definējiet Create_widgets metodi. Izveidojiet kanvas logrīku un nododiet vecākelementu, lai to ievietotu, tā fona krāsu, platumu un augstumu. Izveidot a Atlasiet Fails pogu, lai atlasītu video failu, kuru vēlaties atskaņot. Iestatiet vecākelementu, tekstu, kas tam jāparāda, fontu stilus un komandu, kas jāpalaiž, noklikšķinot uz tā.

Izveidojiet etiķeti, lai parādītu pagājušo laiku un videoklipa ilgumu. Iestatiet vecākelementu, tekstu, fontu stilus, fonta krāsu un fona krāsu. Izveidojiet rāmi, lai kontrolētu video atskaņošanu un piešķirtu tam fona krāsu.

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)

Definējiet Spēlēt poga, Pauze poga, Stop poga, Ātri uz priekšu pogu un Attīt atpakaļ pogu. Izveidojiet video progresa joslas logrīku. Iestatiet vecāku elementu, kurā vēlaties to ievietot, video atskaņošanas pozīcijas atjaunināšanas metodi, fona krāsu un biezumu.

Sakārtojiet visus šos elementus ar atbilstošu polsterējumu abos virzienos.

 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)

Definējiet metodi, atlasīt_failu. Atveriet faila dialoglodziņu, lai atlasītu video failu .mp4 vai .avi pagarinājumu. Ja atlasāt kādu failu, ielādējiet tā ceļu un atjauniniet laika iezīmi ar tā ilgumu. Sāciet atskaņot atlasīto videoklipu.

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

Definējiet metodi, get_duration_str ko izmantosit, lai aprēķinātu kopējo videoklipa ilgumu. Ja lietojumprogramma atskaņo videoklipu, iegūstiet tā ilgumu milisekundēs un pārveidojiet to par HH: MM: SS formātā. Ja netiek atskaņots video, atgriezieties 00:00:00 kā noklusējuma vērtību.

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"

Definējiet metodi, atskaņot_video. Ja videoklips netiek atskaņots, izveidojiet jaunu multivides objektu, izmantojot atlasīto faila ceļu. Saistiet multividi ar iepriekš izveidoto kanvu un sāciet video atskaņošanu. Atjauniniet atskaņo_video valsts uz Taisnība.

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

Definējiet metodi, ātri uz priekšu. Ja tiek atskaņots videoklips, iegūstiet pašreizējo pagājušo laiku un pievienojiet tam 10 000 milisekundes. Iestatiet jauno atskaņošanas laiku. Līdzīgi definējiet metodi, attīt atpakaļ kas atņem 10 000 milisekundes.

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)

Definējiet metodi, pause_video. Ja esat sācis kādu video atskaņošanu un pauzējis to, zvaniet uz spēlēt metodi, kā to atsākt. Pretējā gadījumā zvaniet uz pauze metodi un attiecīgi atjauniniet lietotāja saskarni abos gadījumos.

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

Definējiet metodi, stop. Ja tiek atskaņots videoklips, apturiet to un atiestatiet laika iezīmi. Definējiet metodi, set_video_position. Ja tiek atskaņots videoklips, izgūstiet kopējo ilgumu un aprēķiniet vēlamo pozīciju milisekundēs. Iestatiet video atskaņošanas laiku aprēķinātajā pozīcijā.

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)

Definējiet metodi, update_video_progress. Ja tiek atskaņots videoklips, izgūstiet kopējo ilgumu un pašreizējo atskaņošanas laiku un aprēķiniet progresa procentuālo daļu. Atjauniniet progresa joslu, izmantojot šo aprēķināto vērtību. Formatējiet pašreizējo laiku un kopējo ilgumu HH: MM: SS formātā.

Ieplānojiet šīs metodes atkārtotu palaišanu pēc 1000 milisekundēm. Tādējādi tiek izveidota cilpa, kas video atskaņošanas laikā nepārtraukti atjaunina video norisi un laika iezīmes.

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)

Definējiet klasi, VideoProgressBar kas manto no tk. Mērogs logrīks. Definējiet konstruktoru, kas iestata progresa joslas sākotnējo stāvokli un darbību. Iestatiet parādīt vērtību iespēja uz Nepatiesi lai izvairītos no pašreizējās vērtības parādīšanas.

Inicializējiet progresu ar diapazonu no 0 līdz 100. Norises joslā iestatiet orientāciju, garumu, komandu, kas tai jāpalaiž, un pielāgošanu. Saistiet notikumu ar norises joslu tā, lai, noklikšķinot uz tā, tas izpildītu on_click metodi.

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)

Definējiet metodi, on_click. Pārbaudiet, vai progresa josla nav atspējota, un aprēķina jauno vērtību, pamatojoties uz klikšķa pozīciju. Attiecīgi atjauniniet progresa joslas vērtību.

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

Izveidojiet eksemplāru MediaPlayerApp klasē un zvaniet uz update_video_progress metodi. The mainloop() funkcija liek Python palaist Tkinter notikumu cilpu un klausīties notikumus, līdz aizverat logu.

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

Palaižot programmu, tiek parādīts video multivides atskaņotājs. Tas satur Atlasiet Fails pogu, laika etiķetes, pogas video atskaņošanas vadīšanai un video progresa joslu.

Izvēloties videoklipu, tas tiks atskaņots automātiski no sākuma, atjauninot sākuma laiku un laika iezīmju ilgumu.

Sitot uz Pauze pogu, videoklips tiek apturēts un mainās uz Turpināt pogu. Noklikšķinot uz Ātri uz priekšu pogu, videoklips tiek izlaists par 10 sekundēm uz priekšu.

Līdzīgi, uzsitot uz Attīt atpakaļ pogu, tas pagriežas par 10 sekundēm atpakaļ. Nospiežot pogu Stop pogu, video atskaņošana tiek apturēta. Varat vilkt vai noklikšķināt uz jebkura norises joslas apgabala, lai pārietu uz jebkuru videoklipa daļu, un laika etiķete parāda pagājušo laiku.

Varat uzlabot šo video multivides atskaņotāju, pievienojot iespēju ielādēt un parādīt subtitrus. Varat arī apsvērt tādas iespējas kā malu attiecības maiņa, skaļuma regulēšana un videoklipa daļas cilpa.

Lai ieviestu šīs funkcijas, varat izpētīt Pygame moduli. Pygame ir daudzpusīga, viegli lietojama un labi integrējas ar Tkinter. Bibliotēka ļauj pielāgot, tai ir interaktīvas funkcijas, un tā var darboties jebkurā platformā.