脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → Go FFmpeg视频处理

Golang调用FFmpeg实现视频截图,裁剪与水印添加功能

 更新时间：2026年02月10日 09:15:37   作者：冷冷的菜哥  
这篇文章主要为大家详细介绍了Golang如何调用FFmpeg实现视频截图,裁剪与水印添加功能,文中的示例代码讲解详细,感兴趣的小伙伴可以了解下

1.视频处理参数

package request

import (
	"mime/multipart"
)

// VideoSnapshot 视频截图
type VideoSnapshot struct {
	Video  *multipart.FileHeader `form:"video"`  // 视频文件
	Second int64                 `form:"second"` // 截图间隔秒
}

// VideoCut 视频剪辑
type VideoCut struct {
	Video    *multipart.FileHeader `form:"video"`    // 视频文件
	Start    int64                 `form:"start"`    // 开始时间(秒)
	Duration int64                 `form:"duration"` // 截止时间(秒)
}

// VideoWatermark 视频水印
type VideoWatermark struct {
	Video     *multipart.FileHeader `form:"video"`     // 视频文件
	Watermark *multipart.FileHeader `form:"watermark"` // 水印文件，必须是png
}

2.视频处理接口及实现

package service

import (
	"context"
	"ry-go/common/request"

	"github.com/labstack/echo/v4"
)

// VideoProcessService 视频处理接口
type VideoProcessService interface {
	Snapshot(e context.Context, param *request.VideoSnapshot) (string, error)
	Cut(e context.Context, param *request.VideoCut) (string, error)
	Watermark(e context.Context, param *request.VideoWatermark) (string, error)
}
package serviceImpl

import (
	"archive/zip"
	"bytes"
	"context"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"ry-go/common/request"
	"ry-go/utils"
	"strconv"
	"strings"
	"time"

	"github.com/labstack/echo/v4"
	"github.com/rs/zerolog"
)

type VideoProcessServiceImpl struct {
}

func NewVideoProcessServiceImpl() *VideoProcessServiceImpl {
	return &VideoProcessServiceImpl{}
}

// saveUploadedFile 保存上传的文件到临时位置并返回路径
func saveUploadedFile(fileHeader *multipart.FileHeader) (string, error) {
	logger := zerolog.DefaultContextLogger
	src, err := fileHeader.Open()
	if err != nil {
		logger.Error().Err(err).Msg("打开上传文件失败")
		return "", err
	}
	defer src.Close()

	tmpFile, err := os.CreateTemp("", "upload_*"+filepath.Ext(fileHeader.Filename))
	if err != nil {
		logger.Error().Err(err).Msgf("创建临时文件==%v失败", tmpFile)
		return "", err
	}
	defer tmpFile.Close()

	_, err = io.Copy(tmpFile, src)
	if err != nil {
		os.Remove(tmpFile.Name())
		return "", err
	}

	return tmpFile.Name(), nil
}

// getVideoDuration 返回视频时长（秒）
func getVideoDuration(ctx context.Context, videoPath string) (float64, error) {
	cmd := exec.CommandContext(ctx, "ffprobe",
		"-v", "error",
		"-show_entries", "format=duration",
		"-of", "default=noprint_wrappers=1:nokey=1",
		videoPath,
	)

	output, err := cmd.Output()
	if err != nil {
		return 0, fmt.Errorf("ffprobe failed: %w", err)
	}

	durationStr := strings.TrimSpace(string(output))
	if durationStr == "N/A" {
		return 0, fmt.Errorf("video duration is unavailable")
	}

	duration, err := strconv.ParseFloat(durationStr, 64)
	if err != nil {
		return 0, fmt.Errorf("invalid duration: %s", durationStr)
	}

	return duration, nil
}

