Python takes you to re create short videos

Keywords: Database MySQL

Welcome to pay attention

Python wechat ordering applet course video

Python practical quantitative transaction financial management system

1. Target scenario

Tiktok or Kwai Fu, and so on, once a video is on fire, many UP owners will scramble to imitate or shoot or edit, then upload to the platform, which will bring good traffic in the end.

For general short videos, you can quickly create a new video through a series of operations such as clipping, special effects transition, adding mixed layers and subtitles. These operations can be realized by Python.

The purpose of this article is to take you to use Python to realize the secondary creation of short video.

2 write code

To realize the secondary creation of short video, the following 7 steps are generally required: obtaining the original video attribute data, video frame processing, video region clipping, making background picture video, synthesizing multiple videos, generating description subtitles, adding subtitles and background music.

Step 1: obtain the original video attribute data

First, using the crawler to obtain the original video without watermark, Github has many ready-made wheels.

Then, instantiate the video clip VideoFileClip to obtain the basic attributes of the video, such as width, height, frame rate and so on.

self.video_raw_clip = VideoFileClip(self.video_raw_path)

# Video width and height
self.video_width, self.video_height = self.video_raw_clip.w, self.video_raw_clip.h

self.fps = self.video_raw_clip.fps

Then, separate the audio file, clip the original video, remove the public picture clips added by the video platform, and regenerate a video file. For example, tiktok will append 4s public video.

 # Separate audio =, self.video_raw_clip.duration - 4)

# Clip tail video material
temp_video_clip = self.video_raw_clip.subclip(0, self.video_raw_clip.duration - 4)

# Generate a new video and save it locally

video_path = './source/temp_source_video.mp4'

temp_video_clip.write_videofile(video_path, codec='libx264',

Step 2: video frame processing

To clip a video, first know the starting coordinate point and clipping range.

Use the ffmpeg command to get the picture frame at a certain time point of the video, and save the picture file locally.

def time_to_hms(seconds_time):
    Time turns to minutes and seconds
    :param seconds_time: Seconds
    m, s = divmod(seconds_time, 60)
    h, m = divmod(m, 60)
    return "%02d:%02d:%02d" % (h, m, s)

def get_frame_from_video(video_name, frame_time, img_path):
    Get the frame picture of the video at a certain time and save it locally
    get_frame_from_video('./../source/source.mp4', 1, './22.jpg')
    :param video_name: Video path
    :param frame_time: Time position of intercepted frame(s)
    :param img_path:Generate the full path of the picture
    # Second to hour, minute, second
    time_pre = time_to_hms(frame_time)

    os.system('ffmpeg -ss %s -i %s -frames:v 1 %s' % (time_pre, video_name, img_path))

Then use the ruler and selection tool of PS to cooperate with the information dialog box to obtain the starting coordinates and cutting width and height data to be cut.

# Clipping start coordinates
position1 = (0, 328)

# 630 is the height to be cropped
position2 = (self.video_width, 630)

Step 3: video region clipping

The clip () method provided by moviepy can easily cut the video area.

It should be noted that the coordinate value passed in by the crop() method must be an even number, otherwise region clipping will fail.

def video_crop(self, position1, position2, croped_video_path):
     Video clipping

     # The coordinates of clipping, including the x-axis and Y-axis of the upper left corner; X-axis and y-axis in the lower right corner
     clip2 = fx.all.crop(self.video_clip, x1=position1[0], y1=position1[1], x2=position2[0], y2=position2[1])

     # Save file

     # duration
     self.time = clip2.duration

     return clip2

Step 4: make background pictures and videos

In order to ensure the appearance on the mobile phone, you need to mix and add a vertical screen background picture layer or video.

I wrote an article before Making GIF video with pictures The implementation method here is similar, that is, a picture frame is written to the video file circularly.

def one_pic_to_video(image_path, output_video_path, fps, time):
    A picture composite video
    one_pic_to_video('./../source/1.jpeg', './../source/output.mp4', 25, 10)
    :param path: Picture file path
    :param output_video_path:Path to composite video
    :param fps:Frame rate
    :param time:duration

    image_clip = ImageClip(image_path)
    img_width, img_height = image_clip.w, image_clip.h

    # Total frames
    frame_num = (int)(fps * time)

    img_size = (int(img_width), int(img_height))

    fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')

    video = cv2.VideoWriter(output_video_path, fourcc, fps, img_size)

    for index in range(frame_num):
        frame = cv2.imread(image_path)
        # Zoom directly to the specified size
        frame_suitable = cv2.resize(frame, (img_size[0], img_size[1]), interpolation=cv2.INTER_CUBIC)

        # Write the picture into the video
        # How many repeated writes

    # Release resources

    return VideoFileClip(output_video_path)

It should be noted that the frame rate and duration of the composite picture video should be consistent with the previous video.

Step 5, synthesize two videos

The above two steps have completed the region clipping of the original video and the production of the background video. Now the two videos can be synthesized at one time.

Because the width of the two videos is likely to be different, in order to ensure the unity of the synthetic video, the length and width of one video need to be scaled in equal proportion to ensure the consistency of the width of the two videos.

def synthetic_video(video1_clip, video2_clip2):
    Synthesize two videos, and the width and height of the generated video shall be subject to the first video
    :param video1_clip:
    :param video2_clip2:
    # Finally, the width and height of the video are generated
    width, height = video1_clip.w, video1_clip.h

    # Actual width and height of the second video
    video_width, video_height = video2_clip2.w, video2_clip2.h

    # Zoom the second video
    video_clip1 = video2_clip2.resize((width, width * video_height / video_width))

    # Path to composite video
    synthetic_video_clip = CompositeVideoClip([video1_clip, video_clip1.set_pos("center")])


    return synthetic_video_clip

Step 6: generate caption

A description information can be generated by TextClip. The text information attributes including font name, size, color, position, start time and duration can be set together.

# Caption description
TextClip(text_content, font='./fonts/STHeiti Medium.ttc',
                    fontsize=font_params.get('size'), kerning=font_params.get('kerning'),
                    color=font_params.get('color')).set_position(("center", 150)).set_duration(duration)

The default font may cause Chinese subtitles not to be displayed, so it is best to specify a specific Chinese font.

Step 7, add subtitles and background music

Using CompositeVideoClip, you can embed caption clips into video clips, and then use set_audio adds an audio track to the audio file for the video.

Finally, write to the file, that is, a new short video can be generated.

# Add subtitles
video_with_text_clip = CompositeVideoClip([synthetic_video_clip, desc_text_clip.set_start(0)])

# Set background music
# Delete all temporary files

3 results and conclusions

Through the above 7 steps, you can complete the secondary creation of most short videos.

Full script Download:

Posted by falian on Mon, 22 Nov 2021 04:30:55 -0800