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

#include <dlfcn.h>

#include "common/OboeDebug.h"
#include "EngineOpenSLES.h"
#include "OpenSLESUtilities.h"

using namespace oboe;

// OpenSL ES is deprecated in SDK 30.
// So we use custom dynamic linking to access the library.
#define LIB_OPENSLES_NAME "libOpenSLES.so"

EngineOpenSLES &EngineOpenSLES::getInstance() {
    static EngineOpenSLES sInstance;
    return sInstance;
}

// Satisfy extern in OpenSLES.h
// These are required because of b/337360630, which was causing
// Oboe to have link failures if libOpenSLES.so was not available.
// If you are statically linking Oboe and libOpenSLES.so in a shared library
// and you observe crashes, you can pass DO_NOT_DEFINE_OPENSL_ES_CONSTANTS to cmake.
#ifndef DO_NOT_DEFINE_OPENSL_ES_CONSTANTS
SL_API const SLInterfaceID SL_IID_ENGINE = nullptr;
SL_API const SLInterfaceID SL_IID_ANDROIDSIMPLEBUFFERQUEUE = nullptr;
SL_API const SLInterfaceID SL_IID_ANDROIDCONFIGURATION = nullptr;
SL_API const SLInterfaceID SL_IID_RECORD = nullptr;
SL_API const SLInterfaceID SL_IID_BUFFERQUEUE = nullptr;
SL_API const SLInterfaceID SL_IID_VOLUME = nullptr;
SL_API const SLInterfaceID SL_IID_PLAY = nullptr;
#endif

static const char *getSafeDlerror() {
    static const char *defaultMessage = "not found?";
    char *errorMessage = dlerror();
    return (errorMessage == nullptr) ? defaultMessage : errorMessage;
}

// Load the OpenSL ES library and the one primary entry point.
// @return true if linked OK
bool EngineOpenSLES::linkOpenSLES() {
    if (mDynamicLinkState == kLinkStateBad) {
        LOGE("%s(), OpenSL ES not available, based on previous link failure.", __func__);
    } else if (mDynamicLinkState == kLinkStateUninitialized) {
        // Set to BAD now in case we return because of an error.
        // This is safe form race conditions because this function is always called
        // under mLock amd the state is only accessed from this function.
        mDynamicLinkState = kLinkStateBad;
        // Use RTLD_NOW to avoid the unpredictable behavior that RTLD_LAZY can cause.
        // Also resolving all the links now will prevent a run-time penalty later.
        mLibOpenSlesLibraryHandle = dlopen(LIB_OPENSLES_NAME, RTLD_NOW);
        if (mLibOpenSlesLibraryHandle == nullptr) {
            LOGE("%s() could not dlopen(%s), %s", __func__, LIB_OPENSLES_NAME, getSafeDlerror());
            return false;
        } else {
            mFunction_slCreateEngine = (prototype_slCreateEngine) dlsym(
                    mLibOpenSlesLibraryHandle,
                    "slCreateEngine");
            LOGD("%s(): dlsym(%s) returned %p", __func__,
                 "slCreateEngine", mFunction_slCreateEngine);
            if (mFunction_slCreateEngine == nullptr) {
                LOGE("%s(): dlsym(slCreateEngine) returned null, %s", __func__, getSafeDlerror());
                return false;
            }

            // Load IID interfaces.
            LOCAL_SL_IID_ENGINE = getIidPointer("SL_IID_ENGINE");
            if (LOCAL_SL_IID_ENGINE == nullptr) return false;
            LOCAL_SL_IID_ANDROIDSIMPLEBUFFERQUEUE = getIidPointer(
                    "SL_IID_ANDROIDSIMPLEBUFFERQUEUE");
            if (LOCAL_SL_IID_ANDROIDSIMPLEBUFFERQUEUE == nullptr) return false;
            LOCAL_SL_IID_ANDROIDCONFIGURATION = getIidPointer(
                    "SL_IID_ANDROIDCONFIGURATION");
            if (LOCAL_SL_IID_ANDROIDCONFIGURATION == nullptr) return false;
            LOCAL_SL_IID_RECORD = getIidPointer("SL_IID_RECORD");
            if (LOCAL_SL_IID_RECORD == nullptr) return false;
            LOCAL_SL_IID_BUFFERQUEUE = getIidPointer("SL_IID_BUFFERQUEUE");
            if (LOCAL_SL_IID_BUFFERQUEUE == nullptr) return false;
            LOCAL_SL_IID_VOLUME = getIidPointer("SL_IID_VOLUME");
            if (LOCAL_SL_IID_VOLUME == nullptr) return false;
            LOCAL_SL_IID_PLAY = getIidPointer("SL_IID_PLAY");
            if (LOCAL_SL_IID_PLAY == nullptr) return false;

            mDynamicLinkState = kLinkStateGood;
        }
    }
    return (mDynamicLinkState == kLinkStateGood);
}