func getVideoResolution(ctx context.Context, videoPath string) (width, height int, err error) {
	cmd := exec.CommandContext(
		ctx,
		"ffprobe",
		"-v", "error",
		"-select_streams", "v:0",
		"-show_entries", "stream=width,height",
		"-of", "csv=s=,:p=0",
		videoPath,
	)

	out, err := cmd.Output()
	if err != nil {
		return 0, 0, fmt.Errorf("ffprobe failed: %w", err)
	}

	line := strings.TrimSpace(string(out))
	if line == "" {
		return 0, 0, fmt.Errorf("empty ffprobe output")
	}

	parts := strings.Split(line, ",")
	if len(parts) != 2 {
		return 0, 0, fmt.Errorf("invalid resolution format: %s", line)
	}

	width, err = strconv.Atoi(strings.TrimSpace(parts[0]))
	if err != nil {
		return 0, 0, fmt.Errorf("invalid width: %w", err)
	}

	height, err = strconv.Atoi(strings.TrimSpace(parts[1]))
	if err != nil {
		return 0, 0, fmt.Errorf("invalid height: %w", err)
	}

	return width, height, nil
}

// runFfmpeg 执行ffmpeg命令
func runFfmpeg(ctx context.Context, args ...string) error {
	logger := zerolog.DefaultContextLogger
	cmd := exec.CommandContext(ctx, "ffmpeg", args...)
	var stderr bytes.Buffer
	cmd.Stderr = &stderr

	if err := cmd.Run(); err != nil {
		if ctx.Err() != nil {
			return fmt.Errorf("operation cancelled: %w", ctx.Err())
		}
		logger.Error().Err(err).Msg("执行ffmpeg失败")
		return fmt.Errorf("ffmpeg failed: %w; stderr: %s", err, stderr.String())
	}
	return nil
}


func readDirFileCount(dir, suffix string) int64 {
	entries, _ := os.ReadDir(dir)
	count := int64(0)
	for _, e := range entries {
		if strings.HasSuffix(e.Name(), suffix) {
			count++
		}
	}

	return count
}


func zipDir(zipPath, dir string) error {
	zipFile, err := os.Create(zipPath)
	if err != nil {
		return err
	}
	defer zipFile.Close()

	zipWriter := zip.NewWriter(zipFile)
	defer zipWriter.Close()

	return filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			return nil
		}

		relPath, err := filepath.Rel(dir, path)
		if err != nil {
			return err
		}

		fw, err := zipWriter.Create(relPath)
		if err != nil {
			return err
		}

		fs, err := os.Open(path)
		if err != nil {
			return err
		}
		defer fs.Close()

		_, err = io.Copy(fw, fs)
		return err
	})
}

func (s *VideoProcessServiceImpl) Snapshot(ctx context.Context, param *request.VideoSnapshot) (string, error) {
	logger := zerolog.DefaultContextLogger
	if param.Video == nil {
		return "", fmt.Errorf("video file is required")
	}
	if param.Second < 1 {
		return "", fmt.Errorf("second must be >= 0")
	}

	videoPath, err := saveUploadedFile(param.Video)
	if err != nil {
		logger.Error().Err(err).Msgf("failed to save video %s", videoPath)
		return "", fmt.Errorf("failed to save video: %w", err)
	}
	defer func(name string) {
		if err = os.Remove(name); err != nil {
			logger.Error().Err(err).Msgf("failed to delete video %s", videoPath)
		}
		logger.Debug().Msgf("successful to delete video %s", videoPath)
	}(videoPath)


	// 创建临时目录存放所有截图
	tempDir, err := os.MkdirTemp("", "snapshots_*")
	if err != nil {
		return "", fmt.Errorf("failed to create temp dir: %w", err)
	}

	logger.Debug().Msgf("temp dir === %s", tempDir)

	outputPattern := filepath.Join(tempDir, "snapshot_%04d.jpg")

	args := []string{
		"-i", videoPath,
		"-vf", fmt.Sprintf("fps=1/%d", param.Second),
		"-q:v", "2",
		"-y",
		outputPattern,
	}

	if err = runFfmpeg(ctx, args...); err != nil {
		os.RemoveAll(tempDir)
		logger.Error().Err(err).Msg("ffmpeg batch snapshot failed")
		return "", fmt.Errorf("batch snapshot failed: %w", err)
	}

	// 扫描目录
	count := readDirFileCount(tempDir, ".jpg")

	if err = zipDir(zipPath, tempDir); err != nil {
		os.RemoveAll(tempDir)
		return "", fmt.Errorf("failed to create zip: %w", err)
	}

	// 清理原始图片（保留 zip）
	os.RemoveAll(tempDir)
	logger.Debug().Msgf("successful to delete video temp %s", tempDir)
	logger.Debug().Msgf("Snapshot saved to path %s,count===%d", zipPath, count)
	return zipPath, nil
}

