Iphone OpenAL alSourceUnqueueBuffers&；alSourceUnqueueBuffers

各位，我有一个关于API的问题——当我使用OpenAL Libaray时，也是源队列缓冲区

我的问题如下：

1.我通过流媒体机制播放pcm音乐

2.应用程序可以使用alSourceQueueBuffers将一个或多个缓冲区名称排队

当缓冲区已被处理时。我想在函数getSourceState中填充新的音频数据。但是当我使用OpenAL的API时，alSourceUnqueueBuffers。它返回一个错误 ---AL_操作无效。我这样做是作为关于OpenAL的文档。 所以我测试了一种解决这个问题的方法。我在api alSourceUnqueueBuffers之前使用alSourceStop（源代码），但在填充新数据之后使用alSourcePlay（源代码） alBufferData&alSourceQueueBuffers。但这很糟糕。因为它破坏了音乐

谁能帮我找到这个问题

我在哪里可以找到更多关于openAL的信息和方法

我在等你的帮助。谢谢大家

因此，我的代码如下：

.h:

m

-（void）initOpenAL
{
阿伦误差；
//创建一个新的OpenAL设备
//传递NULL以指定系统的默认输出设备
设备=alcOpenDevice（空）；
如果（设备！=NULL）
{
//创建一个新的OpenAL上下文
//新的上下文将呈现给刚刚创建的OpenAL设备
context=alcreatecontext（设备，0）；
if（上下文！=NULL）
{
//使新上下文成为当前OpenAL上下文
alcMakeContextCurrent（上下文）；
//创建一些OpenAL缓冲区对象
缓冲区=（ALuint*）malloc（sizeof（ALuint）*5）；
阿尔金缓冲区（5，缓冲区）；
如果（（error=algerorr（））！=AL_无错误）{
NSLog（@“生成缓冲区时出错：%x”，错误）；
出口（1）；
}
//创建一些开源对象
阿尔及利亚资源（1，&来源）；
如果（alGetError（）！=AL_无错误）
{
NSLog（@“生成源时出错！%x\n”，错误）；
出口（1）；
}
}
}
//清除任何错误
阿尔及利亚恐怖（）；
[自初始化缓冲]；
[自启动源]；
}
-（void）initBuffer
{
ALenum error=AL_NO_error；
阿伦格式；
ALsizei大小；
阿尔西泽频率；
NSBundle*bundle=[NSBundle mainBundle]；
//从波形文件中获取一些音频数据
CFURLRef fileURL=（CFURLRef）[[NSURL fileURLWithPath:[bundle pathForResource:@“4”of type:@“caf”]]retain]；
如果（文件URL）
{   
data=MyGetOpenALAudioData（文件URL、大小、格式和频率）；
CFRelease（fileURL）；
m_freq=频率；
m_格式=格式；
如果（（error=algerorr（））！=AL_无错误）{
NSLog（@“加载声音时出错：%x\n”，错误）；
出口（1）；
}
alBufferData（缓冲区[0]，格式，数据，读取大小，频率）；
偏移量+=读取大小；
alBufferData（缓冲区[1]，格式，数据+偏移量，读取大小，频率）；
偏移量+=读取大小；
alBufferData（缓冲区[2]，格式，数据+偏移量，读取大小，频率）；
偏移量+=读取大小；
alBufferData（缓冲区[3]，格式，数据+偏移量，读取大小，频率）；
偏移量+=读取大小；
alBufferData（缓冲区[4]，格式，数据+偏移量，读取大小，频率）；
偏移量+=读取大小；
如果（（error=algerorr（））！=AL_无错误）{
NSLog（@“将音频附加到缓冲区时出错：%x\n”，错误）；
}       
}
其他的
NSLog（@“找不到文件！\n”）；
}
-（void）初始源
{
ALenum error=AL_NO_error；
alGetError（）；//清除错误
//打开循环
alSourcei（来源，AL_循环，AL_真实）；
//设置震源位置
float sourcePosAL[]={sourcePos.x，kDefaultDistance，sourcePos.y}；
alSourcefv（震源、AL_位置、震源位置）；
//设置源参考距离
alSourcef（源，基准距离，50.0f）；
alSourceQueueBuffers（源，5个缓冲区）；
如果（（error=algerorr（））！=AL_无错误）{
NSLog（@“将缓冲区附加到源时出错：%x\n”，错误）；
出口（1）；
}   
}
-（无效）开始声音
{
阿伦误差；
NSLog（@“开始！\n”）；
//开始播放源文件
alSourcePlay（来源）；
如果（（error=algerorr（））！=AL_无错误）{
NSLog（@“错误启动源：%x\n”，错误）；
}否则{
//将我们的状态标记为正在播放（视图将查看此）
self.isPlaying=是；
}
而(1){
[自获取源状态]；
}
}
-（void）getSourceState
{
int排队；
int处理；
int状态；
alGetSourcei（源、所有缓冲区排队和排队）；
alGetSourcei（源、所有缓冲区、已处理和已处理）；
alGetSourcei（源、AL_源、状态和状态）；
NSLog（@“%d”，已排队）；
NSLog（@“%d”，已处理）；
NSLog（@“=============================================================”）；
while（已处理>0）{
对于（int i=0；i

我找到了问题的原因

我打开循环的原因：alSourcei（source，AL_Looping，AL_TRUE）

如果设置此值，则当源处理缓冲区时，您希望填充新的dat

    @interface myPlayback : NSObject
    {
    ALuint                  source;
    ALuint              *   buffers;
    ALCcontext*             context;
    ALCdevice*              device;
    unsigned long long      offset;
    ALenum                  m_format;
    ALsizei                 m_freq;
    void*                   data;
    }

@end

    - (void)initOpenAL
    {
    ALenum          error;

    // Create a new OpenAL Device
    // Pass NULL to specify the system’s default output device
    device = alcOpenDevice(NULL);
    if (device != NULL)
    {
        // Create a new OpenAL Context
        // The new context will render to the OpenAL Device just created 
        context = alcCreateContext(device, 0);
        if (context != NULL)
        {
            // Make the new context the Current OpenAL Context
            alcMakeContextCurrent(context);

            // Create some OpenAL Buffer Objects

            buffers = (ALuint*)malloc(sizeof(ALuint) * 5);
            alGenBuffers(5, buffers);
            if((error = alGetError()) != AL_NO_ERROR) {
                NSLog(@"Error Generating Buffers: %x", error);
                exit(1);
            }

            // Create some OpenAL Source Objects
            alGenSources(1, &source);
            if(alGetError() != AL_NO_ERROR) 
            {
                NSLog(@"Error generating sources! %x\n", error);
                exit(1);
            }

        }
    }
    // clear any errors
    alGetError();

    [self initBuffer];  
        [self initSource];
}

    - (void) initBuffer
    {
    ALenum  error = AL_NO_ERROR;
    ALenum  format;
    ALsizei size;
    ALsizei freq;

    NSBundle*               bundle = [NSBundle mainBundle];

    // get some audio data from a wave file
    CFURLRef fileURL = (CFURLRef)[[NSURL fileURLWithPath:[bundle pathForResource:@"4" ofType:@"caf"]] retain];

    if (fileURL)
    {   
        data = MyGetOpenALAudioData(fileURL, &size, &format, &freq);
        CFRelease(fileURL);
        m_freq = freq;
        m_format = format;
        if((error = alGetError()) != AL_NO_ERROR) {
            NSLog(@"error loading sound: %x\n", error);
            exit(1);
        }

        alBufferData(buffers[0], format, data, READ_SIZE , freq);
        offset += READ_SIZE;
        alBufferData(buffers[1], format, data + offset, READ_SIZE, freq);
        offset += READ_SIZE;
        alBufferData(buffers[2], format, data + offset, READ_SIZE, freq);
        offset += READ_SIZE;
        alBufferData(buffers[3], format, data + offset, READ_SIZE, freq);
        offset += READ_SIZE;
        alBufferData(buffers[4], format, data + offset, READ_SIZE, freq);
        offset += READ_SIZE;

        if((error = alGetError()) != AL_NO_ERROR) {
            NSLog(@"error attaching audio to buffer: %x\n", error);
        }       
    }
    else
        NSLog(@"Could not find file!\n");
}

    - (void) initSource
    {
    ALenum error = AL_NO_ERROR;
    alGetError(); // Clear the error

    // Turn Looping ON
    alSourcei(source, AL_LOOPING, AL_TRUE);

    // Set Source Position
    float sourcePosAL[] = {sourcePos.x, kDefaultDistance, sourcePos.y};
    alSourcefv(source, AL_POSITION, sourcePosAL);

    // Set Source Reference Distance
    alSourcef(source, AL_REFERENCE_DISTANCE, 50.0f);

    alSourceQueueBuffers(source, 5, buffers);

    if((error = alGetError()) != AL_NO_ERROR) {
        NSLog(@"Error attaching buffer to source: %x\n", error);
        exit(1);
    }   
}





    - (void)startSound
        {
        ALenum error;

        NSLog(@"Start!\n");
        // Begin playing our source file
        alSourcePlay(source);
        if((error = alGetError()) != AL_NO_ERROR) {
            NSLog(@"error starting source: %x\n", error);
        } else {
            // Mark our state as playing (the view looks at this)
            self.isPlaying = YES;
        }

        while (1) {
            [self getSourceState];
        }
}
    -(void)getSourceState
    {
    int queued;
    int processed;
    int state;
    alGetSourcei(source, AL_BUFFERS_QUEUED, &queued);
    alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
    alGetSourcei(source, AL_SOURCE_STATE, &state);
    NSLog(@"%d", queued);
    NSLog(@"%d", processed);

    NSLog(@"===================================");

    while (processed > 0) {
        for (int i = 0; i < processed; ++i) {
            ALuint buf;
            alGetError();
    //            alSourceStop(source);
            ALenum y = alGetError();
            NSLog(@"%d", y);
            alSourceUnqueueBuffers(source, 1, &buf);
            ALenum i = alGetError();
            NSLog(@"%d", i);
            processed --;
            alBufferData(buf, m_format, data + offset, READ_SIZE, m_freq);
            ALenum j = alGetError();
            NSLog(@"%d", j);
            alSourceQueueBuffers(source, 1, &buf);
            ALenum k = alGetError();
            NSLog(@"%d", k);
            offset += READ_SIZE;
//            alSourcePlay(source);
        }
    }

//    [self getSourceState];
}