Video flipping is a technique for creating a mirror effect of an original video footage. One of the common uses of video flipping is to make text photographed backward (e.g., in a mirror, through glass, or using a reverse-facing camera) to face the right way. You can also use video flipping to add creative effects to your video clips, for example, to invert gravity.
In this article, we’ll explore different methods of video flipping in Python, using libraries and tools like OpenCV, FFmpeg, and Cloudinary.
Flipping videos with OpenCV
OpenCV (Open Source Computer Vision) is a Python library that provides methods for image and video processing, including reading video data, accessing video properties, and performing frame operations.
Here’s the video we will be using for this article: https://res.cloudinary.com/demo/video/upload/dog.mp4.
If you haven’t installed OpenCV yet, you can install it with the command below:
pip install opencv-python
Next, create a main.py
file and add the following code to it:
import cv2 # Open the video file video_input = cv2.VideoCapture('dog.mp4') # Get video properties including width, height, and frames per second (FPS) fps = video_input.get(cv2.CAP_PROP_FPS) frame_width = int(video_input.get(cv2.CAP_PROP_FRAME_WIDTH)) frame_height = int(video_input.get(cv2.CAP_PROP_FRAME_HEIGHT)) # Define the codec and create VideoWriter object fourcc = cv2.VideoWriter_fourcc(*'mp4v') output_video = cv2.VideoWriter('flipped-video.mp4', fourcc, fps, (frame_width, frame_height)) # A loop to read frames from the input video and flip each frame one by one while video_input.isOpened(): ret, frame = video_input.read() if not ret: break flipped_frame = cv2.flip(frame, 0) # Use '0' for vertical flipping and '1' for horizontal flipping and '-1' for both. output_video.write(flipped_frame) # After the loop ends, release the video capture and writer objects and close all windows video_input.release() output_video.release() cv2.destroyAllWindows()
Below is the flipped video output:
If you noticed, the audio in the original video doesn’t play in the flipped video. This is because OpenCV doesn’t handle audio streams by default. To fix this, we can use alternatives such as FFmpeg or movie.py to flip the video while preserving the audio output.
Flipping Videos with FFmpeg
FFmpeg is a popular and powerful multimedia framework that provides command-line utilities for processing audio and video files. It offers extensive capabilities for video manipulation, including flipping operations. One advantage of using FFmpeg over OpenCV is that the audio is preserved when flipping a video with the former.
You can download it from the official website here if you don’t already have it installed.
To flip a video vertically or horizontally using FFmpeg, we can use the vflip
or hflip
filters, respectively.
Here’s the command to flip the example video from before vertically:
ffmpeg -i dog.mp4 -vf "vflip" flipped-video-ffmpeg.mp4
Here’s the output of the command:
Flipping Videos with Cloudinary
Video flipping and rotation are some of the features available on Cloudinary. Flipping videos with Cloudinary is pretty straightforward. Unlike the other Python libraries, you can rotate and flip your videos to any angle with Cloudinary. What’s more, the audio in your video is preserved, and you can even add other transformations, such as overlays, to your videos before flipping them.
In the steps below, we’ll show you how to use Cloudinary to flip videos in a Python application.
Step 1 – Setting up the Project
To get started, create a new directory where you’d like to have the project and run the command below in the terminal to create a virtual environment and activate it:
python3 -m venv env source env/bin/activate
Step 2 – Install Necessary Packages
Now, let’s install the package dependencies we need to build the application.
Run the command below to install the packages with pip:
python3 -m pip install fastapi python-multipart cloudinary pydantic-settings python-dotenv uvicorn[standard]
ul>
- FastAPI: A Python framework for creating web servers and APIs.
- python-multipart: A Python library for handling multipart/form-data POST requests.
- python-dotenv: A Python library for managing environment variables.
- pydantic-settings: A Python library managing application settings and configurations using Pydantic models.
- Cloudinary: A cloud-based service that provides image and video management solutions. It offers features like image upload, storage, manipulation, optimization, and delivery.
- Uvicorn: An ASGI web server implementation for creating web servers in Python.
-
Step 3 – Create a Server
After the installation is complete, create a file named
main.py
in the root of the project and add the following code to it to create a server:from fastapi import FastAPI from fastapi import FastAPI, File, UploadFile from pydantic_settings import BaseSettings import cloudinary class Settings(BaseSettings): CLOUDINARY_CLOUD_NAME: str CLOUDINARY_API_KEY: int CLOUDINARY_API_SECRET: str class Config: env_file = ".env" settings = Settings() config = cloudinary.config(cloud_name = settings.CLOUDINARY_CLOUD_NAME, api_key = settings.CLOUDINARY_API_KEY, api_secret = settings.CLOUDINARY_API_SECRET) import cloudinary.uploader import cloudinary.api app = FastAPI() @app.get("/") async def root(): return {"message": "Hello, World!"}
Step 4 – Add Environment Variables
Before we start the server, create a
.env
file in the root directory and add your Cloudinary credentials to it as follows:CLOUDINARY_API_KEY = <YOUR_CLPOUDINARY_API_KEY>CLOUDINARY_CLOUD_NAME = <YOUR_CLOUDINARY_CLOUD_NAME>CLOUDINARY_API_SECRET = <YOUR_CLOUDINARY_API_SECRET>
You can get your credentials by logging in to your Cloudinary dashboard and copying your API key, Cloud name, and API secret
Next, run the command below in the terminal to start up the server:
uvicorn main:app --reload
Next, navigate to
http://127.0.0.1:8000
in your browser, and you should see the following JSON response:{"message": "Hello, World!"}
Step 5 – Flipping the video programmatically
Modify the entire content of
main.py
to the following:from fastapi import FastAPI, File, UploadFile from pydantic_settings import BaseSettings import cloudinary import os class Settings(BaseSettings): CLOUDINARY_CLOUD_NAME: str CLOUDINARY_API_KEY: int CLOUDINARY_API_SECRET: str class Config: env_file = ".env" settings = Settings() config = cloudinary.config(cloud_name = settings.CLOUDINARY_CLOUD_NAME, api_key = settings.CLOUDINARY_API_KEY, api_secret = settings.CLOUDINARY_API_SECRET) import cloudinary.uploader import cloudinary.api app = FastAPI() async def cloudinary_upload(file): # Upload the video to Cloudinary and flip it flipped_video = cloudinary.uploader.upload(file, angle='vflip', resource_type="video") # Use 'vflip' for vertical fliping and 'hflip' for horizontal flipping return flipped_video @app.get("/") async def root(): return {"message": "Hello, World!"} @app.post("/upload") async def create_video(video: UploadFile = File(...)): # Create a directory called "videos" if it doesn't exist. os.makedirs("videos", exist_ok=True) # Save the uploaded video to disk file_location = f"videos/{video.filename}" with open(file_location, "wb+") as file_object: file_object.write(video.file.read()) result = await cloudinary_upload(file_location) # Extract the secure URL of the flipped video from the result returned by Cloudinary video_file = result["secure_url"] return f"The flipped video can be found here: {video_file}"
Here’s what the code above does.
- In the first five lines, we import the required modules and packages to build the application.
- Next, we define a
Settings
class that inherits fromBaseSettings
. Inside the class, we define the Cloudinary credential variable types, and theConfig
nested class specifies that these variables should be loaded from a.env
file. - Next, we define an asynchronous function
cloudinary_upload
that takes afile
argument. It uses thecloudinary.uploader.upload
method to upload the file (in this case, a video) to Cloudinary. - The
angle='vflip'
parameter tells Cloudinary to flip the video vertically, and theresource_type="video"
specifies that the file we’re uploading is a video. - We also define a route handler for the
/upload
endpoint that accepts the uploaded video and uses thecloudinary_upload
function to flip the video.
Step 6 – Trying it out
Now, let’s see the result of our code so far. If you use VS Code, download the Postman extension to make API calls to our application.
When we upload a video to the
/upload
endpoint in Postman, we get the URL to the flipped video as shown below:Flipped video URL: https://res.cloudinary.com/cloudinarymich/video/upload/v1712485336/r6wnzr0bmlpytecohzsu.mp4
Wrapping Up
Congratulations if you made it this far! In this article, we explore various methods of flipping videos in Python. We walk through how to use Python libraries such as OpenCV and command-line tools like FFmpeg. Additionally, we demonstrated how to achieve the same objective using Cloudinary and highlighted its efficiency and simplicity compared to the other methods.
We hope this article will provide you with a solid foundation in video flipping techniques. Happy coding!
Optimize, transform, and manage your media assets like a pro with Cloudinary. Sign up for free today!