func (s *VideoProcessServiceImpl) Cut(ctx context.Context, param *request.VideoCut) (string, error) {
	logger := zerolog.DefaultContextLogger
	if param.Video == nil {
		logger.Error().Msg("video file can not null")
		return "", fmt.Errorf("video file is required")
	}

	videoPath, err := saveUploadedFile(param.Video)
	if err != nil {
		logger.Error().Err(err).Msgf("failed to save video %s", videoPath)
		return "", fmt.Errorf("failed to save video: %w", err)
	}
	defer os.Remove(videoPath)

	// 记录开始时间
	startCut := time.Now()

	// 获取视频总时长
	videoDuration, err := getVideoDuration(ctx, videoPath)
	if err != nil {
		return "", err
	}

	// 起始时间（秒）
	start := float64(param.Start)

	// 期望截取时长（秒）
	wantDuration := float64(param.Duration)

	// 剩余可截取的最大时长
	maxDuration := videoDuration - start
	if maxDuration <= 0 {
		return "", fmt.Errorf("start time exceeds video duration")
	}

	// 实际截取时长
	actualDuration := wantDuration
	if wantDuration > maxDuration {
		actualDuration = maxDuration
	}
	
	startStr := fmt.Sprintf("%.3f", start)
	durationStr := fmt.Sprintf("%.3f", actualDuration)

	outputPath := filepath.Join(os.TempDir(), fmt.Sprintf("cut_%d.mp4", time.Now().Unix()))

	args := []string{
		"-i", videoPath,
		"-ss", startStr,
		"-to", durationStr,
		"-c", "copy",
		"-y",
		outputPath,
	}

	err = runFfmpeg(ctx, args...)
	if err != nil {
		return "", err
	}

	elapsed := time.Since(startCut)
	logger.Debug().Msgf("视频截取耗时===%f秒", elapsed.Seconds())
	logger.Debug().Msgf("Cut video saved to: %s", outputPath)
	return outputPath, nil
}

func (s *VideoProcessServiceImpl) Watermark(ctx context.Context, param *request.VideoWatermark) (string, error) {
	logger := zerolog.DefaultContextLogger
	if len(param.Video.Header) == 0 {
		return "", fmt.Errorf("missing video file")
	}
	if len(param.Watermark.Header) == 0 {
		return "", fmt.Errorf("missing watermark image")
	}

	videoPath, err := saveUploadedFile(param.Video)
	if err != nil {
		logger.Error().Err(err).Msgf("failed to save video %s", videoPath)
		return "", fmt.Errorf("failed to save video: %w", err)
	}
	defer os.Remove(videoPath)

	watermarkPath, err := saveUploadedFile(param.Watermark)
	if err != nil {
		logger.Error().Err(err).Msgf("failed to save watermark %s", watermarkPath)
		return "", fmt.Errorf("failed to save watermark: %w", err)
	}
	defer os.Remove(watermarkPath)

	outputPath := filepath.Join(os.TempDir(), fmt.Sprintf("watermarked_%d.mp4", time.Now().Unix()))

	// 记录开始时间
	start := time.Now()

	// 获取视频分辨率
	videoWidth, _, err := getVideoResolution(ctx, videoPath)
	if err != nil {
		return "", err
	}

	// 计算水印目标宽度（15%，最小 100，最大 400）
	wmTargetWidth := int(float64(videoWidth) * 0.15)
	if wmTargetWidth < 100 {
		wmTargetWidth = 100
	}
	if wmTargetWidth > 400 {
		wmTargetWidth = 400
	}

	filter := fmt.Sprintf(
		"[1:v]scale=%d:-1[wm];[0:v][wm]overlay=main_w-overlay_w-10:10",
		wmTargetWidth,
	)

	err = runFfmpeg(
		ctx,
		"-i", videoPath,
		"-i", watermarkPath,
		"-filter_complex", filter,
		"-c:v", "libx264",
		"-c:a", "aac",
		"-strict", "-2",
		"-y",
		outputPath,
	)
	if err != nil {
		return "", err
	}

	elapsed := time.Since(start)
	logger.Debug().Msgf("视频水印耗时===%f秒", elapsed.Seconds())
	logger.Debug().Msgf("Watermarked video saved to: %s", outputPath)
	return outputPath, nil
}

