添加水印

java

package nexus.io.media;

public class NativeMedia {
    /**
     * 给视频添加右下角水印（支持中文），输出单独保存的视频。
     * @param inputVideoPath 输入视频文件路径
     * @param outputVideoPath 输出视频文件保存路径
     * @param watermarkText 水印文本，要求传入 UTF-8 编码的文本（支持中文）
     * @param fontFile 字体文件路径，如果为 null 或空字符串，则使用默认字体
     * @return 处理状态信息
     */
    public static native String addWatermarkToVideo(String inputVideoPath,
                                                    String outputVideoPath,
                                                    String watermarkText,
                                                    String fontFile);
}

添加 avfilter

按如下步骤修改的 CMakeLists.txt：

查找 avfilter 的头文件路径
添加：

cmake

find_path(AVFILTER_INCLUDE_DIR libavfilter/avfilter.h)
message(STATUS "AVFILTER_INCLUDE_DIR: ${AVFILTER_INCLUDE_DIR}")

查找 avfilter 的库文件
添加：

cmake

find_library(AVFILTER_LIBRARY avfilter)
message(STATUS "AVFILTER_LIBRARY: ${AVFILTER_LIBRARY}")

将 avfilter 的 include 目录添加到 include_directories()
修改 include_directories 部分：

cmake

include_directories(
        ${AVCODEC_INCLUDE_DIR}
        ${AVFORMAT_INCLUDE_DIR}
        ${SWRESAMPLE_INCLUDE_DIR}
        ${AVUTIL_INCLUDE_DIR}
        ${AVFILTER_INCLUDE_DIR}  # 添加这一行
        jni
)

在 target_link_libraries() 中链接 avfilter 库
修改 target_link_libraries 部分：

cmake

target_link_libraries(native_media
        ${JNI_LIBRARIES}
        ${AVCODEC_LIBRARY}
        ${AVFORMAT_LIBRARY}
        ${SWRESAMPLE_LIBRARY}
        ${AVUTIL_LIBRARY}
        ${AVFILTER_LIBRARY}  # 添加这一行
)

这样修改之后，链接器就能找到 avfilter 中的函数了

安装字体文件

可以通过系统包管理器安装 Noto Sans CJK 字体，下面给出几个常用发行版的安装方法：

Ubuntu / Debian 系列

可以运行以下命令：

bash

sudo apt update
sudo apt install fonts-noto-cjk

安装完成后，字体文件一般位于 /usr/share/fonts/opentype/noto/ 或 /usr/share/fonts/truetype/noto/ 目录下，可以使用如下命令查看安装的字体文件：

bash

fc-list | grep -i noto

Fedora

在 Fedora 上，可以运行：

bash

sudo dnf install google-noto-cjk-fonts

安装后，同样可以用 fc-list 命令确认字体路径和名称。

Arch Linux

在 Arch Linux 上，可以使用 Pacman 来安装：

bash

sudo pacman -S noto-fonts-cjk

手动安装

如果的发行版软件源中没有提供对应的包，也可以从 Google Noto Fonts 的 GitHub 仓库或 Noto 官网下载对应的字体文件（通常是 .ttf 或 .ttc 格式），然后将字体文件复制到系统字体目录（如 /usr/share/fonts 或当前用户下的 ~/.fonts），接着刷新字体缓存：

bash

fc-cache -f -v

使用注意

如果在 native 代码中需要指定字体的全路径，可以使用 fc-list 查找实际安装的 Noto Sans CJK 字体文件的路径，例如：

bash

fc-list | grep -i "NotoSansCJK"

假如查到的路径是 /usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc，那么 native 代码中默认的字体路径就可以设为这个路径。

通过以上方法，就可以在 Linux 环境下安装并使用 NotoSansCJK-Regular 字体，从而在视频水印中正确显示中文。

C 代码

说明：
代码中使用了 FFmpeg 的 libavformat、libavcodec 与 libavfilter 库实现视频解码、重新编码以及过滤器链处理。
水印采用 FFmpeg 内置的 drawtext 过滤器，在这里我们设置参数使水印出现在右下角（表达式 x=w-tw-10 与 y=h-th-10 表示离右边与底边各 10 像素），并采用 24 号字体、白色字体。
为了保证中文能正常显示，必须保证传入的字体文件（例如支持中文的 simhei.ttf 或者其他中文字体）能支持中文字符。
代码中对错误处理做了一定基本处理，但在生产环境中建议加入更完善的错误清理与日志打印。
请确认工程中已经链接相关 FFmpeg 库，并配置好 JNI 环境。

