2023-04-09：使用 Golang 重写的 ffmpeg 示例encode_video.c，实现视频编码并将编码后

2023-04-09：使用 Golang 重写的 ffmpeg 示例encode_video.c，实现视频编码并将编码后的数据封装为容器格式，最终写入输出文件。

答案2023-04-09：

本文介绍的是使用 Golang 重写的 ffmpeg 示例代码 encode_video.c，该示例代码实现了将视频编码并封装为容器格式，并最终写入输出文件的功能。

这个示例程序的主要流程如下：

解析命令行参数，获取输出文件名和所用的编码器名称。
根据编码器名称查找对应的编码器。
分配和初始化一个编码器上下文结构体（AVCodecContext）。
设置编码器参数：比特率、分辨率、帧率等。
打开编码器。
创建一个 AVFrame 结构体并为其分配空间，用于存储待编码的视频帧数据。
创建一个 AVPacket 结构体，用于存储编码后的数据。
循环编码每一帧视频数据：

a. 将待编码的视频数据填充到 AVFrame 结构体中。

b. 发送视频帧到编码器，得到编码后的数据包。

c. 将编码后的数据包写入输出文件。
关闭编码器，并在需要时向输出文件写入结束标记。
释放资源。

在该示例代码中，默认使用 H.264 编码器和 YUV420P 像素格式。在设置编码器参数时，需要指定视频的比特率、分辨率和帧率等参数。通过创建 AVFrame 结构体并为其分配空间，可以将待编码的视频数据填入其中，并发送给编码器进行编码。编码后的数据通过 AVPacket 结构体进行封装，最终写入输出文件。

需要注意的是，在实际应用中，还需要根据具体需求进行相应的配置和优化，例如设置 GOP 大小、调整编码速度等参数，以提高视频质量和编码效率。同时，还需要考虑容器格式的选择，以满足不同场景下的需求。

总之，这个示例代码提供了一个简单的视频编码和封装的实现，为使用 ffmpeg 进行视频处理和转码提供了参考和思路。

代码见moonfdd/ffmpeg-go库。

命令如下：

go run ./examples/internalexamples/encode_video/main.go ./out/encode_video.mp4 mpeg2video

./lib/ffplay  ./out/encode_video.mp4

go代码如下：

package main

import (
    "fmt"
    "os"
    "unsafe"

    "github.com/moonfdd/ffmpeg-go/ffcommon"
    "github.com/moonfdd/ffmpeg-go/libavcodec"
    "github.com/moonfdd/ffmpeg-go/libavutil"
)