3.视频处理控制器

package controller

import (
	"fmt"
	"net/http"
	"net/url"
	"os"
	"ry-go/business/service"
	"ry-go/business/service/serviceImpl"
	"ry-go/common/request"
	"ry-go/common/response"
	"ry-go/utils"
	"strings"
	"time"

	"github.com/labstack/echo/v4"
	"github.com/rs/zerolog"
	"github.com/spf13/cast"
)

type VideoProcessController struct {
	Service service.VideoProcessService
}

// NewVideoProcessController 控制器初始化
func NewVideoProcessController(s *serviceImpl.VideoProcessServiceImpl) *VideoProcessController {
	return &VideoProcessController{
		Service: s,
	}
}

func GetEchoForm(c echo.Context, maxMemory int64) (*multipart.Form, error) {
	// 解析表单，设置表单内存缓存大小
	if err := c.Request().ParseMultipartForm(maxMemory); err != nil {
		return nil, err
	}
	return c.Request().MultipartForm, nil
}

// HandlerSnapshot 视频截图
func (c *VideoProcessController) HandlerSnapshot(e echo.Context) error {
	logger := zerolog.DefaultContextLogger

	form, err := GetEchoForm(e, 32<<20)
	if err != nil {
		response.NewRespCodeErr(e, http.StatusInternalServerError, err)
		return err
	}

	files := form.File["video"]
	if len(files) == 0 {
		response.NewRespCodeMsg(e, http.StatusBadRequest, "video file is required")
		return err
	}

	var second int64
	if vals := form.Value["start"]; len(vals) > 0 {
		second = cast.ToInt64(vals[0])
		if second < 1 {
			response.NewRespCodeMsg(e, http.StatusBadRequest, "start must be >= 1")
			return err
		}
	} else {
		response.NewRespCodeMsg(e, http.StatusBadRequest, "start is required")
		return err
	}

	zipPath, err := c.Service.Snapshot(e.Request().Context(), &request.VideoSnapshot{
		Video:  files[0],
		Second: second,
	})
	if err != nil {
		return err
	}

	replace := strings.Replace(time.Now().Local().Format("20060102150405.000"), ".", "", 1)
	uniqueFileName := url.PathEscape(fmt.Sprintf("snapshot_%s_%s.zip", utils.ShortUUID(), replace))
	e.Response().Header().Set(echo.HeaderContentDisposition,
		fmt.Sprintf("attachment; filename=\"%s\"; filename*=UTF-8''%s", uniqueFileName, uniqueFileName))

	if err = e.Attachment(zipPath, uniqueFileName); err != nil {
		// 发送失败记录日志
		fmt.Printf("Failed to send file %s: %v\n", zipPath, err)
		os.Remove(zipPath)
		response.NewRespCodeMsg(e, http.StatusInternalServerError, "failed to send result")
		return err
	}

	go func(path string) {
		time.Sleep(5 * time.Second)
		os.Remove(path)
		logger.Debug().Msgf("删除了zip临时文件路径===%s", zipPath)
	}(zipPath)

	return nil
}

