音频样本制作者多线程OSX

Question

该问题是先前问题（ 带有OSX AudioComponent使用者线程的音频生产者线程和C中的回调 ）的后续问题，其中包括一个测试示例，该示例可以正常工作并按预期运行，但不能完全回答该问题。 我已对问题做了实质性的表述 ，并对示例进行了重新编码，以使其仅包含纯C代码。 （我发现在前面的示例中，很少有Objective-C的代码部分仅引起混乱，并使读者从问题的本质中分散了注意力。）

为了利用多个处理器内核并使CoreAudio拉模型渲染线程尽可能轻巧，LPCM样本的生成器例程显然必须“坐在”实际优先级之外的其他线程上渲染线程/回调。 它必须将样本馈送到循环缓冲区（在此示例中为TPCircularBuffer ），系统将从该循环缓冲区中安排inNumberFrames数量中的数据提取。

Grand Central Dispatch API提供了一个简单的解决方案，我根据一些个人研究（包括反复试验编码）推论得出。 该解决方案非常优雅，因为它不会阻塞任何东西，也不会在推拉模型之间产生冲突。 但是，应该负责“子线程”的GCD 到目前为止还不能满足生产者代码的工作线程的特定并行化要求，因此我必须根据数量显式地产生许多POSIX线程。可用的逻辑核心。 尽管在加快计算速度方面的结果已经非常显着，但是我仍然觉得混合POSIX和GCD有点不可思议。 特别是，它使用变量wait_interval并正确地对其进行计算，而不是通过预测渲染线程下一个周期可能需要多少个PCM样本来进行计算。

这是我的测试程序在C语言中经过简化和简化的（伪）代码。

控制器声明：

#include "TPCircularBuffer.h"
#include <AudioToolbox/AudioToolbox.h>
#include <AudioUnit/AudioUnit.h>
#include <dispatch/dispatch.h>
#include <sys/sysctl.h>
#include <pthread.h>

typedef struct {
TPCircularBuffer            buffer;
AudioComponentInstance      toneUnit;
Float64                     sampleRate;
AudioStreamBasicDescription streamFormat;   
Float32*                     f;     //array of updated frequencies
Float32*                     a;     //array of updated amps
Float32*                     prevf; //array of prev. frequencies
Float32*                     preva; //array of prev. amps
Float32*                     val;
    int*                    arg;
    int*                    previous_arg;
UInt32                      frames;
int                         state;
Boolean                     midif; //wip
} MyAudioController;

MyAudioController gen;    
dispatch_semaphore_t mSemaphore;
Boolean multithreading, NF;

typedef struct data{
    int tid;
    int cpuCount;
}data;

控制器管理：

void setup (void){
    // Initialize circular buffer
    TPCircularBufferInit(&(self->buffer), kBufferLength);
    // Create the semaphore
    mSemaphore = dispatch_semaphore_create(0);
    // Setup audio
    createToneUnit(&gen);  
}

void dealloc (void) {
    // Release buffer resources
    TPCircularBufferCleanup(&buffer);
    // Clean up semaphore
    dispatch_release(mSemaphore);
    // dispose of audio
    if(gen.toneUnit){
        AudioOutputUnitStop(gen.toneUnit);
        AudioUnitUninitialize(gen.toneUnit);
        AudioComponentInstanceDispose(gen.toneUnit);
    }
}

调度程序调用（从主线程启动生产者队列）：

void dproducer (Boolean on, Boolean multithreading, Boolean NF)
{
if (on == true)
{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
        if((multithreading)||(NF))
            producerSum(on);
        else
            producer(on);
    });
}
return;
}

可怕的生产者例程：

