丢掉龟速的java媒体库，通过Lame实现Android录音同时转换为mp3格式保存

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/zull_kos_mos/article/details/90549834

0.Read Me

Android的媒体处理一直是件让人头疼的事情。Java倒是也有不少媒体第三方的处理库（mp3agic,musicg等）。但是Java那一波三折的运行方式，导致在它在处理大量运算（图像，音频计算等）的时候力不从心。
为此，Java提供了native关键字，通过jni调用C/C++的函数库来充分使用CPU资源。
比如这里有一个需求：Android录音机录音，然后实时的转换成mp3保持在SD卡上

1.Cmake

AS支持cmake之后，ndk的编译变得不再像Android.mk那么痛苦（不过调试还是…
这里准备用Lame库进行音频处理

1.1.处理

lame库下载好后，解压找到libmp3lame目录，保留调.c、.h等文件，复制到项目cpp文件夹下，然后开始对头文件等做些处理。因为Android不支持。

• 1.util.h中extern ieee754_float32_t fast_log2(ieee754_float32_t x);=>extern float fast_log2(float x);
• 2.id3tag.c、machine.h中将HAVE_STRCHR和HAVE_MEMCPY的ifdef结构体删掉
• 3.fft.c中去除vector/lame_intrin.h的头文件引用
• 4.set_get.h中将include <lame.h>改为include "lame.h"

2.jni

编写jni接口

2.1.C引用

函数名指向Java中的全路径名，用下划线 _分隔

#include <cwchar>
#include "lame_util.h"
#include "lamemp3/lame.h"
#include <jni.h>
static lame_global_flags *glf = NULL;

void Java_cos_mos_recorder_decode_ULame_close(JNIEnv *env, jclass type){
    lame_close(glf);
    glf = NULL;
}

jint Java_cos_mos_recorder_decode_ULame_encode(JNIEnv *env, jclass type, jshortArray buffer_l_,
                                        jshortArray buffer_r_, jint samples, jbyteArray mp3buf_) {
    jshort *buffer_l = env->GetShortArrayElements(buffer_l_, NULL);
    jshort *buffer_r = env->GetShortArrayElements(buffer_r_, NULL);
    jbyte *mp3buf = env->GetByteArrayElements(mp3buf_, NULL);
    const jsize mp3buf_size = env->GetArrayLength(mp3buf_);
    int result =lame_encode_buffer(glf, buffer_l, buffer_r, samples, (u_char*)mp3buf, mp3buf_size);
    env->ReleaseShortArrayElements(buffer_l_, buffer_l, 0);
    env->ReleaseShortArrayElements(buffer_r_, buffer_r, 0);
    env->ReleaseByteArrayElements(mp3buf_, mp3buf, 0);
    return result;
}

jint Java_cos_mos_recorder_decode_ULame_flush(JNIEnv *env, jclass type, jbyteArray mp3buf_) {
    jbyte *mp3buf = env->GetByteArrayElements(mp3buf_, NULL);
    const jsize  mp3buf_size = env->GetArrayLength(mp3buf_);
    int result = lame_encode_flush(glf, (u_char*)mp3buf, mp3buf_size);
    env->ReleaseByteArrayElements(mp3buf_, mp3buf, 0);
    return result;
}

void Java_cos_mos_recorder_decode_ULame_init(JNIEnv *env, jclass type, jint inSampleRate, jint outChannel,
                                             jint outSampleRate, jint outBitrate, jint quality) {
    if(glf != NULL){
        lame_close(glf);
        glf = NULL;
    }
    glf = lame_init();
    lame_set_in_samplerate(glf, inSampleRate);
    lame_set_num_channels(glf, outChannel);
    lame_set_out_samplerate(glf, outSampleRate);
    lame_set_brate(glf, outBitrate);
    lame_set_quality(glf, quality);
    lame_init_params(glf);
}

2.2.C头文件

#include <jni.h>

extern "C"
{
void Java_cos_mos_recorder_decode_ULame_close(JNIEnv *env, jclass type);

jint Java_cos_mos_recorder_decode_ULame_encode(JNIEnv *env, jclass type, jshortArray buffer_l_,
                                               jshortArray buffer_r_, jint samples,
                                               jbyteArray mp3buf_);

jint Java_cos_mos_recorder_decode_ULame_flush(JNIEnv *env, jclass type, jbyteArray mp3buf_);

void Java_cos_mos_recorder_decode_ULame_init(JNIEnv *env, jclass type, jint inSampleRate,
                                                    jint outChannel, jint outSampleRate,
                                                    jint outBitrate, jint quality);
}

2.3.Java的方法映射

各个参数的描述我直接写在注释里，这里就不多说了。
注意包名，这里和2.2、2.3中的函数名对应

package cos.mos.recorder.decode;

/**
 * @Description: Lame的jni映射库
 * @Author: Kosmos
 * @Date: 2019.05.24 23:36
 * @Email: [email protected]
 */
public class ULame {
    static {
        System.loadLibrary("lame");
    }

