android录视频水印 android 视频加水印

本文目录

• 前言
• 本文摘要
• ffmpeg常用命令行简介
• 创建ffmpeg-cmd模块

• Step1：目录结构
• Step2：导入libffmpeg.so库
• Step3：导入FFmpeg的相关头文件
• Step4: 导入FFmpeg的相关源码文件
• Step5: 编写CMakeLists.txt文件
• 修改FFmpeg源码
• 编写JNI调用FFmpeg命令

• C代码：
• Java代码：
• 调用FFmpeg命令
• 1、视频转码
• 2、视频剪切
• 3、视频截图
• 4、添加水印

前言

由于工作和学习原因，有段时间没更新博客了。最近都将时间花在kotlin和Flutter的学习上，项目也用上了kotlin和Flutter，利用闲暇时间，写写博客来总结和记录下自己所学的知识挺好的。如果通过分享可以帮到其他开发人员，那就更加有意义了。记得我一位同事说过他写博客的动力是他出自内心感激他这么多年在互联网行业的攫取，他收获很多，所以他想回馈。当然本篇博文并不是介绍Flutter和kotlin，还是介绍Android音视频相关的博文。

本文摘要

我本篇博文主要介绍在Android端如何利用FFmpeg对视频进行裁剪，拼接以及压缩，最后附上项目源码的Github地址。FFmpeg中常用的工具主要是ffmpeg，ffprobe，ffplay，它们分别用作多媒体的编解码工具，内容分析工具和播放器。ffmpeg其实是这三个命令行工具里最强大的一个工具，如果说ffprobe是用于探测媒体文件的格式以及详细信息，ffplay是一个播放媒体文件的工具，那么ffmpeg就是强大的媒体文件转换工具。它可以转换任何格式的媒体文件，并且还可以用自己的AudioFilter以及VideoFilter进行处理和编辑。本文主要介绍如何在Android端使用ffmpeg命令。

ffmpeg常用命令行简介

ffmpeg在做音视频编解码时非常方便，所以在很多场景下转码使用的是ffmpeg，通过ffmpeg --help可以看到ffmpeg场景的命令大概分为6个部分，具体如下：

• ffmpeg信息查询部分
• 公共操作参数部分
• 文件主要操作参数部分
• 视频操作参数部分
• 音频操作参数部分
• 字幕操作参数部分
  常用的命令如下：

