AudioStreamBasicDescription

struct AudioStreamBasicDescription
{
    Float64             mSampleRate;
    AudioFormatID       mFormatID;
    AudioFormatFlags    mFormatFlags;
    UInt32              mBytesPerPacket;
    UInt32              mFramesPerPacket;
    UInt32              mBytesPerFrame;
    UInt32              mChannelsPerFrame;
    UInt32              mBitsPerChannel;
    UInt32              mReserved;
};
typedef struct AudioStreamBasicDescription  AudioStreamBasicDescription;

mSampleRate

采样率，每秒多少个采样。如： 16000， 44100， 48000

mFormatID

AudioFormatID 数据流的格式， 如

kAudioFormatLinearPCM               = 'lpcm',
kAudioFormatMPEG4AAC                = 'aac ',
kAudioFormatMPEGLayer3              = '.mp3',

AudioFormatFlags

描述AudioBufferList的格式

    kAudioFormatFlagIsFloat                     = (1U << 0),     // 0x1
    kAudioFormatFlagIsBigEndian                 = (1U << 1),     // 0x2
    kAudioFormatFlagIsSignedInteger             = (1U << 2),     // 0x4
    kAudioFormatFlagIsPacked                    = (1U << 3),     // 0x8
    kAudioFormatFlagIsNonInterleaved            = (1U << 5),     // 0x20

kAudioFormatFlagIsFloat

是否是浮点数， 没有设置，默认是 int 类型

kAudioFormatFlagIsBigEndian

是否是大端， 没有设置，默认是小端

kAudioFormatFlagIsSignedInteger

是否是 signed int， 没有设置，默认是 unsigned int

kAudioFormatFlagIsPacked

是否mBitsPerChannel 会占满整个通道，如果没有占满， 就会依高位对齐或低位对齐。
没有设置的时候，满足 ((mBitsPerSample / 8) * mChannelsPerFrame) == mBytesPerFrame 的条件，默认会设置此选项。

kAudioFormatFlagIsNonInterleaved

是否是平面类型，是否是交错类型。

双声道的情况

• 交错类型的存储为,只有一个通道，通道内左右声道交错存储 LRLRLRLRLRLR
• 非交错情况为， 左右声道分开存储，每个平面，存单独的声道
  • 平面1 LLLLLLLL
  • 平面2 RRRRRRR

mChannelsPerFrame

描述音频通道的个数。单声道 1， 双声道为 2， 多声道 为 n

In audio data a frame is one sample across all channels. In non-interleaved
audio, the per frame fields identify one channel. In interleaved audio, the per
frame fields identify the set of n channels. In uncompressed audio, a Packet is
one frame, (mFramesPerPacket == 1). In compressed audio, a Packet is an
indivisible chunk of compressed data, for example an AAC packet will contain
1024 sample frames.

• 在音频数据中， 一个采样就是 n 个通道的一个数据集合，一个数据帧就是一个采样 one frame = one sample
• 在 pcm 音频中 one packet = one frame
• 在压缩音频中one packet = n frame, 如 one AAC packet = 1024 sample frames

mBitsPerChannel

每个通道的位深 8, 16, 32等。

• kAudioFormatFlagIsSignedInteger 16 ， 每个通道 2 byte
• kAudioFormatFlagIsFloat 32，每个通道 4 byte

mBytesPerFrame

每个数据帧的字节。例如： kAudioFormatFlagIsSignedInteger 16 ， 每个通道 2 byte

• 交错类型 mBitsPerChannel / 8 * mChannelsPerFrame
• 非交错类型 mBitsPerChannel / 8

mFramesPerPacket

每个数据包，包含的采样数

pcm 类型

• 交错 mFramesPerPacket = 1
• 非交错 mFramesPerPacket = mChannelsPerFrame

mBytesPerPacket

每个数据包，包含的字节数

pcm 类型 mBytesPerPacket = mFramesPerPacket * mBytesPerFrame

例 1

• pcm 类型 16bit unsigned int

+ (AudioStreamBasicDescription)intFormatWithNumberOfChannels:(UInt32)channels
                                                  sampleRate:(float)sampleRate
                                               isInterleaved:(BOOL)isInterleaved
{
    AudioStreamBasicDescription asbd;
    UInt32 byteSize = 2;
    asbd.mChannelsPerFrame = channels;
    asbd.mBitsPerChannel = 8 * byteSize;
    if (isInterleaved) {
        asbd.mBytesPerFrame = asbd.mChannelsPerFrame * byteSize;
    } else {
        asbd.mBytesPerFrame = byteSize;
    }

    asbd.mFramesPerPacket = 1;
    asbd.mBytesPerPacket = asbd.mFramesPerPacket * asbd.mBytesPerFrame;

    if (isInterleaved) {
        asbd.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
    } else {
        asbd.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsNonInterleaved;
    }

    asbd.mFormatID = kAudioFormatLinearPCM;
    asbd.mSampleRate = sampleRate;
    asbd.mReserved = 0;
    return asbd;
}

例 2

• pcm 类型 32bit float

+ (AudioStreamBasicDescription)floatFormatWithNumberOfChannels:(UInt32)channels
                                                    sampleRate:(float)sampleRate
                                                 isInterleaved:(BOOL)isInterleaved
{
    AudioStreamBasicDescription asbd;
    UInt32 floatByteSize = sizeof(float);
    asbd.mChannelsPerFrame = channels;
    asbd.mBitsPerChannel = 8 * floatByteSize;
    if (isInterleaved) {
        asbd.mBytesPerFrame = asbd.mChannelsPerFrame * floatByteSize;
    } else {
        asbd.mBytesPerFrame = floatByteSize;
    }

    asbd.mFramesPerPacket = 1;
    asbd.mBytesPerPacket = asbd.mFramesPerPacket * asbd.mBytesPerFrame;

    if (isInterleaved) {
        asbd.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
    } else {
        asbd.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsNonInterleaved;
    }

    asbd.mFormatID = kAudioFormatLinearPCM;
    asbd.mSampleRate = sampleRate;
    asbd.mReserved = 0;
    return asbd;
}