Python Video Player: 3 Free Options and a Quick Tutorial

Python is a high-level, interpreted programming language known for its ease of learning and flexibility. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming.

Python comes with an extensive standard library that offers a range of functionalities, eliminating the need for external libraries for basic programming tasks. In addition, the Python ecosystem offers a wide range of libraries.

In this article, we’ll review three open source Python libraries that make it possible to play video within Python web applications, and show a tutorial for implementing a video player with one of them.

This is part of a series of articles about video optimization

In this article:

• 3 Modules and Libraries to Build a Video Player in Python
  • Python-vlc
  • TkVideoPlayer
  • cv2
• Adding a Video Player in Python with the python-vlc Module
  • Installing python-vlc
  • Fixing Errors During python-vlc Installation
  • Embedding python-vlc into a Python Application
  • Advanced python-vlc Implementation

3 Modules and Libraries to Build a Video Player in Python

Python-vlc

Python-vlc is a module that allows developers to leverage the VLC media player’s capabilities within Python applications. It acts as a binding to the VLC library, enabling control over media playback, including video files and streams. This module is useful for building a video player in Python as it handles the decoding and rendering of video content.

With python-vlc, developers can implement advanced video playback features, such as adjusting volume, seeking specific positions, and changing playback speed. The extensive features of the VLC media player make it an appropriate choice for developing sophisticated video playback applications in Python.

TkVideoPlayer

TkVideoPlayer is a Python library designed to integrate video playback capabilities into Tkinter applications. It extends the functionality of Tkinter and python-vlc, providing a higher level of abstraction for embedding videos in GUIs. It simplifies the process of creating a video player, allowing developers to focus on the application logic instead of the intricacies of video playback.

Utilizing TkVideoplayer in a project involves minimal setup, with straightforward methods to control the video, such as play, pause, and stop. Its compatibility with Tkinter makes it suitable for applications developed with Python’s standard GUI toolkit, ensuring a consistent user experience.

cv2

The cv2 library, part of OpenCV (Open Source Computer Vision Library), is a versatile library primarily known for its extensive capabilities in image and video processing. While it’s widely recognized for its applications in computer vision and machine learning, cv2 also offers functionalities for video playback. This makes it a useful tool for developers looking to incorporate video content into their Python applications, especially in contexts where video analysis or processing is required.

Using cv2 for video playback involves leveraging its high-level GUI features along with its video capture capabilities. Developers can load, display, and manipulate video frames in real-time, making cv2 an excellent choice for applications that require more than just basic playback functionality. For instance, it allows for frame-by-frame analysis, real-time video processing, and applying filters or transformations to video streams.

Adding a Video Player in Python with the python-vlc Module

Installing python-vlc

To install the python-vlc module, you’ll need to use pip, Python’s package installer. Follow the syntax below to install it:

pip install python-vlc

It’s important to note that the VLC media player must be already installed on your system to use the python-vlc module effectively. After the installation process is complete, you can verify the successful installation by importing the vlc module into a Python script with the following syntax:

import vlc

Save and run your Python file. If no errors occur, the python-vlc module has been installed correctly. If you encounter any issues, consult the following section.

Fixing Errors During python-vlc Installation

If you face errors while importing the python-vlc module, it might be due to the system not recognizing the libvlc.dll file. This can happen if the file path is not included in the system’s PATH variable. To resolve this, add the path to the libvlc.dll file, which is located in the VLC installation directory, to your system’s PATH variable.

In case you’re using a 32-bit version of the VLC media player with a 64-bit version of Python, you will face compatibility issues. Ensure that you install the 64-bit version of the VLC media player if you’re using the 64-bit version of Python.

To address the issue of the system not recognizing the libvlc.dll file, you can import the os module before importing the vlc module and add the VLC directory to the DLL search path as shown below.

On Windows use this command: os.add_dll_directory(r'C:\Program Files\VideoLAN\VLC')

On Ubuntu, ensure vlc is installed via apt installer instead of snap.

Embedding python-vlc into a Python Application

To embed python-vlc into your Python application, you can start with a simple video playback example. First, import the vlc module, and then create a MediaPlayer object with the video file you want to play:

import vlc

my_media = vlc.MediaPlayer("video.mp4")
my_media.play()
While True:
  pass

In this example, a MediaPlayer object is created for the video file “video.mp4”, and the play() method is used to start playback.