下面是完整的示例代码（可以保存为例如 jni_video_watermark.c）：

#include "com_litongjava_media_NativeMedia.h"
#include <jni.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <time.h>

// 包含 FFmpeg 头文件
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/opt.h>
#include <libavutil/pixdesc.h>

JNIEXPORT jstring JNICALL Java_com_litongjava_media_NativeMedia_addWatermarkToVideo
  (JNIEnv *env, jclass clazz, jstring inputVideoPathJ, jstring outputVideoPathJ, jstring watermarkTextJ, jstring fontFileJ) {
    // 从 Java 获取文件路径、水印文本和字体文件路径
    const char *inputPath     = (*env)->GetStringUTFChars(env, inputVideoPathJ, NULL);
    const char *outputPath    = (*env)->GetStringUTFChars(env, outputVideoPathJ, NULL);
    const char *watermarkText = (*env)->GetStringUTFChars(env, watermarkTextJ, NULL);
    const char *fontFile      = (*env)->GetStringUTFChars(env, fontFileJ, NULL);

    AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
    AVCodecContext  *dec_ctx  = NULL, *enc_ctx = NULL;
    AVStream        *in_video_stream = NULL, *out_video_stream = NULL;
    int video_stream_index = -1;
    int ret = 0;

    // 以下变量用于 FFmpeg 滤镜
    AVFilterGraph *filter_graph = NULL;
    AVFilterContext *buffersrc_ctx = NULL, *buffersink_ctx = NULL;
    const AVFilter *buffersrc = NULL, *buffersink = NULL;
    AVFilterInOut *outputs = NULL, *inputs = NULL;
    char filter_descr[512] = {0};

    // 初始化 FFmpeg 库（新版 FFmpeg 可不调用，但为了兼容性建议调用）
    av_register_all();
    avfilter_register_all();

    // 打开输入文件
    if ((ret = avformat_open_input(&ifmt_ctx, inputPath, NULL, NULL)) < 0) {
        goto end_fail;
    }
    if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
        goto end_fail;
    }

    // 寻找视频流
    for (int i = 0; i < ifmt_ctx->nb_streams; i++) {
        if (ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            video_stream_index = i;
            in_video_stream = ifmt_ctx->streams[i];
            break;
        }
    }
    if (video_stream_index < 0) {
        ret = -1;
        goto end_fail;
    }

    // 打开视频解码器
    AVCodec *dec = avcodec_find_decoder(in_video_stream->codecpar->codec_id);
    if (!dec) {
        ret = -1;
        goto end_fail;
    }
    dec_ctx = avcodec_alloc_context3(dec);
    if (!dec_ctx) {
        ret = -1;
        goto end_fail;
    }
    ret = avcodec_parameters_to_context(dec_ctx, in_video_stream->codecpar);
    if (ret < 0) {
        goto end_fail;
    }
    if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {
        goto end_fail;
    }

    // 创建输出文件上下文
    avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, outputPath);
    if (!ofmt_ctx) {
        ret = -1;
        goto end_fail;
    }

    // 为输出文件创建一个新视频流
    out_video_stream = avformat_new_stream(ofmt_ctx, NULL);
    if (!out_video_stream) {
        ret = -1;
        goto end_fail;
    }

    // 使用 H.264 编码器进行编码
    AVCodec *encoder = avcodec_find_encoder(AV_CODEC_ID_H264);
    if (!encoder) {
        ret = -1;
        goto end_fail;
    }
    enc_ctx = avcodec_alloc_context3(encoder);
    if (!enc_ctx) {
        ret = -1;
        goto end_fail;
    }
    // 设置编码参数，根据输入视频设置输出参数（这里保持分辨率一致）
    enc_ctx->height = dec_ctx->height;
    enc_ctx->width  = dec_ctx->width;
    enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
    // 选择 encoder 支持的像素格式（首选 encoder 的列表）
    enc_ctx->pix_fmt = encoder->pix_fmts ? encoder->pix_fmts[0] : dec_ctx->pix_fmt;
    // 时间基设置可以采用解码器的帧率倒数，或者直接使用输入流的时间基
    if (dec_ctx->framerate.num && dec_ctx->framerate.den)
        enc_ctx->time_base = av_inv_q(dec_ctx->framerate);
    else
        enc_ctx->time_base = in_video_stream->time_base;
    if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
        enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

    // 打开编码器
    AVDictionary *enc_opts = NULL;
    av_dict_set(&enc_opts, "preset", "veryfast", 0);
    if ((ret = avcodec_open2(enc_ctx, encoder, &enc_opts)) < 0) {
        av_dict_free(&enc_opts);
        goto end_fail;
    }
    av_dict_free(&enc_opts);

    // 将编码器参数复制到输出流
    ret = avcodec_parameters_from_context(out_video_stream->codecpar, enc_ctx);
    if (ret < 0) {
        goto end_fail;
    }
    out_video_stream->time_base = enc_ctx->time_base;

    // 打开输出文件（如果需要）
    if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {
        ret = avio_open(&ofmt_ctx->pb, outputPath, AVIO_FLAG_WRITE);
        if (ret < 0) {
            goto end_fail;
        }
    }

    // -----------------------------
    //  1. 创建滤镜图（Filter Graph）
    // -----------------------------
    filter_graph = avfilter_graph_alloc();
    if (!filter_graph) {
        ret = -1;
        goto end_fail;
    }

    // 获取 buffer 源和 sink 滤镜
    buffersrc = avfilter_get_by_name("buffer");
    buffersink = avfilter_get_by_name("buffersink");
    if (!buffersrc || !buffersink) {
        ret = -1;
        goto end_fail;
    }

    // 构造 buffer 源的参数字符串
    char args[512] = {0};
    snprintf(args, sizeof(args),
             "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
             dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
             in_video_stream->time_base.num, in_video_stream->time_base.den,
             dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);
    ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);
    if (ret < 0) {
        goto end_fail;
    }

    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph);
    if (ret < 0) {
        goto end_fail;
    }

    // 设置 buffersink 的输出像素格式，仅接受编码器需要的格式
    enum AVPixelFormat pix_fmts[] = { enc_ctx->pix_fmt, AV_PIX_FMT_NONE };
    ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
    if (ret < 0) {
        goto end_fail;
    }

    // 构造 drawtext 滤镜描述字符串
    // 注意：text 参数需要使用 UTF-8 编码（支持中文），fontfile 必须指定支持中文的字体文件
    snprintf(filter_descr, sizeof(filter_descr),
             "drawtext=fontfile='%s':text='%s':x=w-tw-10:y=h-th-10:fontsize=24:fontcolor=white",
             fontFile, watermarkText);

    // 初始化滤镜的输入输出端点
    outputs = avfilter_inout_alloc();
    inputs  = avfilter_inout_alloc();
    if (!outputs || !inputs) {
        ret = -1;
        goto end_fail;
    }

    outputs->name       = av_strdup("in");
    outputs->filter_ctx = buffersrc_ctx;
    outputs->pad_idx    = 0;
    outputs->next       = NULL;

    inputs->name       = av_strdup("out");
    inputs->filter_ctx = buffersink_ctx;
    inputs->pad_idx    = 0;
    inputs->next       = NULL;

    // 解析并构造滤镜链（在 buffersrc 与 buffersink 之间插入 drawtext 过滤器）
    ret = avfilter_graph_parse_ptr(filter_graph, filter_descr, &inputs, &outputs, NULL);
    if (ret < 0) {
        goto end_fail;
    }
    ret = avfilter_graph_config(filter_graph, NULL);
    if (ret < 0) {
        goto end_fail;
    }

    avfilter_inout_free(&inputs);
    avfilter_inout_free(&outputs);

    // -----------------------------
    // 写入输出文件的文件头
    ret = avformat_write_header(ofmt_ctx, NULL);
    if (ret < 0) {
        goto end_fail;
    }

    // 申请解码与滤镜使用的 AVFrame
    AVFrame *frame = av_frame_alloc();
    AVFrame *filt_frame = av_frame_alloc();
    if (!frame || !filt_frame) {
        ret = AVERROR(ENOMEM);
        goto end_fail;
    }

    AVPacket packet;
    av_init_packet(&packet);
    packet.data = NULL;
    packet.size = 0;

    // -----------------------------
    // 逐帧处理：解码 -> 送入滤镜 -> 从滤镜中取出 -> 编码 -> 写入文件
    while (av_read_frame(ifmt_ctx, &packet) >= 0) {
        if (packet.stream_index == video_stream_index) {
            ret = avcodec_send_packet(dec_ctx, &packet);
            if (ret < 0) {
                break;
            }
            while ((ret = avcodec_receive_frame(dec_ctx, frame)) >= 0) {
                // 将解码后的帧送入滤镜图
                if ((ret = av_buffersrc_add_frame(buffersrc_ctx, frame)) < 0) {
                    break;
                }
                // 从滤镜图中获取处理后的帧
                while ((ret = av_buffersink_get_frame(buffersink_ctx, filt_frame)) >= 0) {
                    // 将水印后的视频帧送入编码器
                    filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
                    ret = avcodec_send_frame(enc_ctx, filt_frame);
                    if (ret < 0) {
                        break;
                    }
                    AVPacket enc_pkt;
                    av_init_packet(&enc_pkt);
                    enc_pkt.data = NULL;
                    enc_pkt.size = 0;
                    while ((ret = avcodec_receive_packet(enc_ctx, &enc_pkt)) >= 0) {
                        av_packet_rescale_ts(&enc_pkt, enc_ctx->time_base, out_video_stream->time_base);
                        enc_pkt.stream_index = out_video_stream->index;
                        ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
                        av_packet_unref(&enc_pkt);
                        if (ret < 0) {
                            break;
                        }
                    }
                    av_frame_unref(filt_frame);
                }
                av_frame_unref(frame);
            }
        }
        av_packet_unref(&packet);
    }

    // 刷出残留的解码和编码数据
    avcodec_send_packet(dec_ctx, NULL);
    while (avcodec_receive_frame(dec_ctx, frame) >= 0) {
        av_buffersrc_add_frame(buffersrc_ctx, frame);
        while (av_buffersink_get_frame(buffersink_ctx, filt_frame) >= 0) {
            filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
            avcodec_send_frame(enc_ctx, filt_frame);
            AVPacket enc_pkt;
            av_init_packet(&enc_pkt);
            enc_pkt.data = NULL;
            enc_pkt.size = 0;
            while (avcodec_receive_packet(enc_ctx, &enc_pkt) >= 0) {
                av_packet_rescale_ts(&enc_pkt, enc_ctx->time_base, out_video_stream->time_base);
                enc_pkt.stream_index = out_video_stream->index;
                av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
                av_packet_unref(&enc_pkt);
            }
            av_frame_unref(filt_frame);
        }
        av_frame_unref(frame);
    }

    // 刷出编码器
    avcodec_send_frame(enc_ctx, NULL);
    while (1) {
        AVPacket enc_pkt;
        av_init_packet(&enc_pkt);
        enc_pkt.data = NULL;
        enc_pkt.size = 0;
        ret = avcodec_receive_packet(enc_ctx, &enc_pkt);
        if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
            break;
        if (ret < 0)
            break;
        av_packet_rescale_ts(&enc_pkt, enc_ctx->time_base, out_video_stream->time_base);
        enc_pkt.stream_index = out_video_stream->index;
        av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
        av_packet_unref(&enc_pkt);
    }

    av_write_trailer(ofmt_ctx);

