添加水印
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 的头文件路径
添加：find_path(AVFILTER_INCLUDE_DIR libavfilter/avfilter.h) message(STATUS "AVFILTER_INCLUDE_DIR: ${AVFILTER_INCLUDE_DIR}") - 查找 avfilter 的库文件
添加：find_library(AVFILTER_LIBRARY avfilter) message(STATUS "AVFILTER_LIBRARY: ${AVFILTER_LIBRARY}") - 将 avfilter 的 include 目录添加到 include_directories()
修改 include_directories 部分：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 部分：target_link_libraries(native_media ${JNI_LIBRARIES} ${AVCODEC_LIBRARY} ${AVFORMAT_LIBRARY} ${SWRESAMPLE_LIBRARY} ${AVUTIL_LIBRARY} ${AVFILTER_LIBRARY} # 添加这一行 )
这样修改之后，链接器就能找到 avfilter 中的函数了
安装字体文件
可以通过系统包管理器安装 Noto Sans CJK 字体，下面给出几个常用发行版的安装方法：
Ubuntu / Debian 系列
可以运行以下命令：
sudo apt update
sudo apt install fonts-noto-cjk
安装完成后，字体文件一般位于 /usr/share/fonts/opentype/noto/ 或 /usr/share/fonts/truetype/noto/ 目录下，可以使用如下命令查看安装的字体文件：
fc-list | grep -i noto
Fedora
在 Fedora 上，可以运行：
sudo dnf install google-noto-cjk-fonts
安装后，同样可以用 fc-list 命令确认字体路径和名称。
Arch Linux
在 Arch Linux 上，可以使用 Pacman 来安装：
sudo pacman -S noto-fonts-cjk
手动安装
如果的发行版软件源中没有提供对应的包，也可以从 Google Noto Fonts 的 GitHub 仓库 或 Noto 官网 下载对应的字体文件（通常是 .ttf 或 .ttc 格式），然后将字体文件复制到系统字体目录（如 /usr/share/fonts 或当前用户下的 ~/.fonts），接着刷新字体缓存：
fc-cache -f -v
使用注意
如果在 native 代码中需要指定字体的全路径，可以使用 fc-list 查找实际安装的 Noto Sans CJK 字体文件的路径，例如：
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);
}
}
代码说明
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：
在命令行下执行ffmpeg -filters | grep drawtext如果没有显示 drawtext 滤镜，那么当前使用的 FFmpeg 版本没有启用该滤镜。
使用支持 drawtext 的 FFmpeg 构建版本：
- 如果使用的是预编译版 FFmpeg，请选择一个包含 drawtext 支持（通常需要启用 libfreetype）的版本。
- 或者可以自己编译 FFmpeg。在配置编译参数时，确保启用 libfreetype 支持。例如：这样编译后，drawtext 滤镜就会被包含进来。
./configure --enable-libfreetype --enable-gpl make make install
在 Windows 平台下使用：
- 如果是 Windows 用户，请检查所使用的 FFmpeg 库或者动态链接库（dll）是否支持 drawtext。部分预编译的 FFmpeg 版本可能为了减小体积而禁用了该滤镜。可以尝试从其他渠道下载一个完整支持 drawtext 的 Windows FFmpeg 构建包。
代码运行时的动态库问题：
- 确保在运行 native 库时加载的 FFmpeg 动态库是预期的那一版。如果系统中同时存在多个版本，可能会导致加载了不支持 drawtext 的版本。
- 检查一下 CMake 或项目中链接和加载的库路径是否正确配置。
总结
错误主要源自于 FFmpeg 的 drawtext 滤镜不可用，而不是代码本身的问题。需要换用一个支持 drawtext 的 FFmpeg 库，或者重新编译 FFmpeg 并启用 libfreetype 支持。确认这一点后，再次运行程序就应该能够正确解析 drawtext 过滤器并添加水印了。