1. 列出ffmpeg支持的所有格式命令：ffmpeg -formats
2. 剪切一段媒体文件，可以是音频或者视频文件命令：ffmpeg -i input.mp4 -ss 00:00:50.0 -codec copy -t 20 output.mp4(表示将文件imput.mp4从第50s开始剪切20s的时间，输出到文件output.mp4中，其中-ss指定偏移时间time Offset，-t指定的时长duration)
3. 如果在手机中录制了一个时间比较长的视频无法分享到微信中，那么可以使用ffmpeg将该视频文件切割为多个文件：ffmpeg -i input.mp4 -t 00:00:50 -c copy small-1.mp4 -ss 00:00:50 -codec copy small-2.mp4
4. 提取一个视频文件中的音频文件：ffmpeg -i input.mp4 -vn -acodec copy output.m4a
5. 使一个视频中的音频静音，即只保留视频：ffmpeg -i input.mp4 -an -vcodec copy output.mp4
6. 从MP4文件中抽取视频流到处为裸H264数据：ffmpeg -i output.mp4 -an -vcodec copy -bsf:v h264_mp4toannexb output.h264
7. 使用AAC音频数据和H264的视频生成MP4文件：ffmpeg -i test.aac -i test.h264 -acodec copy -bsf:a aac_adtstoasc -vcodec copy -f mp4 output.mp4
8. 对音频文件的编码格式做转换：ffmpeg -i input.wav -acodec libfdk_acc output.aac
9. 从WAV音频文件中导出PCM裸数据：ffmpeg -i input.wav -acodec pcm_s16le -f s16le output.pcm
10. 重新编码视频文件，复制音频流，同时封装到MP4格式的文件中：ffmpeg -i input.flv -vcodec libx264 -acodec copy output.mp4
11. 将一个MP4格式的视频转换成gif格式的动图：ffmpeg -i input.mp4 -vf scale=100:-1 -t 5 -r 10 image.gif(按照分辨率比例不动宽度改为100使用VideoFilter的scaleFiddler，帧率改为10（-r），只处理前5秒钟（-t）的视频，生成gif。）
12. 将一个视频的画面部分生成图片，比如要分析一个视频里面的每一帧都是什么内容的时候，可能就需要用到这个命令了：ffmpeg -i output.mp4 -r 0.25 frames_%04d.png(每4秒钟截取一帧视频画面生成一张图片，生成的图片从frames_0001.png开始一直递增下去)
13. 使用一组图片可以组成一个gif，如果你连拍了一组照片，就可以用下面命令生成一个gif：ffmpeg -i frames_%04d.png -r 5 output.gif
14. 使用音量效果器，可以改变一个音频媒体文件中的音量：ffmpeg -i input.wav -af ‘volume=0.5’ output.wav(将input.wav中的声音减少一半，输出到output.wav文件中)
15. 淡入效果器的使用：ffmpeg -i input.wav -filter_complex afade=t=in:ss=0:d=5 output.wav(将input.wav文件前5s做一个淡入效果，输出到output.wav中)
16. 淡出效果器的使用：ffmpeg -i input.wav -filter_complex afade=t=out:st=200:d=5 ouput.wav(将input.wav文件从200s开始，做5s的淡出效果，并放到output.wav文件中)
17. 将两路声音进行合并，比如要给一段声音加上背景音乐：ffmpeg -i vocal.wav -i accompany.wav -filter_complex amix=inputs=2:duration=shortest output.wav(将vocal.wav和accompany.wav两个文件进行mix，按照时间长度较短的音频文件的时间长度作为最终输入的output.wav的时间长度)
18. 对声音进行变速但不变调效果器的使用：ffmpeg -i vocal.wav -filter_complex atempo=0.5 output.wav
19. 为视频增加水印效果：ffmpeg -i input.mp4 -i changeba_icon.png -filter_complex ‘[0:v] [1:v] overlay=main_w-overlay_w-10:10:1[out]’ -map ‘[out]’ output.mp4
20. 视频提亮效果器的使用：ffmpeg -i input.flv -c:v libx264 -b:v 800k -c:a libfdk_acc -vf eq=brightness=0.25 -f mp4 output.mp4
21. 为视频增加对比度效果：ffmpeg -i input.flv -c:v libx264 -b:v 800k -c:a libfdk_aac -vf eq=contrast=1.5 -f mp4 output.mp4
22. 视频旋转效果器的使用：ffmpeg -i input.mp4 -vf “transpose=1” -b:v 600k output.mp4
23. 视频裁剪效果器的使用：ffmpeg -i input.mp4 -an -vf “crop=240:480:120:0” -vcodec libx264 -b:v 600k output.mp4
24. 将一张RGBA格式表示的数据转换为JPEG格式的图片：ffmpeg -f rawvideo -pix_fmt rgba -s 480*480 -i texture.rgb -f image2 -vcodec mjpeg output.jpg
25. 将一个YUV格式表示的数据转换为JPEG格式的图片：ffmpeg -f rawvideo -pix_fmt yuv420p -s 480*480 -i texture.yuv -f image2 -vcodec mjpeg output.jpg
26. 将一段视频推送到流媒体服务器上：ffmpeg -re -i input.mp4 -acodec copy -vcodec copy -f flv rtmp://xxx
27. 将流媒体服务器上的流dump到本地：ffmpeg -i http://xxx/xxx.flv -acodec copy -vcodec copy -f flv output.flv
28. 将两个音频文件以两路流的形式封装到一个文件中，比如在K歌的应用场景中，原伴唱实时切换的场景下，可以使用一个文件包含两路流，一路是伴奏流，另外一路是原唱流：ffmpeg -i 131.mp3 -i 134.mp3 -map 0:a libfdk_aac -b🅰️0 96k -map 1:a -c🅰️1 libfdk_aac -b🅰️1 64k -vn -f mp4 output.m4a

下面来看看如何在Android端集成FFmpeg的命令行模式

创建ffmpeg-cmd模块

Step1：目录结构

Step2：导入libffmpeg.so库

在ffmpeg-cmd模块的build.gradle中添加配置：

android {
    
    // 省略其他配置...
    defaultConfig {
        // 省略其他配置...
        
        // 配置cmake构建参数
        externalNativeBuild {
            cmake {
                cppFlags ""
                abiFilters 'armeabi-v7a'
            }
        }
    }

    // 配置cmake构建脚本的路径
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
        }
    }

    // 定义jniLib的目录到libs
    sourceSets.main {
        jniLibs.srcDirs = ['libs']
    }
}