// HandlerCut 视频截取
func (c *VideoProcessController) HandlerCut(e echo.Context) error {
	// 解析表单，设置缓存为 32MB
	form, err := GetEchoForm(e, 32<<20)
	if err != nil {
		response.NewRespCodeErr(e, http.StatusInternalServerError, err)
		return err
	}

	files := form.File["video"]
	if len(files) == 0 {
		response.NewRespCodeMsg(e, http.StatusBadRequest, "video file is required")
		return err
	}

	var start, duration int64
	if vals := form.Value["start"]; len(vals) > 0 {
		start = cast.ToInt64(vals[0])
	} else {
		response.NewRespCodeMsg(e, http.StatusBadRequest, "start is required")
		return err
	}

	if vals := form.Value["duration"]; len(vals) > 0 {
		duration = cast.ToInt64(vals[0])
		if duration <= 0 {
			response.NewRespCodeMsg(e, http.StatusBadRequest, "duration must be > 0")
			return err
		}

		if duration > 0 && duration <= start {
			response.NewRespCodeMsg(e, http.StatusBadRequest, "duration must be > 0 and muse be > start")
			return err
		}
	} else {
		response.NewRespCodeMsg(e, http.StatusBadRequest, "duration is required")
		return err
	}
	outputPath, err := c.Service.Cut(e.Request().Context(), &request.VideoCut{
		Video:    files[0],
		Start:    start,
		Duration: duration,
	})
	if err != nil {
		return err
	}
	// 生成唯一文件名
	replace := strings.Replace(time.Now().Local().Format("20060102150405.000"), ".", "", 1)
	uniqueFileName := url.PathEscape(fmt.Sprintf("cut_%s_%s.mp4", utils.ShortUUID(), replace))
	e.Response().Header().Set(echo.HeaderContentDisposition,
		fmt.Sprintf("attachment; filename=\"%s\"; filename*=UTF-8''%s", uniqueFileName, uniqueFileName))

	if err = e.Attachment(outputPath, uniqueFileName); err != nil {
		// 发送失败记录日志
		fmt.Printf("Failed to send file %s: %v\n", outputPath, err)
		os.Remove(outputPath)
		response.NewRespCodeMsg(e, http.StatusInternalServerError, "failed to send result")
		return err
	}

	go func(path string) {
		time.Sleep(5 * time.Second)
		os.Remove(path)
		zerolog.DefaultContextLogger.Debug().Msgf("删除了视频文件路径===%s", outputPath)
	}(outputPath)

	return nil
}

// HandlerWatermark 视频添加水印
func (c *VideoProcessController) HandlerWatermark(e echo.Context) error {
	// 解析表单，设置缓存为 32MB
	form, err := GetEchoForm(e, 32<<20)
	if err != nil {
		response.NewRespCodeErr(e, http.StatusInternalServerError, err)
		return err
	}

	outputPath, err := c.Service.Watermark(e.Request().Context(), &request.VideoWatermark{
		Video:     form.File["video"][0],
		Watermark: form.File["watermark"][0],
	})
	if err != nil {
		response.NewRespCodeErr(e, http.StatusInternalServerError, err)
		return err
	}

	replace := strings.Replace(time.Now().Local().Format("20060102150405.000"), ".", "", 1)
	uniqueFileName := url.PathEscape(fmt.Sprintf("%s_%s.mp4", utils.ShortUUID(), replace))
	e.Response().Header().Set(echo.HeaderContentDisposition,
		fmt.Sprintf("attachment; filename=\"%s\"; filename*=UTF-8''%s", uniqueFileName, uniqueFileName))

	if err = e.Attachment(outputPath, uniqueFileName); err != nil {
		// 发送失败记录日志
		fmt.Printf("Failed to send file %s: %v\n", outputPath, err)
		os.Remove(outputPath)
		response.NewRespCodeMsg(e, http.StatusInternalServerError, "failed to send result")
		return err
	}

	go func(path string) {
		time.Sleep(10 * time.Second)
		os.Remove(path)
		zerolog.DefaultContextLogger.Debug().Msgf("删除了视频文件路径===%s", outputPath)
	}(outputPath)

	return nil
}

