static void
loadSynthesisLibrary (void) {
#ifdef ENABLE_SHARED_OBJECTS
if (!speechLibrary) {
static const char *name = "libmplinux." LIBRARY_EXTENSION;
char *path = makePath(MIKROPUHE_ROOT, name);
if (path) {
if ((speechLibrary = loadSharedObject(path))) {
const SymbolEntry *symbol = symbolTable;
while (symbol->name) {
void **address = symbol->address;
if (findSharedSymbol(speechLibrary, symbol->name, address)) {
logMessage(LOG_DEBUG, "Mikropuhe symbol: %s -> %p",
symbol->name, *address);
} else {
logMessage(LOG_ERR, "Mikropuhe symbol not found: %s", symbol->name);
}
++symbol;
}
} else {
logMessage(LOG_ERR, "Mikropuhe library not loaded: %s", path);
}
free(path);
}
}
#endif /* ENABLE_SHARED_OBJECTS */
}
static jboolean
Emulator_loadEngine(JNIEnv *env, jobject self, jstring jdir, jstring jlib)
{
const char *dir = env->GetStringUTFChars(jdir, NULL);
const char *lib = env->GetStringUTFChars(jlib, NULL);
if (engineLib != NULL) {
dlclose(engineLib);
engineLib = NULL;
engine = NULL;
}
engine = (EmuEngine *) loadSharedObject(dir, lib, &engineLib);
env->ReleaseStringUTFChars(jdir, dir);
env->ReleaseStringUTFChars(jlib, lib);
static EngineCallbacks cbs;
if (engine == NULL || !engine->initialize(&cbs)) {
LOGE("Cannot load emulator engine");
return JNI_FALSE;
}
return JNI_TRUE;
}
const void *
loadDriver (
const char *driverCode, void **driverObject,
const char *driverDirectory, const DriverEntry *driverTable,
const char *typeName, char typeLetter, const char *symbolPrefix,
const void *nullAddress, const DriverDefinition *nullDefinition
) {
const void *driverAddress = NULL;
*driverObject = NULL;
if (!driverCode || !*driverCode) {
if (driverTable)
if (driverTable->address)
return driverTable->address;
return nullAddress;
}
if (isDriverCode(driverCode, nullDefinition)) return nullAddress;
if (driverTable) {
const DriverEntry *driverEntry = driverTable;
while (driverEntry->address) {
if (isDriverCode(driverCode, driverEntry->definition)) return driverEntry->address;
++driverEntry;
}
}
#ifdef ENABLE_SHARED_OBJECTS
{
char *libraryPath;
const int libraryNameLength = strlen(MODULE_NAME) + strlen(driverCode) + strlen(MODULE_EXTENSION) + 3;
char libraryName[libraryNameLength];
snprintf(libraryName, libraryNameLength, "%s%c%s.%s",
MODULE_NAME, typeLetter, driverCode, MODULE_EXTENSION);
if ((libraryPath = makePath(driverDirectory, libraryName))) {
void *libraryHandle = loadSharedObject(libraryPath);
if (libraryHandle) {
const int driverSymbolLength = strlen(symbolPrefix) + 8 + strlen(driverCode) + 1;
char driverSymbol[driverSymbolLength];
snprintf(driverSymbol, driverSymbolLength, "%s_driver_%s",
symbolPrefix, driverCode);
if (findSharedSymbol(libraryHandle, driverSymbol, &driverAddress)) {
*driverObject = libraryHandle;
{
const void *versionAddress = NULL;
const int versionSymbolLength = strlen(symbolPrefix) + 9 + strlen(driverCode) + 1;
char versionSymbol[versionSymbolLength];
snprintf(versionSymbol, versionSymbolLength, "%s_version_%s",
symbolPrefix, driverCode);
if (findSharedSymbol(libraryHandle, versionSymbol, &versionAddress)) {
const char *actualVersion = versionAddress;
static const char *expectedVersion = DRIVER_VERSION_STRING;
if (strcmp(actualVersion, expectedVersion) != 0) {
logMessage(LOG_WARNING, "%s %s driver version %s does not match expected version %s",
driverCode, typeName, actualVersion, expectedVersion);
}
} else {
logMessage(LOG_WARNING, "cannot find %s %s driver version symbol: %s",
driverCode, typeName, versionSymbol);
}
}
} else {
logMessage(LOG_ERR, "cannot find %s driver symbol: %s", typeName, driverSymbol);
unloadSharedObject(libraryHandle);
driverAddress = NULL;
}
} else {
logMessage(LOG_ERR, "cannot load %s driver: %s", typeName, libraryPath);
}
free(libraryPath);
}
}
#endif /* ENABLE_SHARED_OBJECTS */
return driverAddress;
}
PcmDevice *
openPcmDevice (int errorLevel, const char *device) {
PcmDevice *pcm;
if (!pcmAlsaLibrary) {
if (!(pcmAlsaLibrary = loadSharedObject("libasound.so.2"))) {
logMessage(LOG_ERR, "Unable to load ALSA PCM library.");
return NULL;
}
PCM_ALSA_LOCATE(strerror);
PCM_ALSA_LOCATE(pcm_open);
PCM_ALSA_LOCATE(pcm_close);
PCM_ALSA_LOCATE(pcm_nonblock);
PCM_ALSA_LOCATE(pcm_hw_params_malloc);
PCM_ALSA_LOCATE(pcm_hw_params_any);
PCM_ALSA_LOCATE(pcm_hw_params_set_access);
PCM_ALSA_LOCATE(pcm_hw_params_get_channels);
PCM_ALSA_LOCATE(pcm_hw_params_get_channels_min);
PCM_ALSA_LOCATE(pcm_hw_params_get_channels_max);
PCM_ALSA_LOCATE(pcm_hw_params_set_channels_near);
PCM_ALSA_LOCATE(pcm_hw_params_get_format);
PCM_ALSA_LOCATE(pcm_hw_params_set_format);
PCM_ALSA_LOCATE(pcm_hw_params_get_rate);
PCM_ALSA_LOCATE(pcm_hw_params_get_sbits);
PCM_ALSA_LOCATE(pcm_hw_params_get_rate_min);
PCM_ALSA_LOCATE(pcm_hw_params_get_rate_max);
PCM_ALSA_LOCATE(pcm_hw_params_get_period_size);
PCM_ALSA_LOCATE(pcm_hw_params_set_rate_near);
PCM_ALSA_LOCATE(pcm_hw_params_set_buffer_time_near);
PCM_ALSA_LOCATE(pcm_hw_params_set_period_time_near);
PCM_ALSA_LOCATE(pcm_hw_params);
PCM_ALSA_LOCATE(pcm_hw_params_get_sbits);
PCM_ALSA_LOCATE(pcm_hw_params_free);
PCM_ALSA_LOCATE(pcm_prepare);
PCM_ALSA_LOCATE(pcm_writei);
PCM_ALSA_LOCATE(pcm_drain);
PCM_ALSA_LOCATE(pcm_drop);
PCM_ALSA_LOCATE(pcm_resume);
}
if ((pcm = malloc(sizeof(*pcm)))) {
int result;
if (!*device) device = "default";
if ((result = pcmAlsa_pcm_open(&pcm->handle, device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) >= 0) {
pcmAlsa_pcm_nonblock(pcm->handle, 0);
if ((result = pcmAlsa_pcm_hw_params_malloc(&pcm->hardwareParameters)) >= 0) {
if ((result = pcmAlsa_pcm_hw_params_any(pcm->handle, pcm->hardwareParameters)) >= 0) {
if ((result = pcmAlsa_pcm_hw_params_set_access(pcm->handle, pcm->hardwareParameters, SND_PCM_ACCESS_RW_INTERLEAVED)) >= 0) {
if (configurePcmSampleFormat(pcm, errorLevel)) {
if (configurePcmSampleRate(pcm, errorLevel)) {
if (configurePcmChannelCount(pcm, errorLevel)) {
pcm->bufferTime = 500000;
if ((result = pcmAlsa_pcm_hw_params_set_buffer_time_near(pcm->handle, pcm->hardwareParameters, &pcm->bufferTime, NULL)) >= 0) {
pcm->periodTime = pcm->bufferTime / 8;
if ((result = pcmAlsa_pcm_hw_params_set_period_time_near(pcm->handle, pcm->hardwareParameters, &pcm->periodTime, NULL)) >= 0) {
if ((result = pcmAlsa_pcm_hw_params(pcm->handle, pcm->hardwareParameters)) >= 0) {
logMessage(LOG_DEBUG, "ALSA PCM: Chan=%u Rate=%u BufTim=%u PerTim=%u", pcm->channelCount, pcm->sampleRate, pcm->bufferTime, pcm->periodTime);
return pcm;
} else {
logPcmError(errorLevel, "set hardware parameters", result);
}
} else {
logPcmError(errorLevel, "set period time near", result);
}
} else {
logPcmError(errorLevel, "set buffer time near", result);
}
}
}
}
} else {
logPcmError(errorLevel, "set access", result);
}
} else {
logPcmError(errorLevel, "get hardware parameters", result);
}
pcmAlsa_pcm_hw_params_free(pcm->hardwareParameters);
} else {
logPcmError(errorLevel, "hardware parameters allocation", result);
}
pcmAlsa_pcm_close(pcm->handle);
} else {
logPcmError(errorLevel, "open", result);
}
free(pcm);
} else {
logSystemError("PCM device allocation");
}
return NULL;
}