void producerSum(Boolean on)
{
int rc;
int num = getCPUnum();
pthread_t threads[num];
data thread_args[num];
void* resulT;
static Float32 frames  [FR_MAX];
Float32 wait_interval;
int     bytesToCopy;
Float32 floatmax;

while(on){
    wait_interval = FACT*(gen.frames)/(gen.sampleRate);
    Float32 damp = 1./(Float32)(gen.frames);
    bytesToCopy = gen.frames*sizeof(Float32);
    memset(frames,  0, FR_MAX*sizeof(Float32));
    availableBytes = 0;
    fbuffW  = (Float32**)calloc(num + 1, sizeof(Float32*));
    for (int i=0; i<num; ++i)
    {
        fbuffW[i] = (Float32*)calloc(gen.frames, sizeof(Float32));
        thread_args[i].tid = i; 
        thread_args[i].cpuCount = num;
        rc = pthread_create(&threads[i], NULL, producerTN, (void *) &thread_args[i]);
    }

    for (int i=0; i<num; ++i)  rc = pthread_join(threads[i], &resulT);

    for(UInt32 samp = 0; samp < gen.frames; samp++)
        for(int i = 0; i < num; i++)
            frames[samp] += fbuffW[i][samp];

    //code for managing producer state and GUI updates
    { ... }

    float *head = TPCircularBufferHead(&(gen.buffer), &availableBytes);
    memcpy(head,(const void*)frames,MIN(bytesToCopy, availableBytes));//copies frames to head
    TPCircularBufferProduce(&(gen.buffer),MIN(bytesToCopy,availableBytes));

dispatch_semaphore_wait(mSemaphore, dispatch_time(DISPATCH_TIME_NOW, wait_interval * NSEC_PER_SEC));
if(gen.state == stopped){gen.state = idle; on = false;}

for(int i = 0; i <= num; i++)
        free(fbuffW[i]);
free(fbuffW);
}
return;
}

单个生产者线程可能看起来像这样：

void *producerT  (void *TN)
{
Float32 samples[FR_MAX];
data threadData;
threadData = *((data *)TN);
int tid  = threadData.tid;
int step = threadData.cpuCount;
int *ret = calloc(1,sizeof(int));

do_something(tid, step, &samples);

{ … }
return (void*)ret;
}

这是渲染回调（CoreAudio实时使用者线程）：

static OSStatus audioRenderCallback(void *inRefCon,
                                  AudioUnitRenderActionFlags *ioActionFlags,
                                  const AudioTimeStamp *inTimeStamp,
                                  UInt32 inBusNumber,
                                  UInt32 inNumberFrames,
                                  AudioBufferList *ioData) {    

MyAudioController *THIS = (MyAudioController *)inRefCon;

// An event happens in the render thread- signal whoever is waiting
if (THIS->state == active) dispatch_semaphore_signal(mSemaphore);

// Mono audio rendering: we only need one target buffer
const int channel = 0;
Float32* targetBuffer = (Float32 *)ioData->mBuffers[channel].mData;
memset(targetBuffer,0,inNumberFrames*sizeof(Float32));

// Pull samples from circular buffer
int32_t availableBytes;    
Float32 *buffer = TPCircularBufferTail(&THIS->buffer, &availableBytes);

//copy circularBuffer content to target buffer
int bytesToCopy = ioData->mBuffers[channel].mDataByteSize;
memcpy(targetBuffer, buffer, MIN(bytesToCopy, availableBytes));
{ … };

TPCircularBufferConsume(&THIS->buffer, availableBytes);    
THIS->frames = inNumberFrames;
return noErr;
}

Answer 1

Grand Central Dispatch已经负责将操作分配给多个处理器核心和线程。 在典型的实时音频渲染或处理中，无需等待信号或信号量，因为循环缓冲区的消耗速率非常可预测，并且随着时间的流逝非常缓慢。 AVAudioSession API（如果有），音频单元API和回调允许您设置和确定回调缓冲区的大小，从而确定和更改循环缓冲区的最大速率。 因此，您可以在计时器上分派所有渲染操作，渲染每个计时器周期所需的确切数量，并让缓冲区大小和状态补偿线程分派时间中的任何抖动。

在运行时间非常长的音频渲染中，您可能需要测量计时器操作和实时音频消耗（采样率）之间的漂移，并调整渲染的样本数或计时器偏移量。