xref: /frameworks/wilhelm/tests/sandbox/monkey.c

/*
 * 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.
 */

// single-threaded, single-player monkey test

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

typedef enum {
    STATE_UNCHANGED,
    STATE_INITIAL,
    STATE_NONEXISTENT,
    STATE_CREATED,
    STATE_REALIZED,
    STATE_PAUSED,
    STATE_PLAYING,
    STATE_STOPPED,
    STATE_ERROR,
//    STATE_IDLE,         // after Stop, then sleep for 3 seconds
    STATE_TERMINAL
} State_t;

typedef struct {
    SLObjectItf mObject;
    SLPlayItf mPlay;
    SLSeekItf mSeek;
} Player_t, *Player_pt;

typedef State_t (*Action_pt)(Player_pt player);

SLObjectItf engineObject;
SLEngineItf engineEngine;
SLObjectItf outputMixObject;
int countTransitions = 0;
int maxTransitions = 10;

State_t actionPause(Player_pt p)
{
    assert(NULL != p->mPlay);
    SLresult result = (*p->mPlay)->SetPlayState(p->mPlay, SL_PLAYSTATE_PAUSED);
    assert(SL_RESULT_SUCCESS == result);
    return STATE_PAUSED;
}

State_t actionPlay(Player_pt p)
{
    assert(NULL != p->mPlay);
    SLresult result = (*p->mPlay)->SetPlayState(p->mPlay, SL_PLAYSTATE_PLAYING);
    assert(SL_RESULT_SUCCESS == result);
    return STATE_PLAYING;
}

State_t actionStop(Player_pt p)
{
    assert(NULL != p->mPlay);
    SLresult result = (*p->mPlay)->SetPlayState(p->mPlay, SL_PLAYSTATE_STOPPED);
    assert(SL_RESULT_SUCCESS == result);
    return STATE_STOPPED;
}

State_t actionRewind(Player_pt p)
{
    assert(NULL != p->mSeek);
    SLresult result = (*p->mSeek)->SetPosition(p->mSeek, (SLmillisecond) 0, SL_SEEKMODE_FAST);
    assert(SL_RESULT_SUCCESS == result);
    return STATE_UNCHANGED;
}

State_t actionDestroy(Player_pt p)
{
    assert(NULL != p->mObject);
    (*p->mObject)->Destroy(p->mObject);
    p->mObject = NULL;
    p->mPlay = NULL;
    p->mSeek = NULL;
    return STATE_NONEXISTENT;
}

State_t actionCreate(Player_pt p)
{
    // configure audio source
    SLDataLocator_URI loc_uri;
    loc_uri.locatorType = SL_DATALOCATOR_URI;
    loc_uri.URI = (SLchar *) "wav/frog.wav";
    SLDataFormat_MIME format_mime;
    format_mime.formatType = SL_DATAFORMAT_MIME;
    format_mime.mimeType = NULL;
    format_mime.containerType = SL_CONTAINERTYPE_UNSPECIFIED;
    SLDataSource audioSrc;
    audioSrc.pLocator = &loc_uri;
    audioSrc.pFormat = &format_mime;
    // configure audio sink
    SLDataLocator_OutputMix loc_outmix;
    loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
    loc_outmix.outputMix = outputMixObject;
    SLDataSink audioSnk;
    audioSnk.pLocator = &loc_outmix;
    audioSnk.pFormat = NULL;
    // create audio player
    SLInterfaceID ids[1] = {SL_IID_SEEK};
    SLboolean req[1] = {SL_BOOLEAN_TRUE};
    SLresult result = (*engineEngine)->CreateAudioPlayer(engineEngine, &p->mObject, &audioSrc,
            &audioSnk, 1, ids, req);
    if (SL_RESULT_SUCCESS != result)
        return STATE_ERROR;
    return STATE_CREATED;
}

State_t actionRealize(Player_pt p)
{
    assert(NULL != p->mObject);
    // realize the player
    SLresult result = (*p->mObject)->Realize(p->mObject, SL_BOOLEAN_FALSE);
    assert(SL_RESULT_SUCCESS == result);
    // get interfaces
    result = (*p->mObject)->GetInterface(p->mObject, SL_IID_PLAY, &p->mPlay);
    assert(SL_RESULT_SUCCESS == result);
    result = (*p->mObject)->GetInterface(p->mObject, SL_IID_SEEK, &p->mSeek);
    assert(SL_RESULT_SUCCESS == result);
    return STATE_REALIZED;
}

State_t actionSleep(Player_pt p)
{
    unsigned us = 1000 + (rand() & 0xFFFFF);
    usleep(us);
    return STATE_UNCHANGED;
}

#if 0
State_t actionSleep3(Player_pt p)
{
    sleep(3);
    return STATE_IDLE;
}
#endif

State_t actionTerminateIfDone(Player_pt p)
{
    if (countTransitions >= maxTransitions) {
        assert(NULL == p->mObject);
        // clean up output mix and engine
        assert(NULL != outputMixObject);
        (*outputMixObject)->Destroy(outputMixObject);
        outputMixObject = NULL;
        assert(NULL != engineObject);
        (*engineObject)->Destroy(engineObject);
        engineObject = NULL;
        return STATE_TERMINAL;
    } else
        return STATE_UNCHANGED;
}

