一、为什么要在NDK里写音频效果？

说实话，我刚开始做Android音频开发时，也纠结过这个问题。Java层写起来多快啊，何必自讨苦吃去碰C++？

但后来我接手了一个实时变声项目。用户说话的同时，要完成音调调整、混响叠加、噪声抑制。Java层处理完一帧数据，延迟已经飙到200ms以上了。用户说一句话，半秒后才听到自己的变声效果——这体验，你想想看，谁受得了？

嗯，这就是NDK的价值所在。说白了，音频效果处理对实时性要求极高。Java的GC暂停、JNI调用开销、内存拷贝，每一个都是延迟的元凶。而C++代码直接跑在native层，没有虚拟机干预，性能可控得多。

二、JNI桥接：Java和C++怎么“通话”？

2.1 基本流程

JNI（Java Native Interface）就是一座桥。Java端调用native方法，C++端实现这些方法。数据通过这座桥来回传递。

我个人习惯把JNI层写得尽量薄。它只负责数据搬运，不负责业务逻辑。业务逻辑全在C++层，这样测试和维护都方便。

// Java端声明
public class AudioEffectEngine {
    static {
        System.loadLibrary("audio_effect");
    }
    
    // 初始化引擎
    public native long nativeCreate();
    
    // 处理音频数据
    public native void nativeProcess(long engineHandle, 
                                     short[] inputData, 
                                     short[] outputData, 
                                     int sampleCount);
    
    // 销毁引擎
    public native void nativeDestroy(long engineHandle);
}

// C++端实现
extern "C" JNIEXPORT jlong JNICALL
Java_com_example_audio_AudioEffectEngine_nativeCreate(
    JNIEnv* env, jobject thiz) {
    AudioEffectEngine* engine = new AudioEffectEngine();
    return reinterpret_cast<jlong>(engine);
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_audio_AudioEffectEngine_nativeProcess(
    JNIEnv* env, jobject thiz,
    jlong engineHandle,
    jshortArray inputData,
    jshortArray outputData,
    jint sampleCount) {
    
    AudioEffectEngine* engine = 
        reinterpret_cast<AudioEffectEngine*>(engineHandle);
    
    // 获取Java数组指针
    jshort* in = env->GetShortArrayElements(inputData, nullptr);
    jshort* out = env->GetShortArrayElements(outputData, nullptr);
    
    // 调用C++核心处理
    engine->process(in, out, sampleCount);
    
    // 释放数组引用
    env->ReleaseShortArrayElements(inputData, in, JNI_ABORT);
    env->ReleaseShortArrayElements(outputData, out, 0);
}

2.2 数据传递的坑

我曾经踩过一个坑：每次处理都调用GetShortArrayElements和ReleaseShortArrayElements。这在低频调用时没问题，但音频数据是每帧都要传的，每秒可能几十次。每次调用都有JNI开销和内存拷贝。

后来我改用Direct Buffer技术。Java端分配一块直接内存，C++端直接读写这块内存，省去了拷贝过程。

三、C++编写音频效果：从简单到复杂

3.1 一个简单的增益效果

先来个热身。增益效果就是把每个采样点乘以一个系数。代码很简单，但麻雀虽小五脏俱全。

class AudioEffectEngine {
private:
    float mGain;  // 增益系数，范围0.0 ~ 1.0
    
public:
    AudioEffectEngine() : mGain(0.8f) {}
    
    void setGain(float gain) {
        mGain = gain;
    }
    
    void process(short* input, short* output, int sampleCount) {
        for (int i = 0; i < sampleCount; i++) {
            // 转成浮点处理，避免精度丢失
            float sample = input[i] / 32768.0f;
            sample *= mGain;
            // 防溢出裁剪
            if (sample > 1.0f) sample = 1.0f;
            if (sample < -1.0f) sample = -1.0f;
            output[i] = static_cast<short>(sample * 32768.0f);
        }
    }
};

你可能会问：为什么不用整数直接乘？嗯，这里有个细节。整数乘法容易溢出，而且精度不够。转成浮点处理，虽然多了一步转换，但效果质量好得多。我在项目中测试过，浮点版本的失真度比整数版本低了两个数量级。

3.2 更复杂的混响效果

混响就复杂多了。它需要维护一个延迟缓冲区，把过去的采样点叠加到当前信号上。说白了，就是让声音听起来像在房间里回荡。

class ReverbEffect {
private:
    static const int kDelayLength = 44100;  // 1秒延迟
    float* mDelayBuffer;
    int mWriteIndex;
    float mDecay;  // 衰减系数
    
public:
    ReverbEffect() : mWriteIndex(0), mDecay(0.5f) {
        mDelayBuffer = new float[kDelayLength]();
    }
    
    ~ReverbEffect() {
        delete[] mDelayBuffer;
    }
    
    void process(float* input, float* output, int sampleCount) {
        for (int i = 0; i < sampleCount; i++) {
            // 从延迟缓冲区读取过去的信号
            int readIndex = mWriteIndex - 22050;  // 0.5秒前
            if (readIndex < 0) readIndex += kDelayLength;
            
            float delayed = mDelayBuffer[readIndex] * mDecay;
            
            // 混合原始信号和延迟信号
            output[i] = input[i] + delayed;
            
            // 写入延迟缓冲区
            mDelayBuffer[mWriteIndex] = output[i];
            mWriteIndex = (mWriteIndex + 1) % kDelayLength;
        }
    }
};

四、NDK的性能优势到底在哪？

光说不练假把式。我们来看一组真实数据。我在同一台手机上，分别用Java和C++实现了相同的音频效果处理，对比结果如下：

测试项目	Java实现	C++ NDK实现	提升幅度
单帧处理耗时（512采样点）	1.2ms	0.08ms	15倍
端到端延迟	80ms	15ms	5.3倍
CPU占用率（持续处理）	35%	8%	4.4倍
GC暂停次数（每分钟）	12次	0次	无GC

为什么会差这么多？原因有三：

1. 没有GC暂停。Java层频繁创建short数组，触发GC时整个音频管线都得等。C++手动管理内存，没有这个问题。
2. 减少内存拷贝。Java和C++之间传数据，如果用Direct Buffer，可以做到零拷贝。Java层每次都要从byte[]拷贝到short[]，再拷贝回去。
3. 指令优化。C++编译器可以做循环展开、SIMD向量化等优化。Java的JIT虽然也能做，但启动慢，而且受限于虚拟机。

五、知识体系总览

下面这张图，是我梳理的本章知识脉络。你可以把它当作一张地图，随时回来查阅。

这张图把本章内容分成了三个模块：JNI桥接层负责Java和C++的通信，C++效果引擎是核心业务逻辑，性能优化则是贯穿始终的指导思想。三者缺一不可。

---

公众号:蓝海资料掘金营，微信deep3321