mirror of https://github.com/axmolengine/axmol.git
issue #1284: add auto-detection of I9100 model for OpenSLES
This commit is contained in:
mustime
parent
4eee341407
commit
6f615ce085
|
|
@ -1,689 +0,0 @@
|
||||||
#include "OpenSLEngine.h"
|
|
||||||
|
|
||||||
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,"OPENSL_ENGINE", __VA_ARGS__)
|
|
||||||
|
|
||||||
using namespace std;
|
|
||||||
|
|
||||||
|
|
||||||
OpenSLEngine::OpenSLEngine()
|
|
||||||
:m_musicVolume(0),
|
|
||||||
m_effectVolume(0)
|
|
||||||
{}
|
|
||||||
|
|
||||||
OpenSLEngine::~OpenSLEngine()
|
|
||||||
{
|
|
||||||
closeEngine();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**********************************************************************************
|
|
||||||
* jni
|
|
||||||
**********************************************************************************/
|
|
||||||
#define CLASS_NAME "org/cocos2dx/lib/Cocos2dxActivity"
|
|
||||||
|
|
||||||
typedef struct JniMethodInfo_
|
|
||||||
{
|
|
||||||
JNIEnv * env;
|
|
||||||
jclass classID;
|
|
||||||
jmethodID methodID;
|
|
||||||
} JniMethodInfo;
|
|
||||||
|
|
||||||
extern "C" {
|
|
||||||
static JNIEnv* getJNIEnv(void)
|
|
||||||
{
|
|
||||||
|
|
||||||
JavaVM* jvm = cocos2d::JniHelper::getJavaVM();
|
|
||||||
if (NULL == jvm) {
|
|
||||||
LOGD("Failed to get JNIEnv. JniHelper::getJavaVM() is NULL");
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
JNIEnv *env = NULL;
|
|
||||||
// get jni environment
|
|
||||||
jint ret = jvm->GetEnv((void**)&env, JNI_VERSION_1_4);
|
|
||||||
|
|
||||||
switch (ret) {
|
|
||||||
case JNI_OK :
|
|
||||||
// Success!
|
|
||||||
return env;
|
|
||||||
|
|
||||||
case JNI_EDETACHED :
|
|
||||||
// Thread not attached
|
|
||||||
|
|
||||||
// TODO : If calling AttachCurrentThread() on a native thread
|
|
||||||
// must call DetachCurrentThread() in future.
|
|
||||||
// see: http://developer.android.com/guide/practices/design/jni.html
|
|
||||||
|
|
||||||
if (jvm->AttachCurrentThread(&env, NULL) < 0)
|
|
||||||
{
|
|
||||||
LOGD("Failed to get the environment using AttachCurrentThread()");
|
|
||||||
return NULL;
|
|
||||||
} else {
|
|
||||||
// Success : Attached and obtained JNIEnv!
|
|
||||||
return env;
|
|
||||||
}
|
|
||||||
|
|
||||||
case JNI_EVERSION :
|
|
||||||
// Cannot recover from this error
|
|
||||||
LOGD("JNI interface version 1.4 not supported");
|
|
||||||
default :
|
|
||||||
LOGD("Failed to get the environment using GetEnv()");
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static jclass getClassID(JNIEnv *pEnv)
|
|
||||||
{
|
|
||||||
jclass ret = pEnv->FindClass(CLASS_NAME);
|
|
||||||
if (! ret)
|
|
||||||
{
|
|
||||||
LOGD("Failed to find class of %s", CLASS_NAME);
|
|
||||||
}
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
static bool getStaticMethodInfo(JniMethodInfo &methodinfo, const char *methodName, const char *paramCode)
|
|
||||||
{
|
|
||||||
jmethodID methodID = 0;
|
|
||||||
JNIEnv *pEnv = 0;
|
|
||||||
bool bRet = false;
|
|
||||||
|
|
||||||
do
|
|
||||||
{
|
|
||||||
pEnv = getJNIEnv();
|
|
||||||
if (! pEnv)
|
|
||||||
{
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
jclass classID = getClassID(pEnv);
|
|
||||||
|
|
||||||
methodID = pEnv->GetStaticMethodID(classID, methodName, paramCode);
|
|
||||||
if (! methodID)
|
|
||||||
{
|
|
||||||
LOGD("Failed to find static method id of %s", methodName);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
methodinfo.classID = classID;
|
|
||||||
methodinfo.env = pEnv;
|
|
||||||
methodinfo.methodID = methodID;
|
|
||||||
|
|
||||||
bRet = true;
|
|
||||||
} while (0);
|
|
||||||
|
|
||||||
return bRet;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/*********************************************************************************
|
|
||||||
* helper
|
|
||||||
********************************************************************************/
|
|
||||||
#define PLAYSTATE_UNKNOWN 0
|
|
||||||
#define FILE_NOT_FOUND -1
|
|
||||||
|
|
||||||
#define ASSET_MANAGER_GETTER "getAssetManager"
|
|
||||||
|
|
||||||
#define MIN_VOLUME_MILLIBEL -4000
|
|
||||||
#define MAX_VOLUME_MILLIBEL 0
|
|
||||||
#define RANGE_VOLUME_MILLIBEL 4000
|
|
||||||
|
|
||||||
struct AudioPlayer
|
|
||||||
{
|
|
||||||
SLDataSource audioSrc;
|
|
||||||
SLObjectItf fdPlayerObject;
|
|
||||||
SLPlayItf fdPlayerPlay;
|
|
||||||
SLSeekItf fdPlayerSeek;
|
|
||||||
SLVolumeItf fdPlayerVolume;
|
|
||||||
} musicPlayer; /* for background music */
|
|
||||||
|
|
||||||
typedef map<unsigned int, vector<AudioPlayer*>* > EffectList;
|
|
||||||
typedef pair<unsigned int, vector<AudioPlayer*>* > Effect;
|
|
||||||
|
|
||||||
static EffectList& sharedList()
|
|
||||||
{
|
|
||||||
static EffectList s_List;
|
|
||||||
return s_List;
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int _Hash(const char *key)
|
|
||||||
{
|
|
||||||
unsigned int len = strlen(key);
|
|
||||||
const char *end=key+len;
|
|
||||||
unsigned int hash;
|
|
||||||
|
|
||||||
for (hash = 0; key < end; key++)
|
|
||||||
{
|
|
||||||
hash *= 16777619;
|
|
||||||
hash ^= (unsigned int) (unsigned char) toupper(*key);
|
|
||||||
}
|
|
||||||
return (hash);
|
|
||||||
}
|
|
||||||
|
|
||||||
int getFileDescriptor(const char * filename, off_t & start, off_t & length)
|
|
||||||
{
|
|
||||||
JniMethodInfo methodInfo;
|
|
||||||
if (! getStaticMethodInfo(methodInfo, ASSET_MANAGER_GETTER, "()Landroid/content/res/AssetManager;"))
|
|
||||||
{
|
|
||||||
return FILE_NOT_FOUND;
|
|
||||||
}
|
|
||||||
jobject assetManager = methodInfo.env->CallStaticObjectMethod(methodInfo.classID, methodInfo.methodID);
|
|
||||||
methodInfo.env->DeleteLocalRef(methodInfo.classID);
|
|
||||||
|
|
||||||
AAssetManager* mgr = AAssetManager_fromJava(methodInfo.env, assetManager);
|
|
||||||
assert(NULL != mgr);
|
|
||||||
|
|
||||||
AAsset* Asset = AAssetManager_open(mgr, filename, AASSET_MODE_UNKNOWN);
|
|
||||||
if (NULL == Asset)
|
|
||||||
{
|
|
||||||
LOGD("file not found! Stop preload file: %s", filename);
|
|
||||||
return FILE_NOT_FOUND;
|
|
||||||
}
|
|
||||||
|
|
||||||
// open asset as file descriptor
|
|
||||||
int fd = AAsset_openFileDescriptor(Asset, &start, &length);
|
|
||||||
assert(0 <= fd);
|
|
||||||
AAsset_close(Asset);
|
|
||||||
|
|
||||||
return fd;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**********************************************************************************
|
|
||||||
* engine
|
|
||||||
**********************************************************************************/
|
|
||||||
static SLObjectItf s_pEngineObject = NULL;
|
|
||||||
static SLEngineItf s_pEngineEngine = NULL;
|
|
||||||
static SLObjectItf s_pOutputMixObject = NULL;
|
|
||||||
|
|
||||||
bool createAudioPlayerBySource(AudioPlayer* player)
|
|
||||||
{
|
|
||||||
// configure audio sink
|
|
||||||
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, s_pOutputMixObject};
|
|
||||||
SLDataSink audioSnk = {&loc_outmix, NULL};
|
|
||||||
|
|
||||||
// create audio player
|
|
||||||
const SLInterfaceID ids[3] = {SL_IID_SEEK, SL_IID_MUTESOLO, SL_IID_VOLUME};
|
|
||||||
const SLboolean req[3] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
|
|
||||||
SLresult result = (*s_pEngineEngine)->CreateAudioPlayer(s_pEngineEngine, &(player->fdPlayerObject), &(player->audioSrc), &audioSnk, 3, ids, req);
|
|
||||||
if (SL_RESULT_MEMORY_FAILURE == result)
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
// realize the player
|
|
||||||
result = (*(player->fdPlayerObject))->Realize(player->fdPlayerObject, SL_BOOLEAN_FALSE);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// get the play interface
|
|
||||||
result = (*(player->fdPlayerObject))->GetInterface(player->fdPlayerObject, SL_IID_PLAY, &(player->fdPlayerPlay));
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// get the volume interface
|
|
||||||
result = (*(player->fdPlayerObject))->GetInterface(player->fdPlayerObject, SL_IID_VOLUME, &(player->fdPlayerVolume));
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// get the seek interface
|
|
||||||
result = (*(player->fdPlayerObject))->GetInterface(player->fdPlayerObject, SL_IID_SEEK, &(player->fdPlayerSeek));
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool initAudioPlayer(AudioPlayer* player, const char* filename)
|
|
||||||
{
|
|
||||||
// configure audio source
|
|
||||||
off_t start, length;
|
|
||||||
int fd = getFileDescriptor(filename, start, length);
|
|
||||||
if (FILE_NOT_FOUND == fd)
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
SLDataLocator_AndroidFD loc_fd = {SL_DATALOCATOR_ANDROIDFD, fd, start, length};
|
|
||||||
SLDataFormat_MIME format_mime = {SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED};
|
|
||||||
(player->audioSrc) = {&loc_fd, &format_mime};
|
|
||||||
|
|
||||||
return createAudioPlayerBySource(player);
|
|
||||||
}
|
|
||||||
|
|
||||||
void destroyAudioPlayer(AudioPlayer * player)
|
|
||||||
{
|
|
||||||
if (player && player->fdPlayerObject != NULL)
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
result = (*(player->fdPlayerPlay))->SetPlayState(player->fdPlayerPlay, SL_PLAYSTATE_STOPPED);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
(*(player->fdPlayerObject))->Destroy(player->fdPlayerObject);
|
|
||||||
player->fdPlayerObject = NULL;
|
|
||||||
player->fdPlayerPlay = NULL;
|
|
||||||
player->fdPlayerSeek = NULL;
|
|
||||||
player->fdPlayerVolume = NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::createEngine()
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
if (s_pEngineObject == NULL)
|
|
||||||
{
|
|
||||||
// create engine
|
|
||||||
result = slCreateEngine(&s_pEngineObject, 0, NULL, 0, NULL, NULL);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// realize the engine
|
|
||||||
result = (*s_pEngineObject)->Realize(s_pEngineObject, SL_BOOLEAN_FALSE);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// get the engine interface, which is needed in order to create other objects
|
|
||||||
result = (*s_pEngineObject)->GetInterface(s_pEngineObject, SL_IID_ENGINE, &s_pEngineEngine);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// create output mix
|
|
||||||
const SLInterfaceID ids[1] = {SL_IID_ENVIRONMENTALREVERB};
|
|
||||||
const SLboolean req[1] = {SL_BOOLEAN_FALSE};
|
|
||||||
result = (*s_pEngineEngine)->CreateOutputMix(s_pEngineEngine, &s_pOutputMixObject, 1, ids, req);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// realize the output mix object in sync. mode
|
|
||||||
result = (*s_pOutputMixObject)->Realize(s_pOutputMixObject, SL_BOOLEAN_FALSE);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::closeEngine()
|
|
||||||
{
|
|
||||||
// destroy background players
|
|
||||||
destroyAudioPlayer(&musicPlayer);
|
|
||||||
|
|
||||||
// destroy effect players
|
|
||||||
vector<AudioPlayer*>* vec;
|
|
||||||
EffectList::iterator p = sharedList().begin();
|
|
||||||
while (p != sharedList().end())
|
|
||||||
{
|
|
||||||
vec = p->second;
|
|
||||||
for (vector<AudioPlayer*>::iterator iter = vec->begin() ; iter != vec->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
destroyAudioPlayer(*iter);
|
|
||||||
}
|
|
||||||
vec->clear();
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
sharedList().clear();
|
|
||||||
|
|
||||||
// destroy output mix interface
|
|
||||||
if (s_pOutputMixObject)
|
|
||||||
{
|
|
||||||
(*s_pOutputMixObject)->Destroy(s_pOutputMixObject);
|
|
||||||
s_pOutputMixObject = NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
// destroy opensl engine
|
|
||||||
if (s_pEngineObject)
|
|
||||||
{
|
|
||||||
(*s_pEngineObject)->Destroy(s_pEngineObject);
|
|
||||||
s_pEngineObject = NULL;
|
|
||||||
s_pEngineEngine = NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
LOGD("engine destory");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**********************************************************************************
|
|
||||||
* background music
|
|
||||||
**********************************************************************************/
|
|
||||||
bool OpenSLEngine::preloadBackgroundMusic(const char * filename)
|
|
||||||
{
|
|
||||||
if (musicPlayer.fdPlayerPlay != NULL)
|
|
||||||
{
|
|
||||||
SLresult result = (*(musicPlayer.fdPlayerPlay))->SetPlayState(musicPlayer.fdPlayerPlay, SL_PLAYSTATE_STOPPED);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
|
|
||||||
return initAudioPlayer(&musicPlayer, filename);
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::setBackgroundMusicState(int state)
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
if (NULL != musicPlayer.fdPlayerPlay)
|
|
||||||
{
|
|
||||||
result = (*(musicPlayer.fdPlayerPlay))->SetPlayState(musicPlayer.fdPlayerPlay, state);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int OpenSLEngine::getBackgroundMusicState()
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
SLuint32 state;
|
|
||||||
if (musicPlayer.fdPlayerPlay != NULL)
|
|
||||||
{
|
|
||||||
result = (*(musicPlayer.fdPlayerPlay))->GetPlayState(musicPlayer.fdPlayerPlay, &state);
|
|
||||||
assert(result == SL_RESULT_SUCCESS);
|
|
||||||
}
|
|
||||||
|
|
||||||
return (int)state;
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::rewindBackgroundMusic()
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
|
|
||||||
result = (*(musicPlayer.fdPlayerSeek))->SetPosition(musicPlayer.fdPlayerSeek, 0, SL_SEEKMODE_FAST);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
result = (*(musicPlayer.fdPlayerPlay))->SetPlayState(musicPlayer.fdPlayerPlay, SL_PLAYSTATE_PLAYING);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::setBackgroundMusicLooping(bool isLooping)
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
if (NULL != musicPlayer.fdPlayerSeek)
|
|
||||||
{
|
|
||||||
result = (*(musicPlayer.fdPlayerSeek))->SetLoop(musicPlayer.fdPlayerSeek, (SLboolean) isLooping, 0, SL_TIME_UNKNOWN);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::setBackgroundVolume(int volume)
|
|
||||||
{
|
|
||||||
m_musicVolume = volume;
|
|
||||||
|
|
||||||
SLresult result;
|
|
||||||
if (NULL != musicPlayer.fdPlayerVolume)
|
|
||||||
{
|
|
||||||
result = (*(musicPlayer.fdPlayerVolume))->SetVolumeLevel(musicPlayer.fdPlayerVolume, m_musicVolume);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int OpenSLEngine::getBackgroundVolume()
|
|
||||||
{
|
|
||||||
return m_musicVolume;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**********************************************************************************
|
|
||||||
* sound effect
|
|
||||||
**********************************************************************************/
|
|
||||||
typedef struct _CallbackContext
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec;
|
|
||||||
AudioPlayer* player;
|
|
||||||
} CallbackContext;
|
|
||||||
|
|
||||||
void PlayOverEvent(SLPlayItf caller, void* pContext, SLuint32 playEvent)
|
|
||||||
{
|
|
||||||
CallbackContext* context = (CallbackContext*)pContext;
|
|
||||||
if (playEvent == SL_PLAYEVENT_HEADATEND)
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>::iterator iter;
|
|
||||||
for (iter = (context->vec)->begin() ; iter != (context->vec)->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
if (*iter == context->player)
|
|
||||||
{
|
|
||||||
(context->vec)->erase(iter);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
destroyAudioPlayer(context->player);
|
|
||||||
free(context);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void setSingleEffectVolume(AudioPlayer* player, SLmillibel volume)
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
result = (*(player->fdPlayerVolume))->SetVolumeLevel(player->fdPlayerVolume, volume);
|
|
||||||
assert(result == SL_RESULT_SUCCESS);
|
|
||||||
}
|
|
||||||
|
|
||||||
int getSingleEffectState(AudioPlayer * player)
|
|
||||||
{
|
|
||||||
SLuint32 state = 0;
|
|
||||||
SLresult result;
|
|
||||||
result = (*(player->fdPlayerPlay))->GetPlayState(player->fdPlayerPlay, &state);
|
|
||||||
assert(result == SL_RESULT_SUCCESS);
|
|
||||||
|
|
||||||
return (int)state;
|
|
||||||
}
|
|
||||||
|
|
||||||
void setSingleEffectState(AudioPlayer * player, int state)
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
if (player->fdPlayerPlay != NULL)
|
|
||||||
{
|
|
||||||
// don't set to PAUSED state if it's already set to STOPPED state
|
|
||||||
int oldState = getSingleEffectState(player);
|
|
||||||
if (oldState == SL_PLAYSTATE_STOPPED && state == SL_PLAYSTATE_PAUSED)
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
result = (*(player->fdPlayerPlay))->SetPlayState(player->fdPlayerPlay, state);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void resumeSingleEffect(AudioPlayer * player)
|
|
||||||
{
|
|
||||||
int state = getSingleEffectState(player);
|
|
||||||
// only resume the effect that has been paused
|
|
||||||
if (state == SL_PLAYSTATE_PAUSED)
|
|
||||||
{
|
|
||||||
setSingleEffectState(player, SL_PLAYSTATE_PLAYING);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool OpenSLEngine::recreatePlayer(const char* filename)
|
|
||||||
{
|
|
||||||
unsigned int effectID = _Hash(filename);
|
|
||||||
EffectList::iterator p = sharedList().find(effectID);
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
AudioPlayer* newPlayer = new AudioPlayer();
|
|
||||||
if (!initAudioPlayer(newPlayer, filename))
|
|
||||||
{
|
|
||||||
LOGD("failed to recreate");
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
vec->push_back(newPlayer);
|
|
||||||
|
|
||||||
// set callback
|
|
||||||
SLresult result;
|
|
||||||
CallbackContext* context = new CallbackContext();
|
|
||||||
context->vec = vec;
|
|
||||||
context->player = newPlayer;
|
|
||||||
result = (*(newPlayer->fdPlayerPlay))->RegisterCallback(newPlayer->fdPlayerPlay, PlayOverEvent, (void*)context);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
result = (*(newPlayer->fdPlayerPlay))->SetCallbackEventsMask(newPlayer->fdPlayerPlay, SL_PLAYEVENT_HEADATEND);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
|
|
||||||
// set volume
|
|
||||||
setSingleEffectVolume(newPlayer, m_effectVolume);
|
|
||||||
setSingleEffectState(newPlayer, SL_PLAYSTATE_STOPPED);
|
|
||||||
setSingleEffectState(newPlayer, SL_PLAYSTATE_PLAYING);
|
|
||||||
|
|
||||||
// LOGD("vec count is %d of effectID %d", vec->size(), effectID);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int OpenSLEngine::preloadEffect(const char * filename)
|
|
||||||
{
|
|
||||||
unsigned int nID = _Hash(filename);
|
|
||||||
// if already exists
|
|
||||||
EffectList::iterator p = sharedList().find(nID);
|
|
||||||
if (p != sharedList().end())
|
|
||||||
{
|
|
||||||
return nID;
|
|
||||||
}
|
|
||||||
|
|
||||||
AudioPlayer* player = new AudioPlayer();
|
|
||||||
if (!initAudioPlayer(player, filename))
|
|
||||||
{
|
|
||||||
free(player);
|
|
||||||
return FILE_NOT_FOUND;
|
|
||||||
}
|
|
||||||
|
|
||||||
// set the new player's volume as others'
|
|
||||||
setSingleEffectVolume(player, m_effectVolume);
|
|
||||||
|
|
||||||
vector<AudioPlayer*>* vec = new vector<AudioPlayer*>;
|
|
||||||
vec->push_back(player);
|
|
||||||
sharedList().insert(Effect(nID, vec));
|
|
||||||
return nID;
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::unloadEffect(const char * filename)
|
|
||||||
{
|
|
||||||
unsigned int nID = _Hash(filename);
|
|
||||||
|
|
||||||
EffectList::iterator p = sharedList().find(nID);
|
|
||||||
if (p != sharedList().end())
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
for (vector<AudioPlayer*>::iterator iter = vec->begin() ; iter != vec->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
destroyAudioPlayer(*iter);
|
|
||||||
}
|
|
||||||
vec->clear();
|
|
||||||
sharedList().erase(nID);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int OpenSLEngine::getEffectState(unsigned int effectID)
|
|
||||||
{
|
|
||||||
int state = PLAYSTATE_UNKNOWN;
|
|
||||||
EffectList::iterator p = sharedList().find(effectID);
|
|
||||||
if (p != sharedList().end())
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
// get the last player's state
|
|
||||||
vector<AudioPlayer*>::reverse_iterator r_iter = vec->rbegin();
|
|
||||||
state = getSingleEffectState(*r_iter);
|
|
||||||
}
|
|
||||||
return state;
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::setEffectState(unsigned int effectID, int state, bool isClear)
|
|
||||||
{
|
|
||||||
EffectList::iterator p = sharedList().find(effectID);
|
|
||||||
if (p != sharedList().end())
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
if (state == SL_PLAYSTATE_STOPPED || state == SL_PLAYSTATE_PAUSED)
|
|
||||||
{
|
|
||||||
// if stopped, clear the recreated players which are unused
|
|
||||||
if (isClear)
|
|
||||||
{
|
|
||||||
setSingleEffectState(*(vec->begin()), state);
|
|
||||||
vector<AudioPlayer*>::reverse_iterator r_iter = vec->rbegin();
|
|
||||||
for (int i = 1, size = vec->size() ; i < size ; ++ i)
|
|
||||||
{
|
|
||||||
destroyAudioPlayer(*r_iter);
|
|
||||||
r_iter ++;
|
|
||||||
vec->pop_back();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>::iterator iter;
|
|
||||||
for (iter = vec->begin() ; iter != vec->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
setSingleEffectState(*iter, state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
setSingleEffectState(*(vec->rbegin()), state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::setAllEffectState(int state)
|
|
||||||
{
|
|
||||||
EffectList::iterator p;
|
|
||||||
for (p = sharedList().begin(); p != sharedList().end(); p ++)
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
for (vector<AudioPlayer*>::iterator iter = vec->begin() ; iter != vec->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
setSingleEffectState(*iter, state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::resumeEffect(unsigned int effectID)
|
|
||||||
{
|
|
||||||
EffectList::iterator p = sharedList().find(effectID);
|
|
||||||
if (p != sharedList().end())
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
for (vector<AudioPlayer*>::iterator iter = vec->begin() ; iter != vec->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
resumeSingleEffect(*iter);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::resumeAllEffects()
|
|
||||||
{
|
|
||||||
int state;
|
|
||||||
EffectList::iterator p;
|
|
||||||
for (p = sharedList().begin(); p != sharedList().end() ; ++ p)
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
for (vector<AudioPlayer*>::iterator iter = vec->begin() ; iter != vec->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
resumeSingleEffect(*iter);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::setEffectLooping(unsigned int effectID, bool isLooping)
|
|
||||||
{
|
|
||||||
SLresult result;
|
|
||||||
vector<AudioPlayer*>* vec = sharedList()[effectID];
|
|
||||||
assert(NULL != vec);
|
|
||||||
|
|
||||||
// get the first effect player that to be set loop config
|
|
||||||
vector<AudioPlayer*>::iterator iter = vec->begin();
|
|
||||||
AudioPlayer * player = *iter;
|
|
||||||
|
|
||||||
if (player && player->fdPlayerSeek)
|
|
||||||
{
|
|
||||||
result = (*(player->fdPlayerSeek))->SetLoop(player->fdPlayerSeek, (SLboolean) isLooping, 0, SL_TIME_UNKNOWN);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenSLEngine::setEffectsVolume(float volume)
|
|
||||||
{
|
|
||||||
assert(volume <= 1.0f && volume >= 0.0f);
|
|
||||||
m_effectVolume = int (RANGE_VOLUME_MILLIBEL * volume) + MIN_VOLUME_MILLIBEL;
|
|
||||||
|
|
||||||
SLresult result;
|
|
||||||
EffectList::iterator p;
|
|
||||||
AudioPlayer * player;
|
|
||||||
for (p = sharedList().begin() ; p != sharedList().end() ; ++ p)
|
|
||||||
{
|
|
||||||
vector<AudioPlayer*>* vec = p->second;
|
|
||||||
for (vector<AudioPlayer*>::iterator iter = vec->begin() ; iter != vec->end() ; ++ iter)
|
|
||||||
{
|
|
||||||
player = *iter;
|
|
||||||
result = (*(player->fdPlayerVolume))->SetVolumeLevel(player->fdPlayerVolume, m_effectVolume);
|
|
||||||
assert(SL_RESULT_SUCCESS == result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
float OpenSLEngine::getEffectsVolume()
|
|
||||||
{
|
|
||||||
float volume = (m_effectVolume - MIN_VOLUME_MILLIBEL) / (1.0f * RANGE_VOLUME_MILLIBEL);
|
|
||||||
LOGD("effect volume: %f", volume);
|
|
||||||
return volume;
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue