void SG_validate__ensure__trim(
SG_context* pCtx,
const char* szValue,
SG_uint32 uMin,
SG_uint32 uMax,
const char* szInvalids,
SG_bool bControls,
SG_error uError,
const char* szName,
char** ppTrimmed
)
{
SG_uint32 uResult = 0u;
char* szTrimmed = NULL;
SG_ERR_CHECK( SG_validate__check__trim(pCtx, szValue, uMin, uMax, szInvalids, bControls, &uResult, &szTrimmed) );
SG_ERR_CHECK( _check_result(pCtx, uResult, uError, szName, uMin, uMax, szInvalids) );
if (ppTrimmed != NULL)
{
*ppTrimmed = szTrimmed;
szTrimmed = NULL;
}
fail:
SG_NULLFREE(pCtx, szTrimmed);
return;
}
// ------------------ opensl env -------------------------
static bool
sl_init () {
if(ENV._is_init)
return true;
SLresult result;
memset(&ENV, 0, sizeof(ENV));
source_buffer_init(&ENV.source_record);
ENV.last_error_code = SL_RESULT_SUCCESS;
SLEnvironmentalReverbSettings v = SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR;
ENV.reverbSettings = v;
// create engine
result = slCreateEngine(&ENV.engineObject, 0, NULL, 0, NULL, NULL);
_check_result(result);
// realize the engine
result = (*ENV.engineObject)->Realize(ENV.engineObject, SL_BOOLEAN_FALSE);
_check_result(result);
// get the engine interface, which is needed in order to create other objects
result = (*ENV.engineObject)->GetInterface(ENV.engineObject, SL_IID_ENGINE, &ENV.engineEngine);
_check_result(result);
// create output mix, with environmental reverb specified as a non-required interface
const SLInterfaceID ids[1] = {SL_IID_ENVIRONMENTALREVERB};
const SLboolean req[1] = {SL_BOOLEAN_FALSE};
result = (*ENV.engineEngine)->CreateOutputMix(ENV.engineEngine, &ENV.outputMixObject, 1, ids, req);
_check_result(result);
// realize the output mix
result = (*ENV.outputMixObject)->Realize(ENV.outputMixObject, SL_BOOLEAN_FALSE);
_check_result(result);
result = (*ENV.outputMixObject)->GetInterface(ENV.outputMixObject, SL_IID_ENVIRONMENTALREVERB,
&ENV.outputMixEnvironmentalReverb);
_check_result(result);
if (SL_RESULT_SUCCESS == result) {
result = (*ENV.outputMixEnvironmentalReverb)->SetEnvironmentalReverbProperties(
ENV.outputMixEnvironmentalReverb, &ENV.reverbSettings);
_check_result(result);
}
ENV._is_init = true;
return true;
ERROR:
ENV._is_init = true;
sl_destory();
return false;
}
void SG_validate__ensure(
SG_context* pCtx,
const char* szValue,
SG_uint32 uMin,
SG_uint32 uMax,
const char* szInvalids,
SG_bool bControls,
SG_error uError,
const char* szName
)
{
SG_uint32 uResult = 0u;
SG_ERR_CHECK( SG_validate__check(pCtx, szValue, uMin, uMax, szInvalids, bControls, &uResult) );
SG_ERR_CHECK( _check_result(pCtx, uResult, uError, szName, uMin, uMax, szInvalids) );
fail:
return;
}
bool
sl_bgm_load(const char* file_name) {
if(!file_name) {
return false;
}
struct sl_bgm* bgm = &(ENV.bgm);
if(bgm->file_name && strcmp(file_name, bgm->file_name) == 0) {
SLresult result = (*bgm->fdPlayerPlay)->SetPlayState(bgm->fdPlayerPlay, SL_PLAYSTATE_STOPPED);
return result == SL_RESULT_SUCCESS;
}
_bgm_free(bgm);
bgm->file_name = strdup(file_name);
if(bgm->file_name == NULL) {
return false;
}
AAsset* asset = AAssetManager_open(ENV.asset_mgr, file_name, AASSET_MODE_UNKNOWN);
if(asset == NULL) {
goto ERROR;
}
// open asset as file descriptor
off_t start, length;
int fd = AAsset_openFileDescriptor(asset, &start, &length);
AAsset_close(asset);
if(fd < 0) {
goto ERROR;
}
// configure audio source
SLDataLocator_AndroidFD loc_fd = {SL_DATALOCATOR_ANDROIDFD, fd, start, length};
SLDataFormat_MIME format_mime = {SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED};
SLDataSource audioSrc = {&loc_fd, &format_mime};
// configure audio sink
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, ENV.outputMixObject};
SLDataSink audioSnk = {&loc_outmix, NULL};
// create audio player
SLresult result;
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};
result = (*ENV.engineEngine)->CreateAudioPlayer(ENV.engineEngine, &bgm->fdPlayerObject, &audioSrc, &audioSnk,
3, ids, req);
_check_result(result);
// realize the player
result = (*bgm->fdPlayerObject)->Realize(bgm->fdPlayerObject, SL_BOOLEAN_FALSE);
_check_result(result);
// get the play interface
result = (*bgm->fdPlayerObject)->GetInterface(bgm->fdPlayerObject, SL_IID_PLAY, &bgm->fdPlayerPlay);
_check_result(result);
// get the seek interface
result = (*bgm->fdPlayerObject)->GetInterface(bgm->fdPlayerObject, SL_IID_SEEK, &bgm->fdPlayerSeek);
_check_result(result);
// get the volume interface
result = (*bgm->fdPlayerObject)->GetInterface(bgm->fdPlayerObject, SL_IID_VOLUME, &bgm->fdPlayerVolume);
_check_result(result);
// enable whole file looping
result = (*bgm->fdPlayerSeek)->SetLoop(bgm->fdPlayerSeek, SL_BOOLEAN_FALSE, 0, SL_TIME_UNKNOWN);
_check_result(result);
// set bgm stop
result = (*bgm->fdPlayerPlay)->SetPlayState(bgm->fdPlayerPlay, SL_PLAYSTATE_STOPPED);
_check_result(result);
return true;
ERROR:
_bgm_free(bgm);
return false;
}
struct sl_source*
sl_source_gen() {
struct sl_source* ret = (struct sl_source*)malloc(sizeof(*ret));
if(!ret)
return NULL;
SLresult result;
// configure audio source
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 1, SL_SAMPLINGRATE_44_1,
SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16,
SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN};
SLDataSource audioSrc = {&loc_bufq, &format_pcm};
// configure audio sink
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, ENV.outputMixObject};
SLDataSink audioSnk = {&loc_outmix, NULL};
// create audio player
const SLInterfaceID ids[3] = {SL_IID_BUFFERQUEUE, SL_IID_EFFECTSEND,
/*SL_IID_MUTESOLO,*/ SL_IID_VOLUME};
const SLboolean req[3] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE,
/*SL_BOOLEAN_TRUE,*/ SL_BOOLEAN_TRUE};
sl_log("sl_source_gen!!!! begin!!!\n");
result = (*ENV.engineEngine)->CreateAudioPlayer(ENV.engineEngine, &ret->bqPlayerObject, &audioSrc, &audioSnk,
3, ids, req);
sl_log("sl_source_gen!!!! end : %d!!!\n", result);
_check_result(result);
// realize the player
result = (*ret->bqPlayerObject)->Realize(ret->bqPlayerObject, SL_BOOLEAN_FALSE);
_check_result(result);
// get the play interface
result = (*ret->bqPlayerObject)->GetInterface(ret->bqPlayerObject, SL_IID_PLAY, &ret->bqPlayerPlay);
_check_result(result);
// get the buffer queue interface
result = (*ret->bqPlayerObject)->GetInterface(ret->bqPlayerObject, SL_IID_BUFFERQUEUE,
&ret->bqPlayerBufferQueue);
_check_result(result);
// register callback on the buffer queue
result = (*ret->bqPlayerBufferQueue)->RegisterCallback(ret->bqPlayerBufferQueue, bqPlayerCallback, (void*)ret);
_check_result(result);
// get the volume interface
result = (*ret->bqPlayerObject)->GetInterface(ret->bqPlayerObject, SL_IID_VOLUME, &ret->bqPlayerVolume);
_check_result(result);
// get the pitch interface, may be feature unsupported
result = (*ret->bqPlayerObject)->GetInterface(ret->bqPlayerObject, SL_IID_PITCH, &ret->bqPlayerPitch);
// set the player's state to playing
result = (*ret->bqPlayerPlay)->SetPlayState(ret->bqPlayerPlay, SL_PLAYSTATE_PLAYING);
_check_result(result);
source_buffer_add(&ENV.source_record, ret);
return ret;
ERROR:
sl_source_free(ret);
return NULL;
}
