利用Audio Queue Services录音实战

利用Audio Queue Services录音实战

1.前言

​ 在开了好几个学习笔记博客坑没更新之后，我又来写一个新玩意，而那些我立个flag，我一定会补上更新的，一定！

​ Audio Queue Services是Apple用于录制或播放音频的软件对象。Audio queue services允许您以线性PCM、压缩格式(如Apple无损和AAC)以及用户已安装编解码器的其他格式录制和播放音频。音频队列服务还支持多个音频队列的预定回放和同步，以及音频与视频的同步。

​ 以上摘自apple documentation，简单来说，这个工具可以对音频数据进行实时处理，在某些方面是有极大用处的，因为普通的audio player是等整个资源全部加载完毕再进行处理的。

​ 为什么要写这个呢，因为我做了这件事呀，而且好像很少关于怎么具体去用这个工具去录音和播放的，而我，刚好用到了录音功能，于是乎，我来写写吧。

2.正言

2.1 关于Audio Queue Services

​ 这个我不多讲，因为不论是百度还是Google你会看到很多关于这个的讲解，所以我的重点在于怎么去写，那么不得不提的是指针，对，在swift里我们也要碰指针了，因为这个工具是C实现的，有些底层，而在swift 里指针一律以Unsafe冠名，可见swift对于指针的抵触，但没办法🤷‍♂️，我们还是得迎难而上。

​ 一张很普遍的图来揭示Audio Queue Services的面目

​ 这些buffers就是最主要的东西，我们要做的就是填满buffer，取出buffer中的数据，放回buffer，周而复始

2.2 整体框架

​ 就像上图看到的callback，整个由录音，buffers，callback组成，callback里就是我们对于每个buffer的处理，先上我写的callback函数

2.2.1 callback

func AQAudioQueueInputCallback(inUserData: UnsafeMutableRawPointer?,
                               inAQ: AudioQueueRef,
                               inBuffer: AudioQueueBufferRef,
                               inStartTime: UnsafePointer<AudioTimeStamp>,
                               inNumberPacketDescriptions: UInt32,
                               inPacketDescs: UnsafePointer<AudioStreamPacketDescription>?) {
    let audioService = unsafeBitCast(inUserData!, to:AudioService.self)
    if inBuffer.pointee.mAudioDataByteSize == 0 {
        //audioService.isLastFrame = "0"
        return
    }
    audioService.writePackets(inBuffer: inBuffer)
    AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, nil);
    
    //print("startingPacketCount: \(audioService.startingPacketCount), maxPacketCount: \(audioService.maxPacketCount)")
    if (audioService.maxPacketCount <= audioService.startingPacketCount) {
        audioService.stopRecord()
    }
}

​ 函数声明中的参数很多我没用到，就不解释了，因为后面的类型把这些参数的意义表示的很清楚，其一是inUserData，这里面存储的就是buffer里的声音数据，其二是inBuffer，这个就是包含音频数据的buffer。

​ 函数里面第一个unsafeBitCast是强制类型转换，把指针里的原生数据转成音频数据，现在看可能比较突兀嗷，在初始化的时候你会明白的，然后是做判断，如果buffer里没数据，那么回调结束直接return，不然的话就执行具体的函数并在这之后调用AudioQueueEnqueueBuffer函数，把buffer放回队列中，这里0就是清空这个buffer，nil就是指针指向空。

​ 总所周知，指针的大小是要事先申请的，这也就意味着我们的录音会有时长限制，也许可以没有，但我还没研究出来，而且我做的项目并不需要无限制录音，我也就没管，所以最后的这个判断就是我是否已经写满了我的大的指针数据，写满了后面再录音也不会存进来了。

2.2.2 init

