The implementation of audio and video processing of Golang integrated FFmpeg

Overview

FFmpeg is an open source audio and video processing tool, widely used in video conversion, screenshots, processing and streaming media push. In Go language project, FFmpeg can implement related operations by calling system commands. This article will introduce how to integrate and use FFmpeg in Go, especially for the application of intercepting keyframes and generating images in video processing.

Steps to use

• Install FFmpegFirst make sure FFmpeg is installed and configured in the system's environment variables. You can check whether FFmpeg is installed by running the following command:

  ffmpeg -version
  

  If it is not installed, you can choose the corresponding installation method according to the operating system.

• Install Go language dependency libraryIn Go language, the call to FFmpeg is usually executedTo implement it, so you only need to use the Go standard libraryos/execYou can execute the FFmpeg command. No additional third-party libraries are required.

• Call the FFmpeg commanduseto execute the FFmpeg command and capture the command execution result.

FFmpeg common instructions

Here are some commonly used command line parameters of FFmpeg that can help you better utilize FFmpeg in your Go project:

• Video transcodingConvert video formats (for example: convert MP4 to AVI):

  ffmpeg -i input.mp4 
  

• Take a video screenshotKeyframes of the video:

  ffmpeg -i input.mp4 -vf "select='eq(pict_type,I)'" -vsync vfr output_%
  

• Set the interval time of screenshotsImages are captured every certain time:

  ffmpeg -i input.mp4 -vf "fps=1/5" output_%
  

• Extract audio from videoExtract audio from video and save it to MP3 format:

  ffmpeg -i input.mp4 -vn output.mp3
  

Keyframe interception logic code implementation

Next, we will explain in detail a sample code based on Go and FFmpeg. This sample code will intercept keyframes from the video at a certain time and return the corresponding picture.

Code implementation

The following is the Go language code that implements "Seave video keyframes according to specified time intervals".

// GetMp4ImagesIntervalSeconds
// @Description: Specify the duration to capture the image// @param videoBase64 base64 video// @param intervalSeconds Number of seconds between screenshots// @return imageSlice Screenshot and slicefunc GetMp4ImagesIntervalSeconds(videoBase64 string, intervalSeconds int) (imageSlice []ImageInfo, err error) {
    // Decode base64 string    videoData, err := (videoBase64)
    if err != nil {
        ("GetMp4ImagesIntervalSeconds DecodeString err：%v", ())
        return nil, err
    }

    //Judge whether the directory exists    if _, err = ("./temp"); (err) {
        err = ("./temp", 0755)
        if err != nil {
            ("GetMp4ImagesIntervalSeconds  err：%v", ())
            return nil, err
        }
    }

    // Create temporary video files    tmpVideoFile, err := ("./temp", "tempvideo_*.mp4")
    if err != nil {
        ("GetMp4ImagesIntervalSeconds  err：%v", ())
        return nil, err
    }
    defer (())
    defer ()

    // Write video data to temporary files    _, err = (videoData)
    if err != nil {
        ("GetMp4ImagesIntervalSeconds  err：%v", ())
        return nil, err
    }

    // Create a temporary picture directory    tempImageDir, err := ("./temp", "tempimage_")
    if err != nil {
        ("GetMp4ImagesIntervalSeconds  err：%v", ())
        return nil, err
    }
    defer (tempImageDir)

    // Use ffmpeg to intercept keyframes and put the image into the specified directory    /*
         -i (): Specifies the name of the input file as the temporary video file.
         -vf select='eq(pict_type,I)',fps=1/intervalSeconds: Use the select filter to select the keyframe and specify the frame rate to be 1/intervalSeconds, that is, one frame is taken every intervalSeconds seconds.
         (tempImageDir, "temp_%"): Specifies the format of the output image file name. temp_% means that the format of the output file name is temp_001.jpg, temp_002.jpg, etc. %03d will be replaced with an incremental number sequence.  Here tempImageDir is a temporary directory for saving images.
     */
    cmd := ("ffmpeg", "-i", (), "-vf", ("select='eq(pict_type,I)',fps=1/%d", intervalSeconds), (tempImageDir, "temp_%"))
    err = ()
    if err != nil {
        ("GetMp4ImagesIntervalSeconds  err：%v", ())
        return nil, err
    }

    // traverse the temporary image directory and add the image file name to the slice    files, _ := ((tempImageDir, "temp_*.jpg"))
    for _, fileName := range files {
        imageBase64, dhash, err := fileToBase64(fileName)
        if err != nil {
            ("GetMp4ImagesIntervalSeconds fileToBase64(fileName) err：%v", ())
            return nil, err
        }
        imageSlice = append(imageSlice, ImageInfo{
            ImageBase64: imageBase64,
            DHash:       dhash,
        })
        ("dhash：", dhash)
    }
    ("GetMp4ImagesIntervalSeconds success number:%v", len(imageSlice))
    return imageSlice, nil
}

Code description

• Video data processingpassDecode the Base64 data of the video, obtain the binary stream of the video, and write it to a temporary MP4 file.

• Create a temporary directoryCreate two temporary directories: one for storing video files and the other for storing image files that are intercepted from the video.

• Use the FFmpeg command line to intercept video keyframespassCall the FFmpeg command, parameters-vf select='eq(pict_type,I)',fps=1/{intervalSeconds}Indicates that I frame (keyframe) is selected and screenshots are taken at the specified time interval. The image file is saved to the temporary image directory.

• Return to screenshot resultsThe intercepted image is saved in JPG format. The program traverses the image folder and converts each image into a Base64 string, and generatesImageInfoStructure returns.

Summarize

This article describes how to integrate and use FFmpeg for video processing in a Go project, especially by intercepting keyframes of videos through FFmpeg and saving them as images. In this way, it is very convenient to quickly analyze and process videos, which are suitable for scenes such as image recognition, video content analysis, etc. I hope it will be helpful to everyone's project development!

This is the end of this article about the implementation of Golang integrated FFmpeg audio and video processing. For more related Golang FFmpeg audio and video content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!

Latest Comments