4.视频处理路由配置

package routers

import (
	"ry-go/business/controller"

	"github.com/labstack/echo/v4"
)

func VideoProcessRouterInit(group *echo.Group, videoController *controller.VideoProcessController) {
	routerGroup := group.Group("/video")
	routerGroup.POST("/snapshot", videoController.HandlerSnapshot)
	routerGroup.POST("/cut", videoController.HandlerCut)
	routerGroup.POST("/watermark", videoController.HandlerWatermark)
}

这里的路由使用了echo，具体用法这里不做详细说明了，具体内容请自行查看官网文档

5.其他说明

注意：上述代码依赖 ffmpeg 工具，请先确保它已在您的系统中安装并配置好环境变量。如果您尚未安装，可参考官方文档或相关教程完成安装，本文不再详细介绍。详情参见ffmpeg官网

上述代码均使用apifox测试，功能正常

到此这篇关于Golang调用FFmpeg实现视频截图,裁剪与水印添加功能的文章就介绍到这了,更多相关Go FFmpeg视频处理内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Golang利用compress/flate包来压缩和解压数据

    Golang利用compress/flate包来压缩和解压数据

    在处理需要高效存储和快速传输的数据时,数据压缩成为了一项不可或缺的技术,Go语言的compress/flate包为我们提供了对DEFLATE压缩格式的原生支持,本文将深入探讨compress/flate包的使用方法,揭示如何利用它来压缩和解压数据,并提供实际的代码示例,需要的朋友可以参考下
    2024-08-08
  • GoLang实现日志收集器流程讲解

    GoLang实现日志收集器流程讲解

    这篇文章主要介绍了GoLang实现日志收集器流程，看日志是开发者平时排查BUG所必须的掌握的技能，但是日志冗杂，所以写个小工具来收集这些日志帮助我们排查BUG，感兴趣想要详细了解可以参考下文
    2023-05-05
  • Golang 内存管理简单技巧详解

    Golang 内存管理简单技巧详解

    这篇文章主要为大家介绍了Golang 内存管理简单技巧详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-08-08
  • Golang JSON的进阶用法实例讲解

    Golang JSON的进阶用法实例讲解

    这篇文章主要给大家介绍了关于Golang JSON进阶用法的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用golang具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2018-09-09
  • golang 生成二维码海报的实现代码

    golang 生成二维码海报的实现代码

    这篇文章主要介绍了golang 生成二维码海报的实现代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-02-02
  • Go语言并发范式之future模式详解

    Go语言并发范式之future模式详解

    编程中经常遇到在一个流程中需要调用多个子调用的情况，此时就可以使用Go并发编程中的future模式，下面小编就来和大家聊聊future模式的具体使用，需要的可以参考一下
    2023-06-06
  • 初探GO中unsafe包的使用

    初探GO中unsafe包的使用

    unsafe是Go语言标准库中的一个包,提供了一些不安全的编程操作,本文将深入探讨Go语言中的unsafe包,介绍它的使用方法和注意事项,感兴趣的可以了解下
    2023-08-08
  • Golang单元测试与覆盖率的实例讲解

    Golang单元测试与覆盖率的实例讲解

    这篇文章主要介绍了Golang单元测试与覆盖率的实例讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-11-11
  • go singleflight缓存雪崩源码分析与应用

    go singleflight缓存雪崩源码分析与应用

    这篇文章主要为大家介绍了go singleflight缓存雪崩源码分析与应用示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-09-09
  • go语言中匿名函数的作用域陷阱详解

    go语言中匿名函数的作用域陷阱详解

    GO语言的匿名函数（anonymous function),其实就是闭包.是指不需要定义函数名的一种函数实现方式,下面这篇文章主要给大家介绍了关于go语言中匿名函数作用域陷阱的相关资料,需要的朋友可以参考下
    2022-05-05

最新评论