Exemple #1
0
void alSourceUnqueueBuffers(ALuint source, ALsizei n, ALuint* buffers)
{
    DEBUGLOGCALL(LCF_OPENAL);
    AudioSource* as = audiocontext.getSource(source);
    if (as == nullptr)
        return;

    /* Check if we can unqueue that number of buffers */
    int processedBuffers;
    if (as->state == SOURCE_STOPPED)
        processedBuffers = as->nbQueue();
    else
        processedBuffers = as->nbQueueProcessed();
    if (processedBuffers < n) {
        ALSETERROR(AL_INVALID_VALUE);
        return;
    }

    debuglog(LCF_OPENAL, "Unqueueing ", n, " buffers out of ", as->nbQueue());
    
    std::lock_guard<std::mutex> lock(audiocontext.mutex);

    /* Save the id of the unqueued buffers */
    for (int i=0; i<n; i++) {
        buffers[i] = as->buffer_queue[i]->id;
    }

    /* Remove the buffers from the queue.
     * TODO: This is slow on a vector, maybe use forward_list?
     */
    as->buffer_queue.erase(as->buffer_queue.begin(), as->buffer_queue.begin()+n);
    if (as->state != SOURCE_STOPPED)
        as->queue_index -= n;
}
Exemple #2
0
void alGetSourcei(ALuint source, ALenum param, ALint *value)
{
    debuglog(LCF_OPENAL, __func__, " call for source ", source);

    if (value == nullptr) {
        return;
    }
        
    AudioSource* as = audiocontext.getSource(source);
    if (as == nullptr) {
        ALSETERROR(AL_INVALID_NAME);
        return;
    }

    switch(param) {
        case AL_BUFFER:
            if (! as->buffer_queue.empty())
                // TODO: for queued buffers, return the index of current buffer?
                *value = as->buffer_queue[0]->id;
            else
                *value = AL_NONE;
            break;
        case AL_SOURCE_STATE:
            switch(as->state) {
                case SOURCE_INITIAL:
                    *value = AL_INITIAL;
                    debuglog(LCF_OPENAL, "  Get source state INITIAL");
                    break;
                case SOURCE_PLAYING:
                    *value = AL_PLAYING;
                    debuglog(LCF_OPENAL, "  Get source state PLAYING");
                    break;
                case SOURCE_PAUSED:
                    *value = AL_PAUSED;
                    debuglog(LCF_OPENAL, "  Get source state PAUSED");
                    break;
                case SOURCE_STOPPED:
                    *value = AL_STOPPED;
                    debuglog(LCF_OPENAL, "  Get source state STOPPED");
                    break;
            }
            break;
        case AL_SOURCE_TYPE:
            switch(as->source) {
                case SOURCE_UNDETERMINED:
                    *value = AL_UNDETERMINED;
                    debuglog(LCF_OPENAL, "  Get source type UNDETERMINED");
                    break;
                case SOURCE_STATIC:
                    *value = AL_STATIC;
                    debuglog(LCF_OPENAL, "  Get source type STATIC");
                    break;
                case SOURCE_STREAMING:
                    *value = AL_STREAMING;
                    debuglog(LCF_OPENAL, "  Get source type STREAMING");
                    break;
                default:
                    ALSETERROR(AL_INVALID_VALUE);
                    break;
            }
            break;
        case AL_SOURCE_RELATIVE:
            debuglog(LCF_OPENAL, "Operation not supported");
            break;
        case AL_BUFFERS_QUEUED:
            *value = as->nbQueue();
            debuglog(LCF_OPENAL, "  Get number of queued buffers of ", *value);
            break;
        case AL_BUFFERS_PROCESSED:
            if (as->state == SOURCE_STOPPED)
                *value = as->nbQueue();
            else if (as->state == SOURCE_INITIAL)
                *value = 0;
            else
                *value = as->nbQueueProcessed();
            debuglog(LCF_OPENAL, "  Get number of processed queued buffers of ", *value);
            break;
        case AL_SEC_OFFSET:
        case AL_SAMPLE_OFFSET:
        case AL_BYTE_OFFSET:
            ALfloat res;
            alGetSourcef(source, param, &res);
            *value = (ALint) res;
            break;
        default:
            ALSETERROR(AL_INVALID_OPERATION);
            return;
    }
}