func main0() (ret ffcommon.FInt) {
    var filename, codec_name string
    var codec *libavcodec.AVCodec
    var c *libavcodec.AVCodecContext
    var i, x, y ffcommon.FInt
    var f *os.File
    var frame *libavutil.AVFrame
    var pkt *libavcodec.AVPacket
    endcode := [...]ffcommon.FUint8T{0, 0, 1, 0xb7}

    if len(os.Args) <= 2 {
        fmt.Printf("Usage: %s <output file> <codec name>\n", os.Args[0])
        return 0
    }
    filename = os.Args[1]
    codec_name = os.Args[2]

    /* find the mpeg1video encoder */
    codec = libavcodec.AvcodecFindEncoderByName(codec_name)
    if codec == nil {
        fmt.Printf("Codec '%s' not found\n", codec_name)
        os.Exit(1)
    }

    c = codec.AvcodecAllocContext3()
    if c == nil {
        fmt.Printf("Could not allocate video codec context\n")
        os.Exit(1)
    }

    pkt = libavcodec.AvPacketAlloc()
    if pkt == nil {
        os.Exit(1)
    }

    /* put sample parameters */
    c.BitRate = 400000
    /* resolution must be a multiple of two */
    c.Width = 352
    c.Height = 288
    /* frames per second */
    c.TimeBase = libavutil.AVRational{1, 25}
    c.Framerate = libavutil.AVRational{25, 1}

    /* emit one intra frame every ten frames
     * check frame pict_type before passing frame
     * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
     * then gop_size is ignored and the output of encoder
     * will always be I frame irrespective to gop_size
     */
    c.GopSize = 10
    c.MaxBFrames = 1
    c.PixFmt = libavutil.AV_PIX_FMT_YUV420P

    if codec.Id == libavcodec.AV_CODEC_ID_H264 {
        libavutil.AvOptSet(c.PrivData, "preset", "slow", 0)
    }

    /* open it */
    if c.AvcodecOpen2(codec, nil) < 0 {
        fmt.Printf("Could not open codec\n")
        os.Exit(1)
    }

    f, _ = os.Create(filename)
    if f == nil {
        fmt.Printf("Could not open %s\n", filename)
        os.Exit(1)
    }

    frame = libavutil.AvFrameAlloc()
    if frame == nil {
        fmt.Printf("Could not allocate video frame\n")
        os.Exit(1)
    }
    frame.Format = c.PixFmt
    frame.Width = c.Width
    frame.Height = c.Height

    ret = frame.AvFrameGetBuffer(0)
    if ret < 0 {
        fmt.Printf("Could not allocate the video frame data\n")
        os.Exit(1)
    }
    /* encode 1 second of video */
    for i = 0; i < 25; i++ {
        // fflush(stdout);

        /* make sure the frame data is writable */
        ret = frame.AvFrameMakeWritable()
        if ret < 0 {
            os.Exit(1)
        }

        /* prepare a dummy image */
        /* Y */
        for y = 0; y < c.Height; y++ {
            for x = 0; x < c.Width; x++ {
                *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(frame.Data[0])) + uintptr(y*frame.Linesize[0]+x))) = byte((x + y + i*3) % 256)
            }
        }

        /* Cb and Cr */
        for y = 0; y < c.Height/2; y++ {
            for x = 0; x < c.Width/2; x++ {
                *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(frame.Data[1])) + uintptr(y*frame.Linesize[1]+x))) = byte((128 + y + i*2) % 256)
                *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(frame.Data[2])) + uintptr(y*frame.Linesize[2]+x))) = byte((64 + x + i*5) % 256)
            }
        }

        frame.Pts = int64(i)

        /* encode the image */
        encode(c, frame, pkt, f)
    }

    /* flush the encoder */
    encode(c, nil, pkt, f)

    /* add sequence end code to have a real MPEG file */
    if codec.Id == libavcodec.AV_CODEC_ID_MPEG1VIDEO || codec.Id == libavcodec.AV_CODEC_ID_MPEG2VIDEO {
        f.Write(endcode[:])
    }
    f.Close()

    libavutil.AvFrameFree(&frame)
    libavcodec.AvPacketFree(&pkt)
    libavcodec.AvcodecFreeContext(&c)

    return 0
}

func encode(enc_ctx *libavcodec.AVCodecContext, frame *libavutil.AVFrame, pkt *libavcodec.AVPacket, output *os.File) {
    var ret ffcommon.FInt

    /* send the frame to the encoder */
    if frame != nil {
        fmt.Printf("Send frame %3d\n", frame.Pts)
    }

    ret = enc_ctx.AvcodecSendFrame(frame)
    if ret < 0 {
        fmt.Printf("rror sending a frame for encoding\n")
        os.Exit(1)
    }

    for ret >= 0 {
        ret = enc_ctx.AvcodecReceivePacket(pkt)
        if ret == -libavutil.EAGAIN || ret == libavutil.AVERROR_EOF {
            return
        } else if ret < 0 {
            fmt.Printf("Error during encoding\n")
            os.Exit(1)
        }
        fmt.Printf("Write packet %3d (size=%5d)\n", pkt.Pts, pkt.Size)
        output.Write(ffcommon.ByteSliceFromByteP(pkt.Data, int(pkt.Size)))
        pkt.AvPacketUnref()
    }
}

func main() {
    os.Setenv("Path", os.Getenv("Path")+";./lib")
    ffcommon.SetAvutilPath("./lib/avutil-56.dll")
    ffcommon.SetAvcodecPath("./lib/avcodec-58.dll")
    ffcommon.SetAvdevicePath("./lib/avdevice-58.dll")
    ffcommon.SetAvfilterPath("./lib/avfilter-56.dll")
    ffcommon.SetAvformatPath("./lib/avformat-58.dll")
    ffcommon.SetAvpostprocPath("./lib/postproc-55.dll")
    ffcommon.SetAvswresamplePath("./lib/swresample-3.dll")
    ffcommon.SetAvswscalePath("./lib/swscale-5.dll")

    genDir := "./out"
    _, err := os.Stat(genDir)
    if err != nil {
        if os.IsNotExist(err) {
            os.Mkdir(genDir, 0777) //  Everyone can read write and execute
        }
    }

    main0()
}