xref: /frameworks/wilhelm/tests/automated/BufferQueue_test.cpp

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/** \file BufferQueue_test.cpp */

#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "SLES/OpenSLES.h"

#ifdef ANDROID
#include "gtest/gtest.h"
#else
#define ASSERT_EQ(x, y) assert((x) == (y))
#endif

typedef struct {
    short left;
    short right;
} stereo;

// 1 second of stereo audio at 44.1 kHz
static stereo stereoBuffer1[44100 * 1];

static void do_my_testing()
{
    SLresult result;

    // initialize the test tone to be a sine sweep from 441 Hz to 882 Hz
    unsigned nframes = sizeof(stereoBuffer1) / sizeof(stereoBuffer1[0]);
    float nframes_ = (float) nframes;
    SLuint32 i;
    for (i = 0; i < nframes; ++i) {
        float i_ = (float) i;
        float pcm_ = sin((i_*(1.0f+0.5f*(i_/nframes_))*0.01 * M_PI * 2.0));
        int pcm = (int) (pcm_ * 32766.0);
        assert(-32768 <= pcm && pcm <= 32767);
        stereoBuffer1[i].left = pcm;
        stereoBuffer1[nframes - 1 - i].right = pcm;
    }

    // create engine
    SLObjectItf engineObject;
    result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
    ASSERT_EQ(SL_RESULT_SUCCESS, result);
    result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
    ASSERT_EQ(SL_RESULT_SUCCESS, result);
    SLEngineItf engineEngine;
    result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
    ASSERT_EQ(SL_RESULT_SUCCESS, result);

    // create output mix
    SLObjectItf outputmixObject;
    result = (*engineEngine)->CreateOutputMix(engineEngine, &outputmixObject, 0, NULL, NULL);
    ASSERT_EQ(SL_RESULT_SUCCESS, result);
    result = (*outputmixObject)->Realize(outputmixObject, SL_BOOLEAN_FALSE);
    ASSERT_EQ(SL_RESULT_SUCCESS, result);

    // set up data structures to create an audio player with buffer queue source and output mix sink
    SLDataSource audiosrc;
    SLDataSink audiosnk;
    SLDataFormat_PCM pcm;
    SLDataLocator_OutputMix locator_outputmix;
    SLDataLocator_BufferQueue locator_bufferqueue;
    locator_bufferqueue.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
    locator_bufferqueue.numBuffers = 0;
    locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
    locator_outputmix.outputMix = outputmixObject;
    pcm.formatType = SL_DATAFORMAT_PCM;
    pcm.numChannels = 2;
    pcm.samplesPerSec = SL_SAMPLINGRATE_44_1;
    pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
    pcm.containerSize = 16;
    pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
    pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
    audiosrc.pLocator = &locator_bufferqueue;
    audiosrc.pFormat = &pcm;
    audiosnk.pLocator = &locator_outputmix;
    audiosnk.pFormat = NULL;
    SLObjectItf playerObject;
    SLInterfaceID ids[1] = {SL_IID_BUFFERQUEUE};
    SLboolean flags[1] = {SL_BOOLEAN_TRUE};

    // try creating audio player with various invalid values for numBuffers
    static const SLuint32 invalidNumBuffers[] = {0, 0xFFFFFFFF, 0x80000000, 0x10002, 0x102, 0x101, 0x100};
    for (i = 0; i < sizeof(invalidNumBuffers) / sizeof(invalidNumBuffers[0]); ++i) {
        locator_bufferqueue.numBuffers = invalidNumBuffers[i];
        result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk, 1, ids, flags);
        ASSERT_EQ(SL_RESULT_PARAMETER_INVALID, result);
    }

    // now try some valid values for numBuffers */
    static const SLuint32 validNumBuffers[] = {1, 2, 3, 4, 5, 6, 7, 8, 255};
    for (i = 0; i < sizeof(validNumBuffers) / sizeof(validNumBuffers[0]); ++i) {
        locator_bufferqueue.numBuffers = validNumBuffers[i];
        result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk, 1, ids, flags);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // get the play interface
        SLPlayItf playerPlay;
        result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        SLuint32 playerState;
        // verify that player is initially stopped
        result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(SL_PLAYSTATE_STOPPED, playerState);
        // get the buffer queue interface
        SLBufferQueueItf playerBufferQueue;
        result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &playerBufferQueue);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // verify that buffer queue is initially empty
        SLBufferQueueState bufferqueueState;
        result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.count);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        // try enqueuing the maximum number of buffers while stopped
        SLuint32 j;
        for (j = 0; j < validNumBuffers[i]; ++j) {
            result = (*playerBufferQueue)->Enqueue(playerBufferQueue, "test", 4);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            // verify that each buffer is enqueued properly and increments the buffer count
            result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ(j + 1, bufferqueueState.count);
            ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
            // verify that player is still stopped; enqueue should not affect play state
            result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ(SL_PLAYSTATE_STOPPED, playerState);
        }
        // enqueue one more buffer and make sure it fails
        result = (*playerBufferQueue)->Enqueue(playerBufferQueue, "test", 4);
        ASSERT_EQ(SL_RESULT_BUFFER_INSUFFICIENT, result);
        // verify that the failed enqueue did not affect the buffer count
        result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(validNumBuffers[i], bufferqueueState.count);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        // now clear the buffer queue
        result = (*playerBufferQueue)->Clear(playerBufferQueue);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // make sure the clear works
        result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.count);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        // change play state from paused to stopped
        result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PAUSED);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // verify that player is really paused
        result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(SL_PLAYSTATE_PAUSED, playerState);
        // try enqueuing the maximum number of buffers while paused
        for (j = 0; j < validNumBuffers[i]; ++j) {
            result = (*playerBufferQueue)->Enqueue(playerBufferQueue, "test", 4);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            // verify that each buffer is enqueued properly and increments the buffer count
            result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ(j + 1, bufferqueueState.count);
            ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
            // verify that player is still paused; enqueue should not affect play state
            result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ(SL_PLAYSTATE_PAUSED, playerState);
        }
        // enqueue one more buffer and make sure it fails
        result = (*playerBufferQueue)->Enqueue(playerBufferQueue, "test", 4);
        ASSERT_EQ(SL_RESULT_BUFFER_INSUFFICIENT, result);
        // verify that the failed enqueue did not affect the buffer count
        result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(validNumBuffers[i], bufferqueueState.count);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        // now clear the buffer queue
        result = (*playerBufferQueue)->Clear(playerBufferQueue);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // make sure the clear works
        result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.count);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        // try every possible play state transition while buffer queue is empty
        static const SLuint32 newStates1[] = {
            SL_PLAYSTATE_PAUSED,    // paused -> paused
            SL_PLAYSTATE_STOPPED,   // paused -> stopped
            SL_PLAYSTATE_PAUSED,    // stopped -> paused, also done earlier
            SL_PLAYSTATE_PLAYING,   // paused -> playing
            SL_PLAYSTATE_PLAYING,   // playing -> playing
            SL_PLAYSTATE_STOPPED,   // playing -> stopped
            SL_PLAYSTATE_STOPPED,   // stopped -> stopped
            SL_PLAYSTATE_PLAYING,   // stopped -> playing
            SL_PLAYSTATE_PAUSED     // playing -> paused
        };
        // initially the play state is (still) paused
        result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(SL_PLAYSTATE_PAUSED, playerState);
        for (j = 0; j < sizeof(newStates1) / sizeof(newStates1[0]); ++j) {
            // change play state
            result = (*playerPlay)->SetPlayState(playerPlay, newStates1[j]);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            // make sure the new play state is taken
            result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ(newStates1[j], playerState);
            // changing the play state should not affect the buffer count
            result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ((SLuint32) 0, bufferqueueState.count);
            ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        }
        // finally the play state is (again) paused
        result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(SL_PLAYSTATE_PAUSED, playerState);
        // enqueue a buffer
        result = (*playerBufferQueue)->Enqueue(playerBufferQueue, "test", 4);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // try several inaudible play state transitions while buffer queue is non-empty
        static const SLuint32 newStates2[] = {
            SL_PLAYSTATE_PAUSED,    // paused -> paused
            SL_PLAYSTATE_STOPPED,   // paused -> stopped
            SL_PLAYSTATE_STOPPED,   // stopped -> stopped
            SL_PLAYSTATE_PAUSED    // stopped -> paused
        };
        for (j = 0; j < sizeof(newStates2) / sizeof(newStates2[0]); ++j) {
            // change play state
            result = (*playerPlay)->SetPlayState(playerPlay, newStates2[j]);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            // make sure the new play state is taken
            result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ(newStates2[j], playerState);
            // changing the play state should not affect the buffer count
            result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
            ASSERT_EQ(SL_RESULT_SUCCESS, result);
            ASSERT_EQ((SLuint32) 1, bufferqueueState.count);
            ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        }
        // clear the buffer queue
        result = (*playerBufferQueue)->Clear(playerBufferQueue);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);

        // now we're finally ready to make some noise

        // enqueue a buffer
        result = (*playerBufferQueue)->Enqueue(playerBufferQueue, stereoBuffer1, sizeof(stereoBuffer1));
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // set play state to playing
        result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        // state should be playing immediately after enqueue
        result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(SL_PLAYSTATE_PLAYING, playerState);
        // buffer should still be on the queue
        result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ((SLuint32) 1, bufferqueueState.count);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.playIndex);
        // wait 1.5 seconds
        usleep(1500000);
        // state should still be playing
        result = (*playerPlay)->GetPlayState(playerPlay, &playerState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ(SL_PLAYSTATE_PLAYING, playerState);
        // buffer should be removed from the queue
        result = (*playerBufferQueue)->GetState(playerBufferQueue, &bufferqueueState);
        ASSERT_EQ(SL_RESULT_SUCCESS, result);
        ASSERT_EQ((SLuint32) 0, bufferqueueState.count);
        ASSERT_EQ((SLuint32) 1, bufferqueueState.playIndex);
        // destroy the player
        (*playerObject)->Destroy(playerObject);
    }

    // destroy the output mix
    (*outputmixObject)->Destroy(outputmixObject);
    // destroy the engine
    (*engineObject)->Destroy(engineObject);

}

int main(int argc, char **argv)
{
    do_my_testing();
    return EXIT_SUCCESS;
}