Swift与硬件打交道封装的方法二

之前写过一篇Swift与硬件打交道封装的方法，现在又开始做硬件开发了，主要方向是音频(AudioUnit)视频的采集、播放、合成、以及蓝牙、socket通讯，这里继续记录下开发中封装的一些方法，以便以后再次使用。

获取AudioBuffer中音频数据的平均分贝值

这里是AudioBuffer，且采样位数为16bit，如果是Data类型，也可以按照下文的方法将Data转为UInt16数组再计算（如果采样位数为8bit，需要用Int8计算）
(DBSPL)

    private func getVolumeValue(buffer: AudioBuffer) {
        var pcmAll: Int = 0
        let bufferPoint = UnsafeMutableBufferPointer.init(buffer)
        let bufferArray = Array(bufferPoint)
        let len = bufferArray.count
        for index in 0.. 0 {
            value = db/(97-42)
        }
        print(value)
    }

附DBFS计算(电平表显示)

private func getVolumeValue(buffer: AudioBuffer) {
        let bufferPoint = UnsafeMutableBufferPointer.init(buffer)
        let originalArray = Array(bufferPoint)
        let dic = [
            64: 8,
            128: 16,
            256: 24,
            512: 32,
            1024: 64,
            2048: 128
        ]
        let base = dic[originalArray.count] ?? 16
        var index = base
        var bufferArray = [Int16]()
        while index < originalArray.count {
            bufferArray.append(originalArray[index])
            index += base
        }
        DispatchQueue.global().async {
            let maxValue = bufferArray.max() ?? 0
            let minValue = bufferArray.min() ?? 0
            let value = max(maxValue, abs(minValue))
            let volume: Double = 20 * log10(Double(value)/65535)
            guard "\(volume)" != "nan" else { return }
            self.delegate?.audioRecorder(recorder: self, didUpdate: volume)
        }
    }

根据PCM数据长度生成WAV音频的头

func getWavHeader(asbd: WSASBD, pcmDataLen: Int) -> Data {
        var wavHeader = Data(count: 44)
        // RIFF
        wavHeader[0 ... 3] = "RIFF".data(using: .ascii)!

        // 04~07 文件长度，暂时不填

        // wave
        wavHeader[8 ... 11] = "WAVE".data(using: .ascii)!

        // fmt
        wavHeader[12 ... 15] = "fmt ".data(using: .ascii)!

        // 过滤字节 00000010
        wavHeader[16 ... 19] = withUnsafeBytes(of: UInt32(littleEndian: 16)) { Data($0) }

        // 格式种类(值为1时,表示数据为线性pcm编码)
        wavHeader[20] = 1
        wavHeader[21] = 0

        // chanel
        wavHeader[22] = UInt8(asbd.channels)
        wavHeader[23] = 0

        let samplerate = UInt32(littleEndian: UInt32(asbd.sampleRate))
        wavHeader[24 ... 27] = withUnsafeBytes(of: samplerate) { Data($0) }

        let bitRate = UInt32(littleEndian: UInt32(asbd.sampleRate) * asbd.channels * asbd.mBitsPerChannel / 8)
        wavHeader[28 ... 31] = withUnsafeBytes(of: bitRate) { Data($0) }

        let sampleBit = UInt16(littleEndian: UInt16(asbd.channels * asbd.mBitsPerChannel / 8))
        wavHeader[32 ... 33] = withUnsafeBytes(of: sampleBit) { Data($0) }

        wavHeader[34] = UInt8(asbd.mBitsPerChannel)
        wavHeader[35] = 0

        // data
        wavHeader[36 ... 39] = "data".data(using: .ascii)!

        // 04~07 文件长度
        wavHeader[4 ... 7] = withUnsafeBytes(of: UInt32(littleEndian: UInt32(pcmDataLen + 44 - 8))) { Data($0) }
        // 40-43 PCM数据大小
        wavHeader[40 ... 43] = withUnsafeBytes(of: UInt32(littleEndian: UInt32(pcmDataLen))) { Data($0) }
        return wavHeader
    }

struct WSASBD {
    /// 声道数
    var channels: UInt32 = 1
    /// 采样率：
    var sampleRate: Double = 48000
    /// 位深
    var mBitsPerChannel: UInt32 = 16
}

检测是否有耳机设备

监听设备变化的通知名字AVAudioSession.routeChangeNotification

private func getHeadPhoneState(){
        var state = false
        for outPort in AVAudioSession.sharedInstance().currentRoute.outputs {
            if outPort.portType == .headphones ||
                outPort.portType == .bluetoothA2DP ||
                outPort.portType == .bluetoothHFP
            {
                state = true
                break
            }
        }
        hasHeadPhone = state
    }

Double 类型与 Data 类型互转

这里举例Double类型，其他类型可以以此类推

let value = Date().timeIntervalSince1970
//Double转data
let data = withUnsafeBytes(of: value) { Data($0) }
//data转Double
var value2 = 0.0
let _ = withUnsafeMutableBytes(of: &value2, { data.copyBytes(to: $0)} )
print(value2)

Data 转Int16数组

let data = Data([0, 7, 3, 2, 1, 0, 0, 4])
let int16array = data.withUnsafeBytes {
     Array($0.bindMemory(to: Int16.self)).map(Int16.init(bigEndian:))
}
print(int16array)

Data 截取及移除

extension Data{
    func getSubData(start: Int, num: Int) -> Data?{
        guard start >= 0 && num >= 0 else { return nil }
        guard self.count >= start + num else {
            return nil
        }
        let startIndex = self.index(self.startIndex, offsetBy: start)
        let endIndex = self.index(self.startIndex, offsetBy: start + num)
        let range = startIndex.. Data?{
        guard start >= 0 && num >= 0 else { return nil }
        guard self.count >= start + num else {
            return nil
        }
        let byte = [UInt8](self)
        return Data(byte[start...start+num])
    }
}

private func removeSubData(data: inout Data, start: Int, num: Int){
        guard start >= 0 && num >= 0 else { return }
        guard data.count >= start + num else { return }
        let startIndex = data.index(data.startIndex, offsetBy: start)
        let endIndex = data.index(data.startIndex, offsetBy: start + num)
        let range = startIndex..

十六进制数据 与Data互转 以及大小端模式

在转大小端时，需要先确定转出的数据需要占几个字节，例如需要占2字节则使用UInt16、需要占4字节用Uint32，以此类推，例如我要将0x06转为2字节的Data

let bigEndianData = withUnsafeBytes(of: UInt16(bigEndian: UInt16(0x06))) { Data($0) } //大端 0x0006
var lc: UInt16 = 0
(bigEndianData as NSData).getBytes(&lc, range: NSMakeRange(0, bigEndianData.count))
let bigEndianValue = Int(UInt16(bigEndian: lc)) //6
let littleEndianData = withUnsafeBytes(of: UInt16(littleEndian: UInt16(0x06))) { Data($0) } //小端 0x0600
(littleEndianData as NSData).getBytes(&lc, range: NSMakeRange(0, littleEndianData.count))
let littleEndianValue = Int(UInt16(littleEndian: lc)) //6