    /**
     * @param inSamplerate  采样率(Hz)
     * @param inChannel     流中的通道数
     * @param outSamplerate 输出采样率(Hz)
     * @param outBitrate    压缩比(KHz)
     * @param quality       mp3质量
     * @apiNote 初始化
     * 关于质量∈[0,9]
     * 0->最高质量，最慢
     * 9->最低质量，最快
     * 通常：
     * 2->接近最好的质量，不太慢
     * 5->质量好，速度快
     * 7->音质还凑活, 非常快
     */
    public native static void init(int inSamplerate, int inChannel, int outSamplerate,
                                   int outBitrate, int quality);

    /**
     * @param bufferLeft  左声道的PCM数据
     * @param bufferRight 右声道的PCM数据.
     * @param samples     每个采样通道的样本数
     * @param mp3buf      指定最终编码的MP3流=>数组长度=7200+(1.25 * bufferLeft.length)
     *                    "7200 + (1.25 * buffer_l.length)" length array.
     * @return mp3buf中输出的字节数。可以为0。
     * -1: mp3buf太小
     * -2: 内存分配异常
     * -3: lame初始化失败
     * -4: 音质解析异常
     * @apiNote 缓冲区编码为mp3
     */
    public native static int encode(short[] bufferLeft, short[] bufferRight, int samples, byte[] mp3buf);


    /**
     * @param mp3buf 结果编码的MP3流。您必须指定至少7200字节。
     * @return 输出到encode中mp3buf的字节数，可能为0
     * @apiNote flush掉lame的缓冲区
     * 关于刷流：
     * 0.可能会返回最后的几个mp3帧列数组
     * 1.将刷新lame的内部PCM编码缓冲区，不足数列用0补满最终帧
     * 2.encode中的mp3buf至少>7200字节（否则可能一列都不够用）
     * 3.(如果有)将id3v1标签写入比特流
     */
    public native static int flush(byte[] mp3buf);

    /**
     * 关闭Lame.
     */
    public native static void close();
}

3.CmakeList.txt

先看看目录结构，注意，CmakeList.txt和gradle中所有路径的都是写的相对路径。所有下面的内容因项目而异。
具体的参考谷狗的官方文档

具体的我写在注释里

# 编译本地库时，需要的cmake的最低版本
cmake_minimum_required(VERSION 3.4.1)
# 生成的so动态库最后输出的路径
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/src/main/clibs/${ANDROID_ABI})
#设置变量SRC_DIR为lamemp3的所在路径
set(SRC_DIR src/main/cpp/lamemp3)
#指定头文件所在，可以多次调用，指定多个路径
include_directories(src/main/cpp/lamemp3)
#设定一个目录
aux_source_directory(src/main/cpp/lamemp3 SRC_LIST)
#将前面目录下所有的文件都添加进去
add_library(lame SHARED src/main/cpp/lame_util.cpp ${SRC_LIST})
# 添加编译本地库时所需要的依赖库，cmake已经知道系统库的路径，所以这里只需要指定使用log库
find_library(clog log)
target_link_libraries(lame ${clog})

4.build.gradle

见注释

...
android {
    .....
    defaultConfig {
      .....
        //开启Cmake工具
        externalNativeBuild {
            cmake {
                cppFlags ""
                //需要的so版本
                abiFilters 'armeabi-v7a', 'arm64-v8a'
            }
        }
       .....
    }
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
        }
    }
    sourceSets {
        main {
            jniLibs.srcDirs = ['clibs']
        }
    }
   ....
}
....

5.录音MP3Recorder

录音机的相关操作，还是见注释。

这里假装科普下：

• 1.Android的AudioRecord录音的默认格式为：PCM编码，16Bit、单声道。
• 2.我们平时说的音量其实是一个相对值，
• • 2.1.计算方式：volume=X*log10(P1/P2)
• • 2.2.P1:测量值的声压、P2:参考值的声压、X为参考系数
• • 2.3.人类所能听到的最小声压:20微帕
• 3.人类能听到的声音频率∈[20Hz，20KHz]
• • 3.1.下面的频率计算方式为：FFT(快速傅里叶变换)
• 4.音频帧计算公式： int size = 采样率 * 位宽 * 采样时间 * 通道数
• 5.缓冲区：大小不能低于一音频帧的大小（所以下面代码有个四舍五入到音频帧大小的步骤）
• 6.采样率：每秒钟能够采样的次数

package cos.mos.recorder.decode;

import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;

import java.io.File;
import java.io.IOException;

/**
 * @Description: 录音工具
 * @Author: Kosmos
 * @Date: 2019.05.25 15:16
 * @Email: [email protected]
 */
public class MP3Recorder {
    //Recorder
    private static final int DEFAULT_AUDIO_SOURCE = MediaRecorder.AudioSource.MIC;//音源：麦克风
    private static final int DEFAULT_SAMPLING_RATE = 44100;//采样率：模拟器仅支持从麦克风输入8kHz采样率
    private static final int DEFAULT_CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO;//单声道
    private static final PCMFormat DEFAULT_AUDIO_FORMAT = PCMFormat.PCM_16BIT;///PCM编码,16Bit
    //Lame
    private static final int DEFAULT_LAME_MP3_QUALITY = 7;//音质
    private static final int DEFAULT_LAME_IN_CHANNEL = 1;//mono=>1
    private static final int DEFAULT_LAME_MP3_BIT_RATE = 32;//编码比特率
    //采样配置
    private static final int FRAME_COUNT = 160;//每160帧作为一个数列周期，通知编码
    private AudioRecord record;
    private int bufferSize;
    private short[] bufferPCM;
    private DataEncodeThread encodeThread;
    private boolean isRecording = false;