var buffer: UnsafeMutableRawPointer
var audioQueueObject: AudioQueueRef?
//let numPacketsToRead: UInt32 = 44100
var numPacketsToWrite: UInt32 = 44100*3
var startingPacketCount: UInt32
var maxPacketCount: UInt32
let bytesPerPacket: UInt32 = 2
let seconds: UInt32 = 200
var audioFormat: AudioStreamBasicDescription {
  return AudioStreamBasicDescription(mSampleRate: 44100.0,
                                     mFormatID: kAudioFormatLinearPCM,
                                     mFormatFlags: AudioFormatFlags(kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked),
                                     mBytesPerPacket: 2,
                                     mFramesPerPacket: 1,
                                     mBytesPerFrame: 2,
                                     mChannelsPerFrame: 1,
                                     mBitsPerChannel: 16,
                                     mReserved: 0)
}
var data: NSData? {
  didSet {
    NotificationCenter.default.post(name: .audioServiceDidUpdateData, object: self)
  }
}

init(_ obj: Any?) {
  startingPacketCount = 0
  maxPacketCount = (44100 * seconds)
  buffer = UnsafeMutableRawPointer(malloc(Int(maxPacketCount * bytesPerPacket)))
}

参数讲解：

buffer：原生指针，用来存放整个音频数据

audioQueueObject：音频队列的寄存器，用这个来进行录音开始结束等系列操作

numPacketsToWrite：每个buffer里的数据大小，44100是采样率，*3就表明我一个buffer存3秒的音频数据

startingPacketCount：每次读buffer时进行计数防止超过最大录音时间

maxPacketCount：就是最大录音时长对应的数据量

bytesPerPacket：每个数据的字节数

seconds：最大时长

然后这个audioFormat就是普遍录音前要设置的采样率，通道数等等数据

data：我个人设置的对于其中一些数据临时取出处理的参数

然后init函数里就是我对于以上一些参数的初始化

2.2.3 start&stop

func startRecord() {
        buffer = UnsafeMutableRawPointer(malloc(Int(maxPacketCount * bytesPerPacket)))
        guard audioQueueObject == nil else  { return }
        data = nil
        prepareForRecord()
        let err: OSStatus = AudioQueueStart(audioQueueObject!, nil)
        print("err: \(err)")
    }

startRecord里主要就是再把数据初始化一下防止出错，重要的在prepareForRecord里，准备完了之后就开始录音

private func prepareForRecord() {
        print("prepareForRecord")
        var audioFormat = self.audioFormat
        AudioQueueNewInput(&audioFormat,
                           AQAudioQueueInputCallback,
                           unsafeBitCast(self, to: UnsafeMutableRawPointer.self),
                           CFRunLoopGetCurrent(),
                           CFRunLoopMode.commonModes.rawValue,
                           0,
                           &audioQueueObject)
        startingPacketCount = 0;
        var buffers = Array<AudioQueueBufferRef?>(repeating: nil, count: 3)
        let bufferByteSize: UInt32 = numPacketsToWrite * audioFormat.mBytesPerPacket
        for bufferIndex in 0 ..< buffers.count {
            AudioQueueAllocateBuffer(audioQueueObject!, bufferByteSize, &buffers[bufferIndex])
            AudioQueueEnqueueBuffer(audioQueueObject!, buffers[bufferIndex]!, 0, nil)
        }
    }

​ 小重点来了嗷，AudioQueueNewInput就是创建一个新的音频队列对象，在这里面第一个就是设置音频格式，第二个是指定回调函数，第三个是用于回调的数据结构，我们这里就定为指针，第四个和第五个是回调函数的线程问题，我这里把它们放在录音的音频队列的内部线程里，第六个就必须是0，最后一个是在输出端，新创建的录制音频队列。

​ 后面两句就是创建3个3秒的buffer，在循环体里做的是对缓冲区的处理和重新排队，防止错乱

func stopRecord() {
        AudioQueueStop(audioQueueObject!, true)
        AudioQueueDispose(audioQueueObject!, true)
        audioQueueObject = nil
        data = NSData(bytesNoCopy: buffer, length: Int(startingPacketCount * bytesPerPacket))
    }

​ 这里就是先把录音停了，然后把还在缓冲区里还没处理完的buffer拿出来处理，到最后这个data相当于取出来了整个音频数据

2.2.4 对每个buffer进行个性化处理

​ 之所以叫个性化，其实是因为每个人真对自己要做的项目做自己的处理，我这里呢做的是把每段封装成wav格式进行网络上传

