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库。
命令如下：
代码语言：shell复制go run ./examples/internalexamples/encode_video/main.go ./out/encode_video.mp4 mpeg2video
./lib/ffplay ./out/encode_video.mp4go代码如下：
代码语言：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 foundn", codec_name)
os.Exit(1)
}
c = codec.AvcodecAllocContext3()
if c == nil {
fmt.Printf("Could not allocate video codec contextn")
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 codecn")
os.Exit(1)
}
f, _ = os.Create(filename)
if f == nil {
fmt.Printf("Could not open %sn", filename)
os.Exit(1)
}
frame = libavutil.AvFrameAlloc()
if frame == nil {
fmt.Printf("Could not allocate video framen")
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 datan")
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 =n", frame.Pts)
}
ret = enc_ctx.AvcodecSendFrame(frame)
if ret < 0 {
fmt.Printf("rror sending a frame for encodingn")
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 encodingn")
os.Exit(1)
}
fmt.Printf("Write packet = (size=])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()
}