end_fail:
    {
        char resultMsg[256] = {0};
        if (ret < 0) {
            snprintf(resultMsg, sizeof(resultMsg), "Failed to add watermark, error code: %d", ret);
        } else {
            snprintf(resultMsg, sizeof(resultMsg), "Watermark added successfully, output saved to %s", outputPath);
        }
        // 清理释放分配的资源
        if (filter_graph)
            avfilter_graph_free(&filter_graph);
        if (dec_ctx)
            avcodec_free_context(&dec_ctx);
        if (enc_ctx)
            avcodec_free_context(&enc_ctx);
        if (ifmt_ctx)
            avformat_close_input(&ifmt_ctx);
        if (ofmt_ctx) {
            if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
                avio_closep(&ofmt_ctx->pb);
            avformat_free_context(ofmt_ctx);
        }
        av_frame_free(&frame);
        av_frame_free(&filt_frame);
        if (inputPath)
            (*env)->ReleaseStringUTFChars(env, inputVideoPathJ, inputPath);
        if (outputPath)
            (*env)->ReleaseStringUTFChars(env, outputVideoPathJ, outputPath);
        if (watermarkText)
            (*env)->ReleaseStringUTFChars(env, watermarkTextJ, watermarkText);
        if (fontFile)
            (*env)->ReleaseStringUTFChars(env, fontFileJ, fontFile);
        return (*env)->NewStringUTF(env, resultMsg);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362

代码说明

JNI 接口函数参数说明
- inputVideoPathJ：输入视频文件路径。
- outputVideoPathJ：输出视频文件保存路径。
- watermarkTextJ：水印文字（支持中文，要求以 UTF-8 编码传入）。
- fontFileJ：字体文件路径，必须是一个支持中文的字体（例如 simhei.ttf）。
视频解码与编码
- 使用 avformat_open_input 打开输入文件，并寻找视频流。
- 使用对应的视频解码器打开解码上下文；之后新建 H.264 编码器并设置输出视频参数（分辨率、像素格式、时间基等）。
滤镜图配置
- 通过 avfilter_graph_create_filter 构造 buffer 源（输入滤镜）和 buffer sink（输出滤镜）。
- 构造 drawtext 滤镜描述字符串：
  - 参数 x=w-tw-10 与 y=h-th-10 表示右下角留 10 像素边距。
  - 字体大小、颜色均可根据需要调整。
- 调用 avfilter_graph_parse_ptr 与 avfilter_graph_config 生成完整滤镜图。
处理流程
- 读取视频包并解码为 AVFrame，然后将 AVFrame 送入滤镜图；从滤镜中提取处理后的帧后，再送入编码器，最终写入输出文件。
- 最后对残留帧进行 flush 操作，并写入输出 trailer。
清理与返回
- 无论成功还是失败，均释放所有分配的资源，并返回一条状态消息到 Java 层。

通过以上代码，可以实现一个给视频右下角添加中文水印，并将水印视频单独保存的新功能。请根据实际情况调整滤镜参数（例如字体大小、颜色、位置等），并确保提供的字体文件支持中文显示。

常见错误

No such filter: 'drawtext'

这个错误提示表明 FFmpeg 在运行时找不到 drawtext 滤镜，而 drawtext 滤镜依赖于 FreeType 库。如果 FFmpeg 没有启用 drawtext，就会出现类似 "No such filter: 'drawtext'" 的错误，进而导致后续的滤镜图构建失败和程序崩溃。

解决思路

确认 FFmpeg 是否支持 drawtext：
在命令行下执行
bash
```
ffmpeg -filters | grep drawtext
```
1
如果没有显示 drawtext 滤镜，那么当前使用的 FFmpeg 版本没有启用该滤镜。
使用支持 drawtext 的 FFmpeg 构建版本：
- 如果使用的是预编译版 FFmpeg，请选择一个包含 drawtext 支持（通常需要启用 libfreetype）的版本。
- 或者可以自己编译 FFmpeg。在配置编译参数时，确保启用 libfreetype 支持。例如：
  bash
```
./configure --enable-libfreetype --enable-gpl
make
make install
```
  1
  2
  3
  这样编译后，drawtext 滤镜就会被包含进来。
在 Windows 平台下使用：
- 如果是 Windows 用户，请检查所使用的 FFmpeg 库或者动态链接库（dll）是否支持 drawtext。部分预编译的 FFmpeg 版本可能为了减小体积而禁用了该滤镜。可以尝试从其他渠道下载一个完整支持 drawtext 的 Windows FFmpeg 构建包。
代码运行时的动态库问题：
- 确保在运行 native 库时加载的 FFmpeg 动态库是预期的那一版。如果系统中同时存在多个版本，可能会导致加载了不支持 drawtext 的版本。
- 检查一下 CMake 或项目中链接和加载的库路径是否正确配置。

总结

错误主要源自于 FFmpeg 的 drawtext 滤镜不可用，而不是代码本身的问题。需要换用一个支持 drawtext 的 FFmpeg 库，或者重新编译 FFmpeg 并启用 libfreetype 支持。确认这一点后，再次运行程序就应该能够正确解析 drawtext 过滤器并添加水印了。

添加水印 ​

添加 avfilter ​

安装字体文件 ​

Ubuntu / Debian 系列 ​

Fedora ​

Arch Linux ​

手动安装 ​

使用注意 ​

C 代码 ​

代码说明 ​

常见错误 ​

No such filter: 'drawtext' ​

解决思路 ​

总结 ​

添加水印

添加 avfilter

安装字体文件

Ubuntu / Debian 系列

Fedora

Arch Linux

手动安装

使用注意

C 代码

代码说明

常见错误

No such filter: 'drawtext'

解决思路

总结