func writePackets(inBuffer: AudioQueueBufferRef) {
        //print("writePackets mAudioDataByteSize: \(inBuffer.pointee.mAudioDataByteSize), numPackets: \(inBuffer.pointee.mAudioDataByteSize / 2)")
        var numPackets: UInt32 = (inBuffer.pointee.mAudioDataByteSize / bytesPerPacket)
        if ((maxPacketCount - startingPacketCount) < numPackets) {
            numPackets = (maxPacketCount - startingPacketCount)
        }
        /*
  				**do what you wanna do
  			*/
        if 0 < numPackets {
            memcpy(buffer.advanced(by: Int(bytesPerPacket * startingPacketCount)),
                   inBuffer.pointee.mAudioData,
                   Int(bytesPerPacket * numPackets))
            startingPacketCount += numPackets;
        }
    }

这里面的东西就比较直观了，前面做计算，后面把数据整个移进buffer（之前声明的变量里）

ps：我们录音得到的是原生的pcm数据，要封装成wav还得加头部，我这里把代码放出来

public func writewaveFileHeader(input: NSData, totalAudioLen: Int64, totalDataLen: Int64, longSampleRate: Int64, channels: Int, byteRate: Int64) -> NSMutableData{
        var header: [UInt8] = Array(repeating: 0, count: 44)
        let postData:NSMutableData = NSMutableData()
        // RIFF/WAVE header
        header[0] = UInt8(ascii: "R")
        header[1] = UInt8(ascii: "I")
        header[2] = UInt8(ascii: "F")
        header[3] = UInt8(ascii: "F")
        header[4] = (UInt8)(totalDataLen & 0xff)
        header[5] = (UInt8)((totalDataLen >> 8) & 0xff)
        header[6] = (UInt8)((totalDataLen >> 16) & 0xff)
        header[7] = (UInt8)((totalDataLen >> 24) & 0xff)
        
        //WAVE
        header[8] = UInt8(ascii: "W")
        header[9] = UInt8(ascii: "A")
        header[10] = UInt8(ascii: "V")
        header[11] = UInt8(ascii: "E")
        
        // 'fmt' chunk
        header[12] = UInt8(ascii: "f")
        header[13] = UInt8(ascii: "m")
        header[14] = UInt8(ascii: "t")
        header[15] = UInt8(ascii: " ")
        
        // 4 bytes: size of 'fmt ' chunk
        header[16] = 16
        header[17] = 0
        header[18] = 0
        header[19] = 0
        
        // format = 1
        header[20] = 1
        header[21] = 0
        header[22] = UInt8(channels)
        header[23] = 0
        
        header[24] = (UInt8)(longSampleRate & 0xff)
        header[25] = (UInt8)((longSampleRate >> 8) & 0xff)
        header[26] = (UInt8)((longSampleRate >> 16) & 0xff)
        header[27] = (UInt8)((longSampleRate >> 24) & 0xff)
        
        header[28] = (UInt8)(byteRate & 0xff)
        header[29] = (UInt8)((byteRate >> 8) & 0xff)
        header[30] = (UInt8)((byteRate >> 16) & 0xff)
        header[31] = (UInt8)((byteRate >> 24) & 0xff)
        
        // block align
        header[32] = UInt8(2 * 16 / 8)
        header[33] = 0
        
        // bits per sample
        header[34] = 16
        header[35] = 0
        
        //data
        header[36] = UInt8(ascii: "d")
        header[37] = UInt8(ascii: "a")
        header[38] = UInt8(ascii: "t")
        header[39] = UInt8(ascii: "a")
        header[40] = UInt8(totalAudioLen & 0xff)
        header[41] = UInt8((totalAudioLen >> 8) & 0xff)
        header[42] = UInt8((totalAudioLen >> 16) & 0xff)
        header[43] = UInt8((totalAudioLen >> 24) & 0xff)
        
        postData.append(header, length: header.count)
        postData.append(input as Data)
        
        return postData
    }
    
}

就对着这个函数体写参数就行了

3.小结

​ 这个Audio Queue Services是在AudioToolbox里，所以得import这个，看起来不难，其实你要是去细纠指针的操作，那就是另一回事了。

​ 希望我能尽快填了前面开的博客的坑，唉