// A symbol like SL_IID_PLAY is a pointer to a structure.
// The dlsym() function returns the address of the pointer, not the structure.
// To get the address of the structure we have to dereference the pointer.
SLInterfaceID EngineOpenSLES::getIidPointer(const char *symbolName) {
    SLInterfaceID *iid_address = (SLInterfaceID *) dlsym(
            mLibOpenSlesLibraryHandle,
            symbolName);
    if (iid_address == nullptr) {
        LOGE("%s(): dlsym(%s) returned null, %s", __func__, symbolName, getSafeDlerror());
        return (SLInterfaceID) nullptr;
    }
    return *iid_address; // Get address of the structure.
}

SLresult EngineOpenSLES::open() {
    std::lock_guard<std::mutex> lock(mLock);

    SLresult result = SL_RESULT_SUCCESS;
    if (mOpenCount++ == 0) {
        // load the library and link to it
        if (!linkOpenSLES()) {
            result = SL_RESULT_FEATURE_UNSUPPORTED;
            goto error;
        };

        // create engine
        result = (*mFunction_slCreateEngine)(&mEngineObject, 0, NULL, 0, NULL, NULL);
        if (SL_RESULT_SUCCESS != result) {
            LOGE("EngineOpenSLES - slCreateEngine() result:%s", getSLErrStr(result));
            goto error;
        }

        // realize the engine
        result = (*mEngineObject)->Realize(mEngineObject, SL_BOOLEAN_FALSE);
        if (SL_RESULT_SUCCESS != result) {
            LOGE("EngineOpenSLES - Realize() engine result:%s", getSLErrStr(result));
            goto error;
        }

        // get the engine interface, which is needed in order to create other objects
        result = (*mEngineObject)->GetInterface(mEngineObject,
                                                EngineOpenSLES::getInstance().getIidEngine(),
                                                &mEngineInterface);
        if (SL_RESULT_SUCCESS != result) {
            LOGE("EngineOpenSLES - GetInterface() engine result:%s", getSLErrStr(result));
            goto error;
        }
    }

    return result;

error:
    close_l();
    return result;
}

void EngineOpenSLES::close() {
    std::lock_guard<std::mutex> lock(mLock);
    close_l();
}

// This must be called under mLock
void EngineOpenSLES::close_l() {
    if (--mOpenCount == 0) {
        if (mEngineObject != nullptr) {
            (*mEngineObject)->Destroy(mEngineObject);
            mEngineObject = nullptr;
            mEngineInterface = nullptr;
        }
    }
}

SLresult EngineOpenSLES::createOutputMix(SLObjectItf *objectItf) {
    return (*mEngineInterface)->CreateOutputMix(mEngineInterface, objectItf, 0, 0, 0);
}

SLresult EngineOpenSLES::createAudioPlayer(SLObjectItf *objectItf,
                                           SLDataSource *audioSource,
                                           SLDataSink *audioSink) {

    SLInterfaceID ids[] = {LOCAL_SL_IID_BUFFERQUEUE, LOCAL_SL_IID_ANDROIDCONFIGURATION};
    SLboolean reqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};

    return (*mEngineInterface)->CreateAudioPlayer(mEngineInterface, objectItf, audioSource,
                                                  audioSink,
                                                  sizeof(ids) / sizeof(ids[0]), ids, reqs);
}

SLresult EngineOpenSLES::createAudioRecorder(SLObjectItf *objectItf,
                                             SLDataSource *audioSource,
                                             SLDataSink *audioSink) {

    SLInterfaceID ids[] = {LOCAL_SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
                           LOCAL_SL_IID_ANDROIDCONFIGURATION };
    SLboolean reqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};

    return (*mEngineInterface)->CreateAudioRecorder(mEngineInterface, objectItf, audioSource,
                                                    audioSink,
                                                    sizeof(ids) / sizeof(ids[0]), ids, reqs);
}