Step3：导入FFmpeg的相关头文件

Step4: 导入FFmpeg的相关源码文件

在源码目录的fftools文件夹内

Step5: 编写CMakeLists.txt文件

cmake_minimum_required(VERSION 3.4.1)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")

# 添加头文件路径
include_directories(
        ./src/main/cpp
        ./src/main/cpp/ffmpeg
        ./src/main/cpp/include
)

# 定义源码所在目录
aux_source_directory(./src/main/cpp SRC)
aux_source_directory(./src/main/cpp/ffmpeg SRC_FFMPEG)

# 将 SRC_FFMPEG 添加到 SRC 中
list(APPEND SRC ${SRC_FFMPEG})

# 设置ffmpeg库所在路径的目录
set(distribution_DIR ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI})

# 编译一个ffmpeg-cmd库
add_library(  ffmpeg-cmd   # 库名称
        SHARED             # 库类型
        ${SRC})            # 编译进库的源码

# 添加libffmpeg.so库
add_library( ffmpeg
        SHARED
        IMPORTED )
# 指定libffmpeg.so库的位置
set_target_properties( ffmpeg
        PROPERTIES IMPORTED_LOCATION
        ${distribution_DIR}/libffmpeg.so )

# 查找日志库
find_library(
        log-lib
        log )

# 将其他库链接到目标库ffmpeg-cmd
target_link_libraries( ffmpeg-cmd
        ffmpeg
        -landroid     # native_window
        -ljnigraphics # bitmap
        -lOpenSLES    # openSLES
        ${log-lib} )

修改FFmpeg源码

• ffmpeg.c
  修改main方法：

// 修改前
int main(int argc, char **argv)

// 修改后
int ffmpeg_exec(int argc, char **argv)

在ffmpeg_cleanup函数执行结束前重新初始化：

static void ffmpeg_cleanup(int ret) {
  
    // 省略其他代码...
    
    nb_filtergraphs = 0;
    nb_output_files = 0;
    nb_output_streams = 0;
    nb_input_files = 0;
    nb_input_streams = 0;
}

在print_report函数中添加代码实现FFmpeg命令执行进度的回调：

static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time) {
    
    // 省略其他代码...
    
    // 定义已处理的时长
    float mss;
    
    secs = FFABS(pts) / AV_TIME_BASE;
    us = FFABS(pts) % AV_TIME_BASE;
    // 获取已处理的时长
    mss = secs + ((float) us / AV_TIME_BASE);
    
    // 调用ffmpeg_progress将进度传到Java层，代码后面定义
    ffmpeg_progress(mss);
    
    // 省略其他代码...
}

• ffmpeg.h
  添加ffmpeg_exec方法的声明：

int ffmpeg_exec(int argc, char **argv);

• cmdutils.c
  修改exit_program函数：

void exit_program(int ret) {
    if (program_exit)
        program_exit(ret);

    // 退出线程(该函数后面定义)
    ffmpeg_thread_exit(ret);

    // 删掉下面这行代码，不然执行结束，应用会crash
    //exit(ret);
}

编写JNI调用FFmpeg命令

C代码：

ffmpeg_cmd.h

#include <jni.h>

