int
serialPutLines (SerialDevice *serial, SerialLines high, SerialLines low) {
DCB dcb;
dcb.DCBlength = sizeof(dcb);
if (GetCommState(serial->package.fileHandle, &dcb)) {
if (low & SERIAL_LINE_RTS) {
dcb.fRtsControl = RTS_CONTROL_DISABLE;
} else if (high & SERIAL_LINE_RTS) {
dcb.fRtsControl = RTS_CONTROL_ENABLE;
}
if (low & SERIAL_LINE_DTR) {
dcb.fDtrControl = DTR_CONTROL_DISABLE;
} else if (high & SERIAL_LINE_DTR) {
dcb.fDtrControl = DTR_CONTROL_ENABLE;
}
if (SetCommState(serial->package.fileHandle, &dcb)) return 1;
logWindowsSystemError("SetCommState");
} else {
logWindowsSystemError("GetCommState");
}
return 0;
}
int
removeService (const char *name) {
int removed = 0;
SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (scm) {
SC_HANDLE service = OpenService(scm, name, DELETE);
if (service) {
if (DeleteService(service)) {
logMessage(LOG_NOTICE, "service removed: %s", name);
removed = 1;
} else if (GetLastError() == ERROR_SERVICE_MARKED_FOR_DELETE) {
logMessage(LOG_WARNING, "service already being removed: %s", name);
removed = 1;
} else {
logWindowsSystemError("DeleteService");
}
CloseServiceHandle(service);
} else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) {
logMessage(LOG_WARNING, "service not installed: %s", name);
removed = 1;
} else {
logWindowsSystemError("OpenService");
}
CloseServiceHandle(scm);
} else {
logWindowsSystemError("OpenSCManager");
}
return removed;
}
ssize_t
serialPutData (
SerialDevice *serial,
const void *data, size_t size
) {
COMMTIMEOUTS timeouts = {MAXDWORD, 0, 0, 0, 15000};
size_t left = size;
DWORD bytesWritten;
if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) {
logWindowsSystemError("SetCommTimeouts serialWriteData");
setSystemErrno();
return -1;
}
while (left && WriteFile(serial->package.fileHandle, data, left, &bytesWritten, NULL)) {
if (!bytesWritten) break;
left -= bytesWritten;
data += bytesWritten;
}
if (!left) return size;
logWindowsSystemError("WriteFile");
return -1;
}
int
serialPollInput (SerialDevice *serial, int timeout) {
if (serial->package.pendingCharacter != -1) return 1;
{
COMMTIMEOUTS timeouts = {MAXDWORD, 0, timeout, 0, 0};
DWORD bytesRead;
char c;
if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) {
logWindowsSystemError("SetCommTimeouts serialAwaitInput");
setSystemErrno();
return 0;
}
if (!ReadFile(serial->package.fileHandle, &c, 1, &bytesRead, NULL)) {
logWindowsSystemError("ReadFile");
setSystemErrno();
return 0;
}
if (bytesRead) {
serial->package.pendingCharacter = (unsigned char)c;
return 1;
}
}
errno = EAGAIN;
return 0;
}
ssize_t
serialGetData (
SerialDevice *serial,
void *buffer, size_t size,
int initialTimeout, int subsequentTimeout
) {
size_t length = 0;
COMMTIMEOUTS timeouts = {MAXDWORD, 0, initialTimeout, 0, 0};
DWORD bytesRead;
if (serial->package.pendingCharacter != -1) {
* (unsigned char *) buffer = serial->package.pendingCharacter;
serial->package.pendingCharacter = -1;
bytesRead = 1;
} else {
if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) {
logWindowsSystemError("SetCommTimeouts serialReadChunk1");
setSystemErrno();
return -1;
}
if (!ReadFile(serial->package.fileHandle, buffer, size, &bytesRead, NULL)) {
logWindowsSystemError("ReadFile");
setSystemErrno();
return -1;
}
if (!bytesRead) return 0;
}
size -= bytesRead;
length += bytesRead;
timeouts.ReadTotalTimeoutConstant = subsequentTimeout;
if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) {
logWindowsSystemError("SetCommTimeouts serialReadChunk2");
setSystemErrno();
return -1;
}
while (size && ReadFile(serial->package.fileHandle, buffer + length, size, &bytesRead, NULL)) {
if (!bytesRead) return length;
size -= bytesRead;
length += bytesRead;
}
if (!size) return length;
logWindowsSystemError("ReadFile");
setSystemErrno();
return -1;
}
char *
getProgramPath (void) {
char *path = NULL;
HMODULE handle;
if ((handle = GetModuleHandle(NULL))) {
size_t size = 0X80;
char *buffer = NULL;
while (1) {
{
char *newBuffer = realloc(buffer, size<<=1);
if (!newBuffer) {
logMallocError();
break;
}
buffer = newBuffer;
}
{
DWORD length = GetModuleFileName(handle, buffer, size);
if (!length) {
logWindowsSystemError("GetModuleFileName");
break;
}
if (length < size) {
buffer[length] = 0;
if ((path = strdup(buffer))) {
while (length > 0)
if (path[--length] == '\\')
path[length] = '/';
} else {
logMallocError();
}
break;
}
}
}
free(buffer);
} else {
logWindowsSystemError("GetModuleHandle");
}
return path;
}
void *
loadSharedObject (const char *path) {
HMODULE library;
if (!(library = LoadLibrary(path)))
logWindowsSystemError("loading library");
return library;
}
static int
monitorWindowsPipeConnect (NamedPipeObject *obj) {
if (ResetEvent(obj->windows.connect.event)) {
ZeroMemory(&obj->windows.connect.overlapped, sizeof(obj->windows.connect.overlapped));
obj->windows.connect.overlapped.hEvent = obj->windows.connect.event;
if (ConnectNamedPipe(obj->input.descriptor, &obj->windows.connect.overlapped)) {
if (doWindowsPipeConnected(obj)) {
return 1;
}
} else {
DWORD error = GetLastError();
if (error == ERROR_PIPE_CONNECTED) {
if (doWindowsPipeConnected(obj)) {
return 1;
}
} else if (error == ERROR_IO_PENDING) {
if (asyncMonitorFileInput(&obj->windows.connect.monitor, obj->windows.connect.event, handleWindowsPipeConnected, obj)) {
return 1;
}
} else {
logWindowsError(error, "ConnectNamedPipe");
}
}
} else {
logWindowsSystemError("ResetEvent");
}
return 0;
}
int
serialGetAttributes (SerialDevice *serial, SerialAttributes *attributes) {
attributes->DCBlength = sizeof(serial->currentAttributes);
if (GetCommState(serial->package.fileHandle, attributes)) return 1;
logWindowsSystemError("GetCommState");
return 0;
}
void
processSpeechInput (SpeechSynthesizer *spk) {
#if defined(__MINGW32__)
if (speechInputHandle != INVALID_HANDLE_VALUE) {
if (speechInputConnected ||
(speechInputConnected = ConnectNamedPipe(speechInputHandle, NULL)) ||
(speechInputConnected = (GetLastError() == ERROR_PIPE_CONNECTED))) {
char buffer[0X1000];
DWORD count;
if (ReadFile(speechInputHandle, buffer, sizeof(buffer), &count, NULL)) {
if (count) sayCharacters(spk, buffer, count, 0);
} else {
DWORD error = GetLastError();
if (error != ERROR_NO_DATA) {
speechInputConnected = 0;
DisconnectNamedPipe(speechInputHandle);
if (error != ERROR_BROKEN_PIPE)
logWindowsSystemError("speech input FIFO read");
}
}
}
}
#elif defined(S_ISFIFO)
if (speechInputDescriptor != -1) {
char buffer[0X1000];
int count = read(speechInputDescriptor, buffer, sizeof(buffer));
if (count > 0) sayCharacters(spk, buffer, count, 0);
}
#endif /* process speech input */
}
int
serialMonitorWaitLines (SerialDevice *serial) {
DWORD event;
if (WaitCommEvent(serial->package.fileHandle, &event, NULL)) return 1;
logWindowsSystemError("WaitCommEvent");
return 0;
}
static int
acceptNamedPipeConnection (const char *path) {
HANDLE h;
OVERLAPPED overl = {0, 0, {{0, 0}}, NULL};
DWORD res;
int attempts = 0;
if ((h = CreateNamedPipe(path,
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
1, 0, 0, 0, NULL)) == INVALID_HANDLE_VALUE) {
logWindowsSystemError("CreateNamedPipe");
return -1;
}
overl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!ConnectNamedPipe(h, &overl)) {
switch (GetLastError()) {
case ERROR_IO_PENDING:
while ((res = WaitForSingleObject(overl.hEvent, 10000)) != WAIT_OBJECT_0) {
if (res == WAIT_TIMEOUT) {
++attempts;
logMessage(LOG_DEBUG, "no connection yet, still waiting (%d).", attempts);
} else {
logWindowsSystemError("ConnectNamedPipe");
CloseHandle(h);
h = (HANDLE) -1;
break;
}
}
case ERROR_PIPE_CONNECTED:
break;
default:
logWindowsSystemError("ConnectNamedPipe");
CloseHandle(h);
h = (HANDLE) -1;
break;
}
}
CloseHandle(overl.hEvent);
operations = &namedPipeOperationsEntry;
return (int)h;
}
int
findSharedSymbol (void *object, const char *symbol, void *pointerAddress) {
void **address = pointerAddress;
if ((*address = GetProcAddress((HMODULE) object, symbol)))
return 1;
logWindowsSystemError("looking up symbol in library");
return 0;
}
int
enableSpeechInput (const char *name) {
const char *directory;
onProgramExit("speech-input", exitSpeechInput, NULL);
#if defined(__MINGW32__)
directory = "//./pipe";
#else /* set speech input directory */
directory = ".";
#endif /* set speech input directory */
if ((speechInputPath = makePath(directory, name))) {
#if defined(__MINGW32__)
if ((speechInputHandle = CreateNamedPipe(speechInputPath, PIPE_ACCESS_INBOUND,
PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_NOWAIT,
1, 0, 0, 0, NULL)) != INVALID_HANDLE_VALUE) {
logMessage(LOG_DEBUG, "speech input pipe created: %s: handle=%u",
speechInputPath, (unsigned)speechInputHandle);
return 1;
} else {
logWindowsSystemError("CreateNamedPipe");
}
#elif defined(S_ISFIFO)
int result = mkfifo(speechInputPath, 0);
if ((result == -1) && (errno == EEXIST)) {
struct stat fifo;
if ((lstat(speechInputPath, &fifo) != -1) && S_ISFIFO(fifo.st_mode)) result = 0;
}
if (result != -1) {
chmod(speechInputPath, S_IRUSR|S_IWUSR|S_IWGRP|S_IWOTH);
if ((speechInputDescriptor = open(speechInputPath, O_RDONLY|O_NONBLOCK)) != -1) {
logMessage(LOG_DEBUG, "speech input FIFO created: %s: fd=%d",
speechInputPath, speechInputDescriptor);
return 1;
} else {
logMessage(LOG_ERR, "cannot open speech input FIFO: %s: %s",
speechInputPath, strerror(errno));
}
unlink(speechInputPath);
} else {
logMessage(LOG_ERR, "cannot create speech input FIFO: %s: %s",
speechInputPath, strerror(errno));
}
#endif /* enable speech input */
free(speechInputPath);
speechInputPath = NULL;
}
return 0;
}
static int
testMonitor (const MonitorEntry *monitor, int *error) {
DWORD result = WaitForSingleObject(*monitor, 0);
if (result == WAIT_OBJECT_0) return 1;
if (result == WAIT_FAILED) {
logWindowsSystemError("WaitForSingleObject");
}
return 0;
}
int
prepareHostCommandStream (HostCommandStream *hcs, void *data) {
SECURITY_ATTRIBUTES attributes;
ZeroMemory(&attributes, sizeof(attributes));
attributes.nLength = sizeof(attributes);
attributes.bInheritHandle = TRUE;
attributes.lpSecurityDescriptor = NULL;
if (CreatePipe(&hcs->package.inputHandle, &hcs->package.outputHandle, &attributes, 0)) {
if (SetHandleInformation(*getParentHandle(hcs), HANDLE_FLAG_INHERIT, 0)) {
return 1;
} else {
logWindowsSystemError("SetHandleInformation");
}
} else {
logWindowsSystemError("CreatePipe");
}
return 0;
}
int
installService (const char *name, const char *description) {
int installed = 0;
const char *const arguments[] = {
getProgramPath(),
NULL
};
char *command = makeWindowsCommandLine(arguments);
if (command) {
SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
if (scm) {
SC_HANDLE service = CreateService(scm, name, description, SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
command, NULL, NULL, NULL, NULL, NULL);
if (service) {
logMessage(LOG_NOTICE, "service installed: %s", name);
installed = 1;
CloseServiceHandle(service);
} else if (GetLastError() == ERROR_SERVICE_EXISTS) {
logMessage(LOG_WARNING, "service already installed: %s", name);
installed = 1;
} else {
logWindowsSystemError("CreateService");
}
CloseServiceHandle(scm);
} else {
logWindowsSystemError("OpenSCManager");
}
free(command);
}
return installed;
}
int
serialGetLines (SerialDevice *serial) {
if (!GetCommModemStatus(serial->package.fileHandle, &serial->linesState)) {
logWindowsSystemError("GetCommModemStatus");
return 0;
}
{
DCB dcb;
dcb.DCBlength = sizeof(dcb);
if (!GetCommState(serial->package.fileHandle, &dcb)) {
logWindowsSystemError("GetCommState");
return 0;
}
if (dcb.fRtsControl == RTS_CONTROL_ENABLE) serial->linesState |= SERIAL_LINE_RTS;
if (dcb.fDtrControl == DTR_CONTROL_ENABLE) serial->linesState |= SERIAL_LINE_DTR;
}
return 1;
}
int
serialRegisterWaitLines (SerialDevice *serial, SerialLines lines) {
DWORD eventMask = 0;
if (lines & SERIAL_LINE_CTS) eventMask |= EV_CTS;
if (lines & SERIAL_LINE_DSR) eventMask |= EV_DSR;
if (lines & SERIAL_LINE_RNG) eventMask |= EV_RING;
if (lines & SERIAL_LINE_CAR) eventMask |= EV_RLSD;
if (SetCommMask(serial->package.fileHandle, eventMask)) return 1;
logWindowsSystemError("SetCommMask");
return 0;
}
static int
readNamedPipe (int descriptor, void *buffer, int size) {
{
DWORD available;
if (!PeekNamedPipe((HANDLE)descriptor, NULL, 0, NULL, &available, NULL)) {
logWindowsSystemError("PeekNamedPipe");
return 0;
}
if (!available) {
errno = EAGAIN;
return -1;
}
if (available < size) size = available;
}
{
DWORD received;
OVERLAPPED overl = {0, 0, {{0, 0}}, NULL};
overl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!ReadFile((HANDLE)descriptor, buffer, size, &received, &overl)) {
if (GetLastError() != ERROR_IO_PENDING) {
logWindowsSystemError("ReadPipe");
received = 0;
} else if (!GetOverlappedResult((HANDLE)descriptor, &overl, &received, TRUE)) {
logWindowsSystemError("GetOverlappedResult");
received = 0;
}
}
CloseHandle(overl.hEvent);
return received;
}
}
static int
awaitMonitors (const MonitorGroup *monitors, int timeout) {
if (monitors->count) {
DWORD result = WaitForMultipleObjects(monitors->count, monitors->array, FALSE, timeout);
if ((result >= WAIT_OBJECT_0) && (result < (WAIT_OBJECT_0 + monitors->count))) return 1;
if (result == WAIT_FAILED) {
logWindowsSystemError("WaitForMultipleObjects");
}
} else {
approximateDelay(timeout);
}
return 0;
}
static int
requestNamedPipeConnection (const char *path) {
HANDLE h;
if ((h = CreateFile(path,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) {
logWindowsSystemError("Connect to named pipe");
return -1;
}
operations = &namedPipeOperationsEntry;
return (int)h;
}
int
serialConnectDevice (SerialDevice *serial, const char *device) {
if ((serial->package.fileHandle = CreateFile(device, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL)) != INVALID_HANDLE_VALUE) {
serial->package.pendingCharacter = -1;
if (serialPrepareDevice(serial)) {
logMessage(LOG_CATEGORY(SERIAL_IO), "device opened: %s: fh=%" PRIfd,
device, serial->package.fileHandle);
return 1;
}
CloseHandle(serial->package.fileHandle);
} else {
logWindowsSystemError("CreateFile");
logMessage(LOG_ERR, "cannot open serial device: %s", device);
}
return 0;
}
static int
retrievePeerCredentials (PeerCredentials *credentials, FileDescriptor fd) {
char buffer[0X100+1];
if (GetNamedPipeHandleState(fd, NULL, NULL, NULL, NULL, buffer, sizeof(buffer))) {
buffer[sizeof(buffer) - 1] = 0;
if ((credentials->user = strdup(buffer))) {
return 1;
}
} else {
switch (GetLastError()) {
default:
logWindowsSystemError("GetNamedPipeHandleState");
case ERROR_INSUFFICIENT_BUFFER: /* buffer too small */
case ERROR_INVALID_HANDLE: /* not a named pipe */
case ERROR_CANNOT_IMPERSONATE: /* no data transferred yet */
break;
}
}
return 0;
}
static void
disconnectWindowsPipe (NamedPipeObject *obj) {
if (!DisconnectNamedPipe(obj->input.descriptor)) {
logWindowsSystemError("DisconnectNamedPipe");
}
}
const char *
win_getLocale (void) {
if (GetLocaleInfoExProc) {
#define WIN_LOCALE_SIZE 85
WCHAR buffer[WIN_LOCALE_SIZE];
int result = GetLocaleInfoExProc(LOCALE_NAME_USER_DEFAULT, LOCALE_SNAME, buffer, WIN_LOCALE_SIZE);
if (result > 0) {
static char locale[WIN_LOCALE_SIZE];
const WCHAR *source = buffer;
char *target = locale;
do {
char c = *source;
if (c == '-') c = '_';
*target++ = c;
} while (*source++);
return locale;
} else {
logWindowsSystemError("GetLocaleInfoEx");
}
}
{
DWORD langid;
int result = GetLocaleInfo(LOCALE_USER_DEFAULT,
LOCALE_ILANGUAGE | LOCALE_RETURN_NUMBER,
(char *)&langid, sizeof(langid)/sizeof(TCHAR));
if (result > 0) {
switch (langid) {
#define DIALECT(primary,secondary,locale) case MAKELANGID(LANG_##primary, SUBLANG_##primary##_##secondary): return (locale);
DIALECT(AFRIKAANS, SOUTH_AFRICA, "af_ZA");
DIALECT(ALBANIAN, ALBANIA, "sq_AL");
DIALECT(ALSATIAN, FRANCE, "gsw_FR");
DIALECT(AMHARIC, ETHIOPIA, "am_ET");
DIALECT(ARABIC, ALGERIA, "ar_DZ");
DIALECT(ARABIC, BAHRAIN, "ar_BH");
DIALECT(ARABIC, EGYPT, "ar_EG");
DIALECT(ARABIC, IRAQ, "ar_IQ");
DIALECT(ARABIC, JORDAN, "ar_JO");
DIALECT(ARABIC, KUWAIT, "ar_QW");
DIALECT(ARABIC, LEBANON, "ar_LB");
DIALECT(ARABIC, LIBYA, "ar_LY");
DIALECT(ARABIC, MOROCCO, "ar_MA");
DIALECT(ARABIC, OMAN, "ar_OM");
DIALECT(ARABIC, QATAR, "ar_QA");
DIALECT(ARABIC, SAUDI_ARABIA, "ar_SA");
DIALECT(ARABIC, SYRIA, "ar_SY");
DIALECT(ARABIC, TUNISIA, "ar_TN");
DIALECT(ARABIC, UAE, "ar_AE");
DIALECT(ARABIC, YEMEN, "ar_YE");
DIALECT(ARMENIAN, ARMENIA, "hy_AM");
DIALECT(ASSAMESE, INDIA, "as_IN");
DIALECT(AZERI, CYRILLIC, "az@cyrillic");
DIALECT(AZERI, LATIN, "az@latin");
DIALECT(BASHKIR, RUSSIA, "ba_RU");
DIALECT(BASQUE, BASQUE, "eu_XX");
DIALECT(BELARUSIAN, BELARUS, "be_BY");
DIALECT(BENGALI, BANGLADESH, "bn_HD");
DIALECT(BENGALI, INDIA, "bn_IN");
DIALECT(BOSNIAN, BOSNIA_HERZEGOVINA_CYRILLIC, "bs_BA@cyrillic");
DIALECT(BOSNIAN, BOSNIA_HERZEGOVINA_LATIN, "bs_BA@latin");
DIALECT(BRETON, FRANCE, "br_FR");
DIALECT(BULGARIAN, BULGARIA, "bg_BG");
DIALECT(CATALAN, CATALAN, "ca_XX");
DIALECT(CHINESE, HONGKONG, "zh_HK");
DIALECT(CHINESE, MACAU, "zh_MO");
DIALECT(CHINESE, SIMPLIFIED, "zh_CN");
DIALECT(CHINESE, SINGAPORE, "zh_SG");
DIALECT(CHINESE, TRADITIONAL, "zh_TW");
DIALECT(CORSICAN, FRANCE, "co_FR");
DIALECT(CROATIAN, BOSNIA_HERZEGOVINA_LATIN, "hr_BA@latin");
DIALECT(CROATIAN, CROATIA, "hr_HR");
DIALECT(CZECH, CZECH_REPUBLIC, "cs_CZ");
DIALECT(DANISH, DENMARK, "da_DK");
DIALECT(DIVEHI, MALDIVES, "dv_MV");
DIALECT(DUTCH, BELGIAN, "nl_BE");
DIALECT(DUTCH, NETHERLANDS, "nl_NL");
DIALECT(ENGLISH, AUS, "en_AU");
DIALECT(ENGLISH, BELIZE, "en_BZ");
DIALECT(ENGLISH, CAN, "en_CA");
DIALECT(ENGLISH, CARIBBEAN, "en_XX");
DIALECT(ENGLISH, INDIA, "en_IN");
DIALECT(ENGLISH, IRELAND, "en_IE");
DIALECT(ENGLISH, JAMAICA, "en_JM");
DIALECT(ENGLISH, MALAYSIA, "en_MY");
DIALECT(ENGLISH, NZ, "en_NZ");
DIALECT(ENGLISH, PHILIPPINES, "en_PH");
DIALECT(ENGLISH, SINGAPORE, "en_SG");
DIALECT(ENGLISH, SOUTH_AFRICA, "en_ZA");
DIALECT(ENGLISH, TRINIDAD, "en_TT");
DIALECT(ENGLISH, UK, "en_GB");
DIALECT(ENGLISH, US, "en_US");
DIALECT(ENGLISH, ZIMBABWE, "en_ZW");
DIALECT(ESTONIAN, ESTONIA, "et_EE");
DIALECT(FAEROESE, FAROE_ISLANDS, "fo_FO");
DIALECT(FILIPINO, PHILIPPINES, "fil_PH");
DIALECT(FINNISH, FINLAND, "fi_FI");
DIALECT(FRENCH, BELGIAN, "fr_BE");
DIALECT(FRENCH, CANADIAN, "fr_CA");
DIALECT(FRENCH, FRANCE, "fr_FR");
DIALECT(FRENCH, LUXEMBOURG, "fr_LU");
DIALECT(FRENCH, MONACO, "fr_MC");
DIALECT(FRENCH, SWISS, "fr_CH");
DIALECT(FRISIAN, NETHERLANDS, "fy_NL");
DIALECT(GALICIAN, GALICIAN, "gl_ES");
DIALECT(GEORGIAN, GEORGIA, "ka_GE");
DIALECT(GERMAN, AUSTRIAN, "de_AT");
DIALECT(GERMAN, GERMANY, "de_DE");
DIALECT(GERMAN, LIECHTENSTEIN, "de_LI");
DIALECT(GERMAN, LUXEMBOURG, "de_LU");
DIALECT(GERMAN, SWISS, "de_CH");
DIALECT(GREEK, GREECE, "el_GR");
DIALECT(GREENLANDIC, GREENLAND, "kl_GL");
DIALECT(GUJARATI, INDIA, "gu_IN");
DIALECT(HAUSA, NIGERIA, "ha_NG");
DIALECT(HEBREW, ISRAEL, "he_IL");
DIALECT(HINDI, INDIA, "hi_IN");
DIALECT(HUNGARIAN, HUNGARY, "hu_HU");
DIALECT(ICELANDIC, ICELAND, "is_IS");
DIALECT(IGBO, NIGERIA, "ig_NG");
DIALECT(INDONESIAN, INDONESIA, "id_ID");
DIALECT(INUKTITUT, CANADA, "iu_CA");
DIALECT(IRISH, IRELAND, "ga_IE");
DIALECT(ITALIAN, ITALY, "it_IT");
DIALECT(ITALIAN, SWISS, "it_CH");
DIALECT(JAPANESE, JAPAN, "ja_JP");
DIALECT(KASHMIRI, INDIA, "ks_IN");
DIALECT(KAZAK, KAZAKHSTAN, "kk_KZ");
DIALECT(KHMER, CAMBODIA, "km_KH");
DIALECT(KICHE, GUATEMALA, "quc_GT");
DIALECT(KINYARWANDA, RWANDA, "rw_RW");
DIALECT(KONKANI, INDIA, "kok_IN");
DIALECT(KOREAN, KOREA, "ko_KR");
DIALECT(KYRGYZ, KYRGYZSTAN, "ky_KG");
DIALECT(LAO, LAO_PDR, "lo_LA");
DIALECT(LATVIAN, LATVIA, "lv_LV");
DIALECT(LITHUANIAN, LITHUANIA, "lt_LT");
DIALECT(LOWER_SORBIAN, GERMANY, "dsb_DE");
DIALECT(LUXEMBOURGISH, LUXEMBOURG, "lb_LU");
DIALECT(MACEDONIAN, MACEDONIA, "mk_MK");
DIALECT(MALAY, BRUNEI_DARUSSALAM, "ms_BN");
DIALECT(MALAY, MALAYSIA, "ms_MY");
DIALECT(MALAYALAM, INDIA, "ml_IN");
DIALECT(MALTESE, MALTA, "mt_MT");
DIALECT(MAORI, NEW_ZEALAND, "mi_NZ");
DIALECT(MAPUDUNGUN, CHILE, "arn_CL");
DIALECT(MARATHI, INDIA, "mr_IN");
DIALECT(MOHAWK, MOHAWK, "moh");
DIALECT(MONGOLIAN, CYRILLIC_MONGOLIA, "mn_MN@cyrillic");
DIALECT(MONGOLIAN, PRC, "mn_CN");
DIALECT(NEPALI, INDIA, "ne_IN");
DIALECT(NEPALI, NEPAL, "ne_NP");
DIALECT(NORWEGIAN, BOKMAL, "nb_NO");
DIALECT(NORWEGIAN, NYNORSK, "nn_NO");
DIALECT(OCCITAN, FRANCE, "oc_FR");
DIALECT(ORIYA, INDIA, "or_IN");
DIALECT(PASHTO, AFGHANISTAN, "ps_AF");
DIALECT(PERSIAN, IRAN, "fa_IR");
DIALECT(POLISH, POLAND, "pl_PL");
DIALECT(PORTUGUESE, BRAZILIAN, "pt_BR");
DIALECT(PORTUGUESE, PORTUGAL, "pt_PT");
DIALECT(PUNJABI, INDIA, "pa_IN");
#ifdef SUBLANG_PUNJABI_PAKISTAN
DIALECT(PUNJABI, PAKISTAN, "pa_PK");
#endif /* SUBLANG_PUNJABI_PAKISTAN */
DIALECT(QUECHUA, BOLIVIA, "qu_BO");
DIALECT(QUECHUA, ECUADOR, "qu_EC");
DIALECT(QUECHUA, PERU, "qu_PE");
#ifdef SUBLANG_ROMANIAN_MOLDOVA
DIALECT(ROMANIAN, MOLDOVA, "ro_MD");
#endif /* SUBLANG_ROMANIAN_MOLDOVA */
DIALECT(ROMANIAN, ROMANIA, "ro_RO");
DIALECT(RUSSIAN, RUSSIA, "ru_RU");
DIALECT(SAMI, LULE_NORWAY, "smj_NO");
DIALECT(SAMI, LULE_SWEDEN, "smj_SE");
DIALECT(SAMI, NORTHERN_FINLAND, "sme_FI");
DIALECT(SAMI, NORTHERN_NORWAY, "sme_NO");
DIALECT(SAMI, NORTHERN_SWEDEN, "sme_SE");
DIALECT(SAMI, SOUTHERN_NORWAY, "sma_NO");
DIALECT(SAMI, SOUTHERN_SWEDEN, "sma_SE");
DIALECT(SANSKRIT, INDIA, "sa_IN");
DIALECT(SERBIAN, BOSNIA_HERZEGOVINA_CYRILLIC, "sr_BA@cyrillic");
DIALECT(SERBIAN, BOSNIA_HERZEGOVINA_LATIN, "sr_BA@latin");
DIALECT(SERBIAN, CYRILLIC, "sr@cyrillic");
DIALECT(SERBIAN, LATIN, "sr@latin");
DIALECT(SINDHI, AFGHANISTAN, "sd_AF");
DIALECT(SINHALESE, SRI_LANKA, "si_LK");
DIALECT(SLOVAK, SLOVAKIA, "sk_SK");
DIALECT(SLOVENIAN, SLOVENIA, "sl_SI");
DIALECT(SOTHO, NORTHERN_SOUTH_AFRICA, "st_XX");
DIALECT(SPANISH, ARGENTINA, "es_AR");
DIALECT(SPANISH, BOLIVIA, "es_BO");
DIALECT(SPANISH, CHILE, "es_CL");
DIALECT(SPANISH, COLOMBIA, "es_CO");
DIALECT(SPANISH, COSTA_RICA, "es_CR");
DIALECT(SPANISH, DOMINICAN_REPUBLIC, "es_DO");
DIALECT(SPANISH, ECUADOR, "es_EC");
DIALECT(SPANISH, EL_SALVADOR, "es_SV");
DIALECT(SPANISH, GUATEMALA, "es_GT");
DIALECT(SPANISH, HONDURAS, "es_HN");
DIALECT(SPANISH, MEXICAN, "es_MX");
DIALECT(SPANISH, MODERN, "es_XX");
DIALECT(SPANISH, NICARAGUA, "es_NI");
DIALECT(SPANISH, PANAMA, "es_PA");
DIALECT(SPANISH, PARAGUAY, "es_PY");
DIALECT(SPANISH, PERU, "es_PE");
DIALECT(SPANISH, PUERTO_RICO, "es_PR");
DIALECT(SPANISH, SPAIN, "es_ES");
DIALECT(SPANISH, URUGUAY, "es_UY");
DIALECT(SPANISH, US, "es_US");
DIALECT(SPANISH, VENEZUELA, "es_VE");
DIALECT(SWEDISH, FINLAND, "sv_FI");
DIALECT(SWEDISH, SWEDEN, "sv_SE");
DIALECT(SYRIAC, TURKEY, "syr_TR");
DIALECT(TAMAZIGHT, ALGERIA_LATIN, "ber_DZ@latin");
DIALECT(TAMIL, INDIA, "ta_IN");
DIALECT(TATAR, RUSSIA, "tt_RU");
DIALECT(TELUGU, INDIA, "te_IN");
DIALECT(THAI, THAILAND, "th_TH");
DIALECT(TIBETAN, BHUTAN, "bo_BT");
DIALECT(TIBETAN, PRC, "bo_CN");
DIALECT(TIGRIGNA, ERITREA, "ti_ER");
DIALECT(TSWANA, SOUTH_AFRICA, "tn_ZA");
DIALECT(TURKISH, TURKEY, "tr_TR");
DIALECT(UIGHUR, PRC, "ug_CN");
DIALECT(UKRAINIAN, UKRAINE, "uk_UA");
//DIALECT(UPPER_SORBIAN, GERMANY, "hsb_DE");
DIALECT(URDU, INDIA, "ur_IN");
DIALECT(URDU, PAKISTAN, "ur_PK");
DIALECT(UZBEK, CYRILLIC, "uz@cyrillic");
DIALECT(UZBEK, LATIN, "uz@latin");
DIALECT(VIETNAMESE, VIETNAM, "vi_VN");
DIALECT(WELSH, UNITED_KINGDOM, "cy_GB");
DIALECT(WOLOF, SENEGAL, "fy_SN");
DIALECT(XHOSA, SOUTH_AFRICA, "xh_ZA");
DIALECT(YAKUT, RUSSIA, "sah_RU");
DIALECT(YI, PRC, "ii_CN");
DIALECT(YORUBA, NIGERIA, "yo_NG");
DIALECT(ZULU, SOUTH_AFRICA, "zu_ZA");
#undef DIALECT
}
switch (PRIMARYLANGID(langid)) {
#define LANGUAGE(primary,locale) case LANG_##primary: return (locale);
LANGUAGE(AFRIKAANS, "af");
LANGUAGE(ALBANIAN, "sq");
LANGUAGE(ALSATIAN, "gsw");
LANGUAGE(AMHARIC, "am");
LANGUAGE(ARABIC, "ar");
LANGUAGE(ARMENIAN, "hy");
LANGUAGE(ASSAMESE, "as");
LANGUAGE(AZERI, "az");
LANGUAGE(BASHKIR, "ba");
LANGUAGE(BASQUE, "eu");
LANGUAGE(BELARUSIAN, "be");
LANGUAGE(BENGALI, "bn");
LANGUAGE(BOSNIAN, "bs");
LANGUAGE(BOSNIAN_NEUTRAL, "bs");
LANGUAGE(BRETON, "br");
LANGUAGE(BULGARIAN, "bg");
LANGUAGE(CATALAN, "ca");
LANGUAGE(CHINESE, "zh");
LANGUAGE(CORSICAN, "co");
//LANGUAGE(CROATIAN, "hr");
LANGUAGE(CZECH, "cs");
LANGUAGE(DANISH, "da");
LANGUAGE(DARI, "gbz");
LANGUAGE(DIVEHI, "dv");
LANGUAGE(DUTCH, "nl");
LANGUAGE(ENGLISH, "en");
LANGUAGE(ESTONIAN, "et");
LANGUAGE(FAEROESE, "fo");
LANGUAGE(FILIPINO, "fil");
LANGUAGE(FINNISH, "fi");
LANGUAGE(FRENCH, "fr");
LANGUAGE(FRISIAN, "fy");
LANGUAGE(GALICIAN, "gl");
LANGUAGE(GEORGIAN, "ka");
LANGUAGE(GERMAN, "de");
LANGUAGE(GREEK, "el");
LANGUAGE(GREENLANDIC, "kl");
LANGUAGE(GUJARATI, "gu");
LANGUAGE(HAUSA, "ha");
LANGUAGE(HEBREW, "he");
LANGUAGE(HINDI, "hi");
LANGUAGE(HUNGARIAN, "hu");
LANGUAGE(ICELANDIC, "is");
LANGUAGE(IGBO, "ig");
LANGUAGE(INDONESIAN, "id");
LANGUAGE(INUKTITUT, "iu");
LANGUAGE(IRISH, "ga");
LANGUAGE(ITALIAN, "it");
LANGUAGE(JAPANESE, "ja");
LANGUAGE(KANNADA, "kn");
LANGUAGE(KASHMIRI, "ks");
LANGUAGE(KAZAK, "kk");
LANGUAGE(KHMER, "km");
LANGUAGE(KICHE, "quc");
LANGUAGE(KINYARWANDA, "rw");
LANGUAGE(KONKANI, "kok");
LANGUAGE(KOREAN, "ko");
LANGUAGE(KYRGYZ, "ky");
LANGUAGE(LAO, "lo");
LANGUAGE(LATVIAN, "lv");
LANGUAGE(LITHUANIAN, "lt");
LANGUAGE(LOWER_SORBIAN, "dsb");
LANGUAGE(LUXEMBOURGISH, "lb");
LANGUAGE(MACEDONIAN, "mk");
LANGUAGE(MALAGASY, "mg");
LANGUAGE(MALAY, "ms");
LANGUAGE(MALAYALAM, "ml");
LANGUAGE(MALTESE, "mt");
LANGUAGE(MANIPURI, "mni");
LANGUAGE(MAORI, "mi");
LANGUAGE(MAPUDUNGUN, "arn");
LANGUAGE(MARATHI, "mr");
LANGUAGE(MOHAWK, "moh");
LANGUAGE(MONGOLIAN, "mn");
LANGUAGE(NEPALI, "ne");
LANGUAGE(NORWEGIAN, "no");
LANGUAGE(OCCITAN, "oc");
LANGUAGE(ORIYA, "or");
LANGUAGE(PASHTO, "ps");
LANGUAGE(PERSIAN, "fa");
LANGUAGE(POLISH, "pl");
LANGUAGE(PORTUGUESE, "pt");
LANGUAGE(PUNJABI, "pa");
LANGUAGE(QUECHUA, "qu");
LANGUAGE(ROMANIAN, "ro");
LANGUAGE(RUSSIAN, "ru");
LANGUAGE(SAMI, "se");
LANGUAGE(SANSKRIT, "sa");
//LANGUAGE(SERBIAN, "sr");
LANGUAGE(SERBIAN_NEUTRAL, "sr");
LANGUAGE(SINDHI, "sd");
LANGUAGE(SINHALESE, "si");
LANGUAGE(SLOVAK, "sk");
LANGUAGE(SLOVENIAN, "sl");
LANGUAGE(SOTHO, "st");
LANGUAGE(SPANISH, "es");
LANGUAGE(SWAHILI, "sw");
LANGUAGE(SWEDISH, "sv");
LANGUAGE(SYRIAC, "syr");
LANGUAGE(TAMAZIGHT, "ber");
LANGUAGE(TAMIL, "ta");
LANGUAGE(TATAR, "tt");
LANGUAGE(TELUGU, "te");
LANGUAGE(THAI, "th");
LANGUAGE(TIBETAN, "bo");
LANGUAGE(TIGRIGNA, "ti");
LANGUAGE(TSWANA, "tn");
LANGUAGE(TURKISH, "tr");
LANGUAGE(UIGHUR, "ug");
LANGUAGE(UKRAINIAN, "uk");
//LANGUAGE(UPPER_SORBIAN, "hsb");
LANGUAGE(URDU, "ur");
LANGUAGE(UZBEK, "uz");
LANGUAGE(VIETNAMESE, "vi");
LANGUAGE(WELSH, "cy");
LANGUAGE(WOLOF, "fy");
LANGUAGE(XHOSA, "xh");
LANGUAGE(YAKUT, "sah");
LANGUAGE(YI, "ii");
LANGUAGE(YORUBA, "yo");
LANGUAGE(ZULU, "zu");
#undef LANGUAGE
}
} else {
logWindowsSystemError("GetLocaleInfo");
}
}
return "xx";
}
void
setCurrentTime (const TimeValue *now) {
#if defined(HAVE_CLOCK_SETTIME) && defined(CLOCK_REALTIME)
const struct timespec ts = {
.tv_sec = now->seconds,
.tv_nsec = now->nanoseconds
};
if (clock_settime(CLOCK_REALTIME, &ts) == -1) {
logSystemError("clock_settime");
}
#elif defined(HAVE_SETTIMEOFDAY)
const struct timeval tv = {
.tv_sec = now->seconds,
.tv_usec = now->nanoseconds / NSECS_PER_USEC
};
if (settimeofday(&tv, NULL) == -1) {
logSystemError("settimeofday");
}
#elif defined(__MINGW32__)
TimeComponents components;
expandTimeValue(now, &components);
SYSTEMTIME time = {
.wYear = components.year,
.wMonth = components.month + 1,
.wDay = components.day + 1,
.wHour = components.hour,
.wMinute = components.minute,
.wSecond = components.second,
.wMilliseconds = now->nanoseconds / NSECS_PER_MSEC
};
if (!SetLocalTime(&time)) {
logWindowsSystemError("SetLocalTime");
}
#elif defined(HAVE_STIME)
const time_t seconds = now->seconds;
if (stime(&seconds) == -1) {
logSystemError("stime");
}
#else /* set current time */
#warning set current time not supported on this platform
#endif /* get current time */
}
void
makeTimeValue (TimeValue *value, const TimeComponents *components) {
value->nanoseconds = components->nanosecond;
#if defined(GRUB_RUNTIME)
value->seconds = 0;
#else /* make seconds */
struct tm time = {
.tm_year = components->year - 1900,
.tm_mon = components->month,
.tm_mday = components->day + 1,
.tm_hour = components->hour,
.tm_min = components->minute,
.tm_sec = components->second,
.tm_isdst = -1
};
value->seconds = mktime(&time);
#endif /* make seconds */
}
void
expandTimeValue (const TimeValue *value, TimeComponents *components) {
time_t seconds = value->seconds;
struct tm time;
localtime_r(&seconds, &time);
components->nanosecond = value->nanoseconds;
#if defined(GRUB_RUNTIME)
components->year = time.tm.year;
components->month = time.tm.month - 1;
components->day = time.tm.day - 1;
components->hour = time.tm.hour;
components->minute = time.tm.minute;
components->second = time.tm.second;
#else /* expand seconds */
components->year = time.tm_year + 1900;
components->month = time.tm_mon;
components->day = time.tm_mday - 1;
components->hour = time.tm_hour;
components->minute = time.tm_min;
components->second = time.tm_sec;
#endif /* expand seconds */
}
size_t
formatSeconds (char *buffer, size_t size, const char *format, int32_t seconds) {
time_t time = seconds;
struct tm description;
localtime_r(&time, &description);
return strftime(buffer, size, format, &description);
}
void
normalizeTimeValue (TimeValue *time) {
while (time->nanoseconds < 0) {
time->seconds -= 1;
time->nanoseconds += NSECS_PER_SEC;
}
while (time->nanoseconds >= NSECS_PER_SEC) {
time->seconds += 1;
time->nanoseconds -= NSECS_PER_SEC;
}
}
void
adjustTimeValue (TimeValue *time, int milliseconds) {
TimeValue amount = {
.seconds = milliseconds / MSECS_PER_SEC,
.nanoseconds = (milliseconds % MSECS_PER_SEC) * NSECS_PER_MSEC
};
normalizeTimeValue(time);
normalizeTimeValue(&amount);
time->seconds += amount.seconds;
time->nanoseconds += amount.nanoseconds;
normalizeTimeValue(time);
}
void
unloadSharedObject (void *object) {
if (!(FreeLibrary((HMODULE) object)))
logWindowsSystemError("unloading library");
}
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
if (!allocateCommandDescriptors()) return 0;
inputLength = 0;
inputStart = 0;
inputEnd = 0;
outputLength = 0;
if (isQualifiedDevice(&device, "client")) {
static const ModeEntry clientModeEntry = {
#ifdef AF_LOCAL
requestLocalConnection,
#endif /* AF_LOCAL */
#ifdef __MINGW32__
requestNamedPipeConnection,
#endif /* __MINGW32__ */
requestInetConnection
};
mode = &clientModeEntry;
} else if (isQualifiedDevice(&device, "server")) {
static const ModeEntry serverModeEntry = {
#ifdef AF_LOCAL
acceptLocalConnection,
#endif /* AF_LOCAL */
#ifdef __MINGW32__
acceptNamedPipeConnection,
#endif /* __MINGW32__ */
acceptInetConnection
};
mode = &serverModeEntry;
} else {
unsupportedDevice(device);
goto failed;
}
if (!*device) device = VR_DEFAULT_SOCKET;
#ifdef AF_LOCAL
if (device[0] == '/') {
struct sockaddr_un address;
if (setLocalAddress(device, &address)) {
fileDescriptor = mode->getLocalConnection(&address);
}
} else
#endif /* AF_LOCAL */
#ifdef __MINGW32__
if (device[0] == '\\') {
fileDescriptor = mode->getNamedPipeConnection(device);
} else {
static WSADATA wsadata;
if (WSAStartup(MAKEWORD(1, 1), &wsadata)) {
logWindowsSystemError("socket library start");
goto failed;
}
}
#endif /* __MINGW32__ */
{
struct sockaddr_in address;
if (setInetAddress(device, &address)) {
fileDescriptor = mode->getInetConnection(&address);
}
}
if (fileDescriptor != -1) {
char *line = NULL;
while (1) {
if (line) free(line);
if ((line = readCommandLine())) {
const char *word;
logMessage(LOG_DEBUG, "command received: %s", line);
if ((word = strtok(line, inputDelimiters))) {
if (testWord(word, "cells")) {
if (dimensionsChanged(brl)) {
free(line);
return 1;
}
} else if (testWord(word, "quit")) {
break;
} else {
logMessage(LOG_WARNING, "unexpected command: %s", word);
}
}
} else {
asyncWait(1000);
}
}
if (line) free(line);
close(fileDescriptor);
fileDescriptor = -1;
}
failed:
deallocateCommandDescriptors();
return 0;
}
PcmDevice *
openPcmDevice (int errorLevel, const char *device) {
PcmDevice *pcm;
MMRESULT mmres;
WAVEOUTCAPS caps;
int id = 0;
if (*device) {
if (!isInteger(&id, device) || (id < 0) || (id >= waveOutGetNumDevs())) {
logMessage(errorLevel, "invalid PCM device number: %s", device);
return NULL;
}
}
if (!(pcm = malloc(sizeof(*pcm)))) {
logSystemError("PCM device allocation");
return NULL;
}
pcm->deviceID = id;
if ((waveOutGetDevCaps(pcm->deviceID, &caps, sizeof(caps))) != MMSYSERR_NOERROR)
pcm->format = defaultFormat;
else {
logMessage(errorLevel, "PCM device %d is %s", pcm->deviceID, caps.szPname);
pcm->format.wFormatTag = WAVE_FORMAT_PCM;
if (caps.dwFormats &
(WAVE_FORMAT_1S08
|WAVE_FORMAT_1S16
|WAVE_FORMAT_2S08
|WAVE_FORMAT_2S16
|WAVE_FORMAT_4S08
|WAVE_FORMAT_4S16))
pcm->format.nChannels = 2;
else
pcm->format.nChannels = 1;
if (caps.dwFormats &
(WAVE_FORMAT_4M08
|WAVE_FORMAT_4M16
|WAVE_FORMAT_4S08
|WAVE_FORMAT_4S16))
pcm->format.nSamplesPerSec = 44100;
else if (caps.dwFormats &
(WAVE_FORMAT_2M08
|WAVE_FORMAT_2M16
|WAVE_FORMAT_2S08
|WAVE_FORMAT_2S16))
pcm->format.nSamplesPerSec = 22050;
else if (caps.dwFormats &
(WAVE_FORMAT_1M08
|WAVE_FORMAT_1M16
|WAVE_FORMAT_1S08
|WAVE_FORMAT_1S16))
pcm->format.nSamplesPerSec = 11025;
else {
logMessage(errorLevel, "unknown PCM capability %#lx", caps.dwFormats);
goto out;
}
if (caps.dwFormats &
(WAVE_FORMAT_1M16
|WAVE_FORMAT_1S16
|WAVE_FORMAT_2M16
|WAVE_FORMAT_2S16
|WAVE_FORMAT_4M16
|WAVE_FORMAT_4S16))
pcm->format.wBitsPerSample = 16;
else if (caps.dwFormats &
(WAVE_FORMAT_1M08
|WAVE_FORMAT_1S08
|WAVE_FORMAT_2M08
|WAVE_FORMAT_2S08
|WAVE_FORMAT_4M08
|WAVE_FORMAT_4S08))
pcm->format.wBitsPerSample = 8;
else {
logMessage(LOG_ERR, "unknown PCM capability %#lx", caps.dwFormats);
goto out;
}
recomputeWaveOutFormat(&pcm->format);
pcm->format.cbSize = 0;
}
if (!(pcm->done = CreateEvent(NULL, FALSE, TRUE, NULL))) {
logWindowsSystemError("creating PCM completion event");
goto out;
}
pcm->waveHdr = initWaveHdr;
pcm->bufSize = 0;
if ((mmres = waveOutOpen(&pcm->handle, pcm->deviceID,
&pcm->format, (DWORD) pcm->done, 0, CALLBACK_EVENT)) != MMSYSERR_NOERROR) {
LogWaveOutError(mmres, errorLevel, "opening PCM device");
goto outEvent;
}
return pcm;
outEvent:
CloseHandle(pcm->done);
out:
free(pcm);
return NULL;
}
