Android实现静音检测功能

/**
  * 计算音量
  *
  * @param buffer 录音数据
  * @return 音强
  */
 public static double calculateVolume(byte[] buffer) {
     double sumVolume = 0.0;
     double avgVolume = 0.0;
     double volume = 0.0;

     for (int i = 0; i < buffer.length; i += 2) {
         int v1 = buffer[i] & 0xFF;
         int v2 = buffer[i + 1] & 0xFF;
         int temp = v1 + (v2 << 8);
         if (temp >= 0x8000) {
             temp = 0xffff - temp;
         }
         sumVolume += Math.abs(temp);
     }
     avgVolume = sumVolume / buffer.length / 2;
     volume = Math.log10(1 + avgVolume) * 10;
     return volume;
 }

class VadManager : VadInterface {
    /**
     * vad 配置
     */
    private var mConfig: Config? = null

    /**
     * 录音取数据次数
     */
    private var mCount = 0

    /**
     * 前端点静音次数
     */
    private var mBeginMuteCount = 0

    /**
     * 前端点最大静音次数
     */
    private var mBeginMuteMaxCount = 9

    /**
     * 后端点静音次数
     */
    private var mEndMuteCount = 0

    /**
     * 后端点最大静音次数
     */
    private var mEndMuteMaxCount = 9

    companion object {
        /**
         * 收集录音时长是200毫秒
         */
        const val RECORD_DATA_TIME = 200

        /**
         * 静音值
         */
        const val MUTE_VOLUME = 18.0

        @Volatile
        private var instance: VadInterface? = null

        @JvmStatic
        fun getInstance(): VadInterface {
            if (instance == null) {
                synchronized(VadManager::class.java) {
                    if (instance == null) {
                        instance = VadManager()
                    }
                }
            }
            return instance!!
        }
    }

    override fun startVad(config: Config?) {
        mConfig = config
        mConfig?.let {
            if (it.vadEnable) {
                if (it.vadBos > 0) {
                    mBeginMuteMaxCount = it.vadBos / RECORD_DATA_TIME
                }
                if (it.vadEos > 0) {
                    mEndMuteMaxCount = it.vadEos / RECORD_DATA_TIME
                }
            }
        }

    }

    override fun canStopRecord(volume: Double): Boolean {
        L.i("volume", volume.toString())
        mCount++
        mConfig?.let {
            if (!it.vadEnable) {
                return false
            }
            if (mCount <= mBeginMuteMaxCount) {
                //前端点连续静音计数
                if (volume <= MUTE_VOLUME) {
                    mBeginMuteCount++
                } else {
                    mBeginMuteCount = 0
                }
            } else if (mCount == mBeginMuteMaxCount + 1) {
                //判断是否达到前端点最大静音次数
                if (mBeginMuteCount >= mBeginMuteMaxCount) {
                    closeVad()
                    return true
                }
            } else {
                //后端点连续静音计数
                if (volume <= MUTE_VOLUME) {
                    mEndMuteCount++
                } else {
                    mEndMuteCount = 0
                }
                //如果达到静音最大次数停止录音
                if (mEndMuteCount >= mEndMuteMaxCount) {
                    closeVad()
                    return true
                }
            }
            return false
        }
        return false
    }

    private fun closeVad() {
        mConfig = null
        mCount = 0
        mBeginMuteCount = 0
        mBeginMuteMaxCount = 9
        mEndMuteCount = 0
        mEndMuteMaxCount = 9
    }
}