You can download the sample video here.

Advanced python-vlc Implementation

For a more advanced usage scenario, such as getting the duration of a video file, you can use the following approach:

import time, vlc

def vlc_video(src):
    vlc_obj = vlc.Instance()
    vlcplayer = vlc_obj.media_player_new()
    vlcmedia = vlc_obj.media_new(src)
    vlcplayer.set_media(vlcmedia)
    vlcplayer.play()
    time.sleep(0.5)

vlc_video("video.mp4")

Let’s review the code step by step.

Importing required modules

• time: This module is imported to use the sleep function, which pauses the execution of the program for a specified amount of time. This is necessary to allow the video player some time to load the video file and retrieve its properties, such as duration.
• vlc: This module is the python-vlc package that enables Python scripts to control VLC media player functionalities.

Defining the video playback function

def vlc_video(src):

This function is defined to encapsulate the process of playing a video and obtaining its duration. It takes a single argument, src, which is the path to the video file that you want to play.

Creating VLC objects

vlc_obj = vlc.Instance()

A vlc.Instance object is created, representing an instance of the VLC media player. This object serves as the entry point to using the VLC functionalities through python-vlc.

vlcplayer = vlc_obj.media_player_new()

The media_player_new() method creates a new MediaPlayer object associated with the VLC instance. This object is used to control playback.

vlcmedia = vlc_obj.media_new(src)

The media_new(src) method creates a new Media object for the specified video source src. This media object holds the media resource to be played.

Configuring the media player

vlcplayer.set_media(vlcmedia)

The set_media() method of the MediaPlayer object is used to assign the media object created earlier to the player. This effectively loads the video file into the media player for playback.

Starting playback

vlcplayer.play()

The play() method is called on the MediaPlayer object to start playing the loaded video file.

Pausing execution to load the video

time.sleep(0.5)

The sleep() function pauses the execution of the script for 0.5 seconds. This delay gives the media player sufficient time to begin playback.

Using the function in your application

To use this function, you would call vlc_video("video.mp4"), replacing “video.mp4” with the path to the video file you want to play.

Managing and Optimizing Videos with Cloudinary

Cloudinary offers a powerful solution to optimize and serve video files efficiently, ensuring smooth playback across various devices and platforms. By leveraging Cloudinary’s comprehensive video management capabilities, you can significantly enhance video performance and streamline your workflow.

Cloudinary’s video optimization starts with the ability to automatically adjust the video format, resolution, and bitrate. This ensures that videos are delivered in the highest quality possible while minimizing load times and bandwidth usage. Here’s how you can use Cloudinary to optimize and serve videos for any Python video player:

First, you need to upload your video to Cloudinary. This can be done using Cloudinary’s Python SDK:

import cloudinary
import cloudinary.uploader

cloudinary.config(
  cloud_name='your_cloud_name',
  api_key='your_api_key',
  api_secret='your_api_secret'
)

response = cloudinary.uploader.upload_large("path/to/your/video.mp4", resource_type = "video")
video_url = response['url']

Once your video is uploaded, Cloudinary provides dynamic URLs that can be used to apply various transformations on-the-fly. For example, to optimize the video for web playback, you can use the following URL transformation:

optimized_url = cloudinary.CloudinaryVideo("your_video_public_id").build_url(
    transformation=[
        {'width': 'auto', 'dpr': 'auto', 'crop': 'limit'},
        {'quality': 'auto'}
    ]
)

This URL ensures that the video is dynamically adjusted for optimal performance and quality based on the viewer’s device and network conditions.

Integrating this optimized video into a Python video player is straightforward. Here’s an example using the vlc library:

import vlc

# Create a VLC instance
instance = vlc.Instance()

# Create a player object
player = instance.media_player_new()

# Set the media to the optimized URL
media = instance.media_new(optimized_url)
player.set_media(media)

# Play the video
player.play()

# Keep the video player running
while True:
pass

By using Cloudinary’s dynamic URL transformations, you can ensure that your videos are always optimized for performance and quality, regardless of the playback environment. This not only enhances the user experience but also reduces the complexity and time required to manage video content.

Cloudinary’s powerful tools for video management and optimization provide a robust solution for developers looking to integrate high-performance video playback into their Python applications. By following these steps, you can efficiently manage and deliver video content, ensuring optimal performance across all devices and platforms.