State_t actionInitialize(Player_pt p)
{
    // create engine
    SLresult result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
    assert(SL_RESULT_SUCCESS == result);
    result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
    assert(SL_RESULT_SUCCESS == result);
    result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
    assert(SL_RESULT_SUCCESS == result);

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

    return STATE_NONEXISTENT;
}

typedef struct {
    State_t mEntryState;
    Action_pt mAction;
    unsigned mProbability;
    const char *mActionName;
    unsigned mCount;
} Transition_t;

Transition_t transitionTable[] = {
#define _(entryState, action, probability) {entryState, action, probability, #action, 0},
    _(STATE_INITIAL, actionInitialize, 1)
    _(STATE_CREATED, actionDestroy, 1)
    _(STATE_CREATED, actionRealize, 1)
    _(STATE_CREATED, actionSleep, 1)
    _(STATE_NONEXISTENT, actionCreate, 1)
    _(STATE_NONEXISTENT, actionSleep, 1)
    _(STATE_PAUSED, actionDestroy, 1)
    _(STATE_PAUSED, actionPause, 1)
    _(STATE_PAUSED, actionPlay, 1)
    _(STATE_PAUSED, actionRewind, 1)
    _(STATE_PAUSED, actionSleep, 1)
    _(STATE_PAUSED, actionStop, 1)
    _(STATE_PLAYING, actionDestroy, 1)
    _(STATE_PLAYING, actionPause, 1)
    _(STATE_PLAYING, actionPlay, 1)
    _(STATE_PLAYING, actionRewind, 1)
    _(STATE_PLAYING, actionSleep, 1)
    _(STATE_PLAYING, actionStop, 1)
    _(STATE_REALIZED, actionDestroy, 1)
    _(STATE_REALIZED, actionPause, 1)
    _(STATE_REALIZED, actionPlay, 1)
    _(STATE_REALIZED, actionSleep, 1)
    _(STATE_REALIZED, actionStop, 1)
    _(STATE_STOPPED, actionDestroy, 1)
    _(STATE_STOPPED, actionPause, 1)
    _(STATE_STOPPED, actionPlay, 1)
    _(STATE_STOPPED, actionRewind, 1)
    _(STATE_STOPPED, actionSleep, 1)
    _(STATE_STOPPED, actionStop, 1)
//    _(STATE_STOPPED, actionSleep3, 1)
//    _(STATE_IDLE, actionDestroy, 1)
    _(STATE_NONEXISTENT, actionTerminateIfDone, 1)
};

int main(int argc, char **argv)
{
    int i;
    for (i = 1; i < argc; ++i) {
        char *arg = argv[i];
        if (arg[0] != '-')
            break;
        if (!strncmp(arg, "-m", 2)) {
            maxTransitions = atoi(&arg[2]);
        } else {
            fprintf(stderr, "Unknown option %s\n", arg);
        }
    }
    unsigned possibleTransitions = sizeof(transitionTable) / sizeof(transitionTable[0]);
    Player_t player;
    player.mObject = NULL;
    player.mPlay = NULL;
    player.mSeek = NULL;
    State_t currentState = STATE_INITIAL;
    while (STATE_TERMINAL != currentState) {
        unsigned matchingTransitions = 0;
        unsigned totalProbability = 0;
        for (i = 0; i < (int) possibleTransitions; ++i) {
            if (currentState != transitionTable[i].mEntryState)
                continue;
            ++matchingTransitions;
            totalProbability += transitionTable[i].mProbability;
        }
        if (matchingTransitions == 0) {
            fprintf(stderr, "No matching transitions in state %d\n", currentState);
            assert(SL_BOOLEAN_FALSE);
            break;
        }
        if (totalProbability == 0) {
            fprintf(stderr, "Found at least one matching transition in state %d, "
                    "but with probability 0\n", currentState);
            assert(SL_BOOLEAN_FALSE);
            break;
        }
        unsigned choice = (rand() & 0x7FFFFFFF) % totalProbability;
        totalProbability = 0;
        for (i = 0; i < (int) possibleTransitions; ++i) {
            if (currentState != transitionTable[i].mEntryState)
                continue;
            totalProbability += transitionTable[i].mProbability;
            if (totalProbability <= choice)
                continue;
            ++transitionTable[i].mCount;
            ++countTransitions;
            printf("[%d] Selecting transition %s in state %d for the %u time\n", countTransitions,
                    transitionTable[i].mActionName, currentState, transitionTable[i].mCount);
            State_t nextState = (*transitionTable[i].mAction)(&player);
            if (STATE_UNCHANGED != nextState)
                currentState = nextState;
            goto found;
        }
        fprintf(stderr, "This shouldn't happen\n");
        assert(SL_BOOLEAN_FALSE);
found:
        ;
    }
    for (i = 0; i < (int) possibleTransitions; ++i) {
        printf("state %d action %s count %u\n",
            transitionTable[i].mEntryState,
            transitionTable[i].mActionName,
            transitionTable[i].mCount);
    }
    return EXIT_SUCCESS;
}