#ifndef _Included_FFmpeg_Cmd
#define _Included_FFmpeg_Cmd
#ifdef __cplusplus
extern "C" {
#endif

JNIEXPORT jint JNICALL Java_com_github_xch168_ffmpeg_1cmd_FFmpegCmd_exec(JNIEnv *, jclass, jint, jobjectArray);

JNIEXPORT void JNICALL Java_com_github_xch168_ffmpeg_1cmd_FFmpegCmd_exit(JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif
#endif

void ffmpeg_progress(float progress);

ffmpeg_cmd.c

#include "ffmpeg_cmd.h"

#include <jni.h>
#include <string.h>
#include "ffmpeg_thread.h"
#include "android_log.h"
#include "cmdutils.h"

static JavaVM *jvm = NULL;
//java虚拟机
static jclass m_clazz = NULL;//当前类(面向java)

/**
 * 回调执行Java方法
 * 参看 Jni反射+Java反射
 */
void callJavaMethod(JNIEnv *env, jclass clazz,int ret) {
    if (clazz == NULL) {
        LOGE("---------------clazz isNULL---------------");
        return;
    }
    //获取方法ID (I)V指的是方法签名 通过javap -s -public FFmpegCmd 命令生成
    jmethodID methodID = (*env)->GetStaticMethodID(env, clazz, "onExecuted", "(I)V");
    if (methodID == NULL) {
        LOGE("---------------methodID isNULL---------------");
        return;
    }
    //调用该java方法
    (*env)->CallStaticVoidMethod(env, clazz, methodID,ret);
}
void callJavaMethodProgress(JNIEnv *env, jclass clazz,float ret) {
    if (clazz == NULL) {
        LOGE("---------------clazz isNULL---------------");
        return;
    }
    //获取方法ID (I)V指的是方法签名 通过javap -s -public FFmpegCmd 命令生成
    jmethodID methodID = (*env)->GetStaticMethodID(env, clazz, "onProgress", "(F)V");
    if (methodID == NULL) {
        LOGE("---------------methodID isNULL---------------");
        return;
    }
    //调用该java方法
    (*env)->CallStaticVoidMethod(env, clazz, methodID,ret);
}

/**
 * c语言-线程回调
 */
static void ffmpeg_callback(int ret) {
    JNIEnv *env;
    //附加到当前线程从JVM中取出JNIEnv, C/C++从子线程中直接回到Java里的方法时  必须经过这个步骤
    (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
    callJavaMethod(env, m_clazz,ret);

    //完毕-脱离当前线程
    (*jvm)->DetachCurrentThread(jvm);
}

void ffmpeg_progress(float progress) {
    JNIEnv *env;
    (*jvm)->AttachCurrentThread(jvm, (void **) &env, NULL);
    callJavaMethodProgress(env, m_clazz,progress);
    (*jvm)->DetachCurrentThread(jvm);
}

JNIEXPORT jint JNICALL
Java_com_github_xch168_ffmpeg_1cmd_FFmpegCmd_exec(JNIEnv *env, jclass clazz, jint cmdnum, jobjectArray cmdline) {
    (*env)->GetJavaVM(env, &jvm);
    m_clazz = (*env)->NewGlobalRef(env, clazz);
    //---------------------------------C语言 反射Java 相关----------------------------------------
    //---------------------------------java 数组转C语言数组----------------------------------------
    int i = 0;//满足NDK所需的C99标准
    char **argv = NULL;//命令集 二维指针
    jstring *strr = NULL;

    if (cmdline != NULL) {
        argv = (char **) malloc(sizeof(char *) * cmdnum);
        strr = (jstring *) malloc(sizeof(jstring) * cmdnum);

        for (i = 0; i < cmdnum; ++i) {//转换
            strr[i] = (jstring)(*env)->GetObjectArrayElement(env, cmdline, i);
            argv[i] = (char *) (*env)->GetStringUTFChars(env, strr[i], 0);
        }

    }
    //---------------------------------java 数组转C语言数组----------------------------------------
    //---------------------------------执行FFmpeg命令相关----------------------------------------
    //新建线程 执行ffmpeg 命令
    ffmpeg_thread_run_cmd(cmdnum, argv);
    //注册ffmpeg命令执行完毕时的回调
    ffmpeg_thread_callback(ffmpeg_callback);

    free(strr);
    return 0;
}

JNIEXPORT void JNICALL
Java_com_github_xch168_ffmpeg_1cmd_FFmpegCmd_exit(JNIEnv *env, jclass type) {
    (*env)->GetJavaVM(env, &jvm);
    m_clazz = (*env)->NewGlobalRef(env, type);
    ffmpeg_thread_cancel();

}

ffmpeg_thread.h

#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "ffmpeg.h"
#include <pthread.h>
#include <string.h>

int ffmpeg_thread_run_cmd(int cmdnum,char **argv);

void ffmpeg_thread_exit(int ret);

void ffmpeg_thread_callback(void (*cb)(int ret));

void ffmpeg_thread_cancel();

ffmpeg_thread.c

#include "libavcodec/avcodec.h"
#include "ffmpeg_thread.h"
#include "android_log.h"

pthread_t ntid;
char **argvs = NULL;
int num=0;

void *thread(void *arg) {   //执行
    int result = ffmpeg_exec(num, argvs);
    ffmpeg_thread_exit(result);
    return ((void *)0);
}
/**
 * 新建子线程执行ffmpeg命令
 */
int ffmpeg_thread_run_cmd(int cmdnum,char **argv) {
    num=cmdnum;
    argvs=argv;

    int temp =pthread_create(&ntid,NULL,thread,NULL);
    if(temp!=0) {
        LOGE("can't create thread: %s ",strerror(temp));
        return 1;
    }
    LOGI("create thread succes: %s ",strerror(temp));
    return 0;
}

static void (*ffmpeg_callback)(int ret);

/**
 * 注册线程回调
 */
void ffmpeg_thread_callback(void (*cb)(int ret)) {
    ffmpeg_callback = cb;
}

/**
 * 退出线程
 */
void ffmpeg_thread_exit(int ret) {
    if (ffmpeg_callback) {
        ffmpeg_callback(ret);
    }
    pthread_exit("ffmpeg_thread_exit");
}

/**
 * 取消线程
 */
void ffmpeg_thread_cancel() {
    void *ret=NULL;
    pthread_join(ntid, &ret);
}

Java代码：

FFmpegCmd.java

public class FFmpegCmd
{
    static
    {
        System.loadLibrary("ffmpeg-cmd");
    }

    private static OnCmdExecListener sOnCmdExecListener;
    private static long sDuration;

    public static native int exec(int argc, String[] argv);

    public static native void exit();

    public static void exec(String[] cmds, long duration, OnCmdExecListener listener) {
        sOnCmdExecListener = listener;
        sDuration = duration;

        exec(cmds.length, cmds);
    }

    /**
     * FFmpeg执行结束回调，由C代码中调用
     */
    public static void onExecuted(int ret) {
        if (sOnCmdExecListener != null) {
            if (ret == 0) {
                sOnCmdExecListener.onProgress(sDuration);
                sOnCmdExecListener.onSuccess();
            } else {
                sOnCmdExecListener.onFailure();
            }
        }
    }

    /**
     * FFmpeg执行进度回调，由C代码调用
     */
    public static void onProgress(float progress) {
        if (sOnCmdExecListener != null) {
            if (sDuration != 0) {
                sOnCmdExecListener.onProgress(progress / (sDuration / 1000) * 0.95f);
            }
        }
    }

    public interface OnCmdExecListener {
        void onSuccess();

        void onFailure();

        void onProgress(float progress);
    }
}

FFmpegUtil.java

// 封装FFmpeg命令的调用
public class FFmpegUtil {
    private static final String TAG = "FFmpegUtil";

    public static void execCmd(CmdList cmd, long duration, final OnVideoProcessListener listener) {
        String[] cmds = cmd.toArray(new String[cmd.size()]);
        Log.i(TAG, "cmd:" + cmd);
        listener.onProcessStart();
        FFmpegCmd.exec(cmds, duration, new FFmpegCmd.OnCmdExecListener() {
            @Override
            public void onSuccess() {
                listener.onProcessSuccess();
            }

            @Override
            public void onFailure() {
                listener.onProcessFailure();
            }

            @Override
            public void onProgress(float progress) {
                listener.onProcessProgress(progress);
            }
        });
    }
}

CmdList.java

public class CmdList extends ArrayList<String> {
    public CmdList append(String s) {
        this.add(s);
        return this;
    }

    public CmdList append(int i) {
        this.add(i + "");
        return this;
    }

    public CmdList append(float f) {
        this.add(f + "");
        return this;
    }

    public CmdList append(StringBuilder sb) {
        this.add(sb.toString());
        return this;
    }

    public CmdList append(String[] ss) {
        for (String s:ss) {
            if(!s.replace(" ","").equals("")) {
                this.add(s);
            }
        }
        return this;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (String s : this) {
            sb.append(" ").append(s);
        }
        return sb.toString();
    }
}

调用FFmpeg命令

long duration = endTime - startTime;
// 构建一条视频裁剪命令
CmdList cmd = new CmdList();
cmd.append("ffmpeg");
cmd.append("-y");
cmd.append("-ss").append(startTime/ 1000).append("-t").append(duration / 1000).append("-accurate_seek");
cmd.append("-i").append(srcFile);
cmd.append("-codec").append("copy").append(destFile);

FFmpegUtil.execCmd(cmd, duration, new OnVideoProcessListener() {
    @Override
    public void onProcessStart() {}

    @Override
    public void onProcessProgress(float progress) {}

    @Override
    public void onProcessSuccess() {}

    @Override
    public void onProcessFailure() {}
}

下面在来看看视频剪切，转码与添加水印的核心代码

1、视频转码

视频转码包括格式、码率、尺寸大小等转换，-f代表强制转换格式，-b代表码率，-s代表尺寸，-r代表帧率：

/**
     * 使用ffmpeg命令行进行视频转码
     * @param srcFile 源文件
     * @param targetFile 目标文件（后缀指定转码格式）
     * @return 转码后的文件
     */
    public static String[] transformVideo(String srcFile, String targetFile){
        String transformVideoCmd = "ffmpeg -i %s -r 25 -b 200 -s 1080x720 %s";
        transformVideoCmd = String.format(transformVideoCmd, srcFile, targetFile);
        return transformVideoCmd.split(" ");//以空格分割为字符串数组
    }

2、视频剪切

视频剪切是从视频指定开始时间，剪切指定时长视频，-ss代表开始时间，-t代表时长：

/**
     * 使用ffmpeg命令行进行视频剪切
     * @param srcFile 源文件
     * @param startTime 剪切的开始时间(单位为秒)
     * @param duration 剪切时长(单位为秒)
     * @param targetFile 目标文件
     * @return 剪切后的文件
     */
    public static  String[] cutVideo(String srcFile, int startTime, int duration, String targetFile){
        String cutVideoCmd = "ffmpeg -i %s -ss %d -t %d %s";
        cutVideoCmd = String.format(cutVideoCmd, srcFile, startTime, duration, targetFile);
        return cutVideoCmd.split(" ");//以空格分割为字符串数组
    }

3、视频截图

视频截图是从视频截取当前一帧画面，保存为指定格式的图片，使用image2工具：

/**
     * 使用ffmpeg命令行进行视频截图
     * @param srcFile 源文件
     * @param size 图片尺寸大小
     * @param targetFile 目标文件
     * @return 截图后的文件
     */
    public static  String[] screenShot(String srcFile, String size, String targetFile){
        String screenShotCmd = "ffmpeg -i %s -f image2 -t 0.001 -s %s %s";
        screenShotCmd = String.format(screenShotCmd, srcFile, size, targetFile);
        return screenShotCmd.split(" ");//以空格分割为字符串数组
    }

4、添加水印

给视频添加水印包括：文字和图片，使用到filter_complex滤波器，overlay指定图片在视频的位置：

/**
     * 使用ffmpeg命令行给视频添加水印
     * @param srcFile 源文件
     * @param waterMark 水印文件路径
     * @param targetFile 目标文件
     * @return 添加水印后的文件
     */
    public static  String[] addWaterMark(String srcFile, String waterMark, String targetFile){
        String waterMarkCmd = "ffmpeg -i %s -i %s -filter_complex overlay=0:0 %s";
        waterMarkCmd = String.format(waterMarkCmd, srcFile, waterMark, targetFile);
        return waterMarkCmd.split(" ");//以空格分割为字符串数组
    }