static int
spk_construct (volatile SpeechSynthesizer *spk, char **parameters) {
spk->setVolume = spk_setVolume;
spk->setRate = spk_setRate;
spk->setPitch = spk_setPitch;
spk->setPunctuation = spk_setPunctuation;
clearSettings();
if (parameters[PARM_PORT] && *parameters[PARM_PORT]) {
static const int minimumPort = 0X1;
static const int maximumPort = 0XFFFF;
int port = 0;
if (validateInteger(&port, parameters[PARM_PORT], &minimumPort, &maximumPort)) {
char number[0X10];
snprintf(number, sizeof(number), "%d", port);
setenv("SPEECHD_PORT", number, 1);
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid port number", parameters[PARM_PORT]);
}
}
if (parameters[PARM_MODULE] && *parameters[PARM_MODULE]) {
moduleName = parameters[PARM_MODULE];
}
if (parameters[PARM_LANGUAGE] && *parameters[PARM_LANGUAGE]) {
languageName = parameters[PARM_LANGUAGE];
}
if (parameters[PARM_VOICE] && *parameters[PARM_VOICE]) {
static const SPDVoiceType voices[] = {
SPD_MALE1, SPD_FEMALE1,
SPD_MALE2, SPD_FEMALE2,
SPD_MALE3, SPD_FEMALE3,
SPD_CHILD_MALE, SPD_CHILD_FEMALE
};
static const char *choices[] = {
"male1", "female1",
"male2", "female2",
"male3", "female3",
"child_male", "child_female",
NULL
};
unsigned int choice = 0;
if (validateChoice(&choice, parameters[PARM_VOICE], choices)) {
voiceType = voices[choice];
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid voice type", parameters[PARM_VOICE]);
}
}
return openConnection();
}
int
parseKeyboardProperties (KeyboardProperties *properties, const char *string) {
enum {
KBD_PARM_TYPE,
KBD_PARM_VENDOR,
KBD_PARM_PRODUCT
};
static const char *const names[] = {"type", "vendor", "product", NULL};
char **parameters = getParameters(names, NULL, string);
int ok = 1;
logParameters(names, parameters, "Keyboard Property");
*properties = anyKeyboard;
if (*parameters[KBD_PARM_TYPE]) {
static const KeyboardType types[] = {KBD_TYPE_Any, KBD_TYPE_PS2, KBD_TYPE_USB, KBD_TYPE_Bluetooth};
static const char *choices[] = {"any", "ps2", "usb", "bluetooth", NULL};
unsigned int choice;
if (validateChoice(&choice, parameters[KBD_PARM_TYPE], choices)) {
properties->type = types[choice];
} else {
logMessage(LOG_WARNING, "invalid keyboard type: %s", parameters[KBD_PARM_TYPE]);
ok = 0;
}
}
if (*parameters[KBD_PARM_VENDOR]) {
static const int minimum = 0;
static const int maximum = 0XFFFF;
int value;
if (validateInteger(&value, parameters[KBD_PARM_VENDOR], &minimum, &maximum)) {
properties->vendor = value;
} else {
logMessage(LOG_WARNING, "invalid keyboard vendor code: %s", parameters[KBD_PARM_VENDOR]);
ok = 0;
}
}
if (*parameters[KBD_PARM_PRODUCT]) {
static const int minimum = 0;
static const int maximum = 0XFFFF;
int value;
if (validateInteger(&value, parameters[KBD_PARM_PRODUCT], &minimum, &maximum)) {
properties->product = value;
} else {
logMessage(LOG_WARNING, "invalid keyboard product code: %s", parameters[KBD_PARM_PRODUCT]);
ok = 0;
}
}
deallocateStrings(parameters);
return ok;
}
int
parseTuneDevice (const char *setting) {
if (setting && *setting) {
unsigned int device;
if (!validateChoice(&device, setting, tuneDeviceNames)) {
logMessage(LOG_ERR, "%s: %s", "invalid tune device", setting);
return 0;
}
prefs.tuneDevice = device;
}
return 1;
}
static int
processParameters_AtSpiScreen (char **parameters) {
if (*parameters[PARM_TYPE]) {
static const char *const choices[] = {"text" , "terminal" , "all" , NULL};
static int *const flags [] = {&typeText, &typeTerminal, &typeAll, NULL};
int count;
char **types = splitString(parameters[PARM_TYPE], '+', &count);
{
int *const *flag = flags;
while (*flag) **flag++ = 0;
}
{
int index;
for (index=0; index<count; index++) {
const char *type = types[index];
unsigned int choice;
if (validateChoice(&choice, type, choices)) {
int *flag = flags[choice];
if ((flag == &typeAll) && (index > 0)) {
logMessage(LOG_WARNING, "widget type is mutually exclusive: %s", type);
} else if (*flag || typeAll) {
logMessage(LOG_WARNING, "widget type specified more than once: %s", type);
} else {
*flag = 1;
}
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid widget type", type);
}
}
}
deallocateStrings(types);
}
return 1;
}
int
main (int argc, char *argv[]) {
{
static const OptionsDescriptor descriptor = {
OPTION_TABLE(programOptions),
.applicationName = "tunetest",
.argumentsSummary = "{note duration} ..."
};
PROCESS_OPTIONS(descriptor, argc, argv);
}
resetPreferences();
if (opt_tuneDevice && *opt_tuneDevice) {
unsigned int device;
if (!validateChoice(&device, opt_tuneDevice, deviceNames)) {
logMessage(LOG_ERR, "%s: %s", "invalid tune device", opt_tuneDevice);
return PROG_EXIT_SYNTAX;
}
prefs.tuneDevice = device;
}
#ifdef HAVE_MIDI_SUPPORT
if (opt_midiInstrument && *opt_midiInstrument) {
unsigned char instrument;
if (!validateInstrument(&instrument, opt_midiInstrument)) {
logMessage(LOG_ERR, "%s: %s", "invalid musical instrument", opt_midiInstrument);
return PROG_EXIT_SYNTAX;
}
prefs.midiInstrument = instrument;
}
#endif /* HAVE_MIDI_SUPPORT */
if (opt_outputVolume && *opt_outputVolume) {
static const int minimum = 0;
static const int maximum = 100;
int volume;
if (!validateInteger(&volume, opt_outputVolume, &minimum, &maximum)) {
logMessage(LOG_ERR, "%s: %s", "invalid volume percentage", opt_outputVolume);
return PROG_EXIT_SYNTAX;
}
switch (prefs.tuneDevice) {
case tdPcm:
prefs.pcmVolume = volume;
break;
case tdMidi:
prefs.midiVolume = volume;
break;
case tdFm:
prefs.fmVolume = volume;
break;
default:
break;
}
}
if (!argc) {
logMessage(LOG_ERR, "missing tune.");
return PROG_EXIT_SYNTAX;
}
if (argc % 2) {
logMessage(LOG_ERR, "missing note duration.");
return PROG_EXIT_SYNTAX;
}
{
unsigned int count = argc / 2;
TuneElement *elements = malloc((sizeof(*elements) * count) + 1);
if (elements) {
TuneElement *element = elements;
while (argc) {
int note;
int duration;
{
static const int minimum = 0X01;
static const int maximum = 0X7F;
const char *argument = *argv++;
if (!validateInteger(¬e, argument, &minimum, &maximum)) {
logMessage(LOG_ERR, "%s: %s", "invalid note number", argument);
return PROG_EXIT_SYNTAX;
}
--argc;
}
{
static const int minimum = 1;
static const int maximum = 255;
const char *argument = *argv++;
if (!validateInteger(&duration, argument, &minimum, &maximum)) {
logMessage(LOG_ERR, "%s: %s", "invalid note duration", argument);
return PROG_EXIT_SYNTAX;
}
--argc;
}
{
TuneElement te = TUNE_NOTE(duration, note);
*(element++) = te;
}
}
{
TuneElement te = TUNE_STOP();
*element = te;
}
} else {
logMallocError();
return PROG_EXIT_FATAL;
}
if (!setTuneDevice(prefs.tuneDevice)) {
logMessage(LOG_ERR, "unsupported tune device: %s", deviceNames[prefs.tuneDevice]);
return PROG_EXIT_SEMANTIC;
}
{
playTune(elements);
closeTuneDevice();
}
free(elements);
}
return PROG_EXIT_SUCCESS;
}
static int
spk_construct (volatile SpeechSynthesizer *spk, char **parameters) {
theta_voice_search criteria;
memset(&criteria, 0, sizeof(criteria));
initializeTheta();
spk->setVolume = spk_setVolume;
spk->setRate = spk_setRate;
if (*parameters[PARM_GENDER]) {
const char *const choices[] = {"male", "female", "neuter", NULL};
unsigned int choice;
if (validateChoice(&choice, parameters[PARM_GENDER], choices)) {
criteria.gender = (char *)choices[choice];
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid gender specification", parameters[PARM_GENDER]);
}
}
if (*parameters[PARM_LANGUAGE]) criteria.lang = parameters[PARM_LANGUAGE];
if (*parameters[PARM_AGE]) {
const char *word = parameters[PARM_AGE];
int value;
int younger;
static const int minimumAge = 1;
static const int maximumAge = 99;
if ((younger = word[0] == '-') && word[1]) ++word;
if (validateInteger(&value, word, &minimumAge, &maximumAge)) {
if (younger) value = -value;
criteria.age = value;
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid age specification", word);
}
}
{
const char *name = parameters[PARM_NAME];
if (name && (*name == '/')) {
theta_voice_desc *descriptor = theta_try_voxdir(name, &criteria);
if (descriptor) {
loadVoice(descriptor);
theta_free_voice_desc(descriptor);
}
} else {
theta_voice_desc *descriptors = theta_enum_voices(theta_voxpath, &criteria);
if (descriptors) {
theta_voice_desc *descriptor;
for (descriptor=descriptors; descriptor; descriptor=descriptor->next) {
if (*name)
if (strcasecmp(name, descriptor->human) != 0)
continue;
loadVoice(descriptor);
if (voice) break;
}
theta_free_voicelist(descriptors);
}
}
}
if (voice) {
{
float pitch = 0.0;
static const float minimumPitch = -2.0;
static const float maximumPitch = 2.0;
if (validateFloat(&pitch, parameters[PARM_PITCH], &minimumPitch, &maximumPitch)) {
theta_set_pitch_shift(voice, pitch, NULL);
} else {
logMessage(LOG_WARNING, "%s: %s", "invalid pitch shift specification", parameters[PARM_PITCH]);
}
}
logMessage(LOG_INFO, "Theta Engine: version %s", theta_version);
return 1;
}
logMessage(LOG_WARNING, "No voices found.");
return 0;
}
int
validateFlag (unsigned int *value, const char *string, const char *on, const char *off) {
const char *choices[] = {off, on, NULL};
return validateChoice(value, string, choices);
}