    /**
     * @apiNote 采样率1通道，16位pcm
     */
    public MP3Recorder() {
    }

    public void start(File targetFile) throws IOException {
        if (isRecording) {
            return;
        }
        isRecording = true; //提早，防止init或startRecording被多次调用
        initAudioRecorder(targetFile);
        record.startRecording();
        new Thread() {
            @Override
            public void run() {
                //设置线程权限
                android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);
                while (isRecording) {
                    int readSize = record.read(bufferPCM, 0, bufferSize);
                    if (readSize > 0) {
                        encodeThread.addTask(bufferPCM, readSize);
                        calculateRealVolume(bufferPCM, readSize);
                    }
                }
                //释放
                record.stop();
                record.release();
                record = null;
                // 等待完成转码
                encodeThread.sendStopMessage();
            }

            /**
             * @apiNote 此计算方法来自samsung开发范例
             * @param buffer buffer
             * @param readSize readSize
             */
            private void calculateRealVolume(short[] buffer, int readSize) {
                double sum = 0;
                for (int i = 0; i < readSize; i++) {
                    // 这里没有做运算的优化，为了更加清晰的展示代码
                    sum += buffer[i] * buffer[i];
                }
                if (readSize > 0) {
                    double amplitude = sum / readSize;
                    mVolume = (int) Math.sqrt(amplitude);
                }
            }
        }.start();
    }

    private int mVolume;

    /**
     * @return 真实音量
     * @apiNote 获取真实的音量。 [算法来自三星]
     */
    public int getRealVolume() {
        return mVolume;
    }

   
    public void stop() {
        isRecording = false;
    }

    public boolean isRecording() {
        return isRecording;
    }

    /**
     * @param targetFile 目标文件
     * @apiNote 初始化
     */
    private void initAudioRecorder(File targetFile) throws IOException {
        bufferSize = AudioRecord.getMinBufferSize(DEFAULT_SAMPLING_RATE, DEFAULT_CHANNEL_CONFIG,
            DEFAULT_AUDIO_FORMAT.getAudioFormat());
        int bytesPerFrame = DEFAULT_AUDIO_FORMAT.getBytesPerFrame();//得到样本个数。计算缓冲区大小
        //四舍五入到给定帧大小，方便整除，以通知
        int frameSize = bufferSize / bytesPerFrame;
        if (frameSize % FRAME_COUNT != 0) {
            frameSize += (FRAME_COUNT - frameSize % FRAME_COUNT);
            bufferSize = frameSize * bytesPerFrame;
        }
        record = new AudioRecord(DEFAULT_AUDIO_SOURCE, DEFAULT_SAMPLING_RATE,
            DEFAULT_CHANNEL_CONFIG, DEFAULT_AUDIO_FORMAT.getAudioFormat(), bufferSize);
        bufferPCM = new short[bufferSize];
        //初始化lame缓冲区mp3采样速率与所记录的pcm采样速率相同，比特率为32kbps
        ULame.init(DEFAULT_SAMPLING_RATE, DEFAULT_LAME_IN_CHANNEL, DEFAULT_SAMPLING_RATE,
            DEFAULT_LAME_MP3_BIT_RATE, DEFAULT_LAME_MP3_QUALITY);
        encodeThread = new DataEncodeThread(targetFile, bufferSize);
        encodeThread.start();
        record.setRecordPositionUpdateListener(encodeThread, encodeThread.getHandler());
        record.setPositionNotificationPeriod(FRAME_COUNT);
    }
}

6.中转

• 1.过程耗时，建议交给子线程做
• 2.从缓冲区读取数据，使用lame编码MP3
• 3.缓冲区不足时，使用lame将所有数据刷新到文件中，并添加MP3尾信息

	/** 
     * @return 从缓冲区中读取的数据的长度（没有数据时返回0）
     */
    private int processData() {
        if (mTasks.size() > 0) {
            Task task = mTasks.remove(0);
            short[] buffer = task.getData();
            int readSize = task.getReadSize();
            int encodedSize = ULame.encode(buffer, buffer, readSize, mp3Buffer);
            if (encodedSize > 0) {
                try {
                    outputStream.write(mp3Buffer, 0, encodedSize);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return readSize;
        }
        return 0;
    }

   private void flushAndRelease() {
        //将MP3尾信息写入buffer中
        final int flushResult = ULame.flush(mp3Buffer);
        if (flushResult > 0) {
            try {
                outputStream.write(mp3Buffer, 0, flushResult);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (outputStream != null) {
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                ULame.close();
            }
        }
    }

---

我有时间把代码脱敏之后，会丢Github上，如果丢上去的发，就是这个地址