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

// Demonstrate environmental reverb and preset reverb on an output mix and audio player

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

#define bool int
#define false 0
#define true 1

// Table of I3DL2 named environmental reverb settings

typedef struct {
    const char *mName;
    SLEnvironmentalReverbSettings mSettings;
} Pair;

#define _(name) {#name, SL_I3DL2_ENVIRONMENT_PRESET_##name},

Pair pairs[] = {
    _(DEFAULT)
    _(GENERIC)
    _(PADDEDCELL)
    _(ROOM)
    _(BATHROOM)
    _(LIVINGROOM)
    _(STONEROOM)
    _(AUDITORIUM)
    _(CONCERTHALL)
    _(CAVE)
    _(ARENA)
    _(HANGAR)
    _(CARPETEDHALLWAY)
    _(HALLWAY)
    _(STONECORRIDOR)
    _(ALLEY)
    _(FOREST)
    _(CITY)
    _(MOUNTAINS)
    _(QUARRY)
    _(PLAIN)
    _(PARKINGLOT)
    _(SEWERPIPE)
    _(UNDERWATER)
    _(SMALLROOM)
    _(MEDIUMROOM)
    _(LARGEROOM)
    _(MEDIUMHALL)
    _(LARGEHALL)
    _(PLATE)
};

// Parameters for preset reverb on output mix
bool outputMixPresetItfRequested = false;
SLuint16 outputMixPresetNumber = ~0;

// Parameters for environmental reverb on output mix
bool outputMixEnvironmentalItfRequested = false;
char *outputMixEnvironmentalName = NULL;
SLEnvironmentalReverbSettings outputMixEnvironmentalSettings;

// Parameters for preset reverb on audio player (not supported)
bool playerPresetItfRequested = false;
SLuint16 playerPresetNumber = ~0;

// Parameters for environmental reverb on audio player (not supported)
bool playerEnvironmentalItfRequested = false;
char *playerEnvironmentalName = NULL;
SLEnvironmentalReverbSettings playerEnvironmentalSettings;

// Compare two environmental reverb settings structures.
// Returns true if the settings are identical, or false if they are different.

bool slesutCompareEnvironmentalReverbSettings(
        const SLEnvironmentalReverbSettings *settings1,
        const SLEnvironmentalReverbSettings *settings2)
{
    return
        (settings1->roomLevel == settings2->roomLevel) &&
        (settings1->roomHFLevel == settings2->roomHFLevel) &&
        (settings1->decayTime == settings2->decayTime) &&
        (settings1->decayHFRatio == settings2->decayHFRatio) &&
        (settings1->reflectionsLevel == settings2->reflectionsLevel) &&
        (settings1->reflectionsDelay == settings2->reflectionsDelay) &&
        (settings1->reverbLevel == settings2->reverbLevel) &&
        (settings1->reverbDelay == settings2->reverbDelay) &&
        (settings1->diffusion == settings2->diffusion) &&
        (settings1->density == settings2->density);
}

// Print an environmental reverb settings structure.

void slesutPrintEnvironmentalReverbSettings(const SLEnvironmentalReverbSettings *settings)
{
    printf("roomLevel: %d\n", settings->roomLevel);
    printf("roomHFLevel: %d\n", settings->roomHFLevel);
    printf("decayTime: %d\n", settings->decayTime);
    printf("decayHFRatio: %d\n", settings->decayHFRatio);
    printf("reflectionsLevel: %d\n", settings->reflectionsLevel);
    printf("reflectionsDelay: %d\n", settings->reflectionsDelay);
    printf("reverbLevel: %d\n", settings->reverbLevel);
    printf("reverbDelay: %d\n", settings->reverbDelay);
    printf("diffusion: %d\n", settings->diffusion);
    printf("density: %d\n", settings->density);
}

// Lookup environmental reverb settings by name

const SLEnvironmentalReverbSettings *lookupEnvName(const char *name)
{
    unsigned j;
    for (j = 0; j < sizeof(pairs) / sizeof(pairs[0]); ++j) {
        if (!strcasecmp(name, pairs[j].mName)) {
            return &pairs[j].mSettings;
        }
    }
    return NULL;
}

// Print all available environmental reverb names

void printEnvNames(void)
{
    unsigned j;
    bool needSpace = false;
    bool needNewline = false;
    unsigned lineLen = 0;
    for (j = 0; j < sizeof(pairs) / sizeof(pairs[0]); ++j) {
        const char *name = pairs[j].mName;
        unsigned nameLen = strlen(name);
        if (lineLen + (needSpace ? 1 : 0) + nameLen > 72) {
            putchar('\n');
            needSpace = false;
            needNewline = false;
            lineLen = 0;
        }
        if (needSpace) {
            putchar(' ');
            ++lineLen;
        }
        fputs(name, stdout);
        lineLen += nameLen;
        needSpace = true;
        needNewline = true;
    }
    if (needNewline) {
        putchar('\n');
    }
}

// These are extensions to OpenSL ES 1.0.1 values

#define SL_PREFETCHSTATUS_UNKNOWN 0
#define SL_PREFETCHSTATUS_ERROR   (-1)

// Mutex and condition shared with main program to protect prefetch_status

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
SLuint32 prefetch_status = SL_PREFETCHSTATUS_UNKNOWN;

/* used to detect errors likely to have occured when the OpenSL ES framework fails to open
 * a resource, for instance because a file URI is invalid, or an HTTP server doesn't respond.
 */
#define PREFETCHEVENT_ERROR_CANDIDATE \
        (SL_PREFETCHEVENT_STATUSCHANGE | SL_PREFETCHEVENT_FILLLEVELCHANGE)

// Prefetch status callback

void prefetch_callback(SLPrefetchStatusItf caller, void *context, SLuint32 event)
{
    SLresult result;
    assert(context == NULL);
    SLpermille level;
    result = (*caller)->GetFillLevel(caller, &level);
    assert(SL_RESULT_SUCCESS == result);
    SLuint32 status;
    result = (*caller)->GetPrefetchStatus(caller, &status);
    assert(SL_RESULT_SUCCESS == result);
    SLuint32 new_prefetch_status;
    if ((event & PREFETCHEVENT_ERROR_CANDIDATE) == PREFETCHEVENT_ERROR_CANDIDATE
            && level == 0 && status == SL_PREFETCHSTATUS_UNDERFLOW) {
        new_prefetch_status = SL_PREFETCHSTATUS_ERROR;
    } else if (event == SL_PREFETCHEVENT_STATUSCHANGE &&
            status == SL_PREFETCHSTATUS_SUFFICIENTDATA) {
        new_prefetch_status = status;
    } else {
        return;
    }
    int ok;
    ok = pthread_mutex_lock(&mutex);
    assert(ok == 0);
    prefetch_status = new_prefetch_status;
    ok = pthread_cond_signal(&cond);
    assert(ok == 0);
    ok = pthread_mutex_unlock(&mutex);
    assert(ok == 0);
}

// Main program

int main(int argc, char **argv)
{
    SLresult result;
    bool loop = false;

    // process command line parameters
    char *prog = argv[0];
    int i;
    for (i = 1; i < argc; ++i) {
        char *arg = argv[i];
        if (arg[0] != '-')
            break;
        bool bad = false;   // whether the option string is invalid
        if (!strncmp(arg, "--mix-preset", 12)) {
            if ('\0' == arg[12]) {
                outputMixPresetItfRequested = true;
            } else if ('=' == arg[12]) {
                outputMixPresetNumber = atoi(&arg[13]);
                outputMixPresetItfRequested = true;
            } else {
                bad = true;
            }
        } else if (!strncmp(arg, "--mix-name", 10)) {
            if ('\0' == arg[10]) {
                outputMixEnvironmentalItfRequested = true;
            } else if ('=' == arg[10]) {
                outputMixEnvironmentalName = &arg[11];
                outputMixEnvironmentalItfRequested = true;
            } else {
                bad = true;
            }
        } else if (!strncmp(arg, "--player-preset", 15)) {
            if ('\0' == arg[15]) {
                playerPresetItfRequested = true;
            } else if ('=' == arg[15]) {
                playerPresetNumber = atoi(&arg[16]);
                playerPresetItfRequested = true;
            } else {
                bad = true;
            }
        } else if (!strncmp(arg, "--player-name", 13)) {
            if ('\0' == arg[13]) {
                playerEnvironmentalItfRequested = true;
            } else if ('=' == arg[13]) {
                playerEnvironmentalName = &arg[14];
                playerEnvironmentalItfRequested = true;
            } else {
                bad = true;
            }
        } else if (!strcmp(arg, "--loop")) {
            loop = true;
        } else {
            bad = true;
        }
        if (bad) {
            fprintf(stderr, "%s: unknown option %s ignored\n", prog, arg);
        }
    }
    if (argc - i != 1) {
        fprintf(stderr, "usage: %s --mix-preset=# --mix-name=I3DL2 --player-preset=# "
                "--player-name=I3DL2 --loop filename\n", prog);
        return EXIT_FAILURE;
    }
    char *pathname = argv[i];

    const SLEnvironmentalReverbSettings *envSettings;
    if (NULL != outputMixEnvironmentalName) {
        envSettings = lookupEnvName(outputMixEnvironmentalName);
        if (NULL == envSettings) {
            fprintf(stderr, "%s: output mix environmental reverb name %s not found, "
                    "available names are:\n", prog, outputMixEnvironmentalName);
            printEnvNames();
            return EXIT_FAILURE;
        }
        outputMixEnvironmentalSettings = *envSettings;
    }
    if (NULL != playerEnvironmentalName) {
        envSettings = lookupEnvName(playerEnvironmentalName);
        if (NULL == envSettings) {
            fprintf(stderr, "%s: player environmental reverb name %s not found, "
                    "available names are:\n", prog, playerEnvironmentalName);
            printEnvNames();
            return EXIT_FAILURE;
        }
        playerEnvironmentalSettings = *envSettings;
    }

    // create engine
    SLObjectItf engineObject;
    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);
    SLEngineItf engineEngine;
    result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
    assert(SL_RESULT_SUCCESS == result);

    // create output mix
    SLInterfaceID mix_ids[2];
    SLboolean mix_req[2];
    SLuint32 count = 0;
    if (outputMixPresetItfRequested) {
        mix_req[count] = SL_BOOLEAN_TRUE;
        mix_ids[count++] = SL_IID_PRESETREVERB;
    }
    if (outputMixEnvironmentalItfRequested) {
        mix_req[count] = SL_BOOLEAN_TRUE;
        mix_ids[count++] = SL_IID_ENVIRONMENTALREVERB;
    }
    SLObjectItf mixObject;
    result = (*engineEngine)->CreateOutputMix(engineEngine, &mixObject, count, mix_ids, mix_req);
    assert(SL_RESULT_SUCCESS == result);
    result = (*mixObject)->Realize(mixObject, SL_BOOLEAN_FALSE);
    assert(SL_RESULT_SUCCESS == result);

    // configure preset reverb on output mix
    SLPresetReverbItf outputMixPresetReverb;
    if (outputMixPresetItfRequested) {
        result = (*mixObject)->GetInterface(mixObject, SL_IID_PRESETREVERB, &outputMixPresetReverb);
        assert(SL_RESULT_SUCCESS == result);
        SLuint16 getPresetReverb = 12345;
        result = (*outputMixPresetReverb)->GetPreset(outputMixPresetReverb, &getPresetReverb);
        assert(SL_RESULT_SUCCESS == result);
        printf("Output mix default preset reverb number = %u\n", getPresetReverb);
        if (outputMixPresetNumber != ((SLuint16) ~0)) {
            result = (*outputMixPresetReverb)->SetPreset(outputMixPresetReverb,
                    outputMixPresetNumber);
            if (SL_RESULT_SUCCESS == result) {
                result = (*outputMixPresetReverb)->GetPreset(outputMixPresetReverb,
                        &getPresetReverb);
                assert(SL_RESULT_SUCCESS == result);
                assert(getPresetReverb == outputMixPresetNumber);
                printf("Output mix preset reverb successfully changed to %u\n",
                        outputMixPresetNumber);
            } else {
                printf("Unable to set output mix preset reverb to %u, result=%u\n",
                        outputMixPresetNumber, result);
            }
        }
    }

    // configure environmental reverb on output mix
    SLEnvironmentalReverbItf outputMixEnvironmentalReverb;
    if (outputMixEnvironmentalItfRequested) {
        result = (*mixObject)->GetInterface(mixObject, SL_IID_ENVIRONMENTALREVERB,
                &outputMixEnvironmentalReverb);
        assert(SL_RESULT_SUCCESS == result);
        SLEnvironmentalReverbSettings getSettings;
        result = (*outputMixEnvironmentalReverb)->GetEnvironmentalReverbProperties(
                outputMixEnvironmentalReverb, &getSettings);
        assert(SL_RESULT_SUCCESS == result);
        printf("Output mix default environmental reverb settings\n");
        printf("------------------------------------------------\n");
        slesutPrintEnvironmentalReverbSettings(&getSettings);
        printf("\n");
        if (outputMixEnvironmentalName != NULL) {
            result = (*outputMixEnvironmentalReverb)->SetEnvironmentalReverbProperties(
                    outputMixEnvironmentalReverb, &outputMixEnvironmentalSettings);
            assert(SL_RESULT_SUCCESS == result);
            printf("Output mix new environmental reverb settings\n");
            printf("--------------------------------------------\n");
            slesutPrintEnvironmentalReverbSettings(&outputMixEnvironmentalSettings);
            printf("\n");
            result = (*outputMixEnvironmentalReverb)->GetEnvironmentalReverbProperties(
                    outputMixEnvironmentalReverb, &getSettings);
            assert(SL_RESULT_SUCCESS == result);
            printf("Output mix read environmental reverb settings\n");
            printf("--------------------------------------------\n");
            slesutPrintEnvironmentalReverbSettings(&getSettings);
            printf("\n");
            if (!slesutCompareEnvironmentalReverbSettings(&getSettings,
                    &outputMixEnvironmentalSettings)) {
                printf("Warning: new and read are different; check details above\n");
            } else {
                printf("New and read match, life is good\n");
            }
        }
    }

    // create audio player
    SLDataLocator_URI locURI = {SL_DATALOCATOR_URI, (SLchar *) pathname};
    SLDataFormat_MIME dfMIME = {SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED};
    SLDataSource audioSrc = {&locURI, &dfMIME};
    SLDataLocator_OutputMix locOutputMix = {SL_DATALOCATOR_OUTPUTMIX, mixObject};
    SLDataSink audioSnk = {&locOutputMix, NULL};
    SLInterfaceID player_ids[5];
    SLboolean player_req[5];
    count = 0;
    if (playerPresetItfRequested) {
        player_req[count] = SL_BOOLEAN_TRUE;
        player_ids[count++] = SL_IID_PRESETREVERB;
    }
    if (playerEnvironmentalItfRequested) {
        player_req[count] = SL_BOOLEAN_TRUE;
        player_ids[count++] = SL_IID_ENVIRONMENTALREVERB;
    }
    if (outputMixPresetItfRequested || outputMixEnvironmentalItfRequested) {
        player_req[count] = SL_BOOLEAN_TRUE;
        player_ids[count++] = SL_IID_EFFECTSEND;
    }
    if (loop) {
        player_req[count] = SL_BOOLEAN_TRUE;
        player_ids[count++] = SL_IID_SEEK;
    }
    player_req[count] = SL_BOOLEAN_TRUE;
    player_ids[count++] = SL_IID_PREFETCHSTATUS;
    SLObjectItf playerObject;
    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
        &audioSnk, count, player_ids, player_req);
    assert(SL_RESULT_SUCCESS == result);

    // realize audio player
    result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
    assert(SL_RESULT_SUCCESS == result);

    // if reverb is on output mix (aux effect), then enable it for this player
    if (outputMixPresetItfRequested || outputMixEnvironmentalItfRequested) {
        SLEffectSendItf playerEffectSend;
        result = (*playerObject)->GetInterface(playerObject, SL_IID_EFFECTSEND, &playerEffectSend);
        assert(SL_RESULT_SUCCESS == result);
        SLboolean enabled;
        SLmillibel directLevel;
        SLmillibel sendLevel;
        if (outputMixPresetItfRequested) {
            result = (*playerEffectSend)->IsEnabled(playerEffectSend, outputMixPresetReverb,
                    &enabled);
            assert(SL_RESULT_SUCCESS == result);
            printf("Output mix preset reverb: player effect send default enabled = %s\n",
                    enabled ? "true" : "false");
            directLevel = 12345;
            result = (*playerEffectSend)->GetDirectLevel(playerEffectSend, &directLevel);
            assert(SL_RESULT_SUCCESS == result);
            printf("Output mix preset reverb: player effect send default direct level = %d\n",
                    directLevel);
            sendLevel = 12345;
            result = (*playerEffectSend)->GetSendLevel(playerEffectSend, outputMixPresetReverb,
                    &sendLevel);
            assert(SL_RESULT_SUCCESS == result);
            printf("Output mix preset reverb: player effect send default send level = %d\n",
                    sendLevel);
            if (outputMixPresetNumber != ((SLuint16) ~0)) {
                result = (*playerEffectSend)->EnableEffectSend(playerEffectSend,
                        outputMixPresetReverb, SL_BOOLEAN_TRUE, (SLmillibel) 0);
                assert(SL_RESULT_SUCCESS == result);
                result = (*playerEffectSend)->IsEnabled(playerEffectSend, outputMixPresetReverb,
                        &enabled);
                assert(SL_RESULT_SUCCESS == result);
                directLevel = 12345;
                result = (*playerEffectSend)->GetDirectLevel(playerEffectSend, &directLevel);
                assert(SL_RESULT_SUCCESS == result);
                sendLevel = 12345;
                result = (*playerEffectSend)->GetSendLevel(playerEffectSend, outputMixPresetReverb,
                        &sendLevel);
                assert(SL_RESULT_SUCCESS == result);
                printf("Output mix preset reverb: player effect send new enabled = %s, direct level"
                    " = %d, send level = %d\n", enabled ? "true" : "false", directLevel, sendLevel);
            }
        }
        if (outputMixEnvironmentalItfRequested) {
            if (outputMixEnvironmentalName != NULL) {
                result = (*playerEffectSend)->IsEnabled(playerEffectSend,
                        outputMixEnvironmentalReverb, &enabled);
                assert(SL_RESULT_SUCCESS == result);
                printf("Output mix environmental reverb: player effect send default enabled = %s\n",
                        enabled ? "true" : "false");
                directLevel = 12345;
                result = (*playerEffectSend)->GetDirectLevel(playerEffectSend, &directLevel);
                assert(SL_RESULT_SUCCESS == result);
                printf("Output mix environmental reverb: player effect send default direct level"
                        " = %d\n", directLevel);
                sendLevel = 12345;
                result = (*playerEffectSend)->GetSendLevel(playerEffectSend,
                        outputMixEnvironmentalReverb, &sendLevel);
                assert(SL_RESULT_SUCCESS == result);
                printf("Output mix environmental reverb: player effect send default send level"
                        " = %d\n", sendLevel);
                result = (*playerEffectSend)->EnableEffectSend(playerEffectSend,
                        outputMixEnvironmentalReverb, SL_BOOLEAN_TRUE, (SLmillibel) 0);
                assert(SL_RESULT_SUCCESS == result);
                result = (*playerEffectSend)->IsEnabled(playerEffectSend,
                        outputMixEnvironmentalReverb, &enabled);
                assert(SL_RESULT_SUCCESS == result);
                directLevel = 12345;
                result = (*playerEffectSend)->GetDirectLevel(playerEffectSend, &directLevel);
                assert(SL_RESULT_SUCCESS == result);
                sendLevel = 12345;
                result = (*playerEffectSend)->GetSendLevel(playerEffectSend,
                        outputMixEnvironmentalReverb, &sendLevel);
                assert(SL_RESULT_SUCCESS == result);
                printf("Output mix environmental reverb: player effect send new enabled = %s, "
                    "direct level = %d, send level = %d\n", enabled ? "true" : "false",
                    directLevel, sendLevel);
            }
        }
    }

    // configure preset reverb on player
    SLPresetReverbItf playerPresetReverb;
    if (playerPresetItfRequested) {
        result = (*playerObject)->GetInterface(playerObject, SL_IID_PRESETREVERB,
                &playerPresetReverb);
        assert(SL_RESULT_SUCCESS == result);
        SLuint16 getPresetReverb = 12345;
        result = (*playerPresetReverb)->GetPreset(playerPresetReverb, &getPresetReverb);
        if (SL_RESULT_SUCCESS == result) {
            printf("Player default preset reverb %u\n", getPresetReverb);
            if (playerPresetNumber != ((SLuint16) ~0)) {
                result = (*playerPresetReverb)->SetPreset(playerPresetReverb, playerPresetNumber);
                if (SL_RESULT_SUCCESS == result) {
                    result = (*playerPresetReverb)->GetPreset(playerPresetReverb, &getPresetReverb);
                    assert(SL_RESULT_SUCCESS == result);
                    assert(getPresetReverb == playerPresetNumber);
                    printf("Player preset reverb successfully changed to %u\n", playerPresetNumber);
                } else {
                    printf("Unable to set player preset reverb to %u, result=%u\n",
                            playerPresetNumber, result);
                }
            }
        } else {
            printf("Unable to get player default preset reverb, result=%u\n", result);
        }
    }

    // configure environmental reverb on player
    SLEnvironmentalReverbItf playerEnvironmentalReverb;
    if (playerEnvironmentalItfRequested) {
        result = (*playerObject)->GetInterface(playerObject, SL_IID_ENVIRONMENTALREVERB,
                &playerEnvironmentalReverb);
        assert(SL_RESULT_SUCCESS == result);
        SLEnvironmentalReverbSettings getSettings;
        memset(&getSettings, 0, sizeof(getSettings));
        result = (*playerEnvironmentalReverb)->GetEnvironmentalReverbProperties(
                playerEnvironmentalReverb, &getSettings);
        if (SL_RESULT_SUCCESS == result) {
            printf("Player default environmental reverb settings\n");
            printf("--------------------------------------------\n");
            slesutPrintEnvironmentalReverbSettings(&getSettings);
            printf("\n");
            if (playerEnvironmentalName != NULL) {
                result = (*playerEnvironmentalReverb)->SetEnvironmentalReverbProperties(
                        playerEnvironmentalReverb, &playerEnvironmentalSettings);
                assert(SL_RESULT_SUCCESS == result);
                printf("Player new environmental reverb settings\n");
                printf("----------------------------------------\n");
                slesutPrintEnvironmentalReverbSettings(&playerEnvironmentalSettings);
                printf("\n");
                result = (*playerEnvironmentalReverb)->GetEnvironmentalReverbProperties(
                        playerEnvironmentalReverb, &getSettings);
                assert(SL_RESULT_SUCCESS == result);
                printf("Player read environmental reverb settings\n");
                printf("-----------------------------------------\n");
                slesutPrintEnvironmentalReverbSettings(&getSettings);
                printf("\n");
                if (!slesutCompareEnvironmentalReverbSettings(&getSettings,
                        &playerEnvironmentalSettings)) {
                    printf("Warning: new and read are different; check details above\n");
                } else {
                    printf("New and read match, life is good\n");
                }
            }
        } else {
            printf("Unable to get player default environmental reverb properties, result=%u\n",
                    result);
        }
    }

    // get the play interface
    SLPlayItf playerPlay;
    result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
    assert(SL_RESULT_SUCCESS == result);

    // set play state to paused to enable pre-fetch so we can get a more reliable duration
    result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PAUSED);
    assert(SL_RESULT_SUCCESS == result);

    // get the prefetch status interface
    SLPrefetchStatusItf playerPrefetchStatus;
    result = (*playerObject)->GetInterface(playerObject, SL_IID_PREFETCHSTATUS,
            &playerPrefetchStatus);
    assert(SL_RESULT_SUCCESS == result);

    // enable prefetch status callbacks
    result = (*playerPrefetchStatus)->RegisterCallback(playerPrefetchStatus, prefetch_callback,
            NULL);
    assert(SL_RESULT_SUCCESS == result);
    result = (*playerPrefetchStatus)->SetCallbackEventsMask(playerPrefetchStatus,
            SL_PREFETCHEVENT_STATUSCHANGE | SL_PREFETCHEVENT_FILLLEVELCHANGE);
    assert(SL_RESULT_SUCCESS == result);

    // wait for prefetch status callback to indicate either sufficient data or error
    pthread_mutex_lock(&mutex);
    while (prefetch_status == SL_PREFETCHSTATUS_UNKNOWN) {
        pthread_cond_wait(&cond, &mutex);
    }
    pthread_mutex_unlock(&mutex);
    if (prefetch_status == SL_PREFETCHSTATUS_ERROR) {
        fprintf(stderr, "Error during prefetch, exiting\n");
        goto destroyRes;
    }

    // get the duration
    SLmillisecond duration;
    result = (*playerPlay)->GetDuration(playerPlay, &duration);
    assert(SL_RESULT_SUCCESS == result);
    if (SL_TIME_UNKNOWN == duration) {
        printf("duration: unknown\n");
    } else {
        printf("duration: %.1f seconds\n", duration / 1000.0);
    }

    // enable looping
    if (loop) {
        SLSeekItf playerSeek;
        result = (*playerObject)->GetInterface(playerObject, SL_IID_SEEK, &playerSeek);
        assert(SL_RESULT_SUCCESS == result);
        result = (*playerSeek)->SetLoop(playerSeek, SL_BOOLEAN_TRUE, (SLmillisecond) 0,
                SL_TIME_UNKNOWN);
        assert(SL_RESULT_SUCCESS == result);
    }

    // start audio playing
    result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
    assert(SL_RESULT_SUCCESS == result);

    // wait for audio to finish playing
    SLuint32 state;
    for (;;) {
        result = (*playerPlay)->GetPlayState(playerPlay, &state);
        assert(SL_RESULT_SUCCESS == result);
        if (SL_PLAYSTATE_PLAYING != state)
            break;
        usleep(1000000);
     }
    assert(SL_PLAYSTATE_PAUSED == state);

destroyRes:
    // cleanup objects
    (*playerObject)->Destroy(playerObject);
    (*mixObject)->Destroy(mixObject);
    (*engineObject)->Destroy(engineObject);

    return EXIT